urbanopt-cli 0.9.2 → 0.10.0

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

@@ -1,50 +1,75 @@
 # frozen_string_literal: true
 
 class Lighting
-  def self.apply(runner, model, epw_file, spaces, lighting_groups, lighting, eri_version, schedules_file, cfa)
+  def self.apply(runner, model, epw_file, spaces, lighting_groups, lighting, eri_version, schedules_file, cfa, unavailable_periods)
+    ltg_locns = [HPXML::LocationInterior, HPXML::LocationExterior, HPXML::LocationGarage]
+    ltg_types = [HPXML::LightingTypeCFL, HPXML::LightingTypeLFL, HPXML::LightingTypeLED]
+
+    kwhs_per_year = {}
     fractions = {}
     lighting_groups.each do |lg|
-      fractions[[lg.location, lg.lighting_type]] = lg.fraction_of_units_in_location
+      if ltg_locns.include?(lg.location) && (not lg.kwh_per_year.nil?)
+        kwhs_per_year[lg.location] = lg.kwh_per_year
+      elsif ltg_locns.include?(lg.location) && ltg_types.include?(lg.lighting_type) && (not lg.fraction_of_units_in_location.nil?)
+        fractions[[lg.location, lg.lighting_type]] = lg.fraction_of_units_in_location
+      end
     end
 
-    if fractions[[HPXML::LocationInterior, HPXML::LightingTypeCFL]].nil? # Not the lighting group(s) we're interested in
-      return
+    # Calculate interior lighting kWh/yr
+    int_kwh = kwhs_per_year[HPXML::LocationInterior]
+    if int_kwh.nil?
+      int_kwh = calc_interior_energy(eri_version, cfa,
+                                     fractions[[HPXML::LocationInterior, HPXML::LightingTypeCFL]],
+                                     fractions[[HPXML::LocationInterior, HPXML::LightingTypeLFL]],
+                                     fractions[[HPXML::LocationInterior, HPXML::LightingTypeLED]],
+                                     lighting.interior_usage_multiplier)
+    end
+    int_kwh = 0.0 if int_kwh.nil?
+
+    # Calculate exterior lighting kWh/yr
+    ext_kwh = kwhs_per_year[HPXML::LocationExterior]
+    if ext_kwh.nil?
+      ext_kwh = calc_exterior_energy(eri_version, cfa,
+                                     fractions[[HPXML::LocationExterior, HPXML::LightingTypeCFL]],
+                                     fractions[[HPXML::LocationExterior, HPXML::LightingTypeLFL]],
+                                     fractions[[HPXML::LocationExterior, HPXML::LightingTypeLED]],
+                                     lighting.exterior_usage_multiplier)
     end
+    ext_kwh = 0.0 if ext_kwh.nil?
+
+    # Calculate garage lighting kWh/yr
+    grg_kwh = kwhs_per_year[HPXML::LocationGarage]
+    if grg_kwh.nil?
+      gfa = 0 # Garage floor area
+      if spaces.keys.include? HPXML::LocationGarage
+        gfa = UnitConversions.convert(spaces[HPXML::LocationGarage].floorArea, 'm^2', 'ft^2')
+      end
 
-    gfa = 0
-    if spaces.keys.include? HPXML::LocationGarage
-      gfa = UnitConversions.convert(spaces[HPXML::LocationGarage].floorArea, 'm^2', 'ft^2')
+      grg_kwh = calc_garage_energy(eri_version, gfa,
+                                   fractions[[HPXML::LocationGarage, HPXML::LightingTypeCFL]],
+                                   fractions[[HPXML::LocationGarage, HPXML::LightingTypeLFL]],
+                                   fractions[[HPXML::LocationGarage, HPXML::LightingTypeLED]],
+                                   lighting.garage_usage_multiplier)
     end
+    grg_kwh = 0.0 if grg_kwh.nil?
 
-    int_kwh, ext_kwh, grg_kwh = calc_energy(eri_version, cfa, gfa,
-                                            fractions[[HPXML::LocationInterior, HPXML::LightingTypeCFL]],
-                                            fractions[[HPXML::LocationExterior, HPXML::LightingTypeCFL]],
-                                            fractions[[HPXML::LocationGarage, HPXML::LightingTypeCFL]],
-                                            fractions[[HPXML::LocationInterior, HPXML::LightingTypeLFL]],
-                                            fractions[[HPXML::LocationExterior, HPXML::LightingTypeLFL]],
-                                            fractions[[HPXML::LocationGarage, HPXML::LightingTypeLFL]],
-                                            fractions[[HPXML::LocationInterior, HPXML::LightingTypeLED]],
-                                            fractions[[HPXML::LocationExterior, HPXML::LightingTypeLED]],
-                                            fractions[[HPXML::LocationGarage, HPXML::LightingTypeLED]],
-                                            lighting.interior_usage_multiplier,
-                                            lighting.garage_usage_multiplier,
-                                            lighting.exterior_usage_multiplier)
-
-    # Add lighting to each conditioned space
+    # Add lighting to conditioned space
     if int_kwh > 0
 
       # Create schedule
       interior_sch = nil
