urbanopt-cli 0.5.2 → 0.6.3

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/hvac.rb

@@ -60,6 +60,7 @@ class HVAC
     if (not cooling_system.nil?) && (not heating_system.nil?) && (cooling_system.fan_watts_per_cfm.to_f != heating_system.fan_watts_per_cfm.to_f)
       fail "Fan powers for heating system '#{heating_system.id}' and cooling system '#{cooling_system.id}' are attached to a single distribution system and therefore must be the same."
     end
+
     if (not cooling_system.nil?) && (not cooling_system.fan_watts_per_cfm.nil?)
       fan_watts_per_cfm = cooling_system.fan_watts_per_cfm
     else
@@ -413,25 +414,12 @@ class HVAC
     end
 
     # Cooling Coil
-    clg_coil = OpenStudio::Model::CoilCoolingWaterToAirHeatPumpEquationFit.new(model)
+    clg_total_cap_curve = create_curve_quad_linear(model, hp_ap.cool_cap_ft_spec[0], obj_name + ' clg total cap curve')
+    clg_sens_cap_curve = create_curve_quint_linear(model, hp_ap.cool_sh_ft_spec[0], obj_name + ' clg sens cap curve')
+    clg_power_curve = create_curve_quad_linear(model, hp_ap.cool_power_ft_spec[0], obj_name + ' clg power curve')
+    clg_coil = OpenStudio::Model::CoilCoolingWaterToAirHeatPumpEquationFit.new(model, clg_total_cap_curve, clg_sens_cap_curve, clg_power_curve)
     clg_coil.setName(obj_name + ' clg coil')
     clg_coil.setRatedCoolingCoefficientofPerformance(1.0 / hp_ap.cool_rated_eirs[0])
-    clg_coil.setTotalCoolingCapacityCoefficient1(hp_ap.cool_cap_ft_spec[0][0])
-    clg_coil.setTotalCoolingCapacityCoefficient2(hp_ap.cool_cap_ft_spec[0][1])
-    clg_coil.setTotalCoolingCapacityCoefficient3(hp_ap.cool_cap_ft_spec[0][2])
-    clg_coil.setTotalCoolingCapacityCoefficient4(hp_ap.cool_cap_ft_spec[0][3])
-    clg_coil.setTotalCoolingCapacityCoefficient5(hp_ap.cool_cap_ft_spec[0][4])
-    clg_coil.setSensibleCoolingCapacityCoefficient1(hp_ap.cool_sh_ft_spec[0][0])
-    clg_coil.setSensibleCoolingCapacityCoefficient2(hp_ap.cool_sh_ft_spec[0][1])
-    clg_coil.setSensibleCoolingCapacityCoefficient3(hp_ap.cool_sh_ft_spec[0][2])
-    clg_coil.setSensibleCoolingCapacityCoefficient4(hp_ap.cool_sh_ft_spec[0][3])
-    clg_coil.setSensibleCoolingCapacityCoefficient5(hp_ap.cool_sh_ft_spec[0][4])
-    clg_coil.setSensibleCoolingCapacityCoefficient6(hp_ap.cool_sh_ft_spec[0][5])
-    clg_coil.setCoolingPowerConsumptionCoefficient1(hp_ap.cool_power_ft_spec[0][0])
-    clg_coil.setCoolingPowerConsumptionCoefficient2(hp_ap.cool_power_ft_spec[0][1])
-    clg_coil.setCoolingPowerConsumptionCoefficient3(hp_ap.cool_power_ft_spec[0][2])
-    clg_coil.setCoolingPowerConsumptionCoefficient4(hp_ap.cool_power_ft_spec[0][3])
-    clg_coil.setCoolingPowerConsumptionCoefficient5(hp_ap.cool_power_ft_spec[0][4])
     clg_coil.setNominalTimeforCondensateRemovaltoBegin(1000)
     clg_coil.setRatioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity(1.5)
     clg_coil.setRatedAirFlowRate(UnitConversions.convert(clg_cfm, 'cfm', 'm^3/s'))
@@ -441,19 +429,11 @@ class HVAC
     hvac_map[heat_pump.id] << clg_coil
 
     # Heating Coil
-    htg_coil = OpenStudio::Model::CoilHeatingWaterToAirHeatPumpEquationFit.new(model)
+    htg_cap_curve = create_curve_quad_linear(model, hp_ap.heat_cap_ft_spec[0], obj_name + ' htg cap curve')
+    htg_power_curve = create_curve_quad_linear(model, hp_ap.heat_power_ft_spec[0], obj_name + ' htg power curve')
+    htg_coil = OpenStudio::Model::CoilHeatingWaterToAirHeatPumpEquationFit.new(model, htg_cap_curve, htg_power_curve)
     htg_coil.setName(obj_name + ' htg coil')
     htg_coil.setRatedHeatingCoefficientofPerformance(1.0 / hp_ap.heat_rated_eirs[0])
