openstudio-standards 0.1.3 → 0.1.4

data/lib/openstudio-standards/standards/Standards.CoilHeatingDXMultiSpeed.rb

@@ -0,0 +1,192 @@
+
+# open the class to add methods to return sizing values
+class OpenStudio::Model::CoilHeatingDXMultiSpeed
+
+  def setStandardEfficiencyAndCurves(template, standards, sql_db_vars_map)
+
+    successfully_set_all_properties = true
+  
+    heat_pumps = standards['heat_pumps_heating']
+
+    # Define the criteria to find the unitary properties
+    # in the hvac standards data set.
+    search_criteria = {}
+    search_criteria['template'] = template
+
+    # Determine supplemental heating type if unitary
+    heat_pump = false
+    suppl_heating_type = nil
+    if self.airLoopHVAC.empty?
+      if self.containingHVACComponent.is_initialized
+        containing_comp = containingHVACComponent.get
+        if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.is_initialized
+          heat_pump = true
+          htg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.get.supplementalHeatingCoil
+          if htg_coil.to_CoilHeatingElectric.is_initialized
+            suppl_heating_type = 'Electric Resistance or None'
+          else
+            suppl_heating_type = 'All Other'
+          end
+        end # TODO Add other unitary systems
+      end
+    end
+
+    # TODO Standards - add split system vs single package to model
+    # For now, assume single package
+    subcategory = 'Single Package'
+    search_criteria['subcategory'] = subcategory
+
+    # Get the coil capacity
+    clg_capacity = nil
+    if(heat_pump == true)
+      containing_comp = self.containingHVACComponent.get
+      heat_pump_comp = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.get
+      ccoil = heat_pump_comp.coolingCoil
+      dxcoil = ccoil.to_CoilCoolingDXMultiSpeed.get
+      dxcoil_name = dxcoil.name.to_s
+      if sql_db_vars_map
+        if sql_db_vars_map[dxcoil_name]
+          dxcoil.setName(sql_db_vars_map[dxcoil_name])
+        end
+      end
+      clg_stages = dxcoil.stages
+      if clg_stages.last.grossRatedTotalCoolingCapacity.is_initialized
+        clg_capacity = clg_stages.last.grossRatedTotalCoolingCapacity.get
+      elsif dxcoil.autosizedSpeed4GrossRatedTotalCoolingCapacity.is_initialized
+        clg_capacity = dxcoil.autosizedSpeed4GrossRatedTotalCoolingCapacity.get
+      else
+        OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+        successfully_set_all_properties = false
+        return successfully_set_all_properties  
+      end
+      dxcoil.setName(dxcoil_name)
+    end
+
+    # Convert capacity to Btu/hr
+    capacity_btu_per_hr = OpenStudio.convert(clg_capacity, "W", "Btu/hr").get
+    capacity_kbtu_per_hr = OpenStudio.convert(clg_capacity, "W", "kBtu/hr").get
+
+    # Lookup efficiencies depending on whether it is a unitary AC or a heat pump
+    hp_props = self.model.find_object(heat_pumps, search_criteria, capacity_btu_per_hr)
+
+    # Check to make sure properties were found
+    if hp_props.nil?
+      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultipeed', "For #{self.name}, cannot find efficiency info, cannot apply efficiency standard.")
+      successfully_set_all_properties = false
+      return successfully_set_all_properties
+    end
+
+    # Make the HEAT-CAP-FT curve
+    htg_stages = self.stages
+    heat_cap_ft = self.model.add_curve(hp_props["heat_cap_ft"], standards)
+    if heat_cap_ft
+      htg_stages.each do |istage| 
+        istage.setHeatingCapacityFunctionofTemperatureCurve(heat_cap_ft)
+      end
+    else
+      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name}, cannot find heat_cap_ft curve, will not be set.")
+      successfully_set_all_properties = false
+    end
+
+    # Make the HEAT-CAP-FFLOW curve
+    heat_cap_fflow = self.model.add_curve(hp_props["heat_cap_fflow"], standards)
+    if heat_cap_fflow
+      htg_stages.each do |istage|
+          istage.setHeatingCapacityFunctionofFlowFractionCurve(heat_cap_fflow) 
+      end
+    else
+      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name}, cannot find heat_cap_fflow curve, will not be set.")
+      successfully_set_all_properties = false
+    end
+    
+    # Make the HEAT-EIR-FT curve
+    heat_eir_ft = self.model.add_curve(hp_props["heat_eir_ft"], standards)
+    if heat_eir_ft
+      htg_stages.each do |istage|
+        istage.setEnergyInputRatioFunctionofTemperatureCurve(heat_eir_ft)
+      end
+    else
+      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name}, cannot find heat_eir_ft curve, will not be set.")
+      successfully_set_all_properties = false
+    end
+
+    # Make the HEAT-EIR-FFLOW curve
+    heat_eir_fflow = self.model.add_curve(hp_props["heat_eir_fflow"], standards)
+    if heat_eir_fflow
+      htg_stages.each do |istage|
+        istage.setEnergyInputRatioFunctionofFlowFractionCurve(heat_eir_fflow)
+      end
+    else
+      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name}, cannot find heat_eir_fflow curve, will not be set.")
+      successfully_set_all_properties = false
+    end
+    
+    # Make the HEAT-PLF-FPLR curve
+    heat_plf_fplr = self.model.add_curve(hp_props["heat_plf_fplr"], standards)
+    if heat_plf_fplr
+      htg_stages.each do |istage|
+        istage.setPartLoadFractionCorrelationCurve(heat_plf_fplr)
+      end
+    else
+      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name}, cannot find heat_plf_fplr curve, will not be set.")
+      successfully_set_all_properties = false
+    end 
+    
+    # For NECB the heat pump needs only one stage
+    htg_capacity = nil
+    flow_rate4 = nil    
+    if(template == 'NECB 2011')
+      htg_stages = self.stages
+      if htg_stages.last.grossRatedHeatingCapacity.is_initialized
+        htg_capacity = htg_stages.last.grossRatedHeatingCapacity.get
+      elsif self.autosizedSpeed4GrossRatedHeatingCapacity.is_initialized
+        htg_capacity = self.autosizedSpeed4GrossRatedHeatingCapacity.get
+      else
+        OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+        successfully_set_all_properties = false
+        return successfully_set_all_properties
+      end   
+      if htg_stages.last.ratedAirFlowRate.is_initialized
+        flow_rate4 = htg_stages.last.ratedAirFlowRate.get
+      elsif self.autosizedSpeed4RatedAirFlowRate.is_initialized
+        flow_rate4 = self.autosizedSpeed4RatedAirFlowRate.get
+      else
+        OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+        successfully_set_all_properties = false
+        return successfully_set_all_properties
+      end   
+    end
+    
+    # Convert capacity to Btu/hr
+    capacity_btu_per_hr = OpenStudio.convert(htg_capacity, "W", "Btu/hr").get
+    capacity_kbtu_per_hr = OpenStudio.convert(htg_capacity, "W", "kBtu/hr").get
+
+    # Get the minimum efficiency standards
+    cop = nil
+    
+    # If specified as SEER
+    unless hp_props['minimum_seasonal_energy_efficiency_ratio'].nil?
+      min_seer = hp_props['minimum_seasonal_energy_efficiency_ratio']
+      cop = seer_to_cop(min_seer)
+      self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER")
+      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXMultiSpeed',  "For #{template}: #{self.name}: #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
+    end
+    
+    # If specified as EER
+    unless hp_props['minimum_energy_efficiency_ratio'].nil?
+      min_eer = hp_props['minimum_energy_efficiency_ratio']
+      cop = eer_to_cop(min_eer)
+      self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER")
+      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{template}: #{self.name}:  #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
+    end
+
+    # Set the efficiency values
+    unless cop.nil?
+      htg_stages.each do |istage|
+        istage.setGrossRatedHeatingCOP(cop)
+      end
+    end
+
+  end
+
+end

