TEST_F(EnergyPlusFixture, ForwardTranslator_ExternalInterfaceFunctionalMockupUnitImportToSchedule) {
Model model;
ExternalInterfaceFunctionalMockupUnitImport eifmui(model, "test name");
ExternalInterfaceFunctionalMockupUnitImportToSchedule schedule(model, eifmui, "FMU", "FMU name", 10);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ExternalInterface_FunctionalMockupUnitImport_To_Schedule).size());
//EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ScheduleTypeLimits).size());
WorkspaceObject object = workspace.getObjectsByType(IddObjectType::ExternalInterface_FunctionalMockupUnitImport_To_Schedule)[0];
//WorkspaceObject object2 = workspace.getObjectsByType(IddObjectType::ScheduleTypeLimits)[0];
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ScheduleFields::Name, false));
EXPECT_EQ("External Interface Functional Mockup Unit Import To Schedule 1", object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ScheduleFields::Name, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ScheduleFields::ScheduleTypeLimitsNames, false));
//EXPECT_EQ(object2.nameString(), object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ScheduleFields::ScheduleTypeLimitsNames, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ScheduleFields::FMUFileName, false));
EXPECT_EQ(eifmui.fMUFileName(), object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ScheduleFields::FMUFileName, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ScheduleFields::FMUInstanceName, false));
EXPECT_EQ("FMU", object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ScheduleFields::FMUInstanceName, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ScheduleFields::FMUVariableName, false));
EXPECT_EQ("FMU name", object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ScheduleFields::FMUVariableName, false).get());
ASSERT_TRUE(object.getDouble(ExternalInterface_FunctionalMockupUnitImport_To_ScheduleFields::InitialValue, false));
EXPECT_EQ(10.0, object.getDouble(ExternalInterface_FunctionalMockupUnitImport_To_ScheduleFields::InitialValue, false).get());
model.save(toPath("./ExternalInterfaceFunctionalMockupUnitImportToSchedule.osm"), true);
workspace.save(toPath("./ExternalInterfaceFunctionalMockupUnitImportToSchedule.idf"), true);
}
TEST_F(EnergyPlusFixture, ForwardTranslator_ExternalInterfaceSchedule) {
Model model;
ExternalInterfaceSchedule schedule(model, 10);
EXPECT_EQ(10.0, schedule.initialValue());
EXPECT_EQ("External Interface Schedule 1", schedule.nameString());
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ExternalInterface_Schedule).size());
//EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ScheduleTypeLimits).size());
WorkspaceObject object = workspace.getObjectsByType(IddObjectType::ExternalInterface_Schedule)[0];
//WorkspaceObject object2 = workspace.getObjectsByType(IddObjectType::ScheduleTypeLimits)[0];
ASSERT_TRUE(object.getString(ExternalInterface_ScheduleFields::Name, false));
EXPECT_EQ("External Interface Schedule 1", object.getString(ExternalInterface_ScheduleFields::Name, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_ScheduleFields::ScheduleTypeLimitsName, false));
//EXPECT_EQ(object2.nameString(), object.getString(ExternalInterface_ScheduleFields::ScheduleTypeLimitsName, false).get());
ASSERT_TRUE(object.getDouble(ExternalInterface_ScheduleFields::InitialValue, false));
EXPECT_EQ(10.0, object.getDouble(ExternalInterface_ScheduleFields::InitialValue, false).get());
model.save(toPath("./ExternalInterfaceSchedule.osm"), true);
workspace.save(toPath("./ExternalInterfaceSchedule.idf"), true);
}
TEST_F(EnergyPlusFixture,ForwardTranslator_ThermalZone_OneZone_OneSpace_Building)
{
Model model;
Point3dVector points;
points.push_back(Point3d(0, 0, 0));
points.push_back(Point3d(0, 1, 0));
points.push_back(Point3d(1, 1, 0));
points.push_back(Point3d(1, 0, 0));
SpaceType spaceType(model);
spaceType.setLightingPowerPerFloorArea(1);
Building building = model.getUniqueModelObject<Building>();
building.setSpaceType(spaceType);
ThermalZone zone(model);
Space space(model);
space.setThermalZone(zone);
Surface surface(points, model);
surface.setSpace(space);
EXPECT_EQ(1, space.floorArea());
EXPECT_EQ(1, space.lightingPowerPerFloorArea());
ForwardTranslator trans;
Workspace workspace = trans.translateModel(model);
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Zone).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ZoneList).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Lights).size());
}
TEST_F(EnergyPlusFixture,ForwardTranslator_Surface_Zone)
{
Model model;
ThermalZone thermalZone(model);
Space space(model);
space.setThermalZone(thermalZone);
Point3dVector points;
points.push_back(Point3d(0, 1, 0));
points.push_back(Point3d(0, 0, 0));
points.push_back(Point3d(1, 0, 0));
points.push_back(Point3d(1, 1, 0));
Surface surface(points, model);
surface.setSpace(space);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(0u, forwardTranslator.warnings().size());
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::BuildingSurface_Detailed).size());
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Zone).size());
WorkspaceObject surfaceObject = workspace.getObjectsByType(IddObjectType::BuildingSurface_Detailed)[0];
WorkspaceObject zoneObject = workspace.getObjectsByType(IddObjectType::Zone)[0];
ASSERT_TRUE(surfaceObject.getTarget(BuildingSurface_DetailedFields::ZoneName));
EXPECT_EQ(zoneObject.handle(), surfaceObject.getTarget(BuildingSurface_DetailedFields::ZoneName)->handle());
}
TEST_F(EnergyPlusFixture,ForwardTranslator_Building2)
{
Model model;
Building building = model.getUniqueModelObject<Building>();
building.setName("Building");
Site site = model.getUniqueModelObject<Site>();
SimulationControl simulationControl = model.getUniqueModelObject<SimulationControl>();
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Building).size());
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Site_Location).size());
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::SimulationControl).size());
WorkspaceObject object = workspace.getObjectsByType(IddObjectType::Building)[0];
ASSERT_TRUE(object.getString(BuildingFields::Name));
EXPECT_EQ("Building", object.getString(BuildingFields::Name).get());
EXPECT_TRUE(object.isEmpty(BuildingFields::NorthAxis));
EXPECT_TRUE(object.isEmpty(BuildingFields::Terrain));
EXPECT_TRUE(object.isEmpty(BuildingFields::LoadsConvergenceToleranceValue));
EXPECT_TRUE(object.isEmpty(BuildingFields::TemperatureConvergenceToleranceValue));
EXPECT_TRUE(object.isEmpty(BuildingFields::SolarDistribution));
EXPECT_TRUE(object.isEmpty(BuildingFields::MaximumNumberofWarmupDays));
}
TEST_F(EnergyPlusFixture, ForwardTranslator_ExternalInterfaceFunctionalMockupUnitImportFromVariable) {
Model model;
// add FMU
ExternalInterfaceFunctionalMockupUnitImport eifmui(model, "test name");
std::string outputVariableIndexKeyName = "outputVariableIndexKeyName";
std::string outputVariableName = "outputVariableName";
std::string fMUVariableName = "fMUVariableName";
std::string fMUInstanceName = "fMUInstanceName";
ExternalInterfaceFunctionalMockupUnitImportFromVariable variable(model, outputVariableIndexKeyName, outputVariableName, eifmui, fMUInstanceName, fMUVariableName);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ExternalInterface_FunctionalMockupUnitImport_From_Variable).size());
//EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ScheduleTypeLimits).size());
WorkspaceObject object = workspace.getObjectsByType(IddObjectType::ExternalInterface_FunctionalMockupUnitImport_From_Variable)[0];
//WorkspaceObject object2 = workspace.getObjectsByType(IddObjectType::ScheduleTypeLimits)[0];
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_From_VariableFields::Output_VariableIndexKeyName, false));
EXPECT_EQ(outputVariableIndexKeyName, object.getString(ExternalInterface_FunctionalMockupUnitImport_From_VariableFields::Output_VariableIndexKeyName, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_From_VariableFields::Output_VariableName, false));
EXPECT_EQ(outputVariableName, object.getString(ExternalInterface_FunctionalMockupUnitImport_From_VariableFields::Output_VariableName, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_From_VariableFields::FMUFileName, false));
EXPECT_EQ(eifmui.fMUFileName(), object.getString(ExternalInterface_FunctionalMockupUnitImport_From_VariableFields::FMUFileName, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_From_VariableFields::FMUInstanceName, false));
EXPECT_EQ(fMUInstanceName, object.getString(ExternalInterface_FunctionalMockupUnitImport_From_VariableFields::FMUInstanceName, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_From_VariableFields::FMUVariableName, false));
EXPECT_EQ(fMUVariableName, object.getString(ExternalInterface_FunctionalMockupUnitImport_From_VariableFields::FMUVariableName, false).get());
model.save(toPath("./ExternalInterfaceFunctionalMockupUnitImportFromVariable.osm"), true);
workspace.save(toPath("./ExternalInterfaceFunctionalMockupUnitImportFromVariable.idf"), true);
}
TEST_F(EnergyPlusFixture,ForwardTranslator_ShadingSurface_Space)
{
Model model;
ThermalZone thermalZone(model);
Point3dVector points;
points.push_back(Point3d(0,1,0));
points.push_back(Point3d(1,1,0));
points.push_back(Point3d(1,0,0));
points.push_back(Point3d(0,0,0));
boost::optional<Space> space = Space::fromFloorPrint(points, 1, model);
ASSERT_TRUE(space);
space->setThermalZone(thermalZone);
ShadingSurfaceGroup shadingSurfaceGroup(model);
EXPECT_TRUE(shadingSurfaceGroup.setSpace(*space));
ShadingSurface shadingSurface(points, model);
EXPECT_TRUE(shadingSurface.setShadingSurfaceGroup(shadingSurfaceGroup));
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Zone).size());
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Shading_Zone_Detailed).size());
WorkspaceObject zoneObject = workspace.getObjectsByType(IddObjectType::Zone)[0];
WorkspaceObject shadingSurfaceObject = workspace.getObjectsByType(IddObjectType::Shading_Zone_Detailed)[0];
EXPECT_TRUE(shadingSurfaceObject.getTarget(Shading_Zone_DetailedFields::BaseSurfaceName));
}
TEST_F(EnergyPlusFixture,ForwardTranslator_SpaceInfiltrationEffectiveLeakageArea_NoSpace)
{
Model model;
SpaceInfiltrationEffectiveLeakageArea infiltration(model);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(0u, forwardTranslator.warnings().size());
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::ZoneInfiltration_EffectiveLeakageArea).size());
WorkspaceObject object = workspace.getObjectsByType(IddObjectType::ZoneInfiltration_EffectiveLeakageArea)[0];
EXPECT_TRUE(object.isEmpty(ZoneInfiltration_EffectiveLeakageAreaFields::ZoneName));
}
TEST_F(EnergyPlusFixture,ForwardTranslator_Surface_DefaultConstruction)
{
Model model;
Construction construction(model);
DefaultSurfaceConstructions defaultSurfaceConstructions(model);
defaultSurfaceConstructions.setRoofCeilingConstruction(construction);
DefaultConstructionSet defaultConstructionSet(model);
defaultConstructionSet.setDefaultExteriorSurfaceConstructions(defaultSurfaceConstructions);
Building building = model.getUniqueModelObject<Building>();
building.setDefaultConstructionSet(defaultConstructionSet);
Space space(model);
ThermalZone zone(model);
EXPECT_TRUE(space.setThermalZone(zone));
Point3dVector points;
points.push_back(Point3d(0, 1, 0));
points.push_back(Point3d(0, 0, 0));
points.push_back(Point3d(1, 0, 0));
points.push_back(Point3d(1, 1, 0));
Surface surface(points, model);
surface.setSpace(space);
EXPECT_EQ("RoofCeiling", surface.surfaceType());
EXPECT_EQ("Outdoors", surface.outsideBoundaryCondition());
EXPECT_FALSE(surface.adjacentSurface());
ASSERT_TRUE(surface.construction());
EXPECT_TRUE(surface.isConstructionDefaulted());
EXPECT_EQ(construction.handle(), surface.construction()->handle());
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(0u, forwardTranslator.warnings().size());
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::BuildingSurface_Detailed).size());
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Construction).size());
WorkspaceObject surfaceObject = workspace.getObjectsByType(IddObjectType::BuildingSurface_Detailed)[0];
WorkspaceObject constructionObject = workspace.getObjectsByType(IddObjectType::Construction)[0];
ASSERT_TRUE(surfaceObject.getTarget(BuildingSurface_DetailedFields::ConstructionName));
EXPECT_EQ(constructionObject.handle(), surfaceObject.getTarget(BuildingSurface_DetailedFields::ConstructionName)->handle());
}
TEST_F(EnergyPlusFixture,ForwardTranslatorTest_TranslateConstruction) {
openstudio::model::Model model;
openstudio::model::StandardOpaqueMaterial mat1(model);
mat1.setName("test layer0");
mat1.setRoughness("MediumRough");
mat1.setThickness(0.02);
mat1.setThermalConductivity(1.5);
mat1.setDensity(20.0);
mat1.setSpecificHeat(2.0);
openstudio::model::StandardOpaqueMaterial mat2(model);
mat2.setName("test layer1");
mat2.setRoughness("MediumSmooth");
mat2.setThickness(0.005);
mat2.setThermalConductivity(0.3);
mat2.setDensity(3.0);
mat2.setSpecificHeat(0.3);
openstudio::model::Construction construction(model);
construction.setName("test construction");
construction.insertLayer(0, mat1);
construction.insertLayer(1, mat2);
ForwardTranslator trans;
Workspace workspace = trans.translateModelObject(construction);
ASSERT_EQ(1u, workspace.numObjectsOfType(IddObjectType::Construction));
IdfObject constructionIdf = workspace.getObjectsByType(IddObjectType::Construction)[0];
EXPECT_EQ(unsigned(3), constructionIdf.numFields());
EXPECT_EQ("test construction", *(constructionIdf.name()) );
EXPECT_EQ("test layer0", *(constructionIdf.getString(1)) );
EXPECT_EQ("test layer1", *(constructionIdf.getString(2)) );
}
TEST_F(EnergyPlusFixture, ForwardTranslator_AvailabilityManagerScheduledOff) {
Model m;
AvailabilityManagerScheduledOff avm(m);
// Test Schedule
ScheduleConstant sch(m);
sch.setValue(50);
EXPECT_TRUE(avm.setSchedule(sch));
// Assign it to a plant loop
PlantLoop p(m);
p.addAvailabilityManager(avm);
// ForwardTranslate
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(m);
WorkspaceObjectVector idfObjs(workspace.getObjectsByType(IddObjectType::AvailabilityManager_ScheduledOff));
EXPECT_EQ(1u, idfObjs.size());
WorkspaceObject idf_avm(idfObjs[0]);
// Schedule Name
ASSERT_EQ(sch.name().get(), idf_avm.getString(AvailabilityManager_ScheduledOffFields::ScheduleName).get());
}
TEST_F(EnergyPlusFixture,ForwardTranslator_SpaceInfiltrationDesignFlowRate)
{
Model model;
ThermalZone zone(model);
Space space(model);
space.setThermalZone(zone);
SpaceInfiltrationDesignFlowRate infiltration(model);
infiltration.setSpace(space);
infiltration.setFlowperExteriorWallArea(1.0);
ForwardTranslator ft;
Workspace workspace = ft.translateModel(model);
std::vector<WorkspaceObject> objects = workspace.getObjectsByType(IddObjectType::ZoneInfiltration_DesignFlowRate);
ASSERT_EQ(1u, objects.size());
ASSERT_TRUE(objects[0].getString(ZoneInfiltration_DesignFlowRateFields::DesignFlowRateCalculationMethod));
EXPECT_EQ("Flow/ExteriorWallArea", objects[0].getString(ZoneInfiltration_DesignFlowRateFields::DesignFlowRateCalculationMethod).get());
EXPECT_FALSE(objects[0].getDouble(ZoneInfiltration_DesignFlowRateFields::DesignFlowRate));
EXPECT_FALSE(objects[0].getDouble(ZoneInfiltration_DesignFlowRateFields::FlowperZoneFloorArea));
ASSERT_TRUE(objects[0].getDouble(ZoneInfiltration_DesignFlowRateFields::FlowperExteriorSurfaceArea));
EXPECT_EQ(1.0, objects[0].getDouble(ZoneInfiltration_DesignFlowRateFields::FlowperExteriorSurfaceArea).get());
EXPECT_FALSE(objects[0].getDouble(ZoneInfiltration_DesignFlowRateFields::AirChangesperHour));
}
TEST_F(EnergyPlusFixture,ForwardTranslatorTest_TranslateStandardOpaqueMaterial) {
openstudio::model::Model model;
openstudio::model::StandardOpaqueMaterial mat(model);
mat.setName("Test Material");
mat.setRoughness("Rough");
mat.setThickness(0.0125);
mat.setThermalConductivity(0.5);
mat.setDensity(3.5);
mat.setSpecificHeat(2.5);
mat.setThermalAbsorptance(0.9);
mat.setSolarAbsorptance(0.7);
mat.setVisibleAbsorptance(0.7);
ForwardTranslator trans;
Workspace workspace = trans.translateModelObject(mat);
ASSERT_EQ(1u, workspace.numObjectsOfType(IddObjectType::Material));
openstudio::IdfObject matIdf = workspace.getObjectsByType(IddObjectType::Material)[0];
EXPECT_EQ(unsigned(9), matIdf.numFields());
EXPECT_EQ( "Test Material", *(matIdf.name()) );
EXPECT_EQ( "Rough", *(matIdf.getString(1)) );
EXPECT_EQ( 0.0125, *(matIdf.getDouble(2)) );
EXPECT_EQ( 0.5, *(matIdf.getDouble(3)) );
EXPECT_EQ( 3.5, *(matIdf.getDouble(4)) );
EXPECT_EQ( 2.5, *(matIdf.getDouble(5)) );
EXPECT_EQ( 0.9, *(matIdf.getDouble(6)) );
EXPECT_EQ( 0.7, *(matIdf.getDouble(7)) );
EXPECT_EQ( 0.7, *(matIdf.getDouble(8)) );
}
TEST_F(EnergyPlusFixture,ForwardTranslator_ThermalZone_OneZone_TwoSpaces_DifferentSpaceType)
{
Model model;
Point3dVector points;
points.push_back(Point3d(0, 0, 0));
points.push_back(Point3d(0, 1, 0));
points.push_back(Point3d(1, 1, 0));
points.push_back(Point3d(1, 0, 0));
SpaceType spaceType1(model);
spaceType1.setLightingPowerPerFloorArea(1);
SpaceType spaceType2(model);
spaceType2.setLightingPowerPerFloorArea(2);
ThermalZone zone(model);
Space space1(model);
space1.setThermalZone(zone);
space1.setSpaceType(spaceType1);
Space space2(model);
space2.setThermalZone(zone);
space2.setSpaceType(spaceType2);
Surface surface1(points, model);
surface1.setSpace(space1);
Surface surface2(points, model);
surface2.setSpace(space2);
EXPECT_EQ(1, space1.floorArea());
EXPECT_EQ(1, space2.floorArea());
EXPECT_EQ(1, space1.lightingPowerPerFloorArea());
EXPECT_EQ(2, space2.lightingPowerPerFloorArea());
ForwardTranslator trans;
Workspace workspace = trans.translateModel(model);
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Zone).size());
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::ZoneList).size());
EXPECT_EQ(2u, workspace.getObjectsByType(IddObjectType::Lights).size());
}
TEST_F(EnergyPlusFixture,ForwardTranslator_IlluminanceMap)
{
Model model;
ThermalZone thermalZone(model);
Space space(model);
space.setThermalZone(thermalZone);
IlluminanceMap illuminanceMap(model);
illuminanceMap.setSpace(space);
EXPECT_TRUE(thermalZone.setIlluminanceMap(illuminanceMap));
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Output_IlluminanceMap).size());
// automatically added
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Daylighting_Controls).size());
}
TEST_F(EnergyPlusFixture,ForwardTranslator_ScheduleRuleset_Simple)
{
Model model;
ScheduleRuleset scheduleRuleset(model);
// annual weekday rule
ScheduleRule rule2(scheduleRuleset);
rule2.setApplySunday(false);
rule2.setApplyMonday(true);
rule2.setApplyTuesday(true);
rule2.setApplyWednesday(true);
rule2.setApplyThursday(true);
rule2.setApplyFriday(true);
rule2.setApplySaturday(false);
// annual weekend rule
ScheduleRule rule1(scheduleRuleset);
rule1.setApplySunday(true);
rule1.setApplyMonday(false);
rule1.setApplyTuesday(false);
rule1.setApplyWednesday(false);
rule1.setApplyThursday(false);
rule1.setApplyFriday(false);
rule1.setApplySaturday(true);
ForwardTranslator ft;
Workspace workspace = ft.translateModel(model);
std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
ASSERT_EQ(1u, scheduleYears.size());
std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
ASSERT_EQ(2u, extensibleGroups.size());
// based on 2009 assumed year
// 1/1-1/3
ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
EXPECT_EQ(3, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
// 1/4-12/31
ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth));
EXPECT_EQ(1, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth).get());
ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay));
EXPECT_EQ(4, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay).get());
ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth));
EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth).get());
ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay));
EXPECT_EQ(31, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay).get());
}
TEST_F(EnergyPlusFixture, ForwardTranslator_ExternalInterfaceFunctionalMockupUnitImportToActuator) {
Model model;
Building building = model.getUniqueModelObject<Building>();
// add fan
Schedule s = model.alwaysOnDiscreteSchedule();
FanConstantVolume fan(model, s);
// add FMU
ExternalInterfaceFunctionalMockupUnitImport eifmui(model, "test name");
// add actuator
std::string fanControlType = "Fan Pressure Rise";
std::string ComponentType = "Fan";
ExternalInterfaceFunctionalMockupUnitImportToActuator fanActuator(fan, ComponentType, fanControlType, eifmui, "FMU", "Fan FMU name", 10);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ExternalInterface_FunctionalMockupUnitImport_To_Actuator).size());
WorkspaceObject object = workspace.getObjectsByType(IddObjectType::ExternalInterface_FunctionalMockupUnitImport_To_Actuator)[0];
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::Name, false));
EXPECT_EQ("External Interface Functional Mockup Unit Import To Actuator 1", object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::Name, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::ActuatedComponentUniqueName, false));
EXPECT_EQ(fan.nameString(), object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::ActuatedComponentUniqueName, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::ActuatedComponentType, false));
EXPECT_EQ(ComponentType, object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::ActuatedComponentType, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::ActuatedComponentControlType, false));
EXPECT_EQ(fanControlType, object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::ActuatedComponentControlType, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::FMUFileName, false));
EXPECT_EQ(eifmui.fMUFileName(), object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::FMUFileName, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::FMUVariableName, false));
EXPECT_EQ("Fan FMU name", object.getString(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::FMUVariableName, false).get());
ASSERT_TRUE(object.getDouble(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::InitialValue, false));
EXPECT_EQ(10.0, object.getDouble(ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::InitialValue, false).get());
model.save(toPath("./ExternalInterfaceFunctionalMockupUnitImportToActuator.osm"), true);
workspace.save(toPath("./ExternalInterfaceFunctionalMockupUnitImportToActuator.idf"), true);
}
TEST_F(EnergyPlusFixture,ForwardTranslatorTest_TranslateScheduleCompact) {
openstudio::model::Model model;
openstudio::model::ScheduleCompact scheduleCompact(model);
scheduleCompact.setName("Daytime Ventilation");
scheduleCompact.setString(2,"Fraction");
scheduleCompact.setString(3,"Through: 12/31");
scheduleCompact.setString(4,"For: Weekdays SummerDesignDay");
scheduleCompact.setString(5,"Until: 08:00");
scheduleCompact.setString(6,"0.0");
scheduleCompact.setString(7,"Until: 18:00");
scheduleCompact.setString(8,"1.0");
scheduleCompact.setString(9,"Until: 24:00");
scheduleCompact.setString(10,"0.0");
scheduleCompact.setString(11,"For: Weekends WinterDesignDay");
scheduleCompact.setString(12,"Until: 10:00");
scheduleCompact.setString(13,"0.0");
scheduleCompact.setString(14,"Until: 16:00");
scheduleCompact.setString(15,"1.0");
scheduleCompact.setString(16,"Until: 24:00");
scheduleCompact.setString(17,"0.0");
scheduleCompact.setString(18,"For: Holidays AllOtherDays");
scheduleCompact.setString(19,"Until: 24:00");
scheduleCompact.setString(20,"0.0");
ForwardTranslator trans;
Workspace workspace = trans.translateModelObject(scheduleCompact);
ASSERT_EQ(1u, workspace.numObjectsOfType(IddObjectType::Schedule_Compact));
openstudio::IdfObject scheduleCompactIdf = workspace.getObjectsByType(IddObjectType::Schedule_Compact)[0];
EXPECT_EQ(20u,scheduleCompactIdf.numFields());
EXPECT_EQ(21u,scheduleCompact.numFields());
ASSERT_EQ(scheduleCompactIdf.numFields() + 1,scheduleCompact.numFields());
ASSERT_TRUE(scheduleCompact.name());
ASSERT_TRUE(scheduleCompactIdf.name());
EXPECT_EQ(scheduleCompact.name().get(),scheduleCompactIdf.name().get());
for( unsigned i = OS_Schedule_CompactFields::getValues().size(); i < scheduleCompact.numFields(); i++ )
{
boost::optional<std::string> s1 = scheduleCompactIdf.getString(i-1);
boost::optional<std::string> s2 = scheduleCompact.getString(i);
ASSERT_TRUE(s1);
ASSERT_TRUE(s2);
EXPECT_EQ(s1.get(),s2.get());
}
}
/*
TEST_F(EnergyPlusFixture,ForwardTranslator_LightShelf)
{
ASSERT_TRUE(true);
}
TEST_F(EnergyPlusFixture,ForwardTranslator_Building)
{
openstudio::model::Model model;
openstudio::model::Building building(model);
ForwardTranslator forwardTranslator(model);
OptionalWorkspace outWorkspace = forwardTranslator.convert();
ASSERT_TRUE(outWorkspace);
EXPECT_EQ(static_cast<unsigned>(1), outWorkspace->getObjectsByType(IddObjectType::Building).size());
}
TEST_F(EnergyPlusFixture,ForwardTranslator_Zone)
{
openstudio::model::Model model;
openstudio::model::Zone zone(model);
openstudio::model::Lights lights(model);
lights.addToZone(zone);
ForwardTranslator forwardTranslator(model);
OptionalWorkspace outWorkspace = forwardTranslator.convert();
ASSERT_TRUE(outWorkspace);
ASSERT_EQ(static_cast<unsigned>(1), outWorkspace->getObjectsByType(IddObjectType::Zone).size());
Handle zoneHandle = outWorkspace->getObjectsByType(IddObjectType::Zone)[0].handle();
ASSERT_EQ(static_cast<unsigned>(1), outWorkspace->getObjectsByType(IddObjectType::Lights).size());
WorkspaceObject lightsObject = outWorkspace->getObjectsByType(IddObjectType::Lights)[0];
ASSERT_TRUE(lightsObject.getTarget(openstudio::LightsFields::ZoneorZoneListName));
EXPECT_TRUE(zoneHandle == lightsObject.getTarget(openstudio::LightsFields::ZoneorZoneListName)->handle());
}
*/
TEST_F(EnergyPlusFixture,ForwardTranslator_ExampleModel) {
Model model = exampleModel();
EXPECT_TRUE(model.getOptionalUniqueModelObject<Version>()) << "Example model does not include a Version object.";
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(1u,workspace.getObjectsByType(IddObjectType::Version).size());
model.save(toPath("./example.osm"), true);
workspace.save(toPath("./example.idf"), true);
}
TEST_F(EnergyPlusFixture, ForwardTranslator_ExternalInterfaceVariable) {
Model model;
ExternalInterfaceVariable variable(model, "test name", 10);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ExternalInterface_Variable).size());
WorkspaceObject object = workspace.getObjectsByType(IddObjectType::ExternalInterface_Variable)[0];
ASSERT_TRUE(object.getString(ExternalInterface_VariableFields::Name, false));
EXPECT_EQ("test name", object.getString(ExternalInterface_VariableFields::Name, false).get());
ASSERT_TRUE(object.getDouble(ExternalInterface_VariableFields::InitialValue, false));
EXPECT_EQ(10.0, object.getDouble(ExternalInterface_VariableFields::InitialValue, false).get());
model.save(toPath("./ExternalInterfaceVariable.osm"), true);
workspace.save(toPath("./ExternalInterfaceVariable.idf"), true);
}
TEST_F(EnergyPlusFixture, ForwardTranslator_ExternalInterface) {
Model model;
ExternalInterface externalinterface = model.getUniqueModelObject<ExternalInterface>();
EXPECT_EQ("PtolemyServer", externalinterface.nameofExternalInterface());
EXPECT_TRUE(externalinterface.setNameofExternalInterface("FunctionalMockupUnitImport"));
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ExternalInterface).size());
WorkspaceObject object = workspace.getObjectsByType(IddObjectType::ExternalInterface)[0];
ASSERT_TRUE(object.getString(ExternalInterfaceFields::NameofExternalInterface, false));
EXPECT_EQ("FunctionalMockupUnitImport", object.getString(ExternalInterfaceFields::NameofExternalInterface, false).get());
model.save(toPath("./ExternalInterface.osm"), true);
workspace.save(toPath("./ExternalInterface.idf"), true);
}
TEST_F(EnergyPlusFixture,ForwardTranslator_Building3)
{
Model model;
Building building = model.getUniqueModelObject<Building>();
building.setName("Building");
building.setNorthAxis(20);
building.setNominalFloortoFloorHeight(5);
Site site = model.getUniqueModelObject<Site>();
site.setTerrain("Ocean");
SimulationControl simulationControl = model.getUniqueModelObject<SimulationControl>();
simulationControl.setLoadsConvergenceToleranceValue(0.2);
simulationControl.setTemperatureConvergenceToleranceValue(0.2);
simulationControl.setSolarDistribution("FullInteriorAndExteriorWithReflections");
simulationControl.setMaximumNumberofWarmupDays(2);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Building).size());
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Site_Location).size());
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::SimulationControl).size());
WorkspaceObject object = workspace.getObjectsByType(IddObjectType::Building)[0];
ASSERT_TRUE(object.getString(BuildingFields::Name));
EXPECT_EQ("Building", object.getString(BuildingFields::Name).get());
ASSERT_TRUE(object.getDouble(BuildingFields::NorthAxis));
EXPECT_EQ(20, object.getDouble(BuildingFields::NorthAxis).get());
ASSERT_TRUE(object.getString(BuildingFields::Terrain));
EXPECT_EQ("Ocean", object.getString(BuildingFields::Terrain).get());
ASSERT_TRUE(object.getDouble(BuildingFields::LoadsConvergenceToleranceValue));
EXPECT_EQ(0.2, object.getDouble(BuildingFields::LoadsConvergenceToleranceValue).get());
ASSERT_TRUE(object.getDouble(BuildingFields::TemperatureConvergenceToleranceValue));
EXPECT_EQ(0.2, object.getDouble(BuildingFields::TemperatureConvergenceToleranceValue).get());
ASSERT_TRUE(object.getString(BuildingFields::SolarDistribution));
EXPECT_EQ("FullInteriorAndExteriorWithReflections", object.getString(BuildingFields::SolarDistribution).get());
ASSERT_TRUE(object.getInt(BuildingFields::MaximumNumberofWarmupDays));
EXPECT_EQ(2, object.getInt(BuildingFields::MaximumNumberofWarmupDays).get());
}
TEST_F(EnergyPlusFixture,ForwardTranslator_LifeCycleCostParameters)
{
Model model;
LifeCycleCostParameters lifeCycleCostParameters = model.getUniqueModelObject<LifeCycleCostParameters>();
ForwardTranslator ft;
Workspace workspace = ft.translateModelObject(lifeCycleCostParameters);
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::LifeCycleCost_Parameters).size());
EXPECT_EQ(5u, workspace.getObjectsByType(IddObjectType::LifeCycleCost_UsePriceEscalation).size());
const char *c_regions[] = {"U.S. Avg", "NorthEast", "MidWest", "South", "West"};
const char *c_sectors[] = {"Commercial", "Residential", "Industrial"};
std::vector<std::string> regions(c_regions, c_regions + 5);
std::vector<std::string> sectors(c_sectors, c_sectors + 3);
EXPECT_EQ(5u, regions.size());
EXPECT_EQ(3u, sectors.size());
EXPECT_TRUE(lifeCycleCostParameters.setUseNISTFuelEscalationRates(true));
for (const std::string& region : regions){
for (const std::string& sector : sectors){
EXPECT_TRUE(lifeCycleCostParameters.setNISTRegion(region));
EXPECT_TRUE(lifeCycleCostParameters.setNISTSector(sector));
unsigned numExpected = 5;
if (sector == "Residential"){
numExpected = 4;
}
workspace = ft.translateModelObject(lifeCycleCostParameters);
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::LifeCycleCost_Parameters).size());
EXPECT_EQ(numExpected, workspace.getObjectsByType(IddObjectType::LifeCycleCost_UsePriceEscalation).size()) << region << " " << sector;
}
}
EXPECT_TRUE(lifeCycleCostParameters.setUseNISTFuelEscalationRates(false));
workspace = ft.translateModelObject(lifeCycleCostParameters);
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::LifeCycleCost_Parameters).size());
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::LifeCycleCost_UsePriceEscalation).size());
EXPECT_TRUE(lifeCycleCostParameters.setElectricityInflation(0.01));
workspace = ft.translateModelObject(lifeCycleCostParameters);
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::LifeCycleCost_Parameters).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::LifeCycleCost_UsePriceEscalation).size());
}
TEST_F(EnergyPlusFixture, ForwardTranslator_ExternalInterfaceFunctionalMockupUnitImport) {
Model model;
ExternalInterfaceFunctionalMockupUnitImport eifmui(model, "c:\\Program Files\\Test\\blah.fmu");
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ExternalInterface_FunctionalMockupUnitImport).size());
WorkspaceObject object = workspace.getObjectsByType(IddObjectType::ExternalInterface_FunctionalMockupUnitImport)[0];
ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitImportFields::FMUFileName, false));
EXPECT_EQ("c:\\Program Files\\Test\\blah.fmu", object.getString(ExternalInterface_FunctionalMockupUnitImportFields::FMUFileName, false).get());
ASSERT_TRUE(object.getDouble(ExternalInterface_FunctionalMockupUnitImportFields::FMUTimeout, false));
EXPECT_EQ(0, object.getDouble(ExternalInterface_FunctionalMockupUnitImportFields::FMUTimeout, false).get());
ASSERT_TRUE(object.getDouble(ExternalInterface_FunctionalMockupUnitImportFields::FMULoggingOn, false));
EXPECT_EQ(0, object.getDouble(ExternalInterface_FunctionalMockupUnitImportFields::FMULoggingOn, false).get());
model.save(toPath("./ExternalInterfaceFunctionalMockupUnitImport.osm"), true);
workspace.save(toPath("./ExternalInterfaceFunctionalMockupUnitImport.idf"), true);
}
TEST_F(EnergyPlusFixture,ForwardTranslator_IlluminanceMap_NoZone)
{
Model model;
ThermalZone thermalZone(model);
Space space(model);
space.setThermalZone(thermalZone);
IlluminanceMap illuminanceMap(model);
illuminanceMap.setSpace(space);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Output_IlluminanceMap).size());
}
TEST_F(EnergyPlusFixture, ForwardTranslator_ExternalInterfaceActuator) {
Model model;
Building building = model.getUniqueModelObject<Building>();
// add fan
Schedule s = model.alwaysOnDiscreteSchedule();
FanConstantVolume fan(model, s);
// add actuator
std::string fanControlType = "Fan Pressure Rise";
std::string ComponentType = "Fan";
ExternalInterfaceActuator fanActuator(fan, ComponentType, fanControlType);
std::string fanName = fan.name().get() + "Press Actuator";
fanActuator.setName(fanName);
fanActuator.setOptionalInitialValue(1);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ExternalInterface_Actuator).size());
WorkspaceObject object = workspace.getObjectsByType(IddObjectType::ExternalInterface_Actuator)[0];
ASSERT_TRUE(object.getString(ExternalInterface_ActuatorFields::ActuatedComponentUniqueName, false));
EXPECT_EQ(fan.nameString(), object.getString(ExternalInterface_ActuatorFields::ActuatedComponentUniqueName, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_ActuatorFields::ActuatedComponentType, false));
EXPECT_EQ(ComponentType, object.getString(ExternalInterface_ActuatorFields::ActuatedComponentType, false).get());
ASSERT_TRUE(object.getString(ExternalInterface_ActuatorFields::ActuatedComponentControlType, false));
EXPECT_EQ(fanControlType, object.getString(ExternalInterface_ActuatorFields::ActuatedComponentControlType, false).get());
ASSERT_TRUE(object.getDouble(ExternalInterface_ActuatorFields::OptionalInitialValue, false));
EXPECT_EQ(1.0, object.getDouble(ExternalInterface_ActuatorFields::OptionalInitialValue, false).get());
model.save(toPath("./ExternalInterfaceActuator.osm"), true);
workspace.save(toPath("./ExternalInterfaceActuator.idf"), true);
}
//test orphaning the generator before FT
TEST_F(EnergyPlusFixture, ForwardTranslatorGeneratorMicroTurbine_ELCD_Orphan)
{
// Create a model, a mchp, a mchpHR, a plantLoop and an electricalLoadCenter
Model model;
GeneratorMicroTurbine mchp = GeneratorMicroTurbine(model);
GeneratorMicroTurbineHeatRecovery mchpHR = GeneratorMicroTurbineHeatRecovery(model, mchp);
ASSERT_EQ(mchpHR, mchp.generatorMicroTurbineHeatRecovery().get());
PlantLoop plantLoop(model);
// Add a supply branch for the mchpHR
ASSERT_TRUE(plantLoop.addSupplyBranchForComponent(mchpHR));
// Create a WaterHeater:Mixed
WaterHeaterMixed waterHeater(model);
// Add it on the same branch as the chpHR, right after it
Node mchpHROutletNode = mchpHR.outletModelObject()->cast<Node>();
ASSERT_TRUE(waterHeater.addToNode(mchpHROutletNode));
// Create a plantEquipmentOperationHeatingLoad
PlantEquipmentOperationHeatingLoad operation(model);
operation.setName(plantLoop.name().get() + " PlantEquipmentOperationHeatingLoad");
ASSERT_TRUE(plantLoop.setPlantEquipmentOperationHeatingLoad(operation));
ASSERT_TRUE(operation.addEquipment(mchpHR));
ASSERT_TRUE(operation.addEquipment(waterHeater));
// Create an ELCD
ElectricLoadCenterDistribution elcd = ElectricLoadCenterDistribution(model);
elcd.setName("Capstone C65 ELCD");
elcd.setElectricalBussType("AlternatingCurrent");
elcd.addGenerator(mchp);
// orphan the generator from the ELCD
boost::optional<ElectricLoadCenterDistribution> elcd2 = mchp.electricLoadCenterDistribution();
elcd2.get().remove();
EXPECT_FALSE(mchp.electricLoadCenterDistribution());
// Forward Translates
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
//ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::WaterHeater_Mixed).size());
ASSERT_EQ(0u, workspace.getObjectsByType(IddObjectType::ElectricLoadCenter_Distribution).size());
//model.save(toPath("./ForwardTranslatorGeneratorMicroTurbine_ELCD_orhpan.osm"), true);
//workspace.save(toPath("./ForwardTranslatorGeneratorMicroTurbine_ELCD_orphan.idf"), true);
}
TEST_F(EnergyPlusFixture,ForwardTranslator_People_NoSpace)
{
Model model;
PeopleDefinition def(model);
People people(def);
ForwardTranslator ft;
Workspace workspace = ft.translateModel(model);
std::vector<WorkspaceObject> peopleObjects = workspace.getObjectsByType(IddObjectType::People);
//ASSERT_EQ(0u, peopleObjects.size()); // for now we will let the object come through, this will cause an error in E+
ASSERT_EQ(1u, peopleObjects.size());
}
TEST_F(EnergyPlusFixture,ForwardTranslatorCentralHeatPumpSystem_NoModules) {
boost::optional<WorkspaceObject> _wo;
ForwardTranslator ft;
Model m;
CentralHeatPumpSystem central_hp(m);
// DO NOT Add a Module
EXPECT_EQ(0u, central_hp.modules().size());
// Connect the CentralHP to three plant loops
// CoolingLoop: on the supply side
PlantLoop coolingPlant(m);
EXPECT_TRUE(coolingPlant.addSupplyBranchForComponent(central_hp));
// SourceLoop: on the demand side
PlantLoop sourcePlant(m);
EXPECT_TRUE(sourcePlant.addDemandBranchForComponent(central_hp));
// Also add a CT to the sourcePlant
CoolingTowerSingleSpeed ct(m);
sourcePlant.addSupplyBranchForComponent(ct);
// HeatingLoop: on the supply side
PlantLoop heatingPlant(m);
// Workaround to be able to use addToTertiaryNode directly
// (addSupplyBranchForComponent should work directly, but this is tested in model GTest, so here we just make sure we call
// addToTertiaryNode directly)
BoilerHotWater temp_b(m);
EXPECT_TRUE(heatingPlant.addSupplyBranchForComponent(temp_b));
ASSERT_TRUE(temp_b.inletModelObject());
auto node = temp_b.inletModelObject().get().cast<Node>();
EXPECT_TRUE(central_hp.addToTertiaryNode(node));
temp_b.remove();
EXPECT_TRUE(central_hp.coolingPlantLoop());
EXPECT_TRUE(central_hp.sourcePlantLoop());
EXPECT_TRUE(central_hp.heatingPlantLoop());
Workspace w = ft.translateModel(m);
EXPECT_EQ(0u, ft.errors().size());
EXPECT_EQ(0u, w.getObjectsByType(IddObjectType::CentralHeatPumpSystem).size());
}
TEST_F(EnergyPlusFixture,ForwardTranslator_Surface)
{
Model model;
Point3dVector points;
points.push_back(Point3d(0, 1, 0));
points.push_back(Point3d(0, 0, 0));
points.push_back(Point3d(1, 0, 0));
points.push_back(Point3d(1, 1, 0));
Surface surface(points, model);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(0u, forwardTranslator.warnings().size());
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::BuildingSurface_Detailed).size());
}