-    htg_coil.setHeatingCapacityCoefficient1(hp_ap.heat_cap_ft_spec[0][0])
-    htg_coil.setHeatingCapacityCoefficient2(hp_ap.heat_cap_ft_spec[0][1])
-    htg_coil.setHeatingCapacityCoefficient3(hp_ap.heat_cap_ft_spec[0][2])
-    htg_coil.setHeatingCapacityCoefficient4(hp_ap.heat_cap_ft_spec[0][3])
-    htg_coil.setHeatingCapacityCoefficient5(hp_ap.heat_cap_ft_spec[0][4])
-    htg_coil.setHeatingPowerConsumptionCoefficient1(hp_ap.heat_power_ft_spec[0][0])
-    htg_coil.setHeatingPowerConsumptionCoefficient2(hp_ap.heat_power_ft_spec[0][1])
-    htg_coil.setHeatingPowerConsumptionCoefficient3(hp_ap.heat_power_ft_spec[0][2])
-    htg_coil.setHeatingPowerConsumptionCoefficient4(hp_ap.heat_power_ft_spec[0][3])
-    htg_coil.setHeatingPowerConsumptionCoefficient5(hp_ap.heat_power_ft_spec[0][4])
     htg_coil.setRatedAirFlowRate(UnitConversions.convert(htg_cfm, 'cfm', 'm^3/s'))
     htg_coil.setRatedWaterFlowRate(UnitConversions.convert(hp_ap.GSHP_Loop_flow, 'gal/min', 'm^3/s'))
     htg_coil.setRatedHeatingCapacity(UnitConversions.convert(heat_pump.heating_capacity, 'Btu/hr', 'W'))
@@ -629,7 +609,7 @@ class HVAC
     hvac_map[heat_pump.id] << htg_supp_coil
 
     # Fan
-    fan_power_installed = 0.5 # FIXME
+    fan_power_installed = 0.0 # Use provided net COP
     fan = create_supply_fan(model, obj_name, 1, fan_power_installed, htg_cfm)
     hvac_map[heat_pump.id] += disaggregate_fan_or_pump(model, fan, htg_coil, clg_coil, htg_supp_coil)
 
@@ -1307,11 +1287,12 @@ class HVAC
   def self.set_cool_curves_room_ac(cooling_system)
     clg_ap = cooling_system.additional_properties
 
-    # From Frigidaire 10.7 EER unit in Winkler et. al. Lab Testing of Window ACs (2013)
-    clg_ap.cool_cap_ft_spec = [[0.43945980246913574, -0.0008922469135802481, 0.00013984567901234569, 0.0038489259259259253, -5.6327160493827156e-05, 2.041358024691358e-05]]
-    clg_ap.cool_eir_ft_spec = [[6.310506172839506, -0.17705185185185185, 0.0014645061728395061, 0.012571604938271608, 0.0001493827160493827, -0.00040308641975308644]]
-    clg_ap.cool_cap_fflow_spec = [[0.887, 0.1128, 0]]
-    clg_ap.cool_eir_fflow_spec = [[1.763, -0.6081, 0]]
+    # From "Improved Modeling of Residential Air Conditioners and Heat Pumps for Energy Calculations", Cutler at al
+    # https://www.nrel.gov/docs/fy13osti/56354.pdf
+    clg_ap.cool_cap_ft_spec = [[3.68637657, -0.098352478, 0.000956357, 0.005838141, -0.0000127, -0.000131702]]
+    clg_ap.cool_eir_ft_spec = [[-3.437356399, 0.136656369, -0.001049231, -0.0079378, 0.000185435, -0.0001441]]
+    clg_ap.cool_cap_fflow_spec = [[1, 0, 0]]
+    clg_ap.cool_eir_fflow_spec = [[1, 0, 0]]
   end
 
   def self.set_cool_curves_mshp(heat_pump, num_speeds)
@@ -1851,42 +1832,29 @@ class HVAC
       distribution_system = heating_system.distribution_system
       distribution_type = distribution_system.distribution_system_type
 
