Enable output for <Zone>_QLat_flow

ref lbl-srg/modelica-buildings#2602
NREL · Oct 29, 2021 · 864fd72 · 864fd72
1 parent 2f6861d
commit 864fd72
Show file tree

Hide file tree

Showing 6 changed files with 161 additions and 131 deletions.
diff --git a/lib/spawn.cpp b/lib/spawn.cpp
@@ -320,6 +320,12 @@ void Spawn::updateZoneTemperatures(bool skipConnectedZones) {
   prevWarmupFlag = sim_state.dataGlobal->WarmupFlag;
 }
 
+void Spawn::updateLatentGains() {
+  for (int zonei = 1; zonei <= sim_state.dataGlobal->NumOfZones; ++zonei) {
+    EnergyPlus::InternalHeatGains::SumAllInternalLatentGains(sim_state, zonei, sim_state.dataHeatBalFanSys->ZoneLatentGain(zonei));
+  }
+}
+
 double Spawn::zoneHeatTransfer(const int zonenum) {
   const auto & sums = zoneSums(zonenum);
   // Refer to
@@ -531,6 +537,7 @@ void Spawn::exchange(const bool force)
   EnergyPlus::HVACManager::ReportAirHeatBalance(sim_state);
   EnergyPlus::InternalHeatGains::InitInternalHeatGains(sim_state);
   EnergyPlus::ScheduleManager::UpdateScheduleValues(sim_state);
+  updateLatentGains();
 
   // Now update the outputs
   for( auto & varmap : variables ) {
@@ -561,6 +568,12 @@ void Spawn::exchange(const bool force)
         var.setValue(zoneHeatTransfer( varZoneNum ), spawn::units::UnitSystem::EP);
         break;
       }
+      case VariableType::QLAT_FLOW: {
+        const auto varZoneNum = zoneNum(var.name);
+        const auto value = sim_state.dataHeatBalFanSys->ZoneLatentGain( varZoneNum );
+        var.setValue(sim_state.dataHeatBalFanSys->ZoneLatentGain( varZoneNum ), spawn::units::UnitSystem::EP);
+        break;
+      }
       case VariableType::SENSOR: {
         var.setValue(getSensorValue(var), spawn::units::UnitSystem::EP);
         break;

diff --git a/lib/spawn.hpp b/lib/spawn.hpp
@@ -170,6 +170,7 @@ class Spawn {
   [[nodiscard]] double zoneTemperature(const int zonenum);
   void updateZoneTemperature(const int zonenum, const double & dt);
   void updateZoneTemperatures(bool skipConnectedZones = false);
+  void updateLatentGains();
   void initZoneEquip();
   // Time in seconds of the last zone temperature update
   // This is required for computing the dt in the

diff --git a/lib/variables.cpp b/lib/variables.cpp
@@ -260,9 +260,6 @@ std::map<unsigned int, Variable> parseVariables(const spawn::Input & input) {
         var.real_attributes.emplace_back("relativeQuantity","false");
         var.real_attributes.emplace_back("unit",spawn::units::toString(var.mounittype));
 
-        // TODO exchange this variable with real EnergyPlus data
-        var.setValue(0.0, spawn::units::UnitSystem::MO);
-
         result.emplace(i,std::move(var));
       }
       ++i;

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -24,7 +24,7 @@ add_executable(
   test_temp_directory.cpp
   test_unzip_file.cpp
   test_floating_zone.cpp
-  test_single_family_house_lights_control.cpp
+  test_single_family_house.cpp
   test_fmi.cpp
   test_utils.cpp
   test_mbl_idf.cpp

diff --git a/test/test_single_family_house.cpp b/test/test_single_family_house.cpp
@@ -0,0 +1,146 @@
+#include "../fmu/fmu.hpp"
+#include "../fmu/modeldescription.hpp"
+#include "../fmu/logger.h"
+#include "../util/filesystem.hpp"
+#include "../util/math.hpp"
+#include "paths.hpp"
+#include "create_epfmu.hpp"
+#include <catch2/catch.hpp>
+#include <nlohmann/json.hpp>
+#include <iostream>
+
+using json = nlohmann::json;
+
+TEST_CASE("Test SingleFamilyHouse")
+{
+  std::string spawn_input_string = fmt::format(
+  R"(
+    {{
+      "version": "0.1",
+      "EnergyPlus": {{
+        "idf": "{idfpath}",
+        "weather": "{epwpath}",
+        "relativeSurfaceTolerance": 1.0e-10
+      }},
+      "fmu": {{
+          "name": "MyBuilding.fmu",
+          "version": "2.0",
+          "kind"   : "ME"
+      }},
+      "model": {{
+        "zones": [
+           {{ "name": "LIVING ZONE" }}
+        ],
+        "emsActuators": [
+          {{
+            "variableName"  : "LIVING ZONE People",
+            "componentType" : "People",
+            "controlType"   : "Number of People",
+            "unit"          : "1",
+            "fmiName"       : "living zone people"
+          }}
+        ],
+        "schedules": [
+           {{
+              "name": "HOUSE LIGHTING",
+              "unit": "1",
+              "fmiName": "lighting input"
+           }}
+        ],
+        "outputVariables": [
+          {{
+            "name":    "Lights Electricity Rate",
+            "key":     "LIVING ZONE Lights",
+            "fmiName": "lighting output"
+          }}
+        ]
+      }}
+    }}
+  )", fmt::arg("idfpath", single_family_house_idf_path().generic_string()), fmt::arg("epwpath", chicago_epw_path().generic_string()));
+
+  const auto fmu_file_path = create_epfmu(spawn_input_string);
+  spawn::fmu::FMU fmu{fmu_file_path, false}; // don't require all symbols
+  REQUIRE(fmu.fmi.fmi2GetVersion() == std::string("2.0"));
+
+  const auto resource_path = (fmu.extractedFilesPath() / "resources").string();
+  fmi2CallbackFunctions callbacks = {fmuNothingLogger, calloc, free, NULL, NULL}; // called by the model during simulation
+  const auto comp = fmu.fmi.fmi2Instantiate("test-instance", fmi2ModelExchange, "abc-guid", resource_path.c_str(), &callbacks, false, true);
+
+  fmi2Status status; 
+
+  status = fmu.fmi.fmi2SetupExperiment(comp, false, 0.0, 0.0, false, 0.0);
+  REQUIRE(status == fmi2OK);
+
+  const auto model_description_path = fmu.extractedFilesPath() / fmu.modelDescriptionPath();
+  spawn::fmu::ModelDescription modelDescription(model_description_path);
+
+  // Begin test lighting
+  const auto lighting_input_ref = modelDescription.valueReference("lighting input");
+  const auto lighting_output_ref = modelDescription.valueReference("lighting output");
+
+  const std::array<fmi2ValueReference, 1> lighting_input_refs = {lighting_input_ref};
+  const std::array<fmi2ValueReference, 1> lighting_output_refs = {lighting_output_ref};
+
+  status = fmu.fmi.fmi2ExitInitializationMode(comp);
+  REQUIRE(status == fmi2OK);
+
+  std::array<fmi2Real, lighting_output_refs.size()> lighting_output_values;
+  std::array<fmi2Real, lighting_input_refs.size()> lighting_input_values;
+
+  lighting_input_values[0] = 0.0;
+  status = fmu.fmi.fmi2SetReal(comp, lighting_input_refs.data(), lighting_input_refs.size(), lighting_input_values.data());
+  CHECK(status == fmi2OK);
+
+  status = fmu.fmi.fmi2GetReal(comp, lighting_output_refs.data(), lighting_output_refs.size(), lighting_output_values.data());
+  CHECK(status == fmi2OK);
+  CHECK( lighting_output_values[0] == Approx(0.0) );
+
+  lighting_input_values[0] = 1.0;
+  status = fmu.fmi.fmi2SetReal(comp, lighting_input_refs.data(), lighting_input_refs.size(), lighting_input_values.data());
+  CHECK(status == fmi2OK);
+
+  status = fmu.fmi.fmi2GetReal(comp, lighting_output_refs.data(), lighting_output_refs.size(), lighting_output_values.data());
+  CHECK(status == fmi2OK);
+  CHECK( lighting_output_values[0] == Approx(1000.0) );
+
+  lighting_input_values[0] = 0.5;
+  status = fmu.fmi.fmi2SetReal(comp, lighting_input_refs.data(), lighting_input_refs.size(), lighting_input_values.data());
+  CHECK(status == fmi2OK);
+
+  status = fmu.fmi.fmi2GetReal(comp, lighting_output_refs.data(), lighting_output_refs.size(), lighting_output_values.data());
+  CHECK(status == fmi2OK);
+  CHECK( lighting_output_values[0] == Approx(500.0) );
+
+  lighting_input_values[0] = 0.0;
+  status = fmu.fmi.fmi2SetReal(comp, lighting_input_refs.data(), lighting_input_refs.size(), lighting_input_values.data());
+  CHECK(status == fmi2OK);
+
+  status = fmu.fmi.fmi2GetReal(comp, lighting_output_refs.data(), lighting_output_refs.size(), lighting_output_values.data());
+  CHECK(status == fmi2OK);
+  CHECK( lighting_output_values[0] == Approx(0.0) );
+
+  // Begin test latent heat
+  const auto qlat_flow_ref = modelDescription.valueReference("LIVING ZONE_QLat_flow");
+  const auto people_input_ref = modelDescription.valueReference("living zone people");
+  const std::array<fmi2ValueReference, 1> latent_output_refs = {qlat_flow_ref};
+  const std::array<fmi2ValueReference, 1> latent_input_refs = {people_input_ref};
+
+  std::array<fmi2Real, latent_output_refs.size()> latent_output_values;
+  std::array<fmi2Real, latent_input_refs.size()> latent_input_values;
+
+  status = fmu.fmi.fmi2GetReal(comp, latent_output_refs.data(), latent_output_refs.size(), latent_output_values.data());
+  CHECK(status == fmi2OK);
+  CHECK( latent_output_values[0] == Approx(0.0) );
+
+  latent_input_values[0] = 5.0;
+  status = fmu.fmi.fmi2SetReal(comp, latent_input_refs.data(), latent_input_refs.size(), latent_input_values.data());
+  CHECK(status == fmi2OK);
+
+  status = fmu.fmi.fmi2GetReal(comp, latent_output_refs.data(), latent_output_refs.size(), latent_output_values.data());
+  CHECK(status == fmi2OK);
+  CHECK( latent_output_values[0] > 10.0 );
+
+  status = fmu.fmi.fmi2Terminate(comp);
+  REQUIRE(status == fmi2OK);
+}
+
diff --git a/test/test_single_family_house_lights_control.cpp b/test/test_single_family_house_lights_control.cpp