+      interior_col_name = SchedulesFile::ColumnLightingInterior
       if not schedules_file.nil?
-        design_level = schedules_file.calc_design_level_from_annual_kwh(col_name: SchedulesFile::ColumnLightingInterior, annual_kwh: int_kwh)
-        interior_sch = schedules_file.create_schedule_file(col_name: SchedulesFile::ColumnLightingInterior)
+        design_level = schedules_file.calc_design_level_from_annual_kwh(col_name: interior_col_name, annual_kwh: int_kwh)
+        interior_sch = schedules_file.create_schedule_file(col_name: interior_col_name)
       end
       if interior_sch.nil?
+        interior_unavailable_periods = Schedule.get_unavailable_periods(runner, interior_col_name, unavailable_periods)
         if not lighting.interior_weekday_fractions.nil?
-          interior_sch = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameInteriorLighting + ' schedule', lighting.interior_weekday_fractions, lighting.interior_weekend_fractions, lighting.interior_monthly_multipliers, Constants.ScheduleTypeLimitsFraction)
+          interior_sch = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameInteriorLighting + ' schedule', lighting.interior_weekday_fractions, lighting.interior_weekend_fractions, lighting.interior_monthly_multipliers, Constants.ScheduleTypeLimitsFraction, unavailable_periods: interior_unavailable_periods)
         else
           lighting_sch = get_schedule(epw_file)
-          interior_sch = HourlyByMonthSchedule.new(model, 'lighting schedule', lighting_sch, lighting_sch, Constants.ScheduleTypeLimitsFraction)
+          interior_sch = HourlyByMonthSchedule.new(model, 'lighting schedule', lighting_sch, lighting_sch, Constants.ScheduleTypeLimitsFraction, unavailable_periods: interior_unavailable_periods)
         end
 
         if lighting.interior_weekday_fractions.nil?
@@ -54,9 +79,9 @@ class Lighting
         end
         interior_sch = interior_sch.schedule
       else
-        runner.registerWarning("Both '#{SchedulesFile::ColumnLightingInterior}' schedule file and weekday fractions provided; the latter will be ignored.") if !lighting.interior_weekday_fractions.nil?
-        runner.registerWarning("Both '#{SchedulesFile::ColumnLightingInterior}' schedule file and weekend fractions provided; the latter will be ignored.") if !lighting.interior_weekend_fractions.nil?
-        runner.registerWarning("Both '#{SchedulesFile::ColumnLightingInterior}' schedule file and monthly multipliers provided; the latter will be ignored.") if !lighting.interior_monthly_multipliers.nil?
+        runner.registerWarning("Both '#{interior_col_name}' schedule file and weekday fractions provided; the latter will be ignored.") if !lighting.interior_weekday_fractions.nil?
+        runner.registerWarning("Both '#{interior_col_name}' schedule file and weekend fractions provided; the latter will be ignored.") if !lighting.interior_weekend_fractions.nil?
+        runner.registerWarning("Both '#{interior_col_name}' schedule file and monthly multipliers provided; the latter will be ignored.") if !lighting.interior_monthly_multipliers.nil?
       end
 
       # Add lighting
@@ -73,23 +98,25 @@ class Lighting
       ltg.setSchedule(interior_sch)
     end
 
-    # Add lighting to each garage space
+    # Add lighting to garage space
     if grg_kwh > 0
 
       # Create schedule
       garage_sch = nil
+      garage_col_name = SchedulesFile::ColumnLightingGarage
       if not schedules_file.nil?
-        design_level = schedules_file.calc_design_level_from_annual_kwh(col_name: SchedulesFile::ColumnLightingGarage, annual_kwh: grg_kwh)
-        garage_sch = schedules_file.create_schedule_file(col_name: SchedulesFile::ColumnLightingGarage)
+        design_level = schedules_file.calc_design_level_from_annual_kwh(col_name: garage_col_name, annual_kwh: grg_kwh)
+        garage_sch = schedules_file.create_schedule_file(col_name: garage_col_name)
       end
       if garage_sch.nil?
-        garage_sch = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameGarageLighting + ' schedule', lighting.garage_weekday_fractions, lighting.garage_weekend_fractions, lighting.garage_monthly_multipliers, Constants.ScheduleTypeLimitsFraction)
+        garage_unavailable_periods = Schedule.get_unavailable_periods(runner, garage_col_name, unavailable_periods)
+        garage_sch = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameGarageLighting + ' schedule', lighting.garage_weekday_fractions, lighting.garage_weekend_fractions, lighting.garage_monthly_multipliers, Constants.ScheduleTypeLimitsFraction, unavailable_periods: garage_unavailable_periods)
         design_level = garage_sch.calc_design_level_from_daily_kwh(grg_kwh / 365.0)
         garage_sch = garage_sch.schedule
       else