data/lib/openstudio-standards/standards/Standards.CoilHeatingGasMultiStage.rb

@@ -0,0 +1,65 @@
+
+# open the class to add methods to return sizing values
+class OpenStudio::Model::CoilHeatingGasMultiStage
+
+  def setStandardEfficiencyAndCurves(template, standards)
+    
+    successfully_set_all_properties = true
+    
+    # Get the coil capacity
+    capacity_w = nil
+    htg_stages = self.stages
+    if htg_stages.last.nominalCapacity.is_initialized
+      capacity_w = htg_stages.last.nominalCapacity.get
+    elsif self.autosizedStage4NominalCapacity.is_initialized
+      capacity_w = self.autosizedStage4NominalCapacity.get
+    else
+      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+      successfully_set_all_properties = false
+      return successfully_set_all_properties
+    end   
+
+    # Set number of stages for NECB 2011
+    if(template == 'NECB 2011')
+      num_stages = (capacity_w/(66.0*1000.0)+0.5).round
+      num_stages = [num_stages,4].min
+      stage_cap = []
+      if(num_stages == 1)
+        stage_cap[0] = capacity_w/2.0
+        stage_cap[1] = 2.0*stage_cap[0]
+        stage_cap[2] = stage_cap[1]+0.1
+        stage_cap[3] = stage_cap[2]+0.1
+      else
+        stage_cap[0] = 66.0*1000.0
+        stage_cap[1] = 2.0*stage_cap[0]
+        if(num_stages == 2)
+          stage_cap[2] = stage_cap[1]+0.1
+          stage_cap[3] = stage_cap[2]+0.1         
+        elsif(num_stages == 3)
+          stage_cap[2] = 3.0*stage_cap[0]
+          stage_cap[3] = stage_cap[2]+0.1
+        elsif(num_stages == 4)
+          stage_cap[2] = 3.0*stage_cap[0]
+          stage_cap[3] = 4.0*stage_cap[0]
+        end
+      end
+      # set capacities, flow rates, and sensible heat ratio for stages
+      for istage in 0..3
+        htg_stages[istage].setNominalCapacity(stage_cap[istage])
+      end
+      # PLF vs PLR curve
+      furnace_plffplr_curve_name = 'FURNACE-EFFPLR-NECB2011'
+    end
+
+    # plf vs plr curve for furnace
+    furnace_plffplr_curve = self.model.add_curve(furnace_plffplr_curve_name, standards)
+    if furnace_plffplr_curve
+      self.setPartLoadFractionCorrelationCurve(furnace_plffplr_curve)
+    else
+      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingGasMultiStage', "For #{self.name}, cannot find plffplr curve, will not be set.")
+      successfully_set_all_properties = false
+    end
+    
+  end
+
+end

