Skip to content

Commit

Permalink
#4869 - Add test for AirLoopHVACOutdoorAirSystem: general (missing) +…
Browse files Browse the repository at this point in the history 
… clone (specific)
  • Loading branch information
@jmarrec
jmarrec committed May 2, 2023
1 parent 8054887 commit 0a81cbd
Showing 1 changed file with 268 additions and 49 deletions.
317 changes: 268 additions & 49 deletions src/model/test/AirLoopHVACOutdoorAirSystem_GTest.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,76 +27,295 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
***********************************************************************************************************************/

#include <gtest/gtest.h>
#include "ModelFixture.hpp"

#include "../AirLoopHVACOutdoorAirSystem.hpp"
#include "../AirLoopHVACOutdoorAirSystem_Impl.hpp"

#include "../AirLoopHVAC.hpp"
#include "../CoilHeatingElectric.hpp"
#include "../CoilHeatingElectric_Impl.hpp"
#include "../CoilCoolingDXVariableSpeed.hpp"
#include "../ControllerOutdoorAir.hpp"
#include "../ControllerOutdoorAir_Impl.hpp"
#include "../HVACComponent.hpp"
#include "../HVACComponent_Impl.hpp"
#include "../CoilHeatingElectric.hpp"
#include "../Schedule.hpp"
#include "../HeatExchangerAirToAirSensibleAndLatent.hpp"
#include "../HeatExchangerAirToAirSensibleAndLatent_Impl.hpp"
#include "../Node.hpp"
#include "../AirLoopHVAC.hpp"
#include "../../utilities/idd/IddEnums.hpp"
#include "../Node_Impl.hpp"

#include <utilities/idd/IddEnums.hxx>

using namespace openstudio;
using namespace openstudio::model;