-        runner.registerWarning("Both '#{SchedulesFile::ColumnLightingGarage}' schedule file and weekday fractions provided; the latter will be ignored.") if !lighting.garage_weekday_fractions.nil?
-        runner.registerWarning("Both '#{SchedulesFile::ColumnLightingGarage}' schedule file and weekend fractions provided; the latter will be ignored.") if !lighting.garage_weekend_fractions.nil?
-        runner.registerWarning("Both '#{SchedulesFile::ColumnLightingGarage}' schedule file and monthly multipliers provided; the latter will be ignored.") if !lighting.garage_monthly_multipliers.nil?
+        runner.registerWarning("Both '#{garage_col_name}' schedule file and weekday fractions provided; the latter will be ignored.") if !lighting.garage_weekday_fractions.nil?
+        runner.registerWarning("Both '#{garage_col_name}' schedule file and weekend fractions provided; the latter will be ignored.") if !lighting.garage_weekend_fractions.nil?
+        runner.registerWarning("Both '#{garage_col_name}' schedule file and monthly multipliers provided; the latter will be ignored.") if !lighting.garage_monthly_multipliers.nil?
       end
 
       # Add lighting
@@ -106,22 +133,25 @@ class Lighting
       ltg.setSchedule(garage_sch)
     end
 
+    # Add exterior lighting
     if ext_kwh > 0
 
       # Create schedule
       exterior_sch = nil
+      exterior_col_name = SchedulesFile::ColumnLightingExterior
       if not schedules_file.nil?
-        design_level = schedules_file.calc_design_level_from_annual_kwh(col_name: SchedulesFile::ColumnLightingExterior, annual_kwh: ext_kwh)
-        exterior_sch = schedules_file.create_schedule_file(col_name: SchedulesFile::ColumnLightingExterior)
+        design_level = schedules_file.calc_design_level_from_annual_kwh(col_name: exterior_col_name, annual_kwh: ext_kwh)
+        exterior_sch = schedules_file.create_schedule_file(col_name: exterior_col_name)
       end
       if exterior_sch.nil?
-        exterior_sch = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameExteriorLighting + ' schedule', lighting.exterior_weekday_fractions, lighting.exterior_weekend_fractions, lighting.exterior_monthly_multipliers, Constants.ScheduleTypeLimitsFraction)
+        exterior_unavailable_periods = Schedule.get_unavailable_periods(runner, exterior_col_name, unavailable_periods)
+        exterior_sch = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameExteriorLighting + ' schedule', lighting.exterior_weekday_fractions, lighting.exterior_weekend_fractions, lighting.exterior_monthly_multipliers, Constants.ScheduleTypeLimitsFraction, unavailable_periods: exterior_unavailable_periods)
         design_level = exterior_sch.calc_design_level_from_daily_kwh(ext_kwh / 365.0)
         exterior_sch = exterior_sch.schedule
       else
-        runner.registerWarning("Both '#{SchedulesFile::ColumnLightingExterior}' schedule file and weekday fractions provided; the latter will be ignored.") if !lighting.exterior_weekday_fractions.nil?
-        runner.registerWarning("Both '#{SchedulesFile::ColumnLightingExterior}' schedule file and weekend fractions provided; the latter will be ignored.") if !lighting.exterior_weekend_fractions.nil?
-        runner.registerWarning("Both '#{SchedulesFile::ColumnLightingExterior}' schedule file and monthly multipliers provided; the latter will be ignored.") if !lighting.exterior_monthly_multipliers.nil?
+        runner.registerWarning("Both '#{exterior_col_name}' schedule file and weekday fractions provided; the latter will be ignored.") if !lighting.exterior_weekday_fractions.nil?
+        runner.registerWarning("Both '#{exterior_col_name}' schedule file and weekend fractions provided; the latter will be ignored.") if !lighting.exterior_weekend_fractions.nil?
+        runner.registerWarning("Both '#{exterior_col_name}' schedule file and monthly multipliers provided; the latter will be ignored.") if !lighting.exterior_monthly_multipliers.nil?
       end
 
       # Add exterior lighting
@@ -134,22 +164,25 @@ class Lighting
       ltg.setSchedule(exterior_sch)
     end
 
+    # Add exterior holiday lighting
     if not lighting.holiday_kwh_per_day.nil?
 
       # Create schedule
       exterior_holiday_sch = nil
+      exterior_holiday_col_name = SchedulesFile::ColumnLightingExteriorHoliday
       if not schedules_file.nil?
-        design_level = schedules_file.calc_design_level_from_daily_kwh(col_name: SchedulesFile::ColumnLightingExteriorHoliday, daily_kwh: lighting.holiday_kwh_per_day)
-        exterior_holiday_sch = schedules_file.create_schedule_file(col_name: SchedulesFile::ColumnLightingExteriorHoliday)
+        design_level = schedules_file.calc_design_level_from_daily_kwh(col_name: exterior_holiday_col_name, daily_kwh: lighting.holiday_kwh_per_day)
+        exterior_holiday_sch = schedules_file.create_schedule_file(col_name: exterior_holiday_col_name)
       end
       if exterior_holiday_sch.nil?