data/lib/openstudio-standards/standards/Standards.Fan.rb

@@ -19,17 +19,17 @@ module Fan
       OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.Fan', "For #{self.name} max flow rate is not hard sized, cannot apply efficiency standard.")
       return false
     end
-    
+
     # Convert max flow rate to cfm
     maximum_flow_rate_cfm = OpenStudio.convert(maximum_flow_rate_m3_per_s, 'm^3/s', 'cfm').get
     
     # Get the pressure rise from the fan
     pressure_rise_pa = self.pressureRise
     pressure_rise_in_h2o = OpenStudio.convert(pressure_rise_pa, 'Pa','inH_{2}O').get
-    
+
     # Get the default impeller efficiency
     fan_impeller_eff = self.baselineImpellerEfficiency(template)
-    
+
     # Calculate the Brake Horsepower
     brake_hp = (pressure_rise_in_h2o * maximum_flow_rate_cfm)/(fan_impeller_eff * 6356) 
     allowed_hp = brake_hp * 1.1 # Per PNNL document #TODO add reference
@@ -38,7 +38,7 @@ module Fan
     elsif allowed_hp < 0.01
       allowed_hp = 0.01
     end
-    
+
     # Minimum motor size for efficiency lookup
     # is 1 HP unless the motor serves an exhaust fan,
     # a powered VAV terminal, or a fan coil unit.
@@ -62,6 +62,11 @@ module Fan
       self.setMotorEfficiency(motor_eff)
     end
     
+
+    if(template == 'NECB 2011')
+      fan_power_kw = maximum_flow_rate_m3_per_s*pressure_rise_pa/(fan_impeller_eff*1000.0)
+    end
+
     OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.Fan', "For #{self.name}: allowed_hp = #{allowed_hp.round(2)}HP; motor eff = #{(motor_eff*100).round(2)}%; total fan eff = #{(total_fan_eff*100).round}% based on #{maximum_flow_rate_cfm.round} cfm.")
     
     return true
@@ -273,6 +278,7 @@ module Fan
   # any desired safety factor already included.  This method
   #
   # @param motor_bhp [Double] motor brake horsepower (hp)
+
   # @return [Double] minimum motor efficiency (0.0 to 1.0), nominal HP
   def standard_minimum_motor_efficiency_and_size(template, motor_bhp)
   
@@ -283,12 +289,37 @@ module Fan
     motors = $os_standards["motors"]
     
     # Assuming all fan motors are 4-pole ODP