-      if distribution_type == HPXML::HVACDistributionTypeHydronic
-        if distribution_system.hydronic_type == HPXML::HydronicTypeWaterLoop
-          # Shared boiler w/ WLHP
-          if heating_system.shared_loop_watts.nil?
-            return 265.0 # kWh/yr, per ANSI/RESNET/ICC 301-2019 Table 4.5.2(5)
-          else
-            sp_kw = UnitConversions.convert(heating_system.shared_loop_watts, 'W', 'kW')
-            n_dweq = heating_system.number_of_units_served.to_f
-            aux_in = 0.0 # ANSI/RESNET/ICC 301-2019 Section 4.4.7.2
-          end
+      if not heating_system.shared_loop_watts.nil?
+        sp_kw = UnitConversions.convert(heating_system.shared_loop_watts, 'W', 'kW')
+        n_dweq = heating_system.number_of_units_served.to_f
+        if distribution_system.air_type == HPXML::AirTypeFanCoil
+          aux_in = UnitConversions.convert(heating_system.fan_coil_watts, 'W', 'kW')
         else
-          # Shared boiler w/ baseboard/radiators/etc
-          if heating_system.shared_loop_watts.nil?
-            return 220.0 # kWh/yr, per ANSI/RESNET/ICC 301-2019 Table 4.5.2(5)
-          else
-            sp_kw = UnitConversions.convert(heating_system.shared_loop_watts, 'W', 'kW')
-            n_dweq = heating_system.number_of_units_served.to_f
-            aux_in = 0.0
-          end
+          aux_in = 0.0 # ANSI/RESNET/ICC 301-2019 Section 4.4.7.2
+        end
+        # ANSI/RESNET/ICC 301-2019 Equation 4.4-5
+        return (((sp_kw / n_dweq) + aux_in) * 2080.0).round(2) # kWh/yr
+      elsif distribution_type == HPXML::HVACDistributionTypeHydronic
+        # kWh/yr, per ANSI/RESNET/ICC 301-2019 Table 4.5.2(5)
+        if distribution_system.hydronic_type == HPXML::HydronicTypeWaterLoop # Shared boiler w/ WLHP
+          return 265.0
+        else # Shared boiler w/ baseboard/radiators/etc
+          return 220.0
         end
       elsif distribution_type == HPXML::HVACDistributionTypeAir
-        if distribution_system.air_type == HPXML::AirTypeFanCoil
-          # Shared boiler w/ fan coil
-          if heating_system.shared_loop_watts.nil? || heating_system.fan_coil_watts.nil?
-            return 438.0 # kWh/yr, per ANSI/RESNET/ICC 301-2019 Table 4.5.2(5)
-          else
-            sp_kw = UnitConversions.convert(heating_system.shared_loop_watts, 'W', 'kW')
-            n_dweq = heating_system.number_of_units_served.to_f
-            aux_in = UnitConversions.convert(heating_system.fan_coil_watts, 'W', 'kW')
-          end
+        if distribution_system.air_type == HPXML::AirTypeFanCoil # Shared boiler w/ fan coil
+          return 438.0
         end
       end
 