-        exterior_holiday_sch = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameLightingExteriorHoliday + ' schedule', lighting.holiday_weekday_fractions, lighting.holiday_weekend_fractions, lighting.exterior_monthly_multipliers, Constants.ScheduleTypeLimitsFraction, true, lighting.holiday_period_begin_month, lighting.holiday_period_begin_day, lighting.holiday_period_end_month, lighting.holiday_period_end_day)
+        exterior_holiday_unavailable_periods = Schedule.get_unavailable_periods(runner, exterior_holiday_col_name, unavailable_periods)
+        exterior_holiday_sch = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameLightingExteriorHoliday + ' schedule', lighting.holiday_weekday_fractions, lighting.holiday_weekend_fractions, lighting.exterior_monthly_multipliers, Constants.ScheduleTypeLimitsFraction, true, lighting.holiday_period_begin_month, lighting.holiday_period_begin_day, lighting.holiday_period_end_month, lighting.holiday_period_end_day, unavailable_periods: exterior_holiday_unavailable_periods)
         design_level = exterior_holiday_sch.calc_design_level_from_daily_kwh(lighting.holiday_kwh_per_day)
         exterior_holiday_sch = exterior_holiday_sch.schedule
       else
-        runner.registerWarning("Both '#{SchedulesFile::ColumnLightingExteriorHoliday}' schedule file and weekday fractions provided; the latter will be ignored.") if !lighting.holiday_weekday_fractions.nil?
-        runner.registerWarning("Both '#{SchedulesFile::ColumnLightingExteriorHoliday}' schedule file and weekend fractions provided; the latter will be ignored.") if !lighting.holiday_weekend_fractions.nil?
-        runner.registerWarning("Both '#{SchedulesFile::ColumnLightingExteriorHoliday}' schedule file and monthly multipliers provided; the latter will be ignored.") if !lighting.exterior_monthly_multipliers.nil?
+        runner.registerWarning("Both '#{exterior_holiday_col_name}' schedule file and weekday fractions provided; the latter will be ignored.") if !lighting.holiday_weekday_fractions.nil?
+        runner.registerWarning("Both '#{exterior_holiday_col_name}' schedule file and weekend fractions provided; the latter will be ignored.") if !lighting.holiday_weekend_fractions.nil?
+        runner.registerWarning("Both '#{exterior_holiday_col_name}' schedule file and monthly multipliers provided; the latter will be ignored.") if !lighting.exterior_monthly_multipliers.nil?
       end
 
       # Add exterior holiday lighting
@@ -179,20 +212,15 @@ class Lighting
 
   private
 
-  def self.calc_energy(eri_version, cfa, gfa, f_int_cfl, f_ext_cfl, f_grg_cfl, f_int_lfl, f_ext_lfl, f_grg_lfl,
-                       f_int_led, f_ext_led, f_grg_led,
-                       interior_usage_multiplier = 1.0, garage_usage_multiplier = 1.0, exterior_usage_multiplier = 1.0)
+  def self.calc_interior_energy(eri_version, cfa, f_int_cfl, f_int_lfl, f_int_led, interior_usage_multiplier = 1.0)
+    return if f_int_cfl.nil? || f_int_lfl.nil? || f_int_led.nil?
 
     if Constants.ERIVersions.index(eri_version) >= Constants.ERIVersions.index('2014AEG')
-      # Calculate fluorescent (CFL + LFL) fractions
+      # Calculate fluorescent (CFL + LFL) fraction
       f_int_fl = f_int_cfl + f_int_lfl
-      f_ext_fl = f_ext_cfl + f_ext_lfl
-      f_grg_fl = f_grg_cfl + f_grg_lfl
 
-      # Calculate incandescent fractions
+      # Calculate incandescent fraction
       f_int_inc = 1.0 - f_int_fl - f_int_led
-      f_ext_inc = 1.0 - f_ext_fl - f_ext_led
-      f_grg_inc = 1.0 - f_grg_fl - f_grg_led
 
       # Efficacies (lm/W)
       eff_inc = 15.0
@@ -204,38 +232,104 @@ class Lighting
       eff_ratio_fl = eff_inc / eff_fl
       eff_ratio_led = eff_inc / eff_led
 
-      # Efficiency lighting adjustments
+      # Efficiency lighting adjustment
       int_adj = (f_int_inc * eff_ratio_inc) + (f_int_fl * eff_ratio_fl) + (f_int_led * eff_ratio_led)
