openstudio-standards 0.8.3 → 0.8.5.rc1

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

@@ -1,77 +0,0 @@
-class Standard
-  # @!group CoilCoolingWater
-
-  # Prototype CoilCoolingWater object
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @param chilled_water_loop [<OpenStudio::Model::PlantLoop>] the coil will be placed on the demand side of this plant loop
-  # @param air_loop_node [<OpenStudio::Model::Node>] the coil will be placed on this node of the air loop
-  # @param name [String] the name of the coil, or nil in which case it will be defaulted
-  # @param schedule [String] name of the availability schedule, or [<OpenStudio::Model::Schedule>] Schedule object, or nil in which case default to always on
-  # @param design_inlet_water_temperature [Double] design inlet water temperature in degrees Celsius, default is nil
-  # @param design_inlet_air_temperature [Double] design inlet air temperature in degrees Celsius, default is nil
-  # @param design_outlet_air_temperature [Double] design outlet air temperature in degrees Celsius, default is nil
-  # @return [OpenStudio::Model::CoilCoolingWater] the cooling coil
-  def create_coil_cooling_water(model,
-                                chilled_water_loop,
-                                air_loop_node: nil,
-                                name: 'Clg Coil',
-                                schedule: nil,
-                                design_inlet_water_temperature: nil,
-                                design_inlet_air_temperature: nil,
-                                design_outlet_air_temperature: nil)
-
-    clg_coil = OpenStudio::Model::CoilCoolingWater.new(model)
-
-    # add to chilled water loop
-    chilled_water_loop.addDemandBranchForComponent(clg_coil)
-
-    # add to air loop if specified
-    clg_coil.addToNode(air_loop_node) unless air_loop_node.nil?
-
-    # set coil name
-    if name.nil?
-      clg_coil.setName('Clg Coil')
-    else
-      clg_coil.setName(name)
-    end
-
-    # set coil availability schedule
-    if schedule.nil?
-      # default always on
-      coil_availability_schedule = model.alwaysOnDiscreteSchedule
-    elsif schedule.instance_of?(String)
-      coil_availability_schedule = model_add_schedule(model, schedule)
-
-      if coil_availability_schedule.nil? && schedule == 'alwaysOffDiscreteSchedule'
-        coil_availability_schedule = model.alwaysOffDiscreteSchedule
-      elsif coil_availability_schedule.nil?
-        coil_availability_schedule = model.alwaysOnDiscreteSchedule
-      end
-    elsif !schedule.to_Schedule.empty?
-      coil_availability_schedule = schedule
-    end
-    clg_coil.setAvailabilitySchedule(coil_availability_schedule)
-
-    # rated temperatures
-    if design_inlet_water_temperature.nil?
-      clg_coil.autosizeDesignInletWaterTemperature
-    else
-      clg_coil.setDesignInletWaterTemperature(design_inlet_water_temperature)
-    end
-    clg_coil.setDesignInletAirTemperature(design_inlet_air_temperature) unless design_inlet_air_temperature.nil?
-    clg_coil.setDesignOutletAirTemperature(design_outlet_air_temperature) unless design_outlet_air_temperature.nil?
-
-    # defaults
-    clg_coil.setHeatExchangerConfiguration('CrossFlow')
-
-    # coil controller properties
-    # @note These inputs will get overwritten if addToNode or addDemandBranchForComponent is called on the htg_coil object after this
-    clg_coil_controller = clg_coil.controllerWaterCoil.get
-    clg_coil_controller.setName("#{clg_coil.name} Controller")
-    clg_coil_controller.setAction('Reverse')
-    clg_coil_controller.setMinimumActuatedFlow(0.0)
-
-    return clg_coil
-  end
-end

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