+    template_mod = template.dup
+    if(template == 'NECB 2011') 
+      if(self.class.name == 'OpenStudio::Model::FanConstantVolume')
+        template_mod = template_mod+'-CONSTANT'
+      elsif(self.class.name == 'OpenStudio::Model::FanVariableVolume')
+        template_mod = template_mod+'-VARIABLE'
+        fan_power_kw = 0.909*0.7457*motor_bhp
+        if(fan_power_kw >= 25.0)
+          power_vs_flow_curve_name = 'VarVolFan-FCInletVanes-NECB2011-FPLR'
+        elsif(fan_power_kw >= 7.5 && fan_power_kw < 25)
+          power_vs_flow_curve_name = 'VarVolFan-AFBIInletVanes-NECB2011-FPLR'
+        else
+          power_vs_flow_curve_name = 'VarVolFan-AFBIFanCurve-NECB2011-FPLR'
+        end
+        power_vs_flow_curve = self.model.add_curve(power_vs_flow_curve_name, standards)
+        self.setFanPowerMinimumFlowRateInputMethod("Fraction")
+        self.setFanPowerCoefficient5(0.0)
+        self.setFanPowerMinimumFlowFraction(power_vs_flow_curve.minimumValueofx)
+        self.setFanPowerCoefficient1(power_vs_flow_curve.coefficient1Constant)
+        self.setFanPowerCoefficient2(power_vs_flow_curve.coefficient2x)
+        self.setFanPowerCoefficient3(power_vs_flow_curve.coefficient3xPOW2)
+        self.setFanPowerCoefficient4(power_vs_flow_curve.coefficient4xPOW3)
+      end
+    end
+ 
     search_criteria = {
-      "template" => template,
+      "template" => template_mod,
       "number_of_poles" => 4.0,
       "type" => "Enclosed",
     }
-    
+ 
     motor_properties = self.model.find_object(motors, search_criteria, motor_bhp)
     if motor_properties.nil?
       OpenStudio::logFree(OpenStudio::Error, "openstudio.standards.Fan", "For #{self.name}, could not find motor properties using search criteria: #{search_criteria}, motor_bhp = #{motor_bhp} hp.")

data/lib/openstudio-standards/standards/Standards.Model.rb

@@ -1539,6 +1539,7 @@ class OpenStudio::Model::Model
   
   
   end
+
   
   # Applies the multi-zone VAV outdoor air sizing requirements
   # to all applicable air loops in the model.
@@ -1580,6 +1581,7 @@ class OpenStudio::Model::Model
     #self.getPumpVariableSpeeds.sort.each {|obj| obj.set_standard_minimum_motor_efficiency(building_vintage)}
     
     # Unitary ACs
+
     self.getCoilCoolingDXTwoSpeeds.sort.each {|obj| obj.setStandardEfficiencyAndCurves(building_vintage)}
     self.getCoilCoolingDXSingleSpeeds.sort.each {|obj| sql_db_vars_map = obj.setStandardEfficiencyAndCurves(building_vintage, sql_db_vars_map)}
 
@@ -1587,7 +1589,9 @@ class OpenStudio::Model::Model
     self.getCoilHeatingDXSingleSpeeds.sort.each {|obj| sql_db_vars_map = obj.setStandardEfficiencyAndCurves(building_vintage, sql_db_vars_map)}
 
     # Chillers
-    self.getChillerElectricEIRs.sort.each {|obj| obj.setStandardEfficiencyAndCurves(building_vintage)}
+    clg_tower_objs = self.getCoolingTowerSingleSpeeds
+    self.getChillerElectricEIRs.sort.each {|obj| obj.setStandardEfficiencyAndCurves(building_vintage, clg_tower_objs)}
+
 
     # Boilers
     self.getBoilerHotWaters.sort.each {|obj| obj.setStandardEfficiencyAndCurves(building_vintage)}
@@ -1595,6 +1599,10 @@ class OpenStudio::Model::Model
     # Water Heaters
     self.getWaterHeaterMixeds.sort.each {|obj| obj.setStandardEfficiency(building_vintage)}
 
+    # was this added for necb archetypes?
+    # Heating coils
+    #self.getCoilHeatingGasMultiStages.sort.each {|obj| obj.setStandardEfficiencyAndCurves(self.template, self.standards)}
+   
     OpenStudio::logFree(OpenStudio::Info, 'openstudio.model.Model', 'Finished applying HVAC efficiency standards.')
 
   end
