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_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,ForwardTranslatorTest_TranslateAirLoopHVAC) {
openstudio::model::Model model;
EXPECT_TRUE(model.getOptionalUniqueModelObject<Version>()) << "Blank model does not include a Version object.";
ThermalZone zone1(model);
ThermalZone zone2(model);
ThermalZone zone3(model);
openstudio::model::AirLoopHVAC airLoopHVAC(model);
airLoopHVAC.addBranchForZone(zone1, boost::none);
airLoopHVAC.addBranchForZone(zone2, boost::none);
airLoopHVAC.addBranchForZone(zone3, boost::none);
ForwardTranslator trans;
openstudio::Workspace workspace = trans.translateModel(model);
EXPECT_EQ(1u,workspace.getObjectsByType(IddObjectType::Version).size());
ASSERT_NE(unsigned(0),workspace.objects().size());
openstudio::path outDir = resourcesPath() / openstudio::toPath("airLoopHVAC.idf");
boost::filesystem::ofstream ofs(outDir);
workspace.toIdfFile().print(ofs);
ofs.close();
}
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_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_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_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_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, 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_SpaceInfiltrationEffectiveLeakageArea)
{
Model model;
SpaceInfiltrationEffectiveLeakageArea infiltration(model);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(0u, forwardTranslator.warnings().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_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);
}
/**
* Tests only the controlType of the ForwardTranslator which I exposed after the fact
**/
TEST_F(EnergyPlusFixture,ForwardTranslator_AirLoopHVACUnitarySystem_ControlType)
{
Model m;
AirLoopHVAC airLoop(m);
AirLoopHVACUnitarySystem unitary(m);
Node supplyOutletNode = airLoop.supplyOutletNode();
unitary.addToNode(supplyOutletNode);
// test if Setpoint
unitary.setControlType("Setpoint");
ForwardTranslator ft;
Workspace workspace = ft.translateModel(m);
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::AirLoopHVAC_UnitarySystem).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::AirLoopHVAC).size());
IdfObject idf_unitary = workspace.getObjectsByType(IddObjectType::AirLoopHVAC_UnitarySystem)[0];
ASSERT_EQ("Setpoint",
idf_unitary.getString(AirLoopHVAC_UnitarySystemFields::ControlType).get() );
// test if load (make sure nothing is hardcoded)
unitary.setControlType("Load");
workspace = ft.translateModel(m);
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::AirLoopHVAC_UnitarySystem).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::AirLoopHVAC).size());
idf_unitary = workspace.getObjectsByType(IddObjectType::AirLoopHVAC_UnitarySystem)[0];
ASSERT_EQ("Load",
idf_unitary.getString(AirLoopHVAC_UnitarySystemFields::ControlType).get() );
}
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,ReverseTranslator_DaylightingOffice)
{
openstudio::path idfPath = resourcesPath() / toPath("energyplus/Daylighting_Office/in.idf");
OptionalIdfFile idfFile = IdfFile::load(idfPath, IddFileType::EnergyPlus);
ASSERT_TRUE(idfFile);
Workspace inWorkspace(*idfFile);
ReverseTranslator reverseTranslator;
Model model = reverseTranslator.translateWorkspace(inWorkspace);
model.save( resourcesPath() / toPath("energyplus/Daylighting_Office/in.osm"), true);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
workspace.save( resourcesPath() / toPath("energyplus/Daylighting_Office/in2.idf"), true);
}
TEST_F(EnergyPlusFixture, ForwardTranslatorFuelCell4) {
//TEST orphaned FC
Model model;
Building building = model.getUniqueModelObject<Building>();
GeneratorFuelCellAirSupply airSupply(model);
GeneratorFuelCellAuxiliaryHeater auxHeater(model);
GeneratorFuelCellElectricalStorage elecStorage(model);
GeneratorFuelCellExhaustGasToWaterHeatExchanger exhaustHX(model);
GeneratorFuelCellInverter inverter(model);
GeneratorFuelCellPowerModule powerModule(model);
//GeneratorFuelCellStackCooler stackCooler(model);
GeneratorFuelCellWaterSupply waterSupply(model);
GeneratorFuelSupply fuelSupply(model);
// create default fuelcell
GeneratorFuelCell fuelcell(model, powerModule, airSupply, waterSupply, auxHeater, exhaustHX, elecStorage, inverter, fuelSupply);
// remove the ELCD
boost::optional<ElectricLoadCenterDistribution> elcd = fuelcell.electricLoadCenterDistribution();
elcd.get().remove();
EXPECT_FALSE(fuelcell.electricLoadCenterDistribution());
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(1u, forwardTranslator.warnings().size());
//NO FC components should FT now since it is orphaned
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::ElectricLoadCenter_Generators).size());
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::ElectricLoadCenter_Distribution).size());
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell).size());
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_AirSupply).size());
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_AuxiliaryHeater).size());
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_ElectricalStorage).size());
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_ExhaustGasToWaterHeatExchanger).size());
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_Inverter).size());
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_PowerModule).size());
//expect stack cooler
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_StackCooler).size());
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_WaterSupply).size());
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Generator_FuelSupply).size());
//no water mains expected
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Site_WaterMainsTemperature).size());
model.save(toPath("./fuelcell4.osm"), true);
workspace.save(toPath("./fuelcell4.idf"), true);
}
TEST_F(EnergyPlusFixture,ReverseTranslator_SimpleRelativeTest)
{
openstudio::path idfPath = resourcesPath() / toPath("energyplus/SimpleSurfaces/SimpleSurfaces_Relative.idf");
OptionalIdfFile idfFile = IdfFile::load(idfPath, IddFileType::EnergyPlus);
ASSERT_TRUE(idfFile);
Workspace inWorkspace(*idfFile);
ReverseTranslator reverseTranslator;
Model model = reverseTranslator.translateWorkspace(inWorkspace);
model.save( resourcesPath() / toPath("energyplus/SimpleSurfaces/SimpleSurfaces_Relative.osm"), true);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
workspace.save( resourcesPath() / toPath("energyplus/SimpleSurfaces/SimpleSurfaces_Relative2.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, ForwardTranslatorFuelCell3) {
Model model;
Building building = model.getUniqueModelObject<Building>();
GeneratorFuelCellAirSupply airSupply(model);
GeneratorFuelCellAuxiliaryHeater auxHeater(model);
GeneratorFuelCellElectricalStorage elecStorage(model);
GeneratorFuelCellExhaustGasToWaterHeatExchanger exhaustHX(model);
GeneratorFuelCellInverter inverter(model);
GeneratorFuelCellPowerModule powerModule(model);
GeneratorFuelCellStackCooler stackCooler(model);
GeneratorFuelCellWaterSupply waterSupply(model);
GeneratorFuelSupply fuelSupply(model);
// create default fuelcell
GeneratorFuelCell fuelcell(model, powerModule, airSupply, waterSupply, auxHeater, exhaustHX, elecStorage, inverter, fuelSupply);
// Create an ELCD
ElectricLoadCenterDistribution elcd = ElectricLoadCenterDistribution(model);
elcd.setName("fuelcell ELCD");
elcd.setElectricalBussType("AlternatingCurrent");
elcd.addGenerator(fuelcell);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ElectricLoadCenter_Generators).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ElectricLoadCenter_Distribution).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_AirSupply).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_AuxiliaryHeater).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_ElectricalStorage).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_ExhaustGasToWaterHeatExchanger).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_Inverter).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_PowerModule).size());
//expect stack cooler
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_StackCooler).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_WaterSupply).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelSupply).size());
//no water mains expected
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Site_WaterMainsTemperature).size());
model.save(toPath("./fuelcell3.osm"), true);
workspace.save(toPath("./fuelcell3.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,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,ExteriorLights)
{
Model model;
ExteriorLightsDefinition exteriorLightsDefinition(model);
exteriorLightsDefinition.setDesignLevel(2303.0);
ScheduleConstant schedule(model);
schedule.setValue(1.0);
ExteriorLights exteriorLights(exteriorLightsDefinition,schedule);
exteriorLights.setControlOption("AstronomicalClock");
ForwardTranslator trans;
Workspace workspace = trans.translateModel(model);
}
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());
}
/*
* The Forward Translator should throw if the AVM is missing the required Sensor Node (E+ crash on 8.8.0)
*/
TEST_F(EnergyPlusFixture, ForwardTranslator_AvailabilityManagerLowTemperatureTurnOff_NoSensorNode) {
Model m;
AvailabilityManagerLowTemperatureTurnOff avm(m);
// No Sensor Node
ASSERT_FALSE(avm.sensorNode());
// Assign it to a plant loop (otherwise it's purely not translated anyways...)
PlantLoop p(m);
p.setAvailabilityManager(avm);
// ForwardTranslate
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(m);
EXPECT_EQ(1u, forwardTranslator.errors().size());
}
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_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);
}
