openstudio-standards 0.8.4 → 0.8.5.rc1

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

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

@@ -1,125 +0,0 @@
-class Standard
-  # @!group CoilHeatingWaterToAirHeatPumpEquationFit
-
-  # Prototype CoilHeatingWaterToAirHeatPumpEquationFit 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 heating coefficient of performance
-  # @return [OpenStudio::Model::CoilHeatingWaterToAirHeatPumpEquationFit] the heating coil
-  def create_coil_heating_water_to_air_heat_pump_equation_fit(model,
-                                                              plant_loop,
-                                                              air_loop_node: nil,
-                                                              name: 'Water-to-Air HP Htg Coil',
-                                                              type: nil,
-                                                              cop: 4.2)
-
-    htg_coil = OpenStudio::Model::CoilHeatingWaterToAirHeatPumpEquationFit.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)
-
-    # add to plant loop
-    if plant_loop.nil?
-      OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', 'No plant loop supplied for heating coil')
-      return false
-    end
-    plant_loop.addDemandBranchForComponent(htg_coil)
-
-    # set coil cop
-    if cop.nil?
-      htg_coil.setRatedHeatingCoefficientofPerformance(4.2)
-    else
-      htg_coil.setRatedHeatingCoefficientofPerformance(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')
-        htg_coil.setHeatingCapacityCoefficient1(0.237847462869254)
-        htg_coil.setHeatingCapacityCoefficient2(-3.35823796081626)
-        htg_coil.setHeatingCapacityCoefficient3(3.80640467406376)
-        htg_coil.setHeatingCapacityCoefficient4(0.179200417311554)
-        htg_coil.setHeatingCapacityCoefficient5(0.12860719846082)
-        htg_coil.setHeatingPowerConsumptionCoefficient1(-3.79175529243238)
-        htg_coil.setHeatingPowerConsumptionCoefficient2(3.38799239505527)
-        htg_coil.setHeatingPowerConsumptionCoefficient3(1.5022612076303)
-        htg_coil.setHeatingPowerConsumptionCoefficient4(-0.177653510577989)
-        htg_coil.setHeatingPowerConsumptionCoefficient5(-0.103079864171839)
-      else
-        if model.getCurveByName('Water to Air Heat Pump Heating Capacity Curve').is_initialized
-          heating_capacity_curve = model.getCurveByName('Water to Air Heat Pump Heating Capacity Curve').get
-          heating_capacity_curve = heating_capacity_curve.to_CurveQuadLinear.get
-        else
-          heating_capacity_curve = OpenStudio::Model::CurveQuadLinear.new(model)
-          heating_capacity_curve.setName('Water to Air Heat Pump Heating Capacity Curve')
-          heating_capacity_curve.setCoefficient1Constant(0.237847462869254)
-          heating_capacity_curve.setCoefficient2w(-3.35823796081626)
-          heating_capacity_curve.setCoefficient3x(3.80640467406376)
-          heating_capacity_curve.setCoefficient4y(0.179200417311554)
-          heating_capacity_curve.setCoefficient5z(0.12860719846082)
-          heating_capacity_curve.setMinimumValueofw(-100)
-          heating_capacity_curve.setMaximumValueofw(100)
-          heating_capacity_curve.setMinimumValueofx(-100)
-          heating_capacity_curve.setMaximumValueofx(100)
-          heating_capacity_curve.setMinimumValueofy(0)
-          heating_capacity_curve.setMaximumValueofy(100)
-          heating_capacity_curve.setMinimumValueofz(0)
-          heating_capacity_curve.setMaximumValueofz(100)
-        end
-        htg_coil.setHeatingCapacityCurve(heating_capacity_curve)
-
-        if model.getCurveByName('Water to Air Heat Pump Heating Power Consumption Curve').is_initialized
-          heating_power_consumption_curve = model.getCurveByName('Water to Air Heat Pump Heating Power Consumption Curve').get
-          heating_power_consumption_curve = heating_power_consumption_curve.to_CurveQuadLinear.get
-        else
-          heating_power_consumption_curve = OpenStudio::Model::CurveQuadLinear.new(model)
-          heating_power_consumption_curve.setName('Water to Air Heat Pump Heating Power Consumption Curve')
-          heating_power_consumption_curve.setCoefficient1Constant(-3.79175529243238)
-          heating_power_consumption_curve.setCoefficient2w(3.38799239505527)
-          heating_power_consumption_curve.setCoefficient3x(1.5022612076303)
-          heating_power_consumption_curve.setCoefficient4y(-0.177653510577989)
-          heating_power_consumption_curve.setCoefficient5z(-0.103079864171839)
-          heating_power_consumption_curve.setMinimumValueofw(-100)
-          heating_power_consumption_curve.setMaximumValueofw(100)
-          heating_power_consumption_curve.setMinimumValueofx(-100)
-          heating_power_consumption_curve.setMaximumValueofx(100)
-          heating_power_consumption_curve.setMinimumValueofy(0)
-          heating_power_consumption_curve.setMaximumValueofy(100)
-          heating_power_consumption_curve.setMinimumValueofz(0)
-          heating_power_consumption_curve.setMaximumValueofz(100)
-        end
-        htg_coil.setHeatingPowerConsumptionCurve(heating_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
-        htg_coil.setPartLoadFractionCorrelationCurve(part_load_correlation_curve)
-      end
-    end
-
-    return htg_coil
-  end
-end

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

@@ -1,17 +0,0 @@
-class Standard
-  # @!group ControllerWaterCoil
-
-  # Sets the convergence tolerance to 0.0001 deltaC for all hot water coils.
-  #
-  # @param controller_water_coil [OpenStudio::Model::ControllerWaterCoil] controller water coil object
-  # @return [Boolean] returns true if successful, false if not
-  # @todo Figure out what the reason for this is, because it seems like a workaround for an E+ bug that was probably addressed long ago.
-  def controller_water_coil_set_convergence_limits(controller_water_coil)
-    controller_action = controller_water_coil.action
-    if controller_action.is_initialized && controller_action.get == 'Normal'
-      controller_water_coil.setControllerConvergenceTolerance(0.0001)
-    end
-
-    return true
-  end
-end

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

@@ -1,90 +0,0 @@
-class Standard
-  # Add transformers for some prototypes
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @param wired_lighting_frac [Double] the wired lighting fraction, 0-1
-  # @param transformer_size [Double] the transformer size in VA
-  # @param transformer_efficiency [Double] the transformer efficiency, 0-1
-  # @param excluded_interiorequip_key [String] key to exclude
-  # @param excluded_interiorequip_meter [String] meter to exclude
-  # @return [OpenStudio::Model::ElectricLoadCenterTransformer] the transformer object
-  def model_add_transformer(model,
-                            wired_lighting_frac: nil,
-                            transformer_size: nil,
-                            transformer_efficiency: nil,
-                            excluded_interiorequip_key: '',
-                            excluded_interiorequip_meter: nil)
-    # throw an error if transformer properties are missing
-    if wired_lighting_frac.nil? || transformer_size.nil? || transformer_efficiency.nil?
-      OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.transformers', "Either 'wired_lighting_frac', 'transformer_size', or 'transformer_efficiency' is unspecified.  Cannot add transformer.")
-      return false
-    end
-
-    # @todo default values are for testing only
-    # ems sensor for interior lighting
-    facility_int_ltg = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'InteriorLights:Electricity')
-    facility_int_ltg.setName('Facility_Int_LTG')
-
-    # declaire ems variable for transformer wired lighting portion
-    wired_ltg_var = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'Wired_LTG')
-
-    # ems program for transformer load
-    transformer_load_prog = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-    transformer_load_prog.setName('Transformer_Load_Prog')
-    transformer_load_prog_body = <<-EMS
-    SET Wired_LTG = Facility_Int_LTG*#{wired_lighting_frac}
-    EMS
-    transformer_load_prog.setBody(transformer_load_prog_body)
-
-    # ems program calling manager
-    transformer_load_prog_manager = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
-    transformer_load_prog_manager.setName('Transformer_Load_Prog_Manager')
-    transformer_load_prog_manager.setCallingPoint('AfterPredictorAfterHVACManagers')
-    transformer_load_prog_manager.addProgram(transformer_load_prog)
-
-    # ems output variable
-    wired_ltg_emsout = OpenStudio::Model::EnergyManagementSystemOutputVariable.new(model, wired_ltg_var)
-    wired_ltg_emsout.setName('Wired_LTG')
-    wired_ltg_emsout.setTypeOfDataInVariable('Summed')
-    wired_ltg_emsout.setUpdateFrequency('ZoneTimeStep')
-    wired_ltg_emsout.setUnits('J')
-
-    # meter for ems output
-    wired_ltg_meter = OpenStudio::Model::MeterCustom.new(model)
-    wired_ltg_meter.setName('Wired_LTG_Electricity')
-    wired_ltg_meter.setFuelType('Electricity')
-    wired_ltg_meter.addKeyVarGroup('', 'Wired_LTG')
-
-    # meter for wired int equip
-    unless excluded_interiorequip_meter.nil?
-      wired_int_equip_meter = OpenStudio::Model::MeterCustomDecrement.new(model, 'InteriorEquipment:Electricity')
-      wired_int_equip_meter.setName('Wired_Int_EQUIP')
-      wired_int_equip_meter.setFuelType('Electricity')
-      wired_int_equip_meter.addKeyVarGroup(excluded_interiorequip_key, excluded_interiorequip_meter)
-    end
-
-    # add transformer
-    transformer = OpenStudio::Model::ElectricLoadCenterTransformer.new(model)
-    transformer.setName('Transformer_1')
-    transformer.setAvailabilitySchedule(model.alwaysOnDiscreteSchedule)
-    transformer.setTransformerUsage('PowerInFromGrid')
-    transformer.setRatedCapacity(transformer_size)
-    transformer.setPhase('3')
-    transformer.setConductorMaterial('Aluminum')
-    transformer.setFullLoadTemperatureRise(150)
-    transformer.setFractionofEddyCurrentLosses(0.1)
-    transformer.setPerformanceInputMethod('NominalEfficiency')
-    transformer.setNameplateEfficiency(transformer_efficiency)
-    transformer.setPerUnitLoadforNameplateEfficiency(0.35)
-    transformer.setReferenceTemperatureforNameplateEfficiency(75)
-    transformer.setConsiderTransformerLossforUtilityCost(true)
-    transformer.addMeter('Wired_LTG_Electricity')
-    if excluded_interiorequip_meter.nil?
-      transformer.addMeter('InteriorEquipment:Electricity') # by default, add this as the second meter
-    else
-      transformer.addMeter('Wired_Int_EQUIP')
-    end
-
-    return transformer
-  end
-end

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