@@ -1628,6 +1636,7 @@ class OpenStudio::Model::Model
       space.set_infiltration_rate(building_vintage)
     end
 
+
     case building_vintage
       when 'DOE Ref Pre-1980', 'DOE Ref 1980-2004'
         #"For 'DOE Ref Pre-1980' and 'DOE Ref 1980-2004', infiltration rates are not defined using this method, no changes have been made to the model.
@@ -1639,7 +1648,9 @@ class OpenStudio::Model::Model
           end
         end
       end
-  end
+    end
+ 
+
 
   # Method to search through a hash for the objects that meets the
   # desired search criteria, as passed via a hash.
@@ -1884,6 +1895,7 @@ class OpenStudio::Model::Model
         day_types.include?('Thu') ||
         day_types.include?('Fri')
 
+
         # Make the Rule
         sch_rule = OpenStudio::Model::ScheduleRule.new(sch_ruleset)
         day_sch = sch_rule.daySchedule
@@ -2123,12 +2135,14 @@ class OpenStudio::Model::Model
     # Get the construction properties,
     # which specifies properties by construction category by climate zone set.
     # AKA the info in Tables 5.5-1-5.5-8
+
     props = self.find_object($os_standards['construction_properties'], {'template'=>building_vintage,
                                                                     'climate_zone_set'=> climate_zone_set,
                                                                     'intended_surface_type'=> intended_surface_type,
                                                                     'standards_construction_type'=> standards_construction_type,
                                                                     'building_category' => building_category
                                                                     })
+
     if !props
       OpenStudio::logFree(OpenStudio::Error, 'openstudio.standards.Model', "Could not find construction properties for: #{building_vintage}-#{climate_zone_set}-#{intended_surface_type}-#{standards_construction_type}-#{building_category}.")
       # Return an empty construction
@@ -2168,18 +2182,26 @@ class OpenStudio::Model::Model
     end
 
     # Get the object data
+
     data = self.find_object($os_standards['construction_sets'], {'template'=>building_vintage, 'climate_zone_set'=> climate_zone_set, 'building_type'=>building_type, 'space_type'=>spc_type, 'is_residential'=>is_residential})
     if !data
       data = self.find_object($os_standards['construction_sets'], {'template'=>building_vintage, 'climate_zone_set'=> climate_zone_set, 'building_type'=>building_type, 'space_type'=>spc_type})
+
       if !data
+    
+        # for debugging (maria)
+        #puts "data = #{data}"
+        
         return construction_set
       end
+
     end
 
     OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.Model', "Adding construction set: #{building_vintage}-#{clim}-#{building_type}-#{spc_type}-is_residential#{is_residential}")
 
     name = make_name(building_vintage, clim, building_type, spc_type)
 
+
     # Create a new construction set and name it
     construction_set = OpenStudio::Model::DefaultConstructionSet.new(self)
     construction_set.setName(name)
@@ -2188,6 +2210,7 @@ class OpenStudio::Model::Model
     exterior_surfaces = OpenStudio::Model::DefaultSurfaceConstructions.new(self)
     construction_set.setDefaultExteriorSurfaceConstructions(exterior_surfaces)
     if data['exterior_floor_standards_construction_type'] && data['exterior_floor_building_category']
+
       exterior_surfaces.setFloorConstruction(find_and_add_construction(building_vintage,
                                                                        climate_zone_set,
                                                                        'ExteriorFloor',
@@ -2248,6 +2271,7 @@ class OpenStudio::Model::Model
                                                                        'GroundContactRoof',
                                                                        data['ground_contact_ceiling_standards_construction_type'],
                                                                        data['ground_contact_ceiling_building_category']))
+
     end
 
     # Exterior sub surfaces constructions
@@ -3258,6 +3282,7 @@ class OpenStudio::Model::Model
           sky_area_m2 += ss.netArea * space.multiplier
         end
       end
+
       
       # Determine the space category
       cat = 'NonRes'
@@ -3585,7 +3610,7 @@ class OpenStudio::Model::Model
     case building_vintage
     when 'DOE Ref Pre-1980', 'DOE Ref 1980-2004'
       result = possible_climate_zones.sort.last
-    when '90.1-2007', '90.1-2010', '90.1-2013'
+    when '90.1-2007', '90.1-2010', '90.1-2013', 'NECB 2011'
       result = possible_climate_zones.sort.first
     when '90.1-2004'
       if possible_climate_zones.include? "ClimateZone 3"