-      ext_adj = (f_ext_inc * eff_ratio_inc) + (f_ext_fl * eff_ratio_fl) + (f_ext_led * eff_ratio_led)
-      grg_adj = (f_grg_inc * eff_ratio_inc) + (f_grg_fl * eff_ratio_fl) + (f_grg_led * eff_ratio_led)
 
       # Calculate energy use
       int_kwh = (0.9 / 0.925 * (455.0 + 0.8 * cfa) * int_adj) + (0.1 * (455.0 + 0.8 * cfa))
+    else
+      # Calculate efficient lighting fraction
+      fF_int = f_int_cfl + f_int_lfl + f_int_led
+
+      # Calculate energy use
+      int_kwh = 0.8 * ((4.0 - 3.0 * fF_int) / 3.7) * (455.0 + 0.8 * cfa) + 0.2 * (455.0 + 0.8 * cfa)
+    end
+
+    int_kwh *= interior_usage_multiplier
+
+    return int_kwh
+  end
+
+  def self.calc_exterior_energy(eri_version, cfa, f_ext_cfl, f_ext_lfl, f_ext_led, exterior_usage_multiplier = 1.0)
+    return if f_ext_cfl.nil? || f_ext_lfl.nil? || f_ext_led.nil?
+
+    if Constants.ERIVersions.index(eri_version) >= Constants.ERIVersions.index('2014AEG')
+      # Calculate fluorescent (CFL + LFL) fraction
+      f_ext_fl = f_ext_cfl + f_ext_lfl
+
+      # Calculate incandescent fraction
+      f_ext_inc = 1.0 - f_ext_fl - f_ext_led
+
+      # Efficacies (lm/W)
+      eff_inc = 15.0
+      eff_fl = 60.0
+      eff_led = 90.0
+
+      # Efficacy ratios
+      eff_ratio_inc = eff_inc / eff_inc
+      eff_ratio_fl = eff_inc / eff_fl
+      eff_ratio_led = eff_inc / eff_led
+
+      # Efficiency lighting adjustment
+      ext_adj = (f_ext_inc * eff_ratio_inc) + (f_ext_fl * eff_ratio_fl) + (f_ext_led * eff_ratio_led)
+
+      # Calculate energy use
       ext_kwh = (100.0 + 0.05 * cfa) * ext_adj
+    else
+      # Calculate efficient lighting fraction
+      fF_ext = f_ext_cfl + f_ext_lfl + f_ext_led
+
+      # Calculate energy use
+      ext_kwh = (100.0 + 0.05 * cfa) * (1.0 - fF_ext) + 0.25 * (100.0 + 0.05 * cfa) * fF_ext
+    end
+
+    ext_kwh *= exterior_usage_multiplier
+
+    return ext_kwh
+  end
+
+  def self.calc_garage_energy(eri_version, gfa, f_grg_cfl, f_grg_lfl, f_grg_led, garage_usage_multiplier = 1.0)
+    return if f_grg_cfl.nil? || f_grg_lfl.nil? || f_grg_led.nil?
+
+    if Constants.ERIVersions.index(eri_version) >= Constants.ERIVersions.index('2014AEG')
+      # Calculate fluorescent (CFL + LFL) fraction
+      f_grg_fl = f_grg_cfl + f_grg_lfl
+
+      # Calculate incandescent fraction
+      f_grg_inc = 1.0 - f_grg_fl - f_grg_led
+
+      # Efficacies (lm/W)
+      eff_inc = 15.0
+      eff_fl = 60.0
+      eff_led = 90.0
+
+      # Efficacy ratios
+      eff_ratio_inc = eff_inc / eff_inc
+      eff_ratio_fl = eff_inc / eff_fl
+      eff_ratio_led = eff_inc / eff_led
+
+      # Efficiency lighting adjustment
+      grg_adj = (f_grg_inc * eff_ratio_inc) + (f_grg_fl * eff_ratio_fl) + (f_grg_led * eff_ratio_led)
+
+      # Calculate energy use
       grg_kwh = 0.0
       if gfa > 0
         grg_kwh = 100.0 * grg_adj
       end
     else
-      # Calculate efficient lighting fractions
-      fF_int = f_int_cfl + f_int_lfl + f_int_led
-      fF_ext = f_ext_cfl + f_ext_lfl + f_ext_led
+      # Calculate efficient lighting fraction
       fF_grg = f_grg_cfl + f_grg_lfl + f_grg_led
 
       # Calculate energy use
-      int_kwh = 0.8 * ((4.0 - 3.0 * fF_int) / 3.7) * (455.0 + 0.8 * cfa) + 0.2 * (455.0 + 0.8 * cfa)
-      ext_kwh = (100.0 + 0.05 * cfa) * (1.0 - fF_ext) + 0.25 * (100.0 + 0.05 * cfa) * fF_ext
       grg_kwh = 0.0
       if gfa > 0
         grg_kwh = 100.0 * (1.0 - fF_grg) + 25.0 * fF_grg
       end
     end
 