-      # ANSI/RESNET/ICC 301-2019 Equation 4.4-5
-      return ((sp_kw / n_dweq) + aux_in) * 2080.0 # kWh/yr
-
     else # In-unit boilers
 
       if [HPXML::FuelTypeNaturalGas,
@@ -2765,19 +2733,19 @@ class HVAC
   end
 
   def self.create_curve_biquadratic_constant(model)
-    const_biquadratic = OpenStudio::Model::CurveBiquadratic.new(model)
-    const_biquadratic.setName('ConstantBiquadratic')
-    const_biquadratic.setCoefficient1Constant(1)
-    const_biquadratic.setCoefficient2x(0)
-    const_biquadratic.setCoefficient3xPOW2(0)
-    const_biquadratic.setCoefficient4y(0)
-    const_biquadratic.setCoefficient5yPOW2(0)
-    const_biquadratic.setCoefficient6xTIMESY(0)
-    const_biquadratic.setMinimumValueofx(-100)
-    const_biquadratic.setMaximumValueofx(100)
-    const_biquadratic.setMinimumValueofy(-100)
-    const_biquadratic.setMaximumValueofy(100)
-    return const_biquadratic
+    curve = OpenStudio::Model::CurveBiquadratic.new(model)
+    curve.setName('ConstantBiquadratic')
+    curve.setCoefficient1Constant(1)
+    curve.setCoefficient2x(0)
+    curve.setCoefficient3xPOW2(0)
+    curve.setCoefficient4y(0)
+    curve.setCoefficient5yPOW2(0)
+    curve.setCoefficient6xTIMESY(0)
+    curve.setMinimumValueofx(-100)
+    curve.setMaximumValueofx(100)
+    curve.setMinimumValueofy(-100)
+    curve.setMaximumValueofy(100)
+    return curve
   end
 
   def self.create_curve_quadratic_constant(model)
@@ -2794,15 +2762,15 @@ class HVAC
   end
 
   def self.create_curve_cubic_constant(model)
-    constant_cubic = OpenStudio::Model::CurveCubic.new(model)
-    constant_cubic.setName('ConstantCubic')
-    constant_cubic.setCoefficient1Constant(1)
-    constant_cubic.setCoefficient2x(0)
-    constant_cubic.setCoefficient3xPOW2(0)
-    constant_cubic.setCoefficient4xPOW3(0)
-    constant_cubic.setMinimumValueofx(-100)
-    constant_cubic.setMaximumValueofx(100)
-    return constant_cubic
+    curve = OpenStudio::Model::CurveCubic.new(model)
+    curve.setName('ConstantCubic')
+    curve.setCoefficient1Constant(1)
+    curve.setCoefficient2x(0)
+    curve.setCoefficient3xPOW2(0)
+    curve.setCoefficient4xPOW3(0)
+    curve.setMinimumValueofx(-100)
+    curve.setMaximumValueofx(100)
+    return curve
   end
 
   def self.convert_curve_biquadratic(coeff, ip_to_si = true)
@@ -2911,6 +2879,29 @@ class HVAC
     return curve
   end
 
+  def self.create_curve_quad_linear(model, coeff, name)
+    curve = OpenStudio::Model::CurveQuadLinear.new(model)
+    curve.setName(name)
+    curve.setCoefficient1Constant(coeff[0])
+    curve.setCoefficient2w(coeff[1])
+    curve.setCoefficient3x(coeff[2])
+    curve.setCoefficient4y(coeff[3])
+    curve.setCoefficient5z(coeff[4])
+    return curve
+  end
+
+  def self.create_curve_quint_linear(model, coeff, name)
+    curve = OpenStudio::Model::CurveQuintLinear.new(model)
+    curve.setName(name)
+    curve.setCoefficient1Constant(coeff[0])
+    curve.setCoefficient2v(coeff[1])
+    curve.setCoefficient3w(coeff[2])
+    curve.setCoefficient4x(coeff[3])
+    curve.setCoefficient5y(coeff[4])
+    curve.setCoefficient6z(coeff[5])
+    return curve
+  end
+
   def self.create_dx_cooling_coil(model, obj_name, cooling_system)
     clg_ap = cooling_system.additional_properties
 
@@ -3983,7 +3974,7 @@ class HVAC
     return 30.0 # W/ton, per ANSI/RESNET/ICC 301-2019 Section 4.4.5 (closed loop)
   end
 
-  def self.apply_shared_systems(hpxml)
+  def self.apply_shared_systems(hpxml = true)
     applied_clg = apply_shared_cooling_systems(hpxml)
     applied_htg = apply_shared_heating_systems(hpxml)
     return unless (applied_clg || applied_htg)
@@ -4000,7 +3991,7 @@ class HVAC
     # Remove any orphaned HVAC distributions
     hpxml.hvac_distributions.each do |hvac_distribution|
       hvac_systems = []
-      (hpxml.heating_systems + hpxml.cooling_systems + hpxml.heat_pumps).each do |hvac_system|
+      hpxml.hvac_systems.each do |hvac_system|
         next if hvac_system.distribution_system_idref.nil?
         next unless hvac_system.distribution_system_idref == hvac_distribution.id
 
@@ -4063,12 +4054,19 @@ class HVAC
         fail "Unexpected cooling system type '#{cooling_system.cooling_system_type}'."
       end
 
+      if seer_eq <= 0
+        fail "Negative SEER equivalent calculated for cooling system '#{cooling_system.id}', double check inputs."
+      end
+
       cooling_system.cooling_system_type = HPXML::HVACTypeCentralAirConditioner
-      cooling_system.cooling_efficiency_seer = seer_eq
+      cooling_system.cooling_efficiency_seer = seer_eq.round(2)
       cooling_system.cooling_efficiency_kw_per_ton = nil
       cooling_system.cooling_capacity = nil # Autosize the equipment
       cooling_system.is_shared_system = false
       cooling_system.number_of_units_served = nil
+      cooling_system.shared_loop_watts = nil
+      cooling_system.shared_loop_motor_efficiency = nil
+      cooling_system.fan_coil_watts = nil
 
       # Assign new distribution system to air conditioner
       if distribution_type == HPXML::HVACDistributionTypeHydronic
@@ -4085,6 +4083,29 @@ class HVAC
                                        annual_heating_dse: 1.0)
           cooling_system.distribution_system_idref = hpxml.hvac_distributions[-1].id
         end