@@ -1,154 +0,0 @@
-class Standard
-  # @!group CoilCoolingWaterToAirHeatPumpEquationFit
-
-  # Prototype CoilCoolingWaterToAirHeatPumpEquationFit object
-  # Enters in default curves for coil by type of coil
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @param plant_loop [<OpenStudio::Model::PlantLoop>] the coil will be placed on the demand side of this plant loop
-  # @param air_loop_node [<OpenStudio::Model::Node>] the coil will be placed on this node of the air loop
-  # @param name [String] the name of the system, or nil in which case it will be defaulted
-  # @param type [String] the type of coil to reference the correct curve set
-  # @param cop [Double] rated cooling coefficient of performance
-  # @return [OpenStudio::Model::CoilCoolingWaterToAirHeatPumpEquationFit] the cooling coil
-  def create_coil_cooling_water_to_air_heat_pump_equation_fit(model,
-                                                              plant_loop,
-                                                              air_loop_node: nil,
-                                                              name: 'Water-to-Air HP Clg Coil',
-                                                              type: nil,
-                                                              cop: 3.4)
-
-    clg_coil = OpenStudio::Model::CoilCoolingWaterToAirHeatPumpEquationFit.new(model)
-
-    # add to air loop if specified
-    clg_coil.addToNode(air_loop_node) unless air_loop_node.nil?
-
-    # set coil name
-    clg_coil.setName(name)
-
-    # add to plant loop
-    if plant_loop.nil?
-      OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', 'No plant loop supplied for cooling coil')
-      return false
-    end
-    plant_loop.addDemandBranchForComponent(clg_coil)
-
-    # set coil cop
-    if cop.nil?
-      clg_coil.setRatedCoolingCoefficientofPerformance(3.4)
-    else
-      clg_coil.setRatedCoolingCoefficientofPerformance(cop)
-    end
-
-    # curve sets
-    if type == 'OS default'
-      # use OS default curves
-    else # default curve set
-      if model.version < OpenStudio::VersionString.new('3.2.0')
-        clg_coil.setTotalCoolingCapacityCoefficient1(-4.30266987344639)
-        clg_coil.setTotalCoolingCapacityCoefficient2(7.18536990534372)
-        clg_coil.setTotalCoolingCapacityCoefficient3(-2.23946714486189)
-        clg_coil.setTotalCoolingCapacityCoefficient4(0.139995928440879)
-        clg_coil.setTotalCoolingCapacityCoefficient5(0.102660179888915)
-        clg_coil.setSensibleCoolingCapacityCoefficient1(6.0019444814887)
-        clg_coil.setSensibleCoolingCapacityCoefficient2(22.6300677244073)
-        clg_coil.setSensibleCoolingCapacityCoefficient3(-26.7960783730934)
-        clg_coil.setSensibleCoolingCapacityCoefficient4(-1.72374720346819)
-        clg_coil.setSensibleCoolingCapacityCoefficient5(0.490644802367817)
-        clg_coil.setSensibleCoolingCapacityCoefficient6(0.0693119353468141)
-        clg_coil.setCoolingPowerConsumptionCoefficient1(-5.67775976415698)
-        clg_coil.setCoolingPowerConsumptionCoefficient2(0.438988156976704)
-        clg_coil.setCoolingPowerConsumptionCoefficient3(5.845277342193)
-        clg_coil.setCoolingPowerConsumptionCoefficient4(0.141605667000125)
-        clg_coil.setCoolingPowerConsumptionCoefficient5(-0.168727936032429)
-      else
-        if model.getCurveByName('Water to Air Heat Pump Total Cooling Capacity Curve').is_initialized
-          total_cooling_capacity_curve = model.getCurveByName('Water to Air Heat Pump Total Cooling Capacity Curve').get
-          total_cooling_capacity_curve = total_cooling_capacity_curve.to_CurveQuadLinear.get
-        else
-          total_cooling_capacity_curve = OpenStudio::Model::CurveQuadLinear.new(model)
-          total_cooling_capacity_curve.setName('Water to Air Heat Pump Total Cooling Capacity Curve')
-          total_cooling_capacity_curve.setCoefficient1Constant(-4.30266987344639)
-          total_cooling_capacity_curve.setCoefficient2w(7.18536990534372)
-          total_cooling_capacity_curve.setCoefficient3x(-2.23946714486189)
-          total_cooling_capacity_curve.setCoefficient4y(0.139995928440879)
-          total_cooling_capacity_curve.setCoefficient5z(0.102660179888915)
-          total_cooling_capacity_curve.setMinimumValueofw(-100)
-          total_cooling_capacity_curve.setMaximumValueofw(100)
-          total_cooling_capacity_curve.setMinimumValueofx(-100)
-          total_cooling_capacity_curve.setMaximumValueofx(100)
-          total_cooling_capacity_curve.setMinimumValueofy(0)
-          total_cooling_capacity_curve.setMaximumValueofy(100)
-          total_cooling_capacity_curve.setMinimumValueofz(0)
-          total_cooling_capacity_curve.setMaximumValueofz(100)
-        end
-        clg_coil.setTotalCoolingCapacityCurve(total_cooling_capacity_curve)
-
-        if model.getCurveByName('Water to Air Heat Pump Sensible Cooling Capacity Curve').is_initialized
-          sensible_cooling_capacity_curve = model.getCurveByName('Water to Air Heat Pump Sensible Cooling Capacity Curve').get
-          sensible_cooling_capacity_curve = sensible_cooling_capacity_curve.to_CurveQuintLinear.get
-        else
-          sensible_cooling_capacity_curve = OpenStudio::Model::CurveQuintLinear.new(model)
-          sensible_cooling_capacity_curve.setName('Water to Air Heat Pump Sensible Cooling Capacity Curve')
-          sensible_cooling_capacity_curve.setCoefficient1Constant(6.0019444814887)
-          sensible_cooling_capacity_curve.setCoefficient2v(22.6300677244073)
-          sensible_cooling_capacity_curve.setCoefficient3w(-26.7960783730934)
-          sensible_cooling_capacity_curve.setCoefficient4x(-1.72374720346819)
-          sensible_cooling_capacity_curve.setCoefficient5y(0.490644802367817)
-          sensible_cooling_capacity_curve.setCoefficient6z(0.0693119353468141)
-          sensible_cooling_capacity_curve.setMinimumValueofw(-100)
-          sensible_cooling_capacity_curve.setMaximumValueofw(100)
-          sensible_cooling_capacity_curve.setMinimumValueofx(-100)
-          sensible_cooling_capacity_curve.setMaximumValueofx(100)
-          sensible_cooling_capacity_curve.setMinimumValueofy(0)
-          sensible_cooling_capacity_curve.setMaximumValueofy(100)
-          sensible_cooling_capacity_curve.setMinimumValueofz(0)
-          sensible_cooling_capacity_curve.setMaximumValueofz(100)
-        end
-        clg_coil.setSensibleCoolingCapacityCurve(sensible_cooling_capacity_curve)
-
-        if model.getCurveByName('Water to Air Heat Pump Cooling Power Consumption Curve').is_initialized
-          cooling_power_consumption_curve = model.getCurveByName('Water to Air Heat Pump Cooling Power Consumption Curve').get
-          cooling_power_consumption_curve = cooling_power_consumption_curve.to_CurveQuadLinear.get
-        else
-          cooling_power_consumption_curve = OpenStudio::Model::CurveQuadLinear.new(model)
-          cooling_power_consumption_curve.setName('Water to Air Heat Pump Cooling Power Consumption Curve')
-          cooling_power_consumption_curve.setCoefficient1Constant(-5.67775976415698)
-          cooling_power_consumption_curve.setCoefficient2w(0.438988156976704)
-          cooling_power_consumption_curve.setCoefficient3x(5.845277342193)
-          cooling_power_consumption_curve.setCoefficient4y(0.141605667000125)
-          cooling_power_consumption_curve.setCoefficient5z(-0.168727936032429)
-          cooling_power_consumption_curve.setMinimumValueofw(-100)
-          cooling_power_consumption_curve.setMaximumValueofw(100)
-          cooling_power_consumption_curve.setMinimumValueofx(-100)
-          cooling_power_consumption_curve.setMaximumValueofx(100)
-          cooling_power_consumption_curve.setMinimumValueofy(0)
-          cooling_power_consumption_curve.setMaximumValueofy(100)
-          cooling_power_consumption_curve.setMinimumValueofz(0)
-          cooling_power_consumption_curve.setMaximumValueofz(100)
-        end
-        clg_coil.setCoolingPowerConsumptionCurve(cooling_power_consumption_curve)
-      end
-
-      # part load fraction correlation curve added as a required curve in OS v3.7.0
-      if model.version > OpenStudio::VersionString.new('3.6.1')
-        if model.getCurveByName('Water to Air Heat Pump Part Load Fraction Correlation Curve').is_initialized
-          part_load_correlation_curve = model.getCurveByName('Water to Air Heat Pump Part Load Fraction Correlation Curve').get
-          part_load_correlation_curve = part_load_correlation_curve.to_CurveLinear.get
-        else
-          part_load_correlation_curve = OpenStudio::Model::CurveLinear.new(model)
-          part_load_correlation_curve.setName('Water to Air Heat Pump Part Load Fraction Correlation Curve')
-          part_load_correlation_curve.setCoefficient1Constant(0.833746458696111)
-          part_load_correlation_curve.setCoefficient2x(0.166253541303889)
-          part_load_correlation_curve.setMinimumValueofx(0)
-          part_load_correlation_curve.setMaximumValueofx(1)
-          part_load_correlation_curve.setMinimumCurveOutput(0)
-          part_load_correlation_curve.setMaximumCurveOutput(1)
-        end
-        clg_coil.setPartLoadFractionCorrelationCurve(part_load_correlation_curve)
-      end
-    end
-
-    return clg_coil
-  end
-end

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