@@ -1,4 +0,0 @@
-# Prototype pump calculation methods that are the same regardless of pump type.
-module PrototypePump
-  # @!group Pump
-end

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

@@ -1,70 +0,0 @@
-class Standard
-  include Pump
-
-  # Determine and set type of part load control type for heating and chilled
-  # water variable speed pumps
-  #
-  # @param pump [OpenStudio::Model::PumpVariableSpeed] OpenStudio pump object
-  # @return [Boolean] Returns true if applicable, false otherwise
-  def pump_variable_speed_control_type(pump)
-    # Get plant loop
-    plant_loop = pump.plantLoop.get
-
-    # Get plant loop type
-    plant_loop_type = plant_loop.sizingPlant.loopType
-    return false unless plant_loop_type == 'Heating' || plant_loop_type == 'Cooling'
-
-    # Get rated pump power
-    if pump.ratedPowerConsumption.is_initialized
-      pump_rated_power_w = pump.ratedPowerConsumption.get
-    elsif pump.autosizedRatedPowerConsumption.is_initialized
-      pump_rated_power_w = pump.autosizedRatedPowerConsumption.get
-    else
-      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Pump', "For #{pump.name}, could not find rated pump power consumption, cannot determine w per gpm correctly.")
-      return false
-    end
-
-    # Get nominal nameplate HP
-    pump_nominal_hp = pump_rated_power_w * pump.motorEfficiency / 745.7
-
-    # Assign peformance curves
-    control_type = pump_variable_speed_get_control_type(pump, plant_loop_type, pump_nominal_hp)
-
-    # Set pump part load performance curve coefficients
-    pump_variable_speed_set_control_type(pump, control_type) if control_type
-
-    return true
-  end
-
-  # Determine type of pump part load control type
-  #
-  # @param pump [OpenStudio::Model::PumpVariableSpeed] OpenStudio pump object
-  # @param plant_loop_type [String] Type of plant loop
-  # @param pump_nominal_hp [Float] Pump nominal horsepower
-  # @return [String] Pump part load control type
-  def pump_variable_speed_get_control_type(pump, plant_loop_type, pump_nominal_hp)
-    # Get plant loop
-    plant_loop = pump.plantLoop.get
-
-    # Default assumptions are based on ASHRAE 90.1-2010 Appendix G (G3.1.3.5 and G3.1.3.10)
-    case plant_loop_type
-      when 'Heating'
-        # Determine the area served by the plant loop
-        area_served_m2 = plant_loop_total_floor_area_served(plant_loop)
-        area_served_ft2 = OpenStudio.convert(area_served_m2, 'm^2', 'ft^2').get
-
-        return 'VSD No Reset' if area_served_ft2 > 120_000
-
-        # else
-        return 'Riding Curve'
-      when 'Cooling'
-        # Get plant loop capacity capacity
-        cooling_capacity_w = plant_loop_total_cooling_capacity(plant_loop)
-
-        return 'VSD No Reset' if cooling_capacity_w >= 300
-
-        # else
-        return 'Riding Curve'
-    end
-  end
-end