+      elsif (distribution_type == HPXML::HVACDistributionTypeAir) && (distribution_system.air_type == HPXML::AirTypeFanCoil)
+        # Convert "fan coil" air distribution system to "regular velocity"
+        if distribution_system.hvac_systems.size > 1
+          # Has attached heating system, so create a copy specifically for the cooling system
+          hpxml.hvac_distributions << distribution_system.dup
+          hpxml.hvac_distributions[-1].id += "#{cooling_system.id}AirDistributionSystem"
+          cooling_system.distribution_system_idref = hpxml.hvac_distributions[-1].id
+        end
+        hpxml.hvac_distributions[-1].air_type = HPXML::AirTypeRegularVelocity
+        if hpxml.hvac_distributions[-1].duct_leakage_measurements.select { |lm| (lm.duct_type == HPXML::DuctTypeSupply) && (lm.duct_leakage_total_or_to_outside == HPXML::DuctLeakageToOutside) }.size == 0
+          # Assign zero supply leakage
+          hpxml.hvac_distributions[-1].duct_leakage_measurements.add(duct_type: HPXML::DuctTypeSupply,
+                                                                     duct_leakage_units: HPXML::UnitsCFM25,
+                                                                     duct_leakage_value: 0,
+                                                                     duct_leakage_total_or_to_outside: HPXML::DuctLeakageToOutside)
+        end
+        if hpxml.hvac_distributions[-1].duct_leakage_measurements.select { |lm| (lm.duct_type == HPXML::DuctTypeReturn) && (lm.duct_leakage_total_or_to_outside == HPXML::DuctLeakageToOutside) }.size == 0
+          # Assign zero return leakage
+          hpxml.hvac_distributions[-1].duct_leakage_measurements.add(duct_type: HPXML::DuctTypeReturn,
+                                                                     duct_leakage_units: HPXML::UnitsCFM25,
+                                                                     duct_leakage_value: 0,
+                                                                     duct_leakage_total_or_to_outside: HPXML::DuctLeakageToOutside)
+        end
       end
     end
 

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/hvac_sizing.rb

@@ -890,6 +890,7 @@ class HVACSizing
             sum_ua_wall += (1.0 / wall.insulation_assembly_r_value * wall.net_area)
           end
           fail 'Could not find connected walls.' if sum_a_wall <= 0
+
           u_wall = sum_ua_wall / sum_a_wall
 
           # Calculate partition temperature different cooling (PTDC) per Manual J Figure A12-17
@@ -1434,7 +1435,6 @@ class HVACSizing
 
       hvac_sizing_values.Cool_Capacity = (hvac_sizing_values.Cool_Load_Tot / totalCap_CurveValue)
       hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac.SHRRated[hvac.SizingSpeed]
-      # FIXME: Why not use calc_airflow_rate?
       hvac_sizing_values.Cool_Airflow = hvac.RatedCFMperTonCooling[-1] * hvac.CapacityRatioCooling[-1] * UnitConversions.convert(hvac_sizing_values.Cool_Capacity, 'Btu/hr', 'ton')
 
     elsif hvac.CoolType == HPXML::HVACTypeRoomAirConditioner
@@ -1444,7 +1444,6 @@ class HVACSizing
 
       hvac_sizing_values.Cool_Capacity = hvac_sizing_values.Cool_Load_Tot / totalCap_CurveValue
       hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac.SHRRated[hvac.SizingSpeed]
-      # FIXME: Why not use calc_airflow_rate?
       hvac_sizing_values.Cool_Airflow = hvac.RatedCFMperTonCooling[hvac.SizingSpeed] * UnitConversions.convert(hvac_sizing_values.Cool_Capacity, 'Btu/hr', 'ton')
 
     elsif hvac.CoolType == HPXML::HVACTypeHeatPumpGroundToAir
@@ -1543,7 +1542,6 @@ class HVACSizing
         hvac_sizing_values.Heat_Capacity = hvac_sizing_values.Heat_Load
         hvac_sizing_values.Heat_Capacity_Supp = hvac_sizing_values.Heat_Load
       end
-      # FIXME: Why not use calc_airflow_rate?
       hvac_sizing_values.Heat_Airflow = hvac.RatedCFMperTonHeating[-1] * hvac.CapacityRatioHeating[-1] * UnitConversions.convert(hvac_sizing_values.Heat_Capacity, 'Btu/hr', 'ton') # Maximum air flow under heating operation
 
     elsif hvac.HeatType == HPXML::HVACTypeHeatPumpGroundToAir