@@ -1,214 +0,0 @@
-class Standard
-  # @!group CoilHeatingDXSingleSpeed
-
-  # Prototype CoilHeatingDXSingleSpeed object
-  # Enters in default curves for coil by type of coil
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @param air_loop_node [<OpenStudio::Model::Node>] the coil will be placed on this node of the air loop
-  # @param name [String] the name of the system, or nil in which case it will be defaulted
-  # @param schedule [String] name of the availability schedule, or [<OpenStudio::Model::Schedule>] Schedule object, or nil in which case default to always on
-  # @param type [String] the type of single speed DX coil to reference the correct curve set
-  # @param cop [Double] rated heating coefficient of performance
-  # @param defrost_strategy [String] type of defrost strategy. options are reverse-cycle or resistive
-  # @return [OpenStudio::Model::CoilHeatingDXSingleSpeed] the DX heating coil
-  def create_coil_heating_dx_single_speed(model,
-                                          air_loop_node: nil,
-                                          name: '1spd DX Htg Coil',
-                                          schedule: nil,
-                                          type: nil,
-                                          cop: 3.3,
-                                          defrost_strategy: 'ReverseCycle')
-
-    htg_coil = OpenStudio::Model::CoilHeatingDXSingleSpeed.new(model)
-
-    # add to air loop if specified
-    htg_coil.addToNode(air_loop_node) unless air_loop_node.nil?
-
-    # set coil name
-    htg_coil.setName(name)
-
-    # set coil availability schedule
-    if schedule.nil?
-      # default always on
-      coil_availability_schedule = model.alwaysOnDiscreteSchedule
-    elsif schedule.instance_of?(String)
-      coil_availability_schedule = model_add_schedule(model, schedule)
-
-      if coil_availability_schedule.nil? && schedule == 'alwaysOffDiscreteSchedule'
-        coil_availability_schedule = model.alwaysOffDiscreteSchedule
-      elsif coil_availability_schedule.nil?
-        coil_availability_schedule = model.alwaysOnDiscreteSchedule
-      end
-    elsif !schedule.to_Schedule.empty?
-      coil_availability_schedule = schedule
-    end
-    htg_coil.setAvailabilitySchedule(coil_availability_schedule)
-
-    # set coil cop
-    if cop.nil?
-      htg_coil.setRatedCOP(3.3)
-    else
-      htg_coil.setRatedCOP(cop)
-    end
-
-    htg_cap_f_of_temp = nil
-    htg_cap_f_of_flow = nil
-    htg_energy_input_ratio_f_of_temp = nil
-    htg_energy_input_ratio_f_of_flow = nil
-    htg_part_load_fraction = nil
-    def_eir_f_of_temp = nil
-
-    # curve sets
-    case type
-    when 'OS default'
-      # use OS defaults
-    when 'Residential Central Air Source HP'
-      # Performance curves
-      # These coefficients are in IP UNITS
-      heat_cap_ft_coeffs_ip = [0.566333415, -0.000744164, -0.0000103, 0.009414634, 0.0000506, -0.00000675]
-      heat_eir_ft_coeffs_ip = [0.718398423, 0.003498178, 0.000142202, -0.005724331, 0.00014085, -0.000215321]
-      heat_cap_fflow_coeffs = [0.694045465, 0.474207981, -0.168253446]
-      heat_eir_fflow_coeffs = [2.185418751, -1.942827919, 0.757409168]
-      heat_plf_fplr_coeffs = [0.8, 0.2, 0]
-      defrost_eir_coeffs = [0.1528, 0, 0, 0, 0, 0]
-
-      # Convert coefficients from IP to SI
-      heat_cap_ft_coeffs_si = convert_curve_biquadratic(heat_cap_ft_coeffs_ip)
-      heat_eir_ft_coeffs_si = convert_curve_biquadratic(heat_eir_ft_coeffs_ip)
-
-      htg_cap_f_of_temp = create_curve_biquadratic(model, heat_cap_ft_coeffs_si, 'Heat-Cap-fT', 0, 100, 0, 100, nil, nil)
-      htg_cap_f_of_flow = create_curve_quadratic(model, heat_cap_fflow_coeffs, 'Heat-Cap-fFF', 0, 2, 0, 2, is_dimensionless = true)
-      htg_energy_input_ratio_f_of_temp = create_curve_biquadratic(model, heat_eir_ft_coeffs_si, 'Heat-EIR-fT', 0, 100, 0, 100, nil, nil)
-      htg_energy_input_ratio_f_of_flow = create_curve_quadratic(model, heat_eir_fflow_coeffs, 'Heat-EIR-fFF', 0, 2, 0, 2, is_dimensionless = true)
-      htg_part_load_fraction = create_curve_quadratic(model, heat_plf_fplr_coeffs, 'Heat-PLF-fPLR', 0, 1, 0, 1, is_dimensionless = true)
-
-      # Heating defrost curve for reverse cycle
-      def_eir_f_of_temp = create_curve_biquadratic(model, defrost_eir_coeffs, 'DefrostEIR', -100, 100, -100, 100, nil, nil)
-    when 'Residential Minisplit HP'
-      # Performance curves
-      # These coefficients are in SI UNITS
-      heat_cap_ft_coeffs_si = [1.14715889038462, -0.010386676170938, 0, 0.00865384615384615, 0, 0]
-      heat_eir_ft_coeffs_si = [0.9999941697687026, 0.004684593830254383, 5.901286675833333e-05, -0.0028624467783091973, 1.3041120194135802e-05, -0.00016172918478765433]
-      heat_cap_fflow_coeffs = [1, 0, 0]
-      heat_eir_fflow_coeffs = [1, 0, 0]
-      heat_plf_fplr_coeffs = [0.89, 0.11, 0]
-      defrost_eir_coeffs = [0.1528, 0, 0, 0, 0, 0]
-
-      htg_cap_f_of_temp = create_curve_biquadratic(model, heat_cap_ft_coeffs_si, 'Heat-Cap-fT', -100, 100, -100, 100, nil, nil)
-      htg_cap_f_of_flow = create_curve_quadratic(model, heat_cap_fflow_coeffs, 'Heat-Cap-fFF', 0, 2, 0, 2, is_dimensionless = true)
-      htg_energy_input_ratio_f_of_temp = create_curve_biquadratic(model, heat_eir_ft_coeffs_si, 'Heat-EIR-fT', -100, 100, -100, 100, nil, nil)
-      htg_energy_input_ratio_f_of_flow = create_curve_quadratic(model, heat_eir_fflow_coeffs, 'Heat-EIR-fFF', 0, 2, 0, 2, is_dimensionless = true)
-      htg_part_load_fraction = create_curve_quadratic(model, heat_plf_fplr_coeffs, 'Heat-PLF-fPLR', 0, 1, 0.6, 1, is_dimensionless = true)
-
-      # Heating defrost curve for reverse cycle
-      def_eir_f_of_temp = create_curve_biquadratic(model, defrost_eir_coeffs, 'Defrost EIR', -100, 100, -100, 100, nil, nil)
-    else # default curve set
-      htg_cap_f_of_temp = OpenStudio::Model::CurveCubic.new(model)
-      htg_cap_f_of_temp.setName("#{htg_coil.name} Htg Cap Func of Temp Curve")
-      htg_cap_f_of_temp.setCoefficient1Constant(0.758746)
-      htg_cap_f_of_temp.setCoefficient2x(0.027626)
-      htg_cap_f_of_temp.setCoefficient3xPOW2(0.000148716)
-      htg_cap_f_of_temp.setCoefficient4xPOW3(0.0000034992)
-      htg_cap_f_of_temp.setMinimumValueofx(-20.0)
-      htg_cap_f_of_temp.setMaximumValueofx(20.0)
-
-      htg_cap_f_of_flow = OpenStudio::Model::CurveCubic.new(model)
-      htg_cap_f_of_flow.setName("#{htg_coil.name} Htg Cap Func of Flow Frac Curve")
-      htg_cap_f_of_flow.setCoefficient1Constant(0.84)
-      htg_cap_f_of_flow.setCoefficient2x(0.16)
-      htg_cap_f_of_flow.setCoefficient3xPOW2(0.0)
-      htg_cap_f_of_flow.setCoefficient4xPOW3(0.0)
-      htg_cap_f_of_flow.setMinimumValueofx(0.5)
-      htg_cap_f_of_flow.setMaximumValueofx(1.5)
-
-      htg_energy_input_ratio_f_of_temp = OpenStudio::Model::CurveCubic.new(model)
-      htg_energy_input_ratio_f_of_temp.setName("#{htg_coil.name} EIR Func of Temp Curve")
-      htg_energy_input_ratio_f_of_temp.setCoefficient1Constant(1.19248)
-      htg_energy_input_ratio_f_of_temp.setCoefficient2x(-0.0300438)
-      htg_energy_input_ratio_f_of_temp.setCoefficient3xPOW2(0.00103745)
-      htg_energy_input_ratio_f_of_temp.setCoefficient4xPOW3(-0.000023328)
-      htg_energy_input_ratio_f_of_temp.setMinimumValueofx(-20.0)
-      htg_energy_input_ratio_f_of_temp.setMaximumValueofx(20.0)
-
-      htg_energy_input_ratio_f_of_flow = OpenStudio::Model::CurveQuadratic.new(model)
-      htg_energy_input_ratio_f_of_flow.setName("#{htg_coil.name} EIR Func of Flow Frac Curve")
-      htg_energy_input_ratio_f_of_flow.setCoefficient1Constant(1.3824)
-      htg_energy_input_ratio_f_of_flow.setCoefficient2x(-0.4336)
-      htg_energy_input_ratio_f_of_flow.setCoefficient3xPOW2(0.0512)
-      htg_energy_input_ratio_f_of_flow.setMinimumValueofx(0.0)
-      htg_energy_input_ratio_f_of_flow.setMaximumValueofx(1.0)
-
-      htg_part_load_fraction = OpenStudio::Model::CurveQuadratic.new(model)
-      htg_part_load_fraction.setName("#{htg_coil.name} PLR Correlation Curve")
-      htg_part_load_fraction.setCoefficient1Constant(0.85)
-      htg_part_load_fraction.setCoefficient2x(0.15)
-      htg_part_load_fraction.setCoefficient3xPOW2(0.0)
-      htg_part_load_fraction.setMinimumValueofx(0.0)
-      htg_part_load_fraction.setMaximumValueofx(1.0)
-
-      unless defrost_strategy == 'Resistive'
-        def_eir_f_of_temp = OpenStudio::Model::CurveBiquadratic.new(model)
-        def_eir_f_of_temp.setName("#{htg_coil.name} Defrost EIR Func of Temp Curve")
-        def_eir_f_of_temp.setCoefficient1Constant(0.297145)
-        def_eir_f_of_temp.setCoefficient2x(0.0430933)
-        def_eir_f_of_temp.setCoefficient3xPOW2(-0.000748766)
-        def_eir_f_of_temp.setCoefficient4y(0.00597727)
-        def_eir_f_of_temp.setCoefficient5yPOW2(0.000482112)
-        def_eir_f_of_temp.setCoefficient6xTIMESY(-0.000956448)
-        def_eir_f_of_temp.setMinimumValueofx(-23.33333)
-        def_eir_f_of_temp.setMaximumValueofx(29.44444)
-        def_eir_f_of_temp.setMinimumValueofy(-23.33333)
-        def_eir_f_of_temp.setMaximumValueofy(29.44444)
-      end
-    end
-
-    if type == 'PSZ-AC'
-      htg_coil.setMinimumOutdoorDryBulbTemperatureforCompressorOperation(-12.2)
-      htg_coil.setMaximumOutdoorDryBulbTemperatureforDefrostOperation(1.67)
-      htg_coil.setCrankcaseHeaterCapacity(50.0)
-      htg_coil.setMaximumOutdoorDryBulbTemperatureforCrankcaseHeaterOperation(4.4)
-      htg_coil.setDefrostControl('OnDemand')
-
-      def_eir_f_of_temp = OpenStudio::Model::CurveBiquadratic.new(model)
-      def_eir_f_of_temp.setName("#{htg_coil.name} Defrost EIR Func of Temp Curve")
-      def_eir_f_of_temp.setCoefficient1Constant(0.297145)
-      def_eir_f_of_temp.setCoefficient2x(0.0430933)
-      def_eir_f_of_temp.setCoefficient3xPOW2(-0.000748766)
-      def_eir_f_of_temp.setCoefficient4y(0.00597727)
-      def_eir_f_of_temp.setCoefficient5yPOW2(0.000482112)
-      def_eir_f_of_temp.setCoefficient6xTIMESY(-0.000956448)
-      def_eir_f_of_temp.setMinimumValueofx(-23.33333)
-      def_eir_f_of_temp.setMaximumValueofx(29.44444)
-      def_eir_f_of_temp.setMinimumValueofy(-23.33333)
-      def_eir_f_of_temp.setMaximumValueofy(29.44444)
-    end
-
-    htg_coil.setTotalHeatingCapacityFunctionofTemperatureCurve(htg_cap_f_of_temp) unless htg_cap_f_of_temp.nil?
-    htg_coil.setTotalHeatingCapacityFunctionofFlowFractionCurve(htg_cap_f_of_flow) unless htg_cap_f_of_flow.nil?
-    htg_coil.setEnergyInputRatioFunctionofTemperatureCurve(htg_energy_input_ratio_f_of_temp) unless htg_energy_input_ratio_f_of_temp.nil?
-    htg_coil.setEnergyInputRatioFunctionofFlowFractionCurve(htg_energy_input_ratio_f_of_flow) unless htg_energy_input_ratio_f_of_flow.nil?
-    htg_coil.setPartLoadFractionCorrelationCurve(htg_part_load_fraction) unless htg_part_load_fraction.nil?
-    htg_coil.setDefrostEnergyInputRatioFunctionofTemperatureCurve(def_eir_f_of_temp) unless def_eir_f_of_temp.nil?
-    htg_coil.setDefrostStrategy(defrost_strategy)
-    htg_coil.setDefrostControl('OnDemand')
-
-    return htg_coil
-  end
-
-  # sets defrost curve limits
-  #
-  # @param htg_coil [OpenStudio::Model::CoilHeatingDXSingleSpeed] a DX heating coil
-  # @return [Boolean] returns true if successful, false if not
-  def coil_heating_dx_single_speed_apply_defrost_eir_curve_limits(htg_coil)
-    return false unless htg_coil.defrostEnergyInputRatioFunctionofTemperatureCurve.is_initialized
-
-    def_eir_f_of_temp = htg_coil.defrostEnergyInputRatioFunctionofTemperatureCurve.get.to_CurveBiquadratic.get
-    def_eir_f_of_temp.setMinimumValueofx(12.77778)
-    def_eir_f_of_temp.setMaximumValueofx(23.88889)
-    def_eir_f_of_temp.setMinimumValueofy(21.11111)
-    def_eir_f_of_temp.setMaximumValueofy(46.11111)
-
-    return true
-  end
-end

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

