openstudio-standards 0.8.3 → 0.8.5.rc1

data/lib/openstudio-standards/hvac/components/central_air_source_heat_pump.rb

@@ -0,0 +1,220 @@
+module OpenstudioStandards
+  # The HVAC module provides methods create, modify, and get information about HVAC systems in the model
+  module HVAC
+    # @!group Component:CentralAirSourceHeatPump
+    # Methods to create central air source heat pumps
+
+    # Create CentralAirSourceHeatPump object using PlantComponentUserDefined
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @param hot_water_loop [<OpenStudio::Model::PlantLoop>] a hot water loop served by the central air source heat pump
+    # @param name [String] the name of the central air source heat pump, or nil in which case it will be defaulted
+    # @param cop [Double] air source heat pump rated cop
+    # @return [OpenStudio::Model::PlantComponentUserDefined] a plant component representing the air source heat pump
+    # @todo update curve to better calculate based on the rated cop
+    # @todo refactor to use the new EnergyPlus central air source heat pump object when it becomes available
+    #   set hot_water_loop to an optional keyword argument, and add input keyword arguments for other characteristics
+    def self.create_central_air_source_heat_pump(model,
+                                                 hot_water_loop,
+                                                 name: nil,
+                                                 cop: 3.65)
+
+      # create the PlantComponentUserDefined object as a proxy for the Central Air Source Heat Pump
+      plant_comp = OpenStudio::Model::PlantComponentUserDefined.new(model)
+      if name.nil?
+        if hot_water_loop.nil?
+          name = 'Central Air Source Heat Pump'
+        else
+          name = "#{hot_water_loop.name} Central Air Source Heat Pump"
+        end
+      end
+
+      # change equipment name for EMS validity
+      plant_comp.setName(OpenstudioStandards::HVAC.ems_friendly_name(name))
+
+      # set plant component properties
+      plant_comp.setPlantLoadingMode('MeetsLoadWithNominalCapacityHiOutLimit')
+      plant_comp.setPlantLoopFlowRequestMode('NeedsFlowIfLoopOn')
+
+      # plant design volume flow rate internal variable
+      vdot_des_int_var = OpenStudio::Model::EnergyManagementSystemInternalVariable.new(model, 'Plant Design Volume Flow Rate')
+      vdot_des_int_var.setName("#{plant_comp.name}_Vdot_Des_Int_Var")
+      vdot_des_int_var.setInternalDataIndexKeyName(hot_water_loop.handle.to_s)
+
+      # inlet temperature internal variable
+      tin_int_var = OpenStudio::Model::EnergyManagementSystemInternalVariable.new(model, 'Inlet Temperature for Plant Connection 1')
+      tin_int_var.setName("#{plant_comp.name}_Tin_Int_Var")
+      tin_int_var.setInternalDataIndexKeyName(plant_comp.handle.to_s)
+
+      # inlet mass flow rate internal variable
+      mdot_int_var = OpenStudio::Model::EnergyManagementSystemInternalVariable.new(model, 'Inlet Mass Flow Rate for Plant Connection 1')
+      mdot_int_var.setName("#{plant_comp.name}_Mdot_Int_Var")
+      mdot_int_var.setInternalDataIndexKeyName(plant_comp.handle.to_s)
+
+      # inlet specific heat internal variable
+      cp_int_var = OpenStudio::Model::EnergyManagementSystemInternalVariable.new(model, 'Inlet Specific Heat for Plant Connection 1')
+      cp_int_var.setName("#{plant_comp.name}_Cp_Int_Var")
+      cp_int_var.setInternalDataIndexKeyName(plant_comp.handle.to_s)
+
+      # inlet density internal variable
+      rho_int_var = OpenStudio::Model::EnergyManagementSystemInternalVariable.new(model, 'Inlet Density for Plant Connection 1')
+      rho_int_var.setName("#{plant_comp.name}_rho_Int_Var")
+      rho_int_var.setInternalDataIndexKeyName(plant_comp.handle.to_s)
+
+      # load request internal variable
+      load_int_var = OpenStudio::Model::EnergyManagementSystemInternalVariable.new(model, 'Load Request for Plant Connection 1')
+      load_int_var.setName("#{plant_comp.name}_Load_Int_Var")
+      load_int_var.setInternalDataIndexKeyName(plant_comp.handle.to_s)
+
+      # supply outlet node setpoint temperature sensor
+      setpt_mgr_sch_sen = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Schedule Value')
+      setpt_mgr_sch_sen.setName("#{plant_comp.name}_Setpt_Mgr_Temp_Sen")
+      hot_water_loop.supplyOutletNode.setpointManagers.each do |m|
+        if m.to_SetpointManagerScheduled.is_initialized
+          setpt_mgr_sch_sen.setKeyName(m.to_SetpointManagerScheduled.get.schedule.name.to_s)
+        end
+      end
+
+      # outdoor air drybulb temperature sensor
+      oa_dbt_sen = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Site Outdoor Air Drybulb Temperature')
+      oa_dbt_sen.setName("#{plant_comp.name}_OA_DBT_Sen")
+      oa_dbt_sen.setKeyName('Environment')
+
+      # minimum mass flow rate actuator
+      mdot_min_act = plant_comp.minimumMassFlowRateActuator.get
+      mdot_min_act.setName("#{plant_comp.name}_Mdot_Min_Act")
+
+      # maximum mass flow rate actuator
+      mdot_max_act = plant_comp.maximumMassFlowRateActuator.get
+      mdot_max_act.setName("#{plant_comp.name}_Mdot_Max_Act")
+
+      # design flow rate actuator
+      vdot_des_act = plant_comp.designVolumeFlowRateActuator.get
+      vdot_des_act.setName("#{plant_comp.name}_Vdot_Des_Act")
+
+      # minimum loading capacity actuator
+      cap_min_act = plant_comp.minimumLoadingCapacityActuator.get
+      cap_min_act.setName("#{plant_comp.name}_Cap_Min_Act")
+
+      # maximum loading capacity actuator
+      cap_max_act = plant_comp.maximumLoadingCapacityActuator.get
+      cap_max_act.setName("#{plant_comp.name}_Cap_Max_Act")
+
+      # optimal loading capacity actuator
+      cap_opt_act = plant_comp.optimalLoadingCapacityActuator.get
+      cap_opt_act.setName("#{plant_comp.name}_Cap_Opt_Act")
+
+      # outlet temperature actuator
+      tout_act = plant_comp.outletTemperatureActuator.get
+      tout_act.setName("#{plant_comp.name}_Tout_Act")
+
+      # mass flow rate actuator
+      mdot_req_act = plant_comp.massFlowRateActuator.get
+      mdot_req_act.setName("#{plant_comp.name}_Mdot_Req_Act")
+
+      # heat pump COP curve
+      constant_coeff = 1.932 + (cop - 3.65)
+      hp_cop_curve = OpenStudio::Model::CurveQuadratic.new(model)
+      hp_cop_curve.setCoefficient1Constant(constant_coeff)
+      hp_cop_curve.setCoefficient2x(0.227674286)
+      hp_cop_curve.setCoefficient3xPOW2(-0.007313143)
+      hp_cop_curve.setMinimumValueofx(1.67)
+      hp_cop_curve.setMaximumValueofx(12.78)
+      hp_cop_curve.setInputUnitTypeforX('Temperature')
+      hp_cop_curve.setOutputUnitType('Dimensionless')
+
+      # heat pump COP curve index variable
+      hp_cop_curve_idx_var = OpenStudio::Model::EnergyManagementSystemCurveOrTableIndexVariable.new(model, hp_cop_curve)
+
+      # high outlet temperature limit actuator
+      tout_max_act = OpenStudio::Model::EnergyManagementSystemActuator.new(plant_comp, 'Plant Connection 1', 'High Outlet Temperature Limit')
+      tout_max_act.setName("#{plant_comp.name}_Tout_Max_Act")
+
+      # init program
+      init_pgrm = plant_comp.plantInitializationProgram.get
+      init_pgrm.setName("#{plant_comp.name}_Init_Pgrm")
+      init_pgrm_body = <<-EMS
+      SET Loop_Exit_Temp = #{hot_water_loop.sizingPlant.designLoopExitTemperature}
+      SET Loop_Delta_Temp = #{hot_water_loop.sizingPlant.loopDesignTemperatureDifference}
+      SET Cp = @CPHW Loop_Exit_Temp
+      SET rho = @RhoH2O Loop_Exit_Temp
+      SET #{vdot_des_act.handle} = #{vdot_des_int_var.handle}
+      SET #{mdot_min_act.handle} = 0
+      SET Mdot_Max = #{vdot_des_int_var.handle} * rho
+      SET #{mdot_max_act.handle} = Mdot_Max
+      SET Cap = Mdot_Max * Cp * Loop_Delta_Temp
+      SET #{cap_min_act.handle} = 0
+      SET #{cap_max_act.handle} = Cap
+      SET #{cap_opt_act.handle} = 1 * Cap
+      EMS
+      init_pgrm.setBody(init_pgrm_body)
+
+      # sim program
+      sim_pgrm = plant_comp.plantSimulationProgram.get
+      sim_pgrm.setName("#{plant_comp.name}_Sim_Pgrm")
+      sim_pgrm_body = <<-EMS
+      SET tmp = #{load_int_var.handle}
+      SET tmp = #{tin_int_var.handle}
+      SET tmp = #{mdot_int_var.handle}
+      SET #{tout_max_act.handle} = 75.0
+      IF #{load_int_var.handle} == 0
+      SET #{tout_act.handle} = #{tin_int_var.handle}
+      SET #{mdot_req_act.handle} = 0
+      SET Elec = 0
+      RETURN
+      ENDIF
+      IF #{load_int_var.handle} >= #{cap_max_act.handle}
+      SET Qdot = #{cap_max_act.handle}
+      SET Mdot = #{mdot_max_act.handle}
+      SET #{mdot_req_act.handle} = Mdot
+      SET #{tout_act.handle} = (Qdot / (Mdot * #{cp_int_var.handle})) + #{tin_int_var.handle}
+      IF #{tout_act.handle} > #{tout_max_act.handle}
+      SET #{tout_act.handle} = #{tout_max_act.handle}
+      SET Qdot = Mdot * #{cp_int_var.handle} * (#{tout_act.handle} - #{tin_int_var.handle})
+      ENDIF
+      ELSE
+      SET Qdot = #{load_int_var.handle}
+      SET #{tout_act.handle} = #{setpt_mgr_sch_sen.handle}
+      SET Mdot = Qdot / (#{cp_int_var.handle} * (#{tout_act.handle} - #{tin_int_var.handle}))
+      SET #{mdot_req_act.handle} = Mdot
+      ENDIF
+      SET Tdb = #{oa_dbt_sen.handle}
+      SET COP = @CurveValue #{hp_cop_curve_idx_var.handle} Tdb
+      SET EIR = 1 / COP
+      SET Pwr = Qdot * EIR
+      SET Elec = Pwr * SystemTimestep * 3600
+      EMS
+      sim_pgrm.setBody(sim_pgrm_body)
+
+      # init program calling manager
+      init_mgr = plant_comp.plantInitializationProgramCallingManager.get
+      init_mgr.setName("#{plant_comp.name}_Init_Pgrm_Mgr")
+
+      # sim program calling manager
+      sim_mgr = plant_comp.plantSimulationProgramCallingManager.get
+      sim_mgr.setName("#{plant_comp.name}_Sim_Pgrm_Mgr")
+
+      # metered output variable
+      elec_mtr_out_var = OpenStudio::Model::EnergyManagementSystemMeteredOutputVariable.new(model, "#{plant_comp.name} Electricity Consumption")
+      elec_mtr_out_var.setName("#{plant_comp.name} Electricity Consumption")
+      elec_mtr_out_var.setEMSVariableName('Elec')
+      elec_mtr_out_var.setUpdateFrequency('SystemTimestep')
+      elec_mtr_out_var.setString(4, sim_pgrm.handle.to_s)
+      elec_mtr_out_var.setResourceType('Electricity')
+      elec_mtr_out_var.setGroupType('HVAC')
+      elec_mtr_out_var.setEndUseCategory('Heating')
+      elec_mtr_out_var.setEndUseSubcategory('')
+      elec_mtr_out_var.setUnits('J')
+
+      # add to supply side of hot water loop if specified
+      hot_water_loop&.addSupplyBranchForComponent(plant_comp)
+
+      # add operation scheme
+      htg_op_scheme = OpenStudio::Model::PlantEquipmentOperationHeatingLoad.new(model)
+      htg_op_scheme.addEquipment(1000000000.0, plant_comp)
+      hot_water_loop.setPlantEquipmentOperationHeatingLoad(htg_op_scheme)
+
+      return plant_comp
+    end
+  end
+end

data/lib/openstudio-standards/hvac/components/chiller.rb

@@ -0,0 +1,25 @@
+module OpenstudioStandards
+  # The HVAC module provides methods create, modify, and get information about HVAC systems in the model
+  module HVAC
+    # @!group Component:Chiller
+    # Methods to create, modify, and get information about chillers
+
+    # Return the capacity in W of a ChillerElectricEIR
+    #
+    # @param chiller_electric_eir [OpenStudio::Model::ChillerElectricEIR] chiller object
+    # @return [Double] capacity in W
+    def self.chiller_electric_get_capacity(chiller_electric_eir)
+      capacity_w = nil
+      if chiller_electric_eir.referenceCapacity.is_initialized
+        capacity_w = chiller_electric_eir.referenceCapacity.get
+      elsif chiller_electric_eir.autosizedReferenceCapacity.is_initialized
+        capacity_w = chiller_electric_eir.autosizedReferenceCapacity.get
+      else
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.HVAC.chiller', "For #{chiller_electric_eir.name} capacity is not available.")
+        return capacity_w
+      end
+
+      return capacity_w
+    end
+  end
+end

data/lib/openstudio-standards/hvac/components/coil.rb

@@ -0,0 +1,276 @@
+module OpenstudioStandards
+  # The HVAC module provides methods create, modify, and get information about HVAC systems in the model
+  module HVAC
+    # @!group Component:Coil
+    # Methods to create, modify, and get information about HVAC coil objects
+
+    # Finds the subcategory.  Possible choices are:
+    # Single Package, Split System, PTAC, or PTHP
+    #
+    # @param coil_dx [OpenStudio::Model::StraightComponent] coil cooling object, allowable types:
+    #   CoilCoolingDXSingleSpeed, CoilCoolingDXTwoSpeed, CoilCoolingDXMultiSpeed
+    # @return [String] the coil_dx_subcategory(coil_dx)
+    # @todo Add add split system vs single package to model object
+    def self.coil_dx_subcategory(coil_dx)
+      sub_category = 'Single Package'
+
+      # Fallback to the name, mainly for library export
+      if coil_dx.name.get.to_s.include?('Single Package')
+        sub_category = 'Single Package'
+      elsif coil_dx.name.get.to_s.include?('Split System') ||
+            coil_dx.name.get.to_s.include?('Central Air Source HP')
+        sub_category = 'Split System'
+      elsif coil_dx.name.get.to_s.include?('Minisplit HP')
+        sub_category = 'Minisplit System'
+      elsif coil_dx.name.get.to_s.include?('CRAC')
+        sub_category = 'CRAC'
+      end
+
+      if coil_dx.airLoopHVAC.empty? && coil_dx.containingZoneHVACComponent.is_initialized
+        containing_comp = coil_dx.containingZoneHVACComponent.get
+        # PTHP
+        if containing_comp.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
+          sub_category = 'PTHP'
+        end
+        # @todo Add other zone hvac systems
+      end
+
+      return sub_category
+    end
+
+    # Determine if it is a heat pump
+    #
+    # @param coil_dx [OpenStudio::Model::StraightComponent] coil cooling object, allowable types:
+    #   CoilCoolingDXSingleSpeed, CoilCoolingDXTwoSpeed, CoilCoolingDXMultiSpeed
+    # @return [Boolean] returns true if it is a heat pump, false if not
+    def self.coil_dx_heat_pump?(coil_dx)
+      heat_pump = false
+
+      if coil_dx.airLoopHVAC.empty?
+        if coil_dx.containingHVACComponent.is_initialized
+          containing_comp = coil_dx.containingHVACComponent.get
+          if containing_comp.to_AirLoopHVACUnitarySystem.is_initialized
+            htg_coil = containing_comp.to_AirLoopHVACUnitarySystem.get.heatingCoil
+            unless htg_coil.empty?
+              heat_pump = ['OS_Coil_Heating_DX_SingleSpeed',
+                           'OS_Coil_Heating_DX_MultiSpeed',
+                           'OS_Coil_Heating_DX_VariableSpeed',
+                           'OS_Coil_Heating_WaterToAirHeatPump_EquationFit'].include?(htg_coil.get.iddObjectType.valueName.to_s)
+            end
+          elsif containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
+            heat_pump = true
+          elsif containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.is_initialized
+            htg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.get.heatingCoil
+            if htg_coil.to_CoilHeatingDXMultiSpeed.is_initialized then heat_pump = true end
+          end
+        elsif coil_dx.containingZoneHVACComponent.is_initialized
+          containing_comp = coil_dx.containingZoneHVACComponent.get
+          # PTHP
+          if containing_comp.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
+            heat_pump = true
+          end
+          # @todo Add other zone hvac systems
+        end
+      else
+        if !coil_dx.airLoopHVAC.get.supplyComponents('OS:Coil:Heating:DX:SingleSpeed'.to_IddObjectType).empty? ||
+           !coil_dx.airLoopHVAC.get.supplyComponents('OS:Coil:Heating:DX:MultiSpeed'.to_IddObjectType).empty? ||
+           !coil_dx.airLoopHVAC.get.supplyComponents('OS:Coil:Heating:DX:VariableSpeed'.to_IddObjectType).empty?
+          heat_pump = true
+        end
+      end
+
+      return heat_pump
+    end
+
+    # Determine the heating type for a dx cooling coil. Possible choices are: 'Electric Resistance or None', 'All Other'.
+    #
+    # @param coil_dx [OpenStudio::Model::StraightComponent] coil cooling object, allowable types:
+    #   CoilCoolingDXSingleSpeed, CoilCoolingDXTwoSpeed, CoilCoolingDXMultiSpeed
+    # @return [String] the heating type
+    def self.coil_dx_heating_type(coil_dx)
+      htg_type = nil
+
+      # If Unitary or Zone HVAC (could be a unitary system on an air loop)
+      if coil_dx.airLoopHVAC.empty?
+        if coil_dx.containingHVACComponent.is_initialized
+          containing_comp = coil_dx.containingHVACComponent.get
+          if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
+            htg_type = 'Electric Resistance or None'
+          elsif containing_comp.to_AirLoopHVACUnitarySystem.is_initialized
+            htg_coil = containing_comp.to_AirLoopHVACUnitarySystem.get.heatingCoil
+            if containing_comp.name.to_s.include? 'Minisplit'
+              htg_type = 'All Other'
+            elsif htg_coil.is_initialized
+              htg_coil = htg_coil.get
+              if htg_coil.to_CoilHeatingElectric.is_initialized || htg_coil.to_CoilHeatingDXMultiSpeed.is_initialized
+                htg_type = 'Electric Resistance or None'
+              elsif htg_coil.to_CoilHeatingGas.is_initialized || htg_coil.to_CoilHeatingGasMultiStage.is_initialized || htg_coil.to_CoilHeatingWater.is_initialized
+                htg_type = 'All Other'
+              end
+            else
+              htg_type = 'Electric Resistance or None'
+            end
+          elsif containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.is_initialized
+            htg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.get.heatingCoil
+            supp_htg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.get.supplementalHeatingCoil
+            if htg_coil.to_CoilHeatingDXMultiSpeed.is_initialized || supp_htg_coil.to_CoilHeatingElectric.is_initialized
+              htg_type = 'Electric Resistance or None'
+            elsif htg_coil.to_CoilHeatingGas.is_initialized || htg_coil.to_CoilHeatingGasMultiStage.is_initialized || htg_coil.to_CoilHeatingWater.is_initialized
+              htg_type = 'All Other'
+            end
+          end
+          # @todo Add other unitary systems
+        elsif coil_dx.containingZoneHVACComponent.is_initialized
+          containing_comp = coil_dx.containingZoneHVACComponent.get
+          # PTAC
+          if containing_comp.to_ZoneHVACPackagedTerminalAirConditioner.is_initialized
+            htg_coil = containing_comp.to_ZoneHVACPackagedTerminalAirConditioner.get.heatingCoil
+            if htg_coil.to_CoilHeatingElectric.is_initialized
+              htg_type = 'Electric Resistance or None'
+            elsif htg_coil.to_CoilHeatingGas.is_initialized || htg_coil.to_CoilHeatingGasMultiStage.is_initialized || htg_coil.to_CoilHeatingWater.is_initialized
+              htg_type = 'All Other'
+            end
+          # PTHP
+          elsif containing_comp.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
+            htg_type = 'Electric Resistance or None'
+          end
+          # @todo Add other zone hvac systems
+        end
+      end
+
+      # If on an AirLoop
+      if coil_dx.airLoopHVAC.is_initialized
+        air_loop = coil_dx.airLoopHVAC.get
+        htg_type = if !air_loop.supplyComponents('OS:Coil:Heating:Gas'.to_IddObjectType).empty?
+                     'All Other'
+                   elsif !air_loop.supplyComponents('OS:Coil:Heating:Water'.to_IddObjectType).empty?
+                     'All Other'
+                   elsif !air_loop.supplyComponents('OS:Coil:Heating:DX:SingleSpeed'.to_IddObjectType).empty?
+                     'All Other'
+                   elsif !air_loop.supplyComponents('OS:Coil:Heating:DX:MultiSpeed'.to_IddObjectType).empty?
+                     'All Other'
+                   elsif !air_loop.supplyComponents('OS:Coil:Heating:DX:VariableSpeed'.to_IddObjectType).empty?
+                     'All Other'
+                   elsif !air_loop.supplyComponents('OS:Coil:Heating:Gas:MultiStage'.to_IddObjectType).empty?
+                     'All Other'
+                   elsif !air_loop.supplyComponents('OS:Coil:Heating:Desuperheater'.to_IddObjectType).empty?
+                     'All Other'
+                   elsif !air_loop.supplyComponents('OS:Coil:Heating:WaterToAirHeatPump:EquationFit'.to_IddObjectType).empty?
+                     'All Other'
+                   elsif !air_loop.supplyComponents('OS:Coil:Heating:Electric'.to_IddObjectType).empty?
+                     'Electric Resistance or None'
+                   else
+                     'Electric Resistance or None'
+                   end
+      end
+
+      return htg_type
+    end
+
+    # Return the cooling capacity of the DX cooling coil paired with the heating coil
+    #
+    # @param coil_heating [OpenStudio::Model::CoilHeatingDXSingleSpeed, OpenStudio::Model::CoilHeatingWaterToAirHeatPumpEquationFit] coil heating object
+    # @return [Double] capacity in W to be used for find object
+    def self.coil_heating_get_paired_coil_cooling_capacity(coil_heating)
+      capacity_w = nil
+
+      # Get the paired cooling coil
+      clg_coil = nil
+
+      # Unitary and zone equipment
+      if coil_heating.airLoopHVAC.empty?
+        if coil_heating.containingHVACComponent.is_initialized
+          containing_comp = coil_heating.containingHVACComponent.get
+          if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
+            clg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.get.coolingCoil
+          elsif containing_comp.to_AirLoopHVACUnitarySystem.is_initialized
+            unitary = containing_comp.to_AirLoopHVACUnitarySystem.get
+            if unitary.coolingCoil.is_initialized
+              clg_coil = unitary.coolingCoil.get
+            end
+          end
+          # @todo Add other unitary systems
+        elsif coil_heating.containingZoneHVACComponent.is_initialized
+          containing_comp = coil_heating.containingZoneHVACComponent.get
+          # PTHP
+          if containing_comp.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
+            pthp = containing_comp.to_ZoneHVACPackagedTerminalHeatPump.get
+            clg_coil = containing_comp.to_ZoneHVACPackagedTerminalHeatPump.get.coolingCoil
+          end
+        end
+      end
+
+      # On AirLoop directly
+      if coil_heating.airLoopHVAC.is_initialized
+        air_loop = coil_heating.airLoopHVAC.get
+
+        # Check for the presence of any other type of cooling coil
+        clg_types = ['OS:Coil:Cooling:DX:SingleSpeed',
+                     'OS:Coil:Cooling:DX:TwoSpeed',
+                     'OS:Coil:Cooling:DX:MultiSpeed']
+        clg_types.each do |ct|
+          coils = air_loop.supplyComponents(ct.to_IddObjectType)
+          next if coils.empty?
+
+          clg_coil = coils[0].to_StraightComponent.get
+          # Stop on first DX cooling coil found
+          break
+        end
+      end
+
+      # If no paired cooling coil was found, throw an error and fall back to the heating capacity
+      if clg_coil.nil?
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.HVAC.coil', "For #{coil_heating.name}, the paired DX cooling coil could not be found to determine capacity. Using the coil's heating capacity instead, which will incorrectly select efficiency levels for most standards.")
+
+        if coil_heating.to_CoilHeatingDXSingleSpeed.is_initialized
+          coil_heating = coil_heating.to_CoilHeatingDXSingleSpeed.get
+          capacity_w = OpenstudioStandards::HVAC.coil_heating_dx_single_speed_get_capacity(coil_heating)
+        elsif coil_heating.to_CoilHeatingWaterToAirHeatPumpEquationFit.is_initialized
+          coil_heating = coil_heating.to_CoilHeatingWaterToAirHeatPumpEquationFit.get
+          capacity_w = OpenstudioStandards::HVAC.coil_heating_water_to_air_heat_pump_equation_fit_get_capacity(coil_heating)
+        elsif coil_heating.to_CoilHeatingGas.is_initialized
+          coil_heating = coil_heating.to_CoilHeatingGas.get
+          capacity_w = OpenstudioStandards::HVAC.coil_heating_gas_get_capacity(coil_heating)
+        elsif coil_heating.to_CoilHeatingGasMultiStage.is_initialized
+          coil_heating = coil_heating.to_CoilHeatingGasMultiStage.get
+          capacity_w = OpenstudioStandards::HVAC.coil_heating_gas_multi_stage_get_capacity(coil_heating)
+        else
+          # If the coil is not a supported coil type, we cannot determine the capacity
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.HVAC.coil', "For #{coil_heating.name}, the coil is not a supported coil type and cannot determine capacity.")
+          return nil
+        end
+
+        # return nil if no capacity is available
+        if capacity_w.nil?
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.HVAC.coil', "For #{coil_heating.name} capacity is not available.")
+          return nil
+        end
+
+        return capacity_w
+      end
+
+      multiplier = 1.0
+      if ['PTAC', 'PTHP'].include?(OpenstudioStandards::HVAC.coil_dx_subcategory(clg_coil))
+        thermal_zone = OpenstudioStandards::HVAC.hvac_component_get_thermal_zone(clg_coil)
+        multiplier = thermal_zone.multiplier if !thermal_zone.nil?
+      end
+
+      # If a coil was found, cast to the correct type
+      if clg_coil.to_CoilCoolingDXSingleSpeed.is_initialized
+        clg_coil = clg_coil.to_CoilCoolingDXSingleSpeed.get
+        capacity_w = OpenstudioStandards::HVAC.coil_cooling_dx_single_speed_get_capacity(clg_coil, multiplier: multiplier)
+      elsif clg_coil.to_CoilCoolingDXTwoSpeed.is_initialized
+        clg_coil = clg_coil.to_CoilCoolingDXTwoSpeed.get
+        capacity_w = OpenstudioStandards::HVAC.coil_cooling_dx_two_speed_get_capacity(clg_coil, multiplier: multiplier)
+      elsif clg_coil.to_CoilCoolingDXMultiSpeed.is_initialized
+        clg_coil = clg_coil.to_CoilCoolingDXMultiSpeed.get
+        capacity_w = OpenstudioStandards::HVAC.coil_cooling_dx_multi_speed_get_capacity(clg_coil, multiplier: multiplier)
+      elsif clg_coil.to_CoilCoolingWaterToAirHeatPumpEquationFit.is_initialized
+        clg_coil = clg_coil.to_CoilCoolingWaterToAirHeatPumpEquationFit.get
+        capacity_w = OpenstudioStandards::HVAC.coil_cooling_water_to_air_heat_pump_get_capacity(clg_coil, multiplier: multiplier)
+      end
+
+      return capacity_w
+    end
+  end
+end

data/lib/openstudio-standards/hvac/components/coil_cooling_dx_multi_speed.rb

@@ -0,0 +1,40 @@
+module OpenstudioStandards
+  # The HVAC module provides methods create, modify, and get information about HVAC systems in the model
+  module HVAC
+    # @!group Component:Coil
+    # Methods to create, modify, and get information about HVAC coil objects
+
+    # Return the capacity in W of a CoilCoolingDXMultiSpeed
+    #
+    #
+    # @param coil_cooling_dx_multi_speed [OpenStudio::Model::CoilCoolingDXMultiSpeed] coil cooling dx multi speed object
+    # @param multiplier [Double] zone multiplier, if applicable
+    # @return [Double] capacity in W
+    def self.coil_cooling_dx_multi_speed_get_capacity(coil_cooling_dx_multi_speed, multiplier: nil)
+      capacity_w = nil
+      clg_stages = coil_cooling_dx_multi_speed.stages
+      if clg_stages.last.grossRatedTotalCoolingCapacity.is_initialized
+        capacity_w = clg_stages.last.grossRatedTotalCoolingCapacity.get
+      elsif (clg_stages.size == 1) && coil_cooling_dx_multi_speed.stages[0].autosizedSpeedRatedTotalCoolingCapacity.is_initialized
+        capacity_w = coil_cooling_dx_multi_speed.stages[0].autosizedSpeedRatedTotalCoolingCapacity.get
+      elsif (clg_stages.size == 2) && coil_cooling_dx_multi_speed.stages[1].autosizedGrossRatedTotalCoolingCapacity.is_initialized
+        capacity_w = coil_cooling_dx_multi_speed.stages[1].autosizedGrossRatedTotalCoolingCapacity.get
+      elsif (clg_stages.size == 3) && coil_cooling_dx_multi_speed.stages[2].autosizedGrossRatedTotalCoolingCapacity.is_initialized
+        capacity_w = coil_cooling_dx_multi_speed.stages[2].autosizedSpeedRatedTotalCoolingCapacity.get
+      elsif (clg_stages.size == 4) && coil_cooling_dx_multi_speed.stages[3].autosizedGrossRatedTotalCoolingCapacity.is_initialized
+        capacity_w = coil_cooling_dx_multi_speed.stages[3].autosizedGrossRatedTotalCoolingCapacity.get
+      else
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.HVAC.coil_cooling_dx_multi_speed', "For #{coil_cooling_dx_multi_speed.name} capacity is not available.")
+        return capacity_w
+      end
+
+      if !multiplier.nil? && multiplier > 1
+        total_cap = capacity_w
+        capacity_w /= multiplier
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.HVAC.coil_cooling_dx_multi_speed', "For #{coil_cooling_dx_multi_speed.name}, total capacity of #{OpenStudio.convert(total_cap, 'W', 'kBtu/hr').get.round(2)}kBTU/hr was divided by the zone multiplier of #{multiplier} to give #{capacity_kbtu_per_hr = OpenStudio.convert(capacity_w, 'W', 'kBtu/hr').get.round(2)}kBTU/hr.")
+      end
+
+      return capacity_w
+    end
+  end
+end