Merge branch 'master' of https://github.com/NREL/OpenStudio-HPXML into os_hpxml_v130

# Conflicts:
#	HPXMLtoOpenStudio/measure.xml

Author: shorowit

HPXMLtoOpenStudio/measure.xml

@@ -3,8 +3,8 @@
   <schema_version>3.0</schema_version>
   <name>hpxm_lto_openstudio</name>
   <uid>b1543b30-9465-45ff-ba04-1d1f85e763bc</uid>
-  <version_id>01a467fc-7f4f-4b22-8d44-817db7df91e2</version_id>
-  <version_modified>20211108T201159Z</version_modified>
+  <version_id>341031ed-e5b1-4b9a-a1a0-56f0e307816a</version_id>
+  <version_modified>20211108T201331Z</version_modified>
   <xml_checksum>D8922A73</xml_checksum>
   <class_name>HPXMLtoOpenStudio</class_name>
   <display_name>HPXML to OpenStudio Translator</display_name>
@@ -466,13 +466,13 @@
       <filename>test_battery.rb</filename>
       <filetype>rb</filetype>
       <usage_type>test</usage_type>
-      <checksum>2D76F76D</checksum>
+      <checksum>7C0EFC71</checksum>
     </file>
     <file>
       <filename>battery.rb</filename>
       <filetype>rb</filetype>
       <usage_type>resource</usage_type>
-      <checksum>DA3AC0A2</checksum>
+      <checksum>8AA18CFA</checksum>
     </file>
     <file>
       <filename>version.rb</filename>

HPXMLtoOpenStudio/resources/battery.rb

@@ -4,15 +4,15 @@ class Battery
   def self.apply(runner, model, battery)
     obj_name = battery.id
 
-    power = battery.rated_power_output # W
-    voltage = battery.nominal_voltage # V
+    rated_power_output = battery.rated_power_output # W
+    nominal_voltage = battery.nominal_voltage # V
     if not battery.nominal_capacity_kwh.nil?
-      capacity = battery.nominal_capacity_kwh # kWh
+      nominal_capacity_kwh = battery.nominal_capacity_kwh # kWh
     else
-      capacity = get_kWh_from_Ah(battery.nominal_capacity_ah, voltage) # kWh
+      nominal_capacity_kwh = get_kWh_from_Ah(battery.nominal_capacity_ah, nominal_voltage) # kWh
     end
 
-    return if power <= 0 || capacity <= 0 || voltage <= 0
+    return if rated_power_output <= 0 || nominal_capacity_kwh <= 0 || nominal_voltage <= 0
 
     is_outside = (battery.location == HPXML::LocationOutside)
     if not is_outside
@@ -21,11 +21,13 @@ def self.apply(runner, model, battery)
       frac_sens = 0.0
     end
 
-    # The following calculations are from Rohit C.
-    number_of_cells_in_series = Integer((voltage / 3.6).round)
-    number_of_strings_in_parallel = Integer(((capacity * 1000.0) / (voltage * 3.2)).round)
-    battery_mass = (capacity / 10.0) * 99.0 # kg
-    battery_surface_area = 0.306 * (capacity**(2.0 / 3.0)) # m^2
+    default_nominal_cell_voltage = 3.342 # V, EnergyPlus default
+    default_cell_capacity = 3.2 # Ah, EnergyPlus default
+
+    number_of_cells_in_series = Integer((nominal_voltage / default_nominal_cell_voltage).round)
+    number_of_strings_in_parallel = Integer(((nominal_capacity_kwh * 1000.0) / ((default_nominal_cell_voltage * number_of_cells_in_series) * default_cell_capacity)).round)
+    battery_mass = (nominal_capacity_kwh / 10.0) * 99.0 # kg
+    battery_surface_area = 0.306 * (nominal_capacity_kwh**(2.0 / 3.0)) # m^2
 
     minimum_storage_state_of_charge_fraction = 0.15 # from SAM
     maximum_storage_state_of_charge_fraction = 0.95 # from SAM
@@ -45,6 +47,9 @@ def self.apply(runner, model, battery)
     elcs.setInitialFractionalStateofCharge(initial_fractional_state_of_charge)
     elcs.setBatteryMass(battery_mass)
     elcs.setBatterySurfaceArea(battery_surface_area)
+    elcs.setDefaultNominalCellVoltage(default_nominal_cell_voltage)
+    elcs.setCellVoltageatEndofNominalZone(default_nominal_cell_voltage)
+    elcs.setFullyChargedCellCapacity(default_cell_capacity)
 
     model.getElectricLoadCenterDistributions.each do |elcd|
       next unless elcd.inverter.is_initialized
@@ -55,8 +60,8 @@ def self.apply(runner, model, battery)
       elcd.setStorageOperationScheme('TrackFacilityElectricDemandStoreExcessOnSite')
       elcd.setElectricalStorage(elcs)
       runner.registerWarning("Due to an OpenStudio bug, the battery's rated power output will not be honored; the simulation will proceed without a maximum charge/discharge limit.")
-      elcd.setDesignStorageControlDischargePower(power)
-      elcd.setDesignStorageControlChargePower(power)
+      elcd.setDesignStorageControlDischargePower(rated_power_output)
+      elcd.setDesignStorageControlChargePower(rated_power_output)
     end
   end
 
@@ -68,11 +73,11 @@ def self.get_battery_default_values()
              nominal_voltage: 50.0 }
   end
 
-  def self.get_Ah_from_kWh(capacity, voltage)
-    return capacity * 1000.0 / voltage
+  def self.get_Ah_from_kWh(nominal_capacity_kwh, nominal_voltage)
+    return nominal_capacity_kwh * 1000.0 / nominal_voltage
   end
 