-    int_kwh *= interior_usage_multiplier
-    ext_kwh *= exterior_usage_multiplier
     grg_kwh *= garage_usage_multiplier
 
-    return int_kwh, ext_kwh, grg_kwh
+    return grg_kwh
   end
 
   def self.get_schedule(epw_file)

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

@@ -8,26 +8,10 @@ class Location
     apply_ground_temps(model, weather)
   end
 
-  def self.apply_weather_file(model, runner, weather_file_path, weather_cache_path)
-    if File.exist?(weather_file_path) && weather_file_path.downcase.end_with?('.epw')
-      epw_file = OpenStudio::EpwFile.new(weather_file_path)
-    else
-      fail "'#{weather_file_path}' does not exist or is not an .epw file."
-    end
-
-    OpenStudio::Model::WeatherFile.setWeatherFile(model, epw_file).get
-
-    # Obtain weather object
-    # Load from cache .csv file if exists, as this is faster and doesn't require
-    # parsing the weather file.
-    if File.exist? weather_cache_path
-      weather = WeatherProcess.new(nil, nil, weather_cache_path)
-    end
-    if weather.nil? || weather.data.AnnualAvgDrybulb.nil?
-      weather = WeatherProcess.new(model, runner)
-    end
-
-    return weather, epw_file
+  def self.apply_weather_file(model, epw_path)
+    epw_file = OpenStudio::EpwFile.new(epw_path)
+    OpenStudio::Model::WeatherFile.setWeatherFile(model, epw_file)
+    return epw_file
   end
 
   private

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

@@ -498,6 +498,7 @@ def report_os_warnings(os_log, rundir)
       next if s.logMessage.include? 'Valid instance'
       next if s.logMessage.include? 'xsdValidate'
       next if s.logMessage.include? 'xsltValidate'
+      next if s.logLevel == 0 && s.logMessage.include?('not within the expected limits') # Ignore EpwFile warnings
 
       f << "OS Message: #{s.logMessage}\n"
     end
@@ -536,31 +537,32 @@ end
 def get_argument_values(runner, arguments, user_arguments)
   args = {}
   arguments.each do |argument|
+    key = argument.name.to_sym
     if argument.required
       case argument.type
       when 'Choice'.to_OSArgumentType
-        args[argument.name] = runner.getStringArgumentValue(argument.name, user_arguments)
+        args[key] = runner.getStringArgumentValue(argument.name, user_arguments)
       when 'Boolean'.to_OSArgumentType
-        args[argument.name] = runner.getBoolArgumentValue(argument.name, user_arguments)
+        args[key] = runner.getBoolArgumentValue(argument.name, user_arguments)
       when 'Double'.to_OSArgumentType
-        args[argument.name] = runner.getDoubleArgumentValue(argument.name, user_arguments)
+        args[key] = runner.getDoubleArgumentValue(argument.name, user_arguments)
       when 'Integer'.to_OSArgumentType
-        args[argument.name] = runner.getIntegerArgumentValue(argument.name, user_arguments)
+        args[key] = runner.getIntegerArgumentValue(argument.name, user_arguments)
       when 'String'.to_OSArgumentType
-        args[argument.name] = runner.getStringArgumentValue(argument.name, user_arguments)
+        args[key] = runner.getStringArgumentValue(argument.name, user_arguments)
       end
     else
       case argument.type
       when 'Choice'.to_OSArgumentType
-        args[argument.name] = runner.getOptionalStringArgumentValue(argument.name, user_arguments)
+        args[key] = runner.getOptionalStringArgumentValue(argument.name, user_arguments)
       when 'Boolean'.to_OSArgumentType
-        args[argument.name] = runner.getOptionalBoolArgumentValue(argument.name, user_arguments)
+        args[key] = runner.getOptionalBoolArgumentValue(argument.name, user_arguments)
       when 'Double'.to_OSArgumentType
-        args[argument.name] = runner.getOptionalDoubleArgumentValue(argument.name, user_arguments)
+        args[key] = runner.getOptionalDoubleArgumentValue(argument.name, user_arguments)
       when 'Integer'.to_OSArgumentType
-        args[argument.name] = runner.getOptionalIntegerArgumentValue(argument.name, user_arguments)
+        args[key] = runner.getOptionalIntegerArgumentValue(argument.name, user_arguments)
       when 'String'.to_OSArgumentType
-        args[argument.name] = runner.getOptionalStringArgumentValue(argument.name, user_arguments)
+        args[key] = runner.getOptionalStringArgumentValue(argument.name, user_arguments)
       end
     end
   end

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

@@ -1,31 +1,32 @@
 # frozen_string_literal: true
 
 class MiscLoads
-  def self.apply_plug(model, runner, plug_load, obj_name, living_space, apply_ashrae140_assumptions, schedules_file)
+  def self.apply_plug(model, runner, plug_load, obj_name, living_space, apply_ashrae140_assumptions, schedules_file, unavailable_periods)
     kwh = 0
     if not plug_load.nil?