@@ -1,53 +0,0 @@
-class Standard
-  # @!group CoilHeatingElectric
-
-  # Prototype CoilHeatingElectric object
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @param air_loop_node [<OpenStudio::Model::Node>] the coil will be placed on this node of the air loop
-  # @param name [String] the name of the system, or nil in which case it will be defaulted
-  # @param schedule [String] name of the availability schedule, or [<OpenStudio::Model::Schedule>] Schedule object, or nil in which case default to always on
-  # @param nominal_capacity [Double] rated nominal capacity
-  # @param efficiency [Double] rated heating efficiency
-  # @return [OpenStudio::Model::CoilHeatingElectric] the electric heating coil
-  def create_coil_heating_electric(model,
-                                   air_loop_node: nil,
-                                   name: 'Electric Htg Coil',
-                                   schedule: nil,
-                                   nominal_capacity: nil,
-                                   efficiency: 1.0)
-
-    htg_coil = OpenStudio::Model::CoilHeatingElectric.new(model)
-
-    # add to air loop if specified
-    htg_coil.addToNode(air_loop_node) unless air_loop_node.nil?
-
-    # set coil name
-    htg_coil.setName(name)
-
-    # set coil availability schedule
-    if schedule.nil?
-      # default always on
-      coil_availability_schedule = model.alwaysOnDiscreteSchedule
-    elsif schedule.instance_of?(String)
-      coil_availability_schedule = model_add_schedule(model, schedule)
-
-      if coil_availability_schedule.nil? && schedule == 'alwaysOffDiscreteSchedule'
-        coil_availability_schedule = model.alwaysOffDiscreteSchedule
-      elsif coil_availability_schedule.nil?
-        coil_availability_schedule = model.alwaysOnDiscreteSchedule
-      end
-    elsif !schedule.to_Schedule.empty?
-      coil_availability_schedule = schedule
-    end
-    htg_coil.setAvailabilitySchedule(coil_availability_schedule)
-
-    # set capacity
-    htg_coil.setNominalCapacity(nominal_capacity) unless nominal_capacity.nil?
-
-    # set efficiency
-    htg_coil.setEfficiency(efficiency) unless efficiency.nil?
-
-    return htg_coil
-  end
-end

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