-  def self.get_kWh_from_Ah(capacity, voltage)
-    return capacity * voltage / 1000.0
+  def self.get_kWh_from_Ah(nominal_capacity_ah, nominal_voltage)
+    return nominal_capacity_ah * nominal_voltage / 1000.0
   end
 end

HPXMLtoOpenStudio/tests/test_battery.rb

@@ -20,6 +20,11 @@ def get_battery(model, name)
     end
   end
 
+  def calc_nom_capacity(battery)
+    return (battery.numberofCellsinSeries * battery.numberofStringsinParallel *
+            battery.cellVoltageatEndofNominalZone * battery.fullyChargedCellCapacity)
+  end
+
   def test_battery_default
     args_hash = {}
     args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-misc-defaults.xml'))
@@ -32,11 +37,12 @@ def test_battery_default
       assert(!battery.thermalZone.is_initialized)
       assert_equal(0, battery.radiativeFraction)
       assert_equal(HPXML::BatteryLifetimeModelNone, battery.lifetimeModel)
-      assert_in_epsilon(14, battery.numberofCellsinSeries, 0.01)
-      assert_in_epsilon(63, battery.numberofStringsinParallel, 0.01)
+      assert_in_epsilon(15, battery.numberofCellsinSeries, 0.01)
+      assert_in_epsilon(62, battery.numberofStringsinParallel, 0.01)
       assert_in_epsilon(0.5, battery.initialFractionalStateofCharge, 0.01)
       assert_in_epsilon(99.0, battery.batteryMass, 0.01)
       assert_in_epsilon(1.42, battery.batterySurfaceArea, 0.01)
+      assert_in_epsilon(10000, calc_nom_capacity(battery), 0.01)
 
       elcds = model.getElectricLoadCenterDistributions
       assert_equal(1, elcds.size)
@@ -78,11 +84,12 @@ def test_pv_battery_outside
       assert(!battery.thermalZone.is_initialized)
       assert_equal(0, battery.radiativeFraction)
       assert_equal(HPXML::BatteryLifetimeModelNone, battery.lifetimeModel)
-      assert_in_epsilon(14, battery.numberofCellsinSeries, 0.01)
+      assert_in_epsilon(15, battery.numberofCellsinSeries, 0.01)
       assert_in_epsilon(125, battery.numberofStringsinParallel, 0.01)
       assert_in_epsilon(0.5, battery.initialFractionalStateofCharge, 0.01)
       assert_in_epsilon(198.0, battery.batteryMass, 0.01)
       assert_in_epsilon(2.25, battery.batterySurfaceArea, 0.01)
+      assert_in_epsilon(20000, calc_nom_capacity(battery), 0.01)
 
       elcds = model.getElectricLoadCenterDistributions
       assert_equal(1, elcds.size)
@@ -109,11 +116,12 @@ def test_pv_battery_outside_degrades
       assert(!battery.thermalZone.is_initialized)
       assert_equal(0, battery.radiativeFraction)
       assert_equal(HPXML::BatteryLifetimeModelKandlerSmith, battery.lifetimeModel)
-      assert_in_epsilon(14, battery.numberofCellsinSeries, 0.01)
+      assert_in_epsilon(15, battery.numberofCellsinSeries, 0.01)
       assert_in_epsilon(125, battery.numberofStringsinParallel, 0.01)
       assert_in_epsilon(0.5, battery.initialFractionalStateofCharge, 0.01)
       assert_in_epsilon(198.0, battery.batteryMass, 0.01)
       assert_in_epsilon(2.25, battery.batterySurfaceArea, 0.01)
+      assert_in_epsilon(20000, calc_nom_capacity(battery), 0.01)
 
       elcds = model.getElectricLoadCenterDistributions
       assert_equal(1, elcds.size)
@@ -141,11 +149,12 @@ def test_pv_battery_garage
       assert_equal(HPXML::LocationGarage, battery.thermalZone.get.name.to_s)
       assert_equal(0.9, battery.radiativeFraction)
       assert_equal(HPXML::BatteryLifetimeModelNone, battery.lifetimeModel)
-      assert_in_epsilon(14, battery.numberofCellsinSeries, 0.01)
+      assert_in_epsilon(15, battery.numberofCellsinSeries, 0.01)
       assert_in_epsilon(125, battery.numberofStringsinParallel, 0.01)
       assert_in_epsilon(0.5, battery.initialFractionalStateofCharge, 0.01)
       assert_in_epsilon(198.0, battery.batteryMass, 0.01)
       assert_in_epsilon(2.25, battery.batterySurfaceArea, 0.01)
+      assert_in_epsilon(20000, calc_nom_capacity(battery), 0.01)
 
       elcds = model.getElectricLoadCenterDistributions
       assert_equal(1, elcds.size)
@@ -172,11 +181,12 @@ def test_pv_battery_ah
       assert(!battery.thermalZone.is_initialized)
       assert_equal(0, battery.radiativeFraction)
       assert_equal(HPXML::BatteryLifetimeModelNone, battery.lifetimeModel)
-      assert_in_epsilon(14, battery.numberofCellsinSeries, 0.01)
+      assert_in_epsilon(15, battery.numberofCellsinSeries, 0.01)
       assert_in_epsilon(125, battery.numberofStringsinParallel, 0.01)
       assert_in_epsilon(0.5, battery.initialFractionalStateofCharge, 0.01)
       assert_in_epsilon(198.0, battery.batteryMass, 0.01)
       assert_in_epsilon(2.25, battery.batterySurfaceArea, 0.01)
+      assert_in_epsilon(20000, calc_nom_capacity(battery), 0.01)
 
       elcds = model.getElectricLoadCenterDistributions
       assert_equal(1, elcds.size)