TEST_F(ModelFixture, AirLoopHVACOutdoorAirSystem_AirLoopHVACOutdoorAirSystem) {
Model model = Model();
OptionalModelObject modelObject;
TEST_F(ModelFixture, AirLoopHVACOutdoorAirSystem_GettersSetters) {
Model m;

ControllerOutdoorAir controller(m);
AirLoopHVACOutdoorAirSystem oaSystem(m, controller);
oaSystem.setName("My AirLoopHVACOutdoorAirSystem");
EXPECT_EQ(controller, oaSystem.getControllerOutdoorAir());

ControllerOutdoorAir controller2(m);
EXPECT_TRUE(oaSystem.setControllerOutdoorAir(controller2));
EXPECT_EQ(controller2, oaSystem.getControllerOutdoorAir());

EXPECT_EQ(2, oaSystem.components().size());
EXPECT_EQ(1, oaSystem.reliefComponents().size());
ASSERT_TRUE(oaSystem.outboardReliefNode());
auto outboardReliefNode = oaSystem.outboardReliefNode().get();
outboardReliefNode.setName("Outboard Relief Node");

ASSERT_TRUE(oaSystem.reliefAirModelObject());
EXPECT_EQ(oaSystem.outboardReliefNode().get(), oaSystem.reliefAirModelObject().get());

EXPECT_EQ(1, oaSystem.oaComponents().size());
ASSERT_TRUE(oaSystem.outboardOANode());
auto outboardOANode = oaSystem.outboardOANode().get();
outboardOANode.setName("Outboard OA Node");

ASSERT_TRUE(oaSystem.outdoorAirModelObject());
EXPECT_EQ(oaSystem.outboardOANode().get(), oaSystem.outdoorAirModelObject().get());

EXPECT_FALSE(oaSystem.returnAirModelObject());
EXPECT_FALSE(oaSystem.mixedAirModelObject());

EXPECT_FALSE(oaSystem.airLoopHVAC());

AirLoopHVAC a(m);
EXPECT_FALSE(a.mixedAirNode());
EXPECT_FALSE(a.returnAirNode());
EXPECT_FALSE(a.outdoorAirNode());
EXPECT_FALSE(a.reliefAirNode());
EXPECT_EQ(2, a.supplyComponents().size());
EXPECT_EQ(0, a.supplyComponents(openstudio::IddObjectType::OS_AirLoopHVAC_OutdoorAirSystem).size());

auto demandInletNode = a.demandInletNode();
EXPECT_FALSE(oaSystem.addToNode(demandInletNode));
EXPECT_FALSE(a.addBranchForHVACComponent(oaSystem));

auto supplyInletNode = a.supplyInletNode();
EXPECT_TRUE(oaSystem.addToNode(supplyInletNode));
ASSERT_TRUE(oaSystem.airLoopHVAC());
EXPECT_EQ(a, oaSystem.airLoopHVAC().get());

EXPECT_EQ(3, a.supplyComponents().size());
EXPECT_EQ(1, a.supplyComponents(openstudio::IddObjectType::OS_AirLoopHVAC_OutdoorAirSystem).size());
ASSERT_TRUE(a.supplyComponent(oaSystem.handle()));

ASSERT_TRUE(a.reliefAirNode());
EXPECT_EQ(2, oaSystem.components().size());
EXPECT_EQ(1, oaSystem.reliefComponents().size());
ASSERT_TRUE(oaSystem.outboardReliefNode());
ASSERT_TRUE(oaSystem.reliefAirModelObject());
EXPECT_EQ(oaSystem.outboardReliefNode().get(), oaSystem.reliefAirModelObject().get());
EXPECT_EQ(a.reliefAirNode().get(), oaSystem.reliefAirModelObject().get());

ASSERT_TRUE(a.outdoorAirNode());
EXPECT_EQ(1, oaSystem.oaComponents().size());
ASSERT_TRUE(oaSystem.outboardOANode());
ASSERT_TRUE(oaSystem.outdoorAirModelObject());
EXPECT_EQ(oaSystem.outboardOANode().get(), oaSystem.outdoorAirModelObject().get());
EXPECT_EQ(a.outdoorAirNode().get(), oaSystem.outdoorAirModelObject().get());

ASSERT_TRUE(a.mixedAirNode());
a.mixedAirNode().get().setName("Mixed Air Node");
ASSERT_TRUE(oaSystem.mixedAirModelObject());
EXPECT_EQ(a.mixedAirNode().get(), oaSystem.mixedAirModelObject().get());

ASSERT_TRUE(a.returnAirNode());
a.returnAirNode().get().setName("Return Air Node");
ASSERT_TRUE(oaSystem.returnAirModelObject());
EXPECT_EQ(a.returnAirNode().get(), oaSystem.returnAirModelObject().get());

CoilHeatingElectric oaCoil(m);
EXPECT_TRUE(oaCoil.addToNode(outboardOANode));

EXPECT_EQ(4, oaSystem.components().size());
EXPECT_EQ(1, oaSystem.reliefComponents().size()); // (Relief)
EXPECT_EQ(outboardReliefNode, oaSystem.outboardReliefNode().get()); //
EXPECT_EQ(3, oaSystem.oaComponents().size()); // (OA)-----Coil------o
EXPECT_EQ(outboardOANode, oaSystem.outboardOANode().get());

ControllerOutdoorAir controller(model);
AirLoopHVACOutdoorAirSystem oaSystem = AirLoopHVACOutdoorAirSystem(model, controller);
HeatExchangerAirToAirSensibleAndLatent erv(m);
EXPECT_TRUE(erv.addToNode(outboardOANode));

ASSERT_EQ(openstudio::IddObjectType::OS_AirLoopHVAC_OutdoorAirSystem, oaSystem.iddObjectType().value());
EXPECT_EQ(8, oaSystem.components().size());
EXPECT_EQ(outboardReliefNode, oaSystem.outboardReliefNode().get());
EXPECT_EQ(outboardOANode, oaSystem.outboardOANode().get());
EXPECT_EQ(3, oaSystem.reliefComponents().size()); // o-----ERV-----(Relief)
EXPECT_EQ(5, oaSystem.oaComponents().size()); // (OA)-----ERV-----o-----Coil1-----o
// <=>
// (RE)---- ERV---------------------o
// X
// (OA)-----ERV-----o-----Coil1-----o

CoilHeatingElectric reliefCoil(m);
EXPECT_TRUE(reliefCoil.addToNode(outboardReliefNode));
EXPECT_EQ(10, oaSystem.components().size());
EXPECT_EQ(outboardReliefNode, oaSystem.outboardReliefNode().get());
EXPECT_EQ(outboardOANode, oaSystem.outboardOANode().get());
EXPECT_EQ(5, oaSystem.reliefComponents().size()); // o-----ERV-----o-----Coil2----(Relief)
EXPECT_EQ(5, oaSystem.oaComponents().size()); // (OA)-----ERV-----o-----Coil1-----o
// <=>
// (RE)---- Coil2-----o----ERV---------------------o
// X
// (OA)--------------------ERV-----o-----Coil1-----o
}

TEST_F(ModelFixture, AirLoopHVACOutdoorAirSystem_controllerOutdoorAir) {
Model model = Model();
OptionalModelObject modelObject;
TEST_F(ModelFixture, AirLoopHVACOutdoorAirSystem_Clone_Simple) {
Model m;

ControllerOutdoorAir controller(m);
AirLoopHVACOutdoorAirSystem oaSystem(m, controller);

ASSERT_TRUE(oaSystem.outboardReliefNode());
auto outboardReliefNode = oaSystem.outboardReliefNode().get();
auto outboardOANode = oaSystem.outboardOANode().get();
outboardOANode.setName("Outboard OA Node");

CoilHeatingElectric oaCoil(m);
EXPECT_TRUE(oaCoil.addToNode(outboardOANode));

CoilHeatingElectric reliefCoil(m);
EXPECT_TRUE(reliefCoil.addToNode(outboardReliefNode));

EXPECT_EQ(6, oaSystem.components().size());
EXPECT_EQ(3, oaSystem.reliefComponents().size());
EXPECT_EQ(3, oaSystem.oaComponents().size()); // (OA)-----Coil------o
EXPECT_EQ(1, m.getConcreteModelObjects<AirLoopHVACOutdoorAirSystem>().size());
EXPECT_EQ(1, m.getConcreteModelObjects<ControllerOutdoorAir>().size());
EXPECT_EQ(4, m.getConcreteModelObjects<Node>().size());
EXPECT_EQ(2, m.getConcreteModelObjects<CoilHeatingElectric>().size());

{
// Other model first
Model m2;
auto oaSystem2 = oaSystem.clone(m2).cast<AirLoopHVACOutdoorAirSystem>();

ControllerOutdoorAir controller(model);
AirLoopHVACOutdoorAirSystem oaSystem = AirLoopHVACOutdoorAirSystem(model, controller);
EXPECT_NE(controller, oaSystem2.getControllerOutdoorAir());

ASSERT_EQ(openstudio::IddObjectType::OS_Controller_OutdoorAir, oaSystem.getControllerOutdoorAir().iddObjectType().value());
EXPECT_EQ(6, oaSystem2.components().size());
EXPECT_EQ(3, oaSystem2.reliefComponents().size());
EXPECT_EQ(3, oaSystem2.oaComponents().size()); // (OA)-----Coil------o
EXPECT_EQ(1, m2.getConcreteModelObjects<AirLoopHVACOutdoorAirSystem>().size());
EXPECT_EQ(1, m2.getConcreteModelObjects<ControllerOutdoorAir>().size());
EXPECT_EQ(4, m2.getConcreteModelObjects<Node>().size());
EXPECT_EQ(2, m2.getConcreteModelObjects<CoilHeatingElectric>().size());
}

{
// Same model
auto oaSystem2 = oaSystem.clone(m).cast<AirLoopHVACOutdoorAirSystem>();

EXPECT_NE(controller, oaSystem2.getControllerOutdoorAir());

EXPECT_EQ(6, oaSystem2.components().size());
EXPECT_EQ(3, oaSystem2.reliefComponents().size());
EXPECT_EQ(3, oaSystem2.oaComponents().size()); // (OA)-----Coil------o
EXPECT_EQ(2, m.getConcreteModelObjects<AirLoopHVACOutdoorAirSystem>().size());
EXPECT_EQ(2, m.getConcreteModelObjects<ControllerOutdoorAir>().size());
EXPECT_EQ(8, m.getConcreteModelObjects<Node>().size());
EXPECT_EQ(4, m.getConcreteModelObjects<CoilHeatingElectric>().size());
}
}

TEST_F(ModelFixture, AirLoopHVACOutdoorAirSystem_clone) {
Model model = Model();
Model model2 = Model();
OptionalModelObject modelObject;
TEST_F(ModelFixture, AirLoopHVACOutdoorAirSystem_Clone_Shared) {
Model m;

ControllerOutdoorAir controller(m);
AirLoopHVACOutdoorAirSystem oaSystem(m, controller);

ASSERT_TRUE(oaSystem.outboardReliefNode());
auto outboardReliefNode = oaSystem.outboardReliefNode().get();
auto outboardOANode = oaSystem.outboardOANode().get();
outboardOANode.setName("Outboard OA Node");

CoilHeatingElectric oaCoil(m);
oaCoil.setName("OACoil");
EXPECT_TRUE(oaCoil.addToNode(outboardOANode));

ControllerOutdoorAir controller(model);
AirLoopHVACOutdoorAirSystem oaSystem = AirLoopHVACOutdoorAirSystem(model, controller);
HeatExchangerAirToAirSensibleAndLatent erv(m);
erv.setName("ERV");
EXPECT_TRUE(erv.addToNode(outboardOANode));

ASSERT_EQ(openstudio::IddObjectType::OS_Controller_OutdoorAir, oaSystem.getControllerOutdoorAir().iddObjectType().value());
CoilHeatingElectric reliefCoil(m);
reliefCoil.setName("RECoil");
EXPECT_TRUE(reliefCoil.addToNode(outboardReliefNode));

auto oaSystem2 = oaSystem.clone(model2).cast<AirLoopHVACOutdoorAirSystem>();
EXPECT_EQ(10, oaSystem.components().size()); // ERV counted twice
EXPECT_EQ(5, oaSystem.reliefComponents().size()); // o-----ERV-----o-----RECoil----(RE)
EXPECT_EQ(5, oaSystem.oaComponents().size()); // (OA)-----ERV-----o-----OACoil-----o
// <=>
// (RE)---- RECoil-----o-----ERV----------------------o
// X
// (OA)----------------------ERV-----o-----OACoil-----o
EXPECT_EQ(1, m.getConcreteModelObjects<AirLoopHVACOutdoorAirSystem>().size());
EXPECT_EQ(1, m.getConcreteModelObjects<ControllerOutdoorAir>().size());
EXPECT_EQ(6, m.getConcreteModelObjects<Node>().size());
EXPECT_EQ(2, m.getConcreteModelObjects<CoilHeatingElectric>().size());
EXPECT_EQ(1, m.getConcreteModelObjects<HeatExchangerAirToAirSensibleAndLatent>().size());

ASSERT_EQ(openstudio::IddObjectType::OS_Controller_OutdoorAir, oaSystem2.getControllerOutdoorAir().iddObjectType().value());
{
// Other model first
Model m2;
auto oaSystem2 = oaSystem.clone(m2).cast<AirLoopHVACOutdoorAirSystem>();

EXPECT_NE(controller, oaSystem2.getControllerOutdoorAir());

EXPECT_EQ(10, oaSystem2.components().size());
EXPECT_EQ(5, oaSystem2.reliefComponents().size());
EXPECT_EQ(5, oaSystem2.oaComponents().size());
EXPECT_EQ(1, m2.getConcreteModelObjects<AirLoopHVACOutdoorAirSystem>().size());
EXPECT_EQ(1, m2.getConcreteModelObjects<ControllerOutdoorAir>().size());
EXPECT_EQ(6, m2.getConcreteModelObjects<Node>().size());
EXPECT_EQ(2, m2.getConcreteModelObjects<CoilHeatingElectric>().size());
EXPECT_EQ(1, m2.getConcreteModelObjects<HeatExchangerAirToAirSensibleAndLatent>().size());
}

{
// Same model
auto oaSystem2 = oaSystem.clone(m).cast<AirLoopHVACOutdoorAirSystem>();

EXPECT_NE(controller, oaSystem2.getControllerOutdoorAir());

EXPECT_EQ(10, oaSystem2.components().size());
EXPECT_EQ(5, oaSystem2.reliefComponents().size());
EXPECT_EQ(5, oaSystem2.oaComponents().size());
EXPECT_EQ(2, m.getConcreteModelObjects<AirLoopHVACOutdoorAirSystem>().size());
EXPECT_EQ(2, m.getConcreteModelObjects<ControllerOutdoorAir>().size());
EXPECT_EQ(12, m.getConcreteModelObjects<Node>().size());
EXPECT_EQ(4, m.getConcreteModelObjects<CoilHeatingElectric>().size());
EXPECT_EQ(2, m.getConcreteModelObjects<HeatExchangerAirToAirSensibleAndLatent>().size());
}
}

//TEST_F(ModelFixture,AirLoopHVACOutdoorAirSystem_edges)
//{
// Model m;
// Schedule s = m.alwaysOnDiscreteSchedule();
// AirLoopHVAC airLoop(m);
// ControllerOutdoorAir controllerOutdoorAir(m);
// AirLoopHVACOutdoorAirSystem outdoorAirSystem(m,controllerOutdoorAir);
// CoilHeatingElectric coil(m, s);
//
// Node supplyOutletNode = airLoop.supplyOutletNode();
// outdoorAirSystem.addToNode(supplyOutletNode);
// coil.addToNode(supplyOutletNode);
// boost::optional<ModelObject> testObject = airLoop.supplyComponent(outdoorAirSystem.handle());
// ASSERT_TRUE(testObject);
// EXPECT_EQ(outdoorAirSystem, *testObject);
// std::vector<HVACComponent> edges = outdoorAirSystem.getImpl<detail::HVACComponent_Impl>()->edges(false); // should be Node
// ASSERT_EQ(1, edges.size());
// edges = edges[0].getImpl<detail::HVACComponent_Impl>()->edges(false); // should be CoilHeatingElectric
// ASSERT_EQ(1, edges.size());
// EXPECT_EQ(coil, edges[0]);
//}
TEST_F(ModelFixture, AirLoopHVACOutdoorAirSystem_HeatCoolFuelTypes) {
Model m;

ControllerOutdoorAir controller(m);
AirLoopHVACOutdoorAirSystem oaSystem(m, controller);
auto outboardReliefNode = oaSystem.outboardReliefNode().get();
auto outboardOANode = oaSystem.outboardOANode().get();

EXPECT_EQ(ComponentType(ComponentType::None), oaSystem.componentType());
testFuelTypeEquality({}, oaSystem.coolingFuelTypes());
testFuelTypeEquality({}, oaSystem.heatingFuelTypes());
testAppGFuelTypeEquality({}, oaSystem.appGHeatingFuelTypes());

CoilHeatingElectric oaCoil(m);
EXPECT_TRUE(oaCoil.addToNode(outboardOANode));

EXPECT_EQ(ComponentType(ComponentType::Heating), oaSystem.componentType());
testFuelTypeEquality({}, oaSystem.coolingFuelTypes());
testFuelTypeEquality({FuelType::Electricity}, oaSystem.heatingFuelTypes());
testAppGFuelTypeEquality({AppGFuelType::Electric}, oaSystem.appGHeatingFuelTypes());

CoilCoolingDXVariableSpeed reliefCoil(m);
EXPECT_TRUE(reliefCoil.addToNode(outboardReliefNode));

EXPECT_EQ(ComponentType(ComponentType::Both), oaSystem.componentType());
testFuelTypeEquality({FuelType::Electricity}, oaSystem.coolingFuelTypes());
testFuelTypeEquality({FuelType::Electricity}, oaSystem.heatingFuelTypes());
testAppGFuelTypeEquality({AppGFuelType::Electric}, oaSystem.appGHeatingFuelTypes());
}

0 comments on commit 0a81cbd

Please sign in to comment.