@@ -1,72 +0,0 @@
-class Standard
-  # @!group CoilHeatingGas
-
-  # Prototype CoilHeatingGas object
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @param air_loop_node [<OpenStudio::Model::Node>] the coil will be placed on this node of the air loop
-  # @param name [String] the name of the system, or nil in which case it will be defaulted
-  # @param schedule [String] name of the availability schedule, or [<OpenStudio::Model::Schedule>] Schedule object, or nil in which case default to always on
-  # @param nominal_capacity [Double] rated nominal capacity
-  # @param efficiency [Double] rated heating efficiency
-  # @return [OpenStudio::Model::CoilHeatingGas] the gas heating coil
-  def create_coil_heating_gas(model,
-                              air_loop_node: nil,
-                              name: 'Gas Htg Coil',
-                              schedule: nil,
-                              nominal_capacity: nil,
-                              efficiency: 0.80)
-
-    htg_coil = OpenStudio::Model::CoilHeatingGas.new(model)
-
-    # add to air loop if specified
-    htg_coil.addToNode(air_loop_node) unless air_loop_node.nil?
-
-    # set coil name
-    htg_coil.setName(name)
-
-    # set coil availability schedule
-    if schedule.nil?
-      # default always on
-      coil_availability_schedule = model.alwaysOnDiscreteSchedule
-    elsif schedule.instance_of?(String)
-      coil_availability_schedule = model_add_schedule(model, schedule)
-
-      if coil_availability_schedule.nil? && schedule == 'alwaysOffDiscreteSchedule'
-        coil_availability_schedule = model.alwaysOffDiscreteSchedule
-      elsif coil_availability_schedule.nil?
-        coil_availability_schedule = model.alwaysOnDiscreteSchedule
-      end
-    elsif !schedule.to_Schedule.empty?
-      coil_availability_schedule = schedule
-    end
-    htg_coil.setAvailabilitySchedule(coil_availability_schedule)
-
-    # set capacity
-    htg_coil.setNominalCapacity(nominal_capacity) unless nominal_capacity.nil?
-
-    # set efficiency
-    htg_coil.setGasBurnerEfficiency(efficiency)
-
-    # defaults
-    if model.version < OpenStudio::VersionString.new('3.7.0')
-      htg_coil.setParasiticElectricLoad(0.0)
-      htg_coil.setParasiticGasLoad(0.0)
-    else
-      htg_coil.setOnCycleParasiticElectricLoad(0.0)
-      htg_coil.setOffCycleParasiticGasLoad(0.0)
-    end
-
-    return htg_coil
-  end
-
-  # Updates the efficiency of some gas heating coils per the prototype assumptions.
-  # Defaults to making no changes.
-  #
-  # @param coil_heating_gas [OpenStudio::Model::CoilHeatingGas] a gas heating coil
-  # @return [Boolean] returns true if successful, false if not
-  def coil_heating_gas_apply_prototype_efficiency(coil_heating_gas)
-    # do nothing
-    return true
-  end
-end

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