-      kwh = plug_load.kWh_per_year * plug_load.usage_multiplier
+      kwh = plug_load.kwh_per_year * plug_load.usage_multiplier
     end
 
     return if kwh <= 0
 
     # Create schedule
     sch = nil
+    if plug_load.plug_load_type == HPXML::PlugLoadTypeOther
+      col_name = SchedulesFile::ColumnPlugLoadsOther
+    elsif plug_load.plug_load_type == HPXML::PlugLoadTypeTelevision
+      col_name = SchedulesFile::ColumnPlugLoadsTV
+    elsif plug_load.plug_load_type == HPXML::PlugLoadTypeElectricVehicleCharging
+      col_name = SchedulesFile::ColumnPlugLoadsVehicle
+    elsif plug_load.plug_load_type == HPXML::PlugLoadTypeWellPump
+      col_name = SchedulesFile::ColumnPlugLoadsWellPump
+    end
     if not schedules_file.nil?
-      if plug_load.plug_load_type == HPXML::PlugLoadTypeOther
-        col_name = SchedulesFile::ColumnPlugLoadsOther
-      elsif plug_load.plug_load_type == HPXML::PlugLoadTypeTelevision
-        col_name = SchedulesFile::ColumnPlugLoadsTV
-      elsif plug_load.plug_load_type == HPXML::PlugLoadTypeElectricVehicleCharging
-        col_name = SchedulesFile::ColumnPlugLoadsVehicle
-      elsif plug_load.plug_load_type == HPXML::PlugLoadTypeWellPump
-        col_name = SchedulesFile::ColumnPlugLoadsWellPump
-      end
       space_design_level = schedules_file.calc_design_level_from_annual_kwh(col_name: col_name, annual_kwh: kwh)
       sch = schedules_file.create_schedule_file(col_name: col_name)
     end
     if sch.nil?
-      sch = MonthWeekdayWeekendSchedule.new(model, obj_name + ' schedule', plug_load.weekday_fractions, plug_load.weekend_fractions, plug_load.monthly_multipliers, Constants.ScheduleTypeLimitsFraction)
+      col_unavailable_periods = Schedule.get_unavailable_periods(runner, col_name, unavailable_periods)
+      sch = MonthWeekdayWeekendSchedule.new(model, obj_name + ' schedule', plug_load.weekday_fractions, plug_load.weekend_fractions, plug_load.monthly_multipliers, Constants.ScheduleTypeLimitsFraction, unavailable_periods: col_unavailable_periods)
       space_design_level = sch.calc_design_level_from_daily_kwh(kwh / 365.0)
       sch = sch.schedule
     else
@@ -58,7 +59,7 @@ class MiscLoads
     mel.setSchedule(sch)
   end
 
-  def self.apply_fuel(model, runner, fuel_load, obj_name, living_space, schedules_file)
+  def self.apply_fuel(model, runner, fuel_load, obj_name, living_space, schedules_file, unavailable_periods)
     therm = 0
 
     if not fuel_load.nil?
@@ -66,19 +67,20 @@ class MiscLoads
 
       # Create schedule
       sch = nil
+      if fuel_load.fuel_load_type == HPXML::FuelLoadTypeGrill
+        col_name = SchedulesFile::ColumnFuelLoadsGrill
+      elsif fuel_load.fuel_load_type == HPXML::FuelLoadTypeLighting
+        col_name = SchedulesFile::ColumnFuelLoadsLighting
+      elsif fuel_load.fuel_load_type == HPXML::FuelLoadTypeFireplace
+        col_name = SchedulesFile::ColumnFuelLoadsFireplace
+      end
       if not schedules_file.nil?
-        if fuel_load.fuel_load_type == HPXML::FuelLoadTypeGrill
-          col_name = SchedulesFile::ColumnFuelLoadsGrill
-        elsif fuel_load.fuel_load_type == HPXML::FuelLoadTypeLighting
-          col_name = SchedulesFile::ColumnFuelLoadsLighting
-        elsif fuel_load.fuel_load_type == HPXML::FuelLoadTypeFireplace
-          col_name = SchedulesFile::ColumnFuelLoadsFireplace
-        end
         space_design_level = schedules_file.calc_design_level_from_annual_therm(col_name: col_name, annual_therm: therm)
         sch = schedules_file.create_schedule_file(col_name: col_name)
       end
       if sch.nil?
-        sch = MonthWeekdayWeekendSchedule.new(model, obj_name + ' schedule', fuel_load.weekday_fractions, fuel_load.weekend_fractions, fuel_load.monthly_multipliers, Constants.ScheduleTypeLimitsFraction)
+        col_unavailable_periods = Schedule.get_unavailable_periods(runner, col_name, unavailable_periods)
+        sch = MonthWeekdayWeekendSchedule.new(model, obj_name + ' schedule', fuel_load.weekday_fractions, fuel_load.weekend_fractions, fuel_load.monthly_multipliers, Constants.ScheduleTypeLimitsFraction, unavailable_periods: col_unavailable_periods)
         space_design_level = sch.calc_design_level_from_daily_therm(therm / 365.0)
         sch = sch.schedule
       else