@@ -2587,7 +2585,7 @@ class HVACSizing
     else # Unvented space
       ach = 0.1 # Assumption
     end
-    # FUTURE: Reuse code from measure.rb set_zone_volumes()
+    # FUTURE: Reuse code from Geometry.set_zone_volumes()
     if [HPXML::LocationAtticVented, HPXML::LocationAtticUnvented].include? space_type
       floor_area = @hpxml.frame_floors.select { |f| [f.interior_adjacent_to, f.exterior_adjacent_to].include? space_type }.map { |s| s.area }.sum(0.0)
       roofs = @hpxml.roofs.select { |r| r.interior_adjacent_to == space_type }

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/meta_measure.rb

@@ -3,7 +3,8 @@
 require 'fileutils'
 
 def run_hpxml_workflow(rundir, measures, measures_dir, debug: false, output_vars: [],
-                       output_meters: [], run_measures_only: false, print_prefix: '')
+                       output_meters: [], run_measures_only: false, print_prefix: '',
+                       ep_input_format: 'idf')
   rm_path(rundir)
   FileUtils.mkdir_p(rundir)
 
@@ -47,10 +48,10 @@ def run_hpxml_workflow(rundir, measures, measures_dir, debug: false, output_vars
     om.setReportingFrequency(output_meter[1])
   end
 
-  # Translate model to IDF
+  # Translate model to workspace
   forward_translator = OpenStudio::EnergyPlus::ForwardTranslator.new
   forward_translator.setExcludeLCCObjects(true)
-  model_idf = forward_translator.translateModel(model)
+  workspace = forward_translator.translateModel(model)
   success = report_ft_errors_warnings(forward_translator, rundir)
 
   if not success
@@ -60,16 +61,25 @@ def run_hpxml_workflow(rundir, measures, measures_dir, debug: false, output_vars
   end
 
   # Apply reporting measure output requests
-  apply_energyplus_output_requests(measures_dir, measures, runner, model, model_idf)
-
-  # Write IDF to file
-  File.open(File.join(rundir, 'in.idf'), 'w') { |f| f << model_idf.to_s }
+  apply_energyplus_output_requests(measures_dir, measures, runner, model, workspace)
+
+  # Write to file
+  if ep_input_format == 'idf'
+    ep_input_filename = 'in.idf'
+    File.open(File.join(rundir, ep_input_filename), 'w') { |f| f << workspace.to_s }
+  elsif ep_input_format == 'epjson'
+    ep_input_filename = 'in.epJSON'
+    json = OpenStudio::EPJSON::toJSONString(workspace.toIdfFile)
+    File.open(File.join(rundir, ep_input_filename), 'w') { |f| f << json.to_s }
+  else
+    fail "Unexpected ep_input_format: #{ep_input_format}."
+  end
 
   # Run simulation
   print "#{print_prefix}Running simulation...\n"
   ep_path = File.absolute_path(File.join(OpenStudio.getOpenStudioCLI.to_s, '..', '..', 'EnergyPlus', 'energyplus')) # getEnergyPlusDirectory can be unreliable, using getOpenStudioCLI instead
   simulation_start = Time.now
-  command = "\"#{ep_path}\" -w \"#{model.getWeatherFile.path.get}\" in.idf"
+  command = "\"#{ep_path}\" -w \"#{model.getWeatherFile.path.get}\" #{ep_input_filename}"
   if debug
     File.open(File.join(rundir, 'run.log'), 'a') do |f|
       f << "Executing command '#{command}' from working directory '#{rundir}'.\n"
@@ -159,7 +169,7 @@ def apply_measures(measures_dir, measures, runner, model, show_measure_calls = t
   return true
 end
 
-def apply_energyplus_output_requests(measures_dir, measures, runner, model, model_idf)
+def apply_energyplus_output_requests(measures_dir, measures, runner, model, workspace)
   # Call each measure in the specified order
   measures.keys.each do |measure_subdir|
     # Gather measure arguments and call measure
@@ -173,7 +183,7 @@ def apply_energyplus_output_requests(measures_dir, measures, runner, model, mode
       runner.setLastOpenStudioModel(model)
       idf_objects = measure.energyPlusOutputRequests(runner, argument_map)
       idf_objects.each do |idf_object|
-        model_idf.addObject(idf_object)
+        workspace.addObject(idf_object)
       end
     end
   end
@@ -433,6 +443,7 @@ def report_os_warnings(os_log, rundir)
       next if s.logMessage.include? 'WorkflowStepResult value called with undefined stepResult'
       next if s.logMessage.include?("Object of type 'Schedule:Constant' and named 'Always") && s.logMessage.include?('points to an object named') && s.logMessage.include?('but that object cannot be located')
       next if s.logMessage.include? 'Appears there are no design condition fields in the EPW file'
+      next if s.logMessage.include?('Using EnergyPlusVersion version') && s.logMessage.include?("which should have 'Year' field, but it's always zero")
 
       f << "OS Message: #{s.logMessage}\n"
     end

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/minitest_helper.rb

@@ -1,30 +1,8 @@
 # frozen_string_literal: true
 
-called_from_cli = true
-begin
-  OpenStudio.getOpenStudioCLI
-rescue
-  called_from_cli = false
-end
+require 'minitest/autorun'
 
-if not called_from_cli # cli can't load codecov gem
-  require 'simplecov'
-  require 'codecov'
+require 'minitest/reporters'
+require 'minitest/reporters/spec_reporter' # Needed when run via OS CLI
 
-  # save to CircleCI's artifacts directory if we're on CircleCI
-  if ENV['CI']
-    if ENV['CIRCLE_ARTIFACTS']
-      dir = File.join(ENV['CIRCLE_ARTIFACTS'], 'coverage')
-      SimpleCov.coverage_dir(dir)
-    end
-    SimpleCov.formatter = SimpleCov::Formatter::Codecov
-  else
-    SimpleCov.coverage_dir('coverage')
-  end
-  SimpleCov.start
-
-  require 'minitest/autorun'
-  require 'minitest/reporters'
-
-  Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new # spec-like progress
-end
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new # spec-like progress

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/misc_loads.rb

@@ -145,17 +145,18 @@ class MiscLoads
         heater_sch = heater_sch.schedule
       end
 
-      mel_def = OpenStudio::Model::GasEquipmentDefinition.new(model)
-      mel = OpenStudio::Model::GasEquipment.new(mel_def)
-      mel.setName(obj_name)
-      mel.setEndUseSubcategory(obj_name)
-      mel.setSpace(living_space)
-      mel_def.setName(obj_name)
-      mel_def.setDesignLevel(space_design_level)
-      mel_def.setFractionRadiant(0)
-      mel_def.setFractionLatent(0)
-      mel_def.setFractionLost(1)
-      mel.setSchedule(heater_sch)
+      mfl_def = OpenStudio::Model::OtherEquipmentDefinition.new(model)
+      mfl = OpenStudio::Model::OtherEquipment.new(mfl_def)
+      mfl.setName(obj_name)
+      mfl.setEndUseSubcategory(obj_name)
+      mfl.setFuelType(EPlus.fuel_type(HPXML::FuelTypeNaturalGas))
+      mfl.setSpace(living_space)
+      mfl_def.setName(obj_name)
+      mfl_def.setDesignLevel(space_design_level)
+      mfl_def.setFractionRadiant(0)
+      mfl_def.setFractionLatent(0)
+      mfl_def.setFractionLost(1)
+      mfl.setSchedule(heater_sch)
     end
   end
 

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/pv.rb

@@ -9,6 +9,7 @@ class PV
     else
       # Apportion to single dwelling unit by # bedrooms
       fail if pv_system.number_of_bedrooms_served.to_f <= nbeds.to_f # EPvalidator.xml should prevent this
+
       max_power = pv_system.max_power_output * nbeds.to_f / pv_system.number_of_bedrooms_served.to_f
     end
 
@@ -40,7 +41,7 @@ class PV
     ipvwatts.setName("#{obj_name} inverter")
     ipvwatts.setInverterEfficiency(pv_system.inverter_efficiency)
 
-    elcd = gpvwatts.electricLoadCenterDistribution.get
+    elcd = OpenStudio::Model::ElectricLoadCenterDistribution.new(model)
     elcd.setName("#{obj_name} elec load center dist")
     elcd.addGenerator(gpvwatts)
     elcd.setInverter(ipvwatts)

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/schedules.rb

@@ -1086,7 +1086,7 @@ class SchedulesFile
     schedule_file.setColumnNumber(col_index + 1)
     schedule_file.setRowstoSkipatTop(rows_to_skip)
     schedule_file.setNumberofHoursofData(num_hrs_in_year.to_i)
-    schedule_file.setMinutesperItem("#{min_per_item.to_i}")
+    schedule_file.setMinutesperItem(min_per_item.to_i)
 
     return schedule_file
   end
@@ -1220,6 +1220,33 @@ class SchedulesFile
     update(col_names: col_names.keys)
   end
 
+  def set_outage(outage_start_date:,
+                 outage_end_date:)
+
+    minutes_per_step = 60
+    if @model.getSimulationControl.timestep.is_initialized
+      minutes_per_step = 60 / @model.getSimulationControl.timestep.get.numberOfTimestepsPerHour
+    end
+
+    col_names = ScheduleGenerator.col_names
+
+    sec_per_step = minutes_per_step * 60.0
+    col_names.each do |col_name, val|
+      next if col_name == 'occupants'
+      next if val.nil?
+
+      ts = Time.new(outage_start_date.year, 'Jan', 1)
+      @schedules[col_name].each_with_index do |step, i|
+        if outage_start_date <= ts && ts < outage_end_date # in the outage period
+          @schedules[col_name][i] = 0.0
+        end
+        ts += sec_per_step
+      end
+    end
+
+    update(col_names: col_names.keys)
+  end
+
   def import(col_names:)
     @schedules = {}
     col_names += ['vacancy']

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/simcontrols.rb

@@ -1,23 +1,34 @@
 # frozen_string_literal: true
 
 class SimControls
-  def self.apply(model, header)
+  def self.apply(model, hpxml)
     sim = model.getSimulationControl
     sim.setRunSimulationforSizingPeriods(false)
 
     tstep = model.getTimestep
-    tstep.setNumberOfTimestepsPerHour(60 / header.timestep)
+    tstep.setNumberOfTimestepsPerHour(60 / hpxml.header.timestep)
 
     shad = model.getShadowCalculation
     shad.setMaximumFiguresInShadowOverlapCalculations(200)
-    # Detailed diffuse algorithm is required for window interior shading with varying
-    # transmittance schedules
-    shad.setSkyDiffuseModelingAlgorithm('DetailedSkyDiffuseModeling')
     # Use EnergyPlus default of 20 days for update frequency; it is a reasonable balance
     # between speed and accuracy (e.g., sun position, picking up any change in window
     # interior shading transmittance, etc.).
     shad.setShadingCalculationUpdateFrequency(20)
 
+    has_windows_varying_transmittance = false
+    hpxml.windows.each do |window|
+      sf_summer = window.interior_shading_factor_summer * window.exterior_shading_factor_summer
+      sf_winter = window.interior_shading_factor_winter * window.exterior_shading_factor_winter
+      next if sf_summer == sf_winter
+
+      has_windows_varying_transmittance = true
+    end
+    if has_windows_varying_transmittance
+      # Detailed diffuse algorithm is required for window interior shading with varying
+      # transmittance schedules
+      shad.setSkyDiffuseModelingAlgorithm('DetailedSkyDiffuseModeling')
+    end
+
     outsurf = model.getOutsideSurfaceConvectionAlgorithm
     outsurf.setAlgorithm('DOE-2')
 
@@ -31,9 +42,9 @@ class SimControls
     convlim.setMinimumSystemTimestep(0)
 
     run_period = model.getRunPeriod
-    run_period.setBeginMonth(header.sim_begin_month)
-    run_period.setBeginDayOfMonth(header.sim_begin_day)
-    run_period.setEndMonth(header.sim_end_month)
-    run_period.setEndDayOfMonth(header.sim_end_day)
+    run_period.setBeginMonth(hpxml.header.sim_begin_month)
+    run_period.setBeginDayOfMonth(hpxml.header.sim_begin_day)
+    run_period.setEndMonth(hpxml.header.sim_end_month)
+    run_period.setEndDayOfMonth(hpxml.header.sim_end_day)
   end
 end

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/version.rb

@@ -2,7 +2,7 @@
 
 class Version
   OS_HPXML_Version = '1.1.0' # Version of the OS-HPXML workflow
-  OS_Version = '3.1.0' # Required version of OpenStudio (can be 'X.X' or 'X.X.X')
+  OS_Version = '3.2.0' # Required version of OpenStudio (can be 'X.X' or 'X.X.X')
   HPXML_Version = '3.0' # HPXML schemaVersion
 
   def self.check_openstudio_version

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/waterheater.rb

@@ -183,6 +183,7 @@ class Waterheater
       if water_heating_system.standby_loss <= 0
         fail 'A negative indirect water heater standby loss was calculated, double check water heater inputs.'
       end
+
       act_vol = calc_storage_tank_actual_vol(water_heating_system.tank_volume, nil)
       a_side = calc_tank_areas(act_vol)[1]
       ua = calc_indirect_ua_with_standbyloss(act_vol, water_heating_system, a_side, solar_fraction)

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/xmlhelper.rb

@@ -62,6 +62,7 @@ class XMLHelper
     if element.nil?
       return
     end
+
     value = element.text
 
     if datatype == :integer