@@ -1,95 +0,0 @@
-class Standard
-  # @!group CoilHeatingWater
-
-  # Prototype CoilHeatingWater object
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @param hot_water_loop [<OpenStudio::Model::PlantLoop>] the coil will be placed on the demand side of this plant loop
-  # @param air_loop_node [<OpenStudio::Model::Node>] the coil will be placed on this node of the air loop
-  # @param name [String] the name of the coil, or nil in which case it will be defaulted
-  # @param schedule [String] name of the availability schedule, or [<OpenStudio::Model::Schedule>] Schedule object, or nil in which case default to always on
-  # @param rated_inlet_water_temperature [Double] rated inlet water temperature in degrees Celsius, default is hot water loop design exit temperature
-  # @param rated_outlet_water_temperature [Double] rated outlet water temperature in degrees Celsius, default is hot water loop design return temperature
-  # @param rated_inlet_air_temperature [Double] rated inlet air temperature in degrees Celsius, default is 16.6 (62F)
-  # @param rated_outlet_air_temperature [Double] rated outlet air temperature in degrees Celsius, default is 32.2 (90F)
-  # @param controller_convergence_tolerance [Double] controller convergence tolerance
-  # @return [OpenStudio::Model::CoilHeatingWater] the heating coil
-  def create_coil_heating_water(model,
-                                hot_water_loop,
-                                air_loop_node: nil,
-                                name: 'Htg Coil',
-                                schedule: nil,
-                                rated_inlet_water_temperature: nil,
-                                rated_outlet_water_temperature: nil,
-                                rated_inlet_air_temperature: 16.6,
-                                rated_outlet_air_temperature: 32.2,
-                                controller_convergence_tolerance: 0.1)
-
-    htg_coil = OpenStudio::Model::CoilHeatingWater.new(model)
-
-    # add to hot water loop
-    hot_water_loop.addDemandBranchForComponent(htg_coil)
-
-    # add to air loop if specified
-    htg_coil.addToNode(air_loop_node) unless air_loop_node.nil?
-
-    # set coil name
-    if name.nil?
-      htg_coil.setName('Htg Coil')
-    else
-      htg_coil.setName(name)
-    end
-
-    # set coil availability schedule
-    if schedule.nil?
-      # default always on
-      coil_availability_schedule = model.alwaysOnDiscreteSchedule
-    elsif schedule.instance_of?(String)
-      coil_availability_schedule = model_add_schedule(model, schedule)
-
-      if coil_availability_schedule.nil? && schedule == 'alwaysOffDiscreteSchedule'
-        coil_availability_schedule = model.alwaysOffDiscreteSchedule
-      elsif coil_availability_schedule.nil?
-        coil_availability_schedule = model.alwaysOnDiscreteSchedule
-      end
-    elsif !schedule.to_Schedule.empty?
-      coil_availability_schedule = schedule
-    end
-    htg_coil.setAvailabilitySchedule(coil_availability_schedule)
-
-    # rated water temperatures, use hot water loop temperatures if defined
-    if rated_inlet_water_temperature.nil?
-      rated_inlet_water_temperature = hot_water_loop.sizingPlant.designLoopExitTemperature
-      htg_coil.setRatedInletWaterTemperature(rated_inlet_water_temperature)
-    else
-      htg_coil.setRatedInletWaterTemperature(rated_inlet_water_temperature)
-    end
-    if rated_outlet_water_temperature.nil?
-      rated_outlet_water_temperature = rated_inlet_water_temperature - hot_water_loop.sizingPlant.loopDesignTemperatureDifference
-      htg_coil.setRatedOutletWaterTemperature(rated_outlet_water_temperature)
-    else
-      htg_coil.setRatedOutletWaterTemperature(rated_outlet_water_temperature)
-    end
-
-    # rated air temperatures
-    if rated_inlet_air_temperature.nil?
-      htg_coil.setRatedInletAirTemperature(16.6)
-    else
-      htg_coil.setRatedInletAirTemperature(rated_inlet_air_temperature)
-    end
-    if rated_outlet_air_temperature.nil?
-      htg_coil.setRatedOutletAirTemperature(32.2)
-    else
-      htg_coil.setRatedOutletAirTemperature(rated_outlet_air_temperature)
-    end
-
-    # coil controller properties
-    # @note These inputs will get overwritten if addToNode or addDemandBranchForComponent is called on the htg_coil object after this
-    htg_coil_controller = htg_coil.controllerWaterCoil.get
-    htg_coil_controller.setName("#{htg_coil.name} Controller")
-    htg_coil_controller.setMinimumActuatedFlow(0.0)
-    htg_coil_controller.setControllerConvergenceTolerance(controller_convergence_tolerance) unless controller_convergence_tolerance.nil?
-
-    return htg_coil
-  end
-end