@@ -108,7 +110,7 @@ class MiscLoads
     mfl.setSchedule(sch)
   end
 
-  def self.apply_pool_or_hot_tub_heater(runner, model, pool_or_hot_tub, obj_name, living_space, schedules_file)
+  def self.apply_pool_or_hot_tub_heater(runner, model, pool_or_hot_tub, obj_name, living_space, schedules_file, unavailable_periods)
     return if pool_or_hot_tub.heater_type == HPXML::TypeNone
 
     heater_kwh = 0
@@ -116,16 +118,13 @@ class MiscLoads
 
     # Create schedule
     heater_sch = nil
+    col_name = (obj_name.include?('pool') ? 'pool_heater' : 'hot_tub_heater')
     if not schedules_file.nil?
-      if obj_name.include?('pool')
-        col_name = 'pool_heater'
-      else
-        col_name = 'hot_tub_heater'
-      end
       heater_sch = schedules_file.create_schedule_file(col_name: col_name)
     end
     if heater_sch.nil?
-      heater_sch = MonthWeekdayWeekendSchedule.new(model, obj_name + ' schedule', pool_or_hot_tub.heater_weekday_fractions, pool_or_hot_tub.heater_weekend_fractions, pool_or_hot_tub.heater_monthly_multipliers, Constants.ScheduleTypeLimitsFraction)
+      col_unavailable_periods = Schedule.get_unavailable_periods(runner, col_name, unavailable_periods)
+      heater_sch = MonthWeekdayWeekendSchedule.new(model, obj_name + ' schedule', pool_or_hot_tub.heater_weekday_fractions, pool_or_hot_tub.heater_weekend_fractions, pool_or_hot_tub.heater_monthly_multipliers, Constants.ScheduleTypeLimitsFraction, unavailable_periods: col_unavailable_periods)
     else
       runner.registerWarning("Both '#{col_name}' schedule file and weekday fractions provided; the latter will be ignored.") if !pool_or_hot_tub.heater_weekday_fractions.nil?
       runner.registerWarning("Both '#{col_name}' schedule file and weekend fractions provided; the latter will be ignored.") if !pool_or_hot_tub.heater_weekend_fractions.nil?
@@ -139,9 +138,10 @@ class MiscLoads
     end
 
     if heater_kwh > 0
-      if (not schedules_file.nil?)
+      if not schedules_file.nil?
         space_design_level = schedules_file.calc_design_level_from_annual_kwh(col_name: col_name, annual_kwh: heater_kwh)
-      else
+      end
+      if space_design_level.nil?
         space_design_level = heater_sch.calc_design_level_from_daily_kwh(heater_kwh / 365.0)
         heater_sch = heater_sch.schedule
       end
@@ -183,21 +183,18 @@ class MiscLoads
     end
   end
 
-  def self.apply_pool_or_hot_tub_pump(runner, model, pool_or_hot_tub, obj_name, living_space, schedules_file)
+  def self.apply_pool_or_hot_tub_pump(runner, model, pool_or_hot_tub, obj_name, living_space, schedules_file, unavailable_periods)
     pump_kwh = 0
 
     # Create schedule
     pump_sch = nil
+    col_name = (obj_name.include?('pool') ? 'pool_pump' : 'hot_tub_pump')
     if not schedules_file.nil?
-      if obj_name.include?('pool')
-        col_name = 'pool_pump'
-      else
-        col_name = 'hot_tub_pump'
-      end
       pump_sch = schedules_file.create_schedule_file(col_name: col_name)
     end
     if pump_sch.nil?
-      pump_sch = MonthWeekdayWeekendSchedule.new(model, obj_name + ' schedule', pool_or_hot_tub.pump_weekday_fractions, pool_or_hot_tub.pump_weekend_fractions, pool_or_hot_tub.pump_monthly_multipliers, Constants.ScheduleTypeLimitsFraction)
+      col_unavailable_periods = Schedule.get_unavailable_periods(runner, col_name, unavailable_periods)
+      pump_sch = MonthWeekdayWeekendSchedule.new(model, obj_name + ' schedule', pool_or_hot_tub.pump_weekday_fractions, pool_or_hot_tub.pump_weekend_fractions, pool_or_hot_tub.pump_monthly_multipliers, Constants.ScheduleTypeLimitsFraction, unavailable_periods: col_unavailable_periods)
     else
       runner.registerWarning("Both '#{col_name}' schedule file and weekday fractions provided; the latter will be ignored.") if !pool_or_hot_tub.pump_weekday_fractions.nil?
       runner.registerWarning("Both '#{col_name}' schedule file and weekend fractions provided; the latter will be ignored.") if !pool_or_hot_tub.pump_weekend_fractions.nil?