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_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_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_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,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_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_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, 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_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, 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_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_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);
}
/**
* Tests whether the ForwarTranslator will handle the name of the GeneratorMicroTurbine correctly in the PlantEquipmentOperationHeatingLoad
**/
TEST_F(EnergyPlusFixture,ForwardTranslatorGeneratorMicroTurbine_ELCD_PlantLoop)
{
// TODO: Temporarily output the Log in the console with the Trace (-3) level
// for debug
// openstudio::Logger::instance().standardOutLogger().enable();
// openstudio::Logger::instance().standardOutLogger().setLogLevel(Trace);
// 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);
// 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(1u, workspace.getObjectsByType(IddObjectType::ElectricLoadCenter_Distribution).size());
// The MicroTurbine should have been forward translated since there is an ELCD
WorkspaceObjectVector microTurbineObjects(workspace.getObjectsByType(IddObjectType::Generator_MicroTurbine));
EXPECT_EQ(1u, microTurbineObjects.size());
// Check that the HR nodes have been set
WorkspaceObject idf_mchp(microTurbineObjects[0]);
EXPECT_EQ(mchpHR.inletModelObject()->name().get(), idf_mchp.getString(Generator_MicroTurbineFields::HeatRecoveryWaterInletNodeName).get());
EXPECT_EQ(mchpHR.outletModelObject()->name().get(), idf_mchp.getString(Generator_MicroTurbineFields::HeatRecoveryWaterOutletNodeName).get());
OptionalWorkspaceObject idf_operation(workspace.getObjectByTypeAndName(IddObjectType::PlantEquipmentOperation_HeatingLoad,*(operation.name())));
ASSERT_TRUE(idf_operation);
// Get the extensible
ASSERT_EQ(1u, idf_operation->numExtensibleGroups());
// IdfExtensibleGroup eg = idf_operation.getExtensibleGroup(0);
// idf_operation.targets[0]
ASSERT_EQ(1u, idf_operation->targets().size());
WorkspaceObject plantEquipmentList(idf_operation->targets()[0]);
ASSERT_EQ(2u, plantEquipmentList.extensibleGroups().size());
IdfExtensibleGroup eg(plantEquipmentList.extensibleGroups()[0]);
ASSERT_EQ("Generator:MicroTurbine", eg.getString(PlantEquipmentListExtensibleFields::EquipmentObjectType).get());
// This fails
EXPECT_EQ(mchp.name().get(), eg.getString(PlantEquipmentListExtensibleFields::EquipmentName).get());
IdfExtensibleGroup eg2(plantEquipmentList.extensibleGroups()[1]);
ASSERT_EQ("WaterHeater:Mixed", eg2.getString(PlantEquipmentListExtensibleFields::EquipmentObjectType).get());
EXPECT_EQ(waterHeater.name().get(), eg2.getString(PlantEquipmentListExtensibleFields::EquipmentName).get());
model.save(toPath("./ForwardTranslatorGeneratorMicroTurbine_ELCD_PlantLoop.osm"), true);
workspace.save(toPath("./ForwardTranslatorGeneratorMicroTurbine_ELCD_PlantLoop.idf"), true);
}
/* This tests ensures that the CentralHeatPumpSystem ends up in a PlantEquipmentOperation:HeatingLoad for the heating loop
* and PlantEquipmentOperation:CoolingLoad for the cooling loop. For the source loop, it's on the demand side so it shouldn't
* be part of the plant equipment list used
*/
TEST_F(EnergyPlusFixture,ForwardTranslatorCentralHeatPumpSystem_PlantEquipmentOperation) {
boost::optional<WorkspaceObject> _wo;
ForwardTranslator ft;
Model m;
CentralHeatPumpSystem central_hp(m);
// Add a Module
CentralHeatPumpSystemModule central_hp_module(m);
central_hp.addModule(central_hp_module);
EXPECT_EQ(1, central_hp_module.numberofChillerHeaterModules());
// 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();
Workspace w = ft.translateModel(m);
EXPECT_EQ(0u, ft.errors().size());
EXPECT_EQ(1u, w.getObjectsByType(IddObjectType::CentralHeatPumpSystem).size());
IdfObject i_central_hp = w.getObjectsByType(IddObjectType::CentralHeatPumpSystem)[0];
// Get the Loops, and find their plant operation scheme
// supply = Cooling
{
_wo = w.getObjectByTypeAndName(IddObjectType::PlantLoop, coolingPlant.name().get());
ASSERT_TRUE(_wo.is_initialized());
WorkspaceObject idf_coolingPlant = _wo.get();
WorkspaceObject idf_plant_op = idf_coolingPlant.getTarget(PlantLoopFields::PlantEquipmentOperationSchemeName).get();
// Should have created a Cooling Load one only
ASSERT_EQ(1u, idf_plant_op.extensibleGroups().size());
WorkspaceExtensibleGroup w_eg = idf_plant_op.extensibleGroups()[0].cast<WorkspaceExtensibleGroup>();
ASSERT_EQ("PlantEquipmentOperation:CoolingLoad", w_eg.getString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType).get());
// Get the Operation Scheme
_wo = w_eg.getTarget(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName);
ASSERT_TRUE(_wo.is_initialized());
WorkspaceObject idf_op_scheme = _wo.get();
// Get the Plant Equipment List of this CoolingLoad scheme
// There should only be one Load Range
ASSERT_EQ(1u, idf_op_scheme.extensibleGroups().size());
// Load range 1
w_eg = idf_op_scheme.extensibleGroups()[0].cast<WorkspaceExtensibleGroup>();
_wo = w_eg.getTarget(PlantEquipmentOperation_CoolingLoadExtensibleFields::RangeEquipmentListName);
ASSERT_TRUE(_wo.is_initialized());
WorkspaceObject idf_peq_list = _wo.get();
// Should have one equipment on it: CentralHeatPumpSystem
ASSERT_EQ(1u, idf_peq_list.extensibleGroups().size());
IdfExtensibleGroup idf_eg(idf_peq_list.extensibleGroups()[0]);
ASSERT_EQ(central_hp.name().get(), idf_eg.getString(PlantEquipmentListExtensibleFields::EquipmentName).get());
}
// tertiary = Heating
{
_wo = w.getObjectByTypeAndName(IddObjectType::PlantLoop, heatingPlant.name().get());
ASSERT_TRUE(_wo.is_initialized());
WorkspaceObject idf_heatingPlant = _wo.get();
WorkspaceObject idf_plant_op = idf_heatingPlant.getTarget(PlantLoopFields::PlantEquipmentOperationSchemeName).get();
// Should have created a Heating Load one only
ASSERT_EQ(1u, idf_plant_op.extensibleGroups().size());
WorkspaceExtensibleGroup w_eg = idf_plant_op.extensibleGroups()[0].cast<WorkspaceExtensibleGroup>();
ASSERT_EQ("PlantEquipmentOperation:HeatingLoad", w_eg.getString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType).get());
// Get the Operation Scheme
_wo = w_eg.getTarget(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName);
ASSERT_TRUE(_wo.is_initialized());
WorkspaceObject idf_op_scheme = _wo.get();
// Get the Plant Equipment List of this HeatingLoad scheme
// There should only be one Load Range
ASSERT_EQ(1u, idf_op_scheme.extensibleGroups().size());
// Load range 1
w_eg = idf_op_scheme.extensibleGroups()[0].cast<WorkspaceExtensibleGroup>();
_wo = w_eg.getTarget(PlantEquipmentOperation_HeatingLoadExtensibleFields::RangeEquipmentListName);
ASSERT_TRUE(_wo.is_initialized());
WorkspaceObject idf_peq_list = _wo.get();
// Should have one equipment on it: CentralHeatPumpSystem
ASSERT_EQ(1u, idf_peq_list.extensibleGroups().size());
IdfExtensibleGroup idf_eg(idf_peq_list.extensibleGroups()[0]);
ASSERT_EQ(central_hp.name().get(), idf_eg.getString(PlantEquipmentListExtensibleFields::EquipmentName).get());
}
// SourceLoop: on the demand side. So it shouldn't be on it
{
_wo = w.getObjectByTypeAndName(IddObjectType::PlantLoop, sourcePlant.name().get());
ASSERT_TRUE(_wo.is_initialized());
WorkspaceObject idf_sourcePlant = _wo.get();
WorkspaceObject idf_plant_op = idf_sourcePlant.getTarget(PlantLoopFields::PlantEquipmentOperationSchemeName).get();
// Should have created a Cooling Load one only
ASSERT_EQ(1u, idf_plant_op.extensibleGroups().size());
WorkspaceExtensibleGroup w_eg = idf_plant_op.extensibleGroups()[0].cast<WorkspaceExtensibleGroup>();
ASSERT_EQ("PlantEquipmentOperation:CoolingLoad", w_eg.getString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType).get());
// Get the Operation Scheme
_wo = w_eg.getTarget(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName);
ASSERT_TRUE(_wo.is_initialized());
WorkspaceObject idf_op_scheme = _wo.get();
// Get the Plant Equipment List of this HeatingLoad scheme
// There should only be one Load Range
ASSERT_EQ(1u, idf_op_scheme.extensibleGroups().size());
// Load range 1
w_eg = idf_op_scheme.extensibleGroups()[0].cast<WorkspaceExtensibleGroup>();
_wo = w_eg.getTarget(PlantEquipmentOperation_CoolingLoadExtensibleFields::RangeEquipmentListName);
ASSERT_TRUE(_wo.is_initialized());
WorkspaceObject idf_peq_list = _wo.get();
// Should have one equipment on it: Cooling Tower
ASSERT_EQ(1u, idf_peq_list.extensibleGroups().size());
IdfExtensibleGroup idf_eg(idf_peq_list.extensibleGroups()[0]);
ASSERT_EQ(ct.name().get(), idf_eg.getString(PlantEquipmentListExtensibleFields::EquipmentName).get());
}
m.save(toPath("./ft_central_hp.osm"), true);
w.save(toPath("./ft_central_hp.idf"), true);
}
TEST_F(EnergyPlusFixture,ForwardTranslator_ScheduleFixedInterval_Hourly)
{
//Vector values = linspace(0, 100, 8760);
Vector values = linspace(1, 8760, 8760);
TimeSeries timeseries(DateTime(Date(MonthOfYear::Jan, 1), Time(0,1,0)), Time(0,1,0), values, "");
Model model;
boost::optional<ScheduleInterval> scheduleInterval = ScheduleInterval::fromTimeSeries(timeseries, model);
ASSERT_TRUE(scheduleInterval);
EXPECT_TRUE(scheduleInterval->optionalCast<ScheduleFixedInterval>());
ForwardTranslator ft;
Workspace workspace = ft.translateModel(model);
std::vector<WorkspaceObject> objects = workspace.getObjectsByType(IddObjectType::Schedule_Compact);
ASSERT_EQ(1u, objects.size());
boost::regex throughRegex("^Through:\\s*(.*)/\\s*(.*)\\s*");
boost::regex untilRegex("^Until:\\s*(.*):(.*)\\s*");
workspace.save(toPath("./ForwardTranslator_ScheduleFixedInterval_Hourly.idf"), true);
unsigned N = objects[0].numFields();
boost::optional<Date> lastDateThrough;
bool until24Found = false;
bool nextValueShouldBeLast = false;
unsigned numUntils = 0;
for ( unsigned i = 0; i < N; ++i){
boost::optional<std::string> field = objects[0].getString(i, true, false);
ASSERT_TRUE(field);
if (nextValueShouldBeLast){
double value = boost::lexical_cast<double>(*field);
EXPECT_EQ(8760.0, value);
nextValueShouldBeLast = false;
}
boost::smatch throughMatches;
if (boost::regex_search(*field, throughMatches, throughRegex)){
std::string monthText(throughMatches[1].first, throughMatches[1].second);
std::string dayText(throughMatches[2].first, throughMatches[2].second);
int month = boost::lexical_cast<int>(monthText);
int day = boost::lexical_cast<int>(dayText);
Date date(MonthOfYear(month), day);
if (lastDateThrough){
// check that this date is greater than last date
EXPECT_TRUE(date > *lastDateThrough) << date << " <= " << *lastDateThrough;
// DLM: this schedule should not wrap around to 1/1, it should end on 12/31 at 24:00
// check that last date was closed at 24:00
EXPECT_TRUE(until24Found);
}
lastDateThrough = date;
until24Found = false;
}
boost::smatch untilMatches;
if (boost::regex_search(*field, untilMatches, untilRegex)){
numUntils += 1;
std::string hrText(untilMatches[1].first, untilMatches[1].second);
std::string minText(untilMatches[2].first, untilMatches[2].second);
int hr = boost::lexical_cast<int>(hrText);
int min = boost::lexical_cast<int>(minText);
EXPECT_TRUE(hr <= 24);
EXPECT_TRUE(min < 60);
if ((hr == 24) && (min == 0)){
until24Found = true;
}
// should see Until: 00:00,
EXPECT_FALSE((hr==0) && (min==0));
if ((lastDateThrough == Date(MonthOfYear(12),31)) && until24Found){
nextValueShouldBeLast = true;
}
}
}
bool lastUntil24Found = until24Found;
// check last date was closed
EXPECT_TRUE(lastUntil24Found);
// check that there were 8760 untils
EXPECT_EQ(8760, numUntils);
}
TEST_F(EnergyPlusFixture,ForwardTranslator_ScheduleVariableInterval_500)
{
long numbers[500] = {86313,48668,46739,86313,86313,35939,28787,81175,41086,60467,71308,36332,
75050,44913,86313,36150,86313,86313,86313,86313,49633,23793,86313,86313,86313,78168,72707,
56754,35868,29986,25413,40812,62829,31364,77455,76379,86313,50167,34835,70623,86313,70817,
48215,52955,59462,27876,27334,52308,32575,86313,86313,53883,57044,86313,45829,38304,42861,
86313,86313,29215,35662,86313,86313,63866,73697,58074,80833,85161,60866,85214,38748,86313,
86313,36676,33285,86313,38269,86313,67373,56445,86313,85745,54775,51067,86313,23644,34226,
86313,71364,64214,45392,86313,49499,71086,50232,86313,86313,75456,62390,78586,67472,66497,
51741,76133,86313,52833,72670,65395,86313,86180,67179,86313,86313,86313,33630,48006,42881,
69935,39664,63806,41471,35258,31512,83115,86313,73282,86313,86313,53505,47981,61876,86313,
31543,86313,37030,66163,47482,58352,86313,73380,86313,46900,59984,57889,41704,42690,86313,
86313,51497,71154,42596,73589,27242,61291,43573,86313,65535,86313,58071,86313,79620,86313,
26578,32739,86313,34133,70385,27867,81956,72324,38580,29633,33298,59005,27369,32838,61259,
35188,77004,86313,60872,86313,49717,43171,27070,35573,30796,86313,86313,86313,86313,63163,
77254,45155,86313,86313,57614,59737,48050,86313,86313,72316,52488,60663,50962,35766,81130,
70904,34878,76407,68502,82977,86313,55383,33518,86313,29334,28864,44800,64615,86313,78882,
66482,50578,78395,66541,68202,83235,61364,81762,86313,47870,34782,46302,50788,49417,44120,
74002,25114,86313,24457,53465,26107,33636,86313,80121,64977,30723,40309,86313,86313,76107,
86313,33956,52007,62567,86313,58138,41487,31619,33507,62906,35965,86313,43492,86313,24031,
83944,86313,86313,71510,86284,56508,28345,39127,86313,37952,54719,79620,36024,86313,86313,
86313,86313,30591,83941,64038,74265,75851,56856,44849,27458,30350,24754,31329,56821,55979,
39576,50515,52438,84957,85891,51660,86313,49117,86313,63442,24063,77802,29621,37905,53515,
72884,81821,86313,86313,86313,86313,84048,86313,76408,70785,55767,86313,41679,83722,85612,
86313,86313,29925,86313,52021,86313,78981,86313,86313,50598,74333,67904,86313,31582,86313,
70034,86313,35070,74448,45073,86313,86313,71613,35444,63476,53592,84978,26717,58140,61863,
84549,58604,34180,62200,36225,83922,33905,83064,24935,51077,86313,49476,61010,41624,65246,
30697,86313,26883,86313,75916,48961,86313,53663,86313,38177,51527,79510,86313,26712,74984,
64740,86313,49378,86313,86313,47440,32930,25094,76695,68608,35416,86313,86313,26731,86313,
65665,57451,86313,64561,47067,76935,31435,72573,86313,38846,72254,42634,86313,86313,71265,
86313,56154,86313,66939,86313,30369,36409,67475,86313,86313,86313,86313,38236,86313,57408,
66435,29802,72062,86313,43899,86313,47590,64377,53064,68569,37843,86313,86313,86313,86313,
69253,54914,33398,26446,49428,59356,86313,86313,86313,78915,44437,61977,75481,86313,86313,
47774,71126,86313,84201,86313,66183,44427,59010,24018,34729,86313,32745,86313,48847,61975,
76417,86313,86313,66541,51775,86313,86129,36853,86313,70306,46162,86313,86313,29768,46103,
24318,26234,59933,43230,65930,86313,86313,54580};
Vector values = linspace(1, 500, 500);
std::vector<long> seconds(500);
seconds[0] = 0;
seconds[1] = numbers[1];
for(unsigned i=2;i<500;i++) {
seconds[i]=numbers[i]+seconds[i-1];
}
TimeSeries timeseries(DateTime(Date(MonthOfYear::Jan, 1),Time(0,0,0,numbers[0])), seconds, values, "");
Model model;
boost::optional<ScheduleInterval> scheduleInterval = ScheduleInterval::fromTimeSeries(timeseries, model);
ASSERT_TRUE(scheduleInterval);
ASSERT_TRUE(scheduleInterval->optionalCast<ScheduleVariableInterval>());
ForwardTranslator ft;
Workspace workspace = ft.translateModel(model);
std::vector<WorkspaceObject> objects = workspace.getObjectsByType(IddObjectType::Schedule_Compact);
ASSERT_EQ(1u, objects.size());
boost::regex throughRegex("^Through:\\s*(.*)/\\s*(.*)\\s*");
boost::regex untilRegex("^Until:\\s*(.*):(.*)\\s*");
workspace.save(toPath("./ForwardTranslator_ScheduleVariableInterval_500.idf"), true);
unsigned N = objects[0].numFields();
boost::optional<Date> lastDateThrough;
bool until24Found = false;
bool nextValueShouldBeLast = false;
unsigned numUntils = 0;
for (unsigned i = 0; i < N; ++i){
boost::optional<std::string> field = objects[0].getString(i, true, false);
ASSERT_TRUE(field);
if (nextValueShouldBeLast){
double value = boost::lexical_cast<double>(*field);
EXPECT_EQ(500.0, value);
nextValueShouldBeLast = false;
}
boost::smatch throughMatches;
if (boost::regex_search(*field, throughMatches, throughRegex)){
std::string monthText(throughMatches[1].first, throughMatches[1].second);
std::string dayText(throughMatches[2].first, throughMatches[2].second);
int month = boost::lexical_cast<int>(monthText);
int day = boost::lexical_cast<int>(dayText);
Date date(MonthOfYear(month), day);
if (lastDateThrough){
// check that this date is greater than last date
EXPECT_TRUE(date > *lastDateThrough) << date << " <= " << *lastDateThrough;
// check that last date was closed at 24:00
EXPECT_TRUE(until24Found);
}
lastDateThrough = date;
until24Found = false;
}
boost::smatch untilMatches;
if (boost::regex_search(*field, untilMatches, untilRegex)){
numUntils += 1;
std::string hrText(untilMatches[1].first, untilMatches[1].second);
std::string minText(untilMatches[2].first, untilMatches[2].second);
int hr = boost::lexical_cast<int>(hrText);
int min = boost::lexical_cast<int>(minText);
EXPECT_TRUE(hr <= 24);
EXPECT_TRUE(min < 60);
if ((hr == 24) && (min == 0)){
until24Found = true;
}
// should see Until: 00:00,
EXPECT_FALSE((hr==0) && (min==0));
if ((lastDateThrough == Date(MonthOfYear(12),31)) && until24Found){
nextValueShouldBeLast = true;
}
}
}
bool lastUntil24Found = until24Found;
// check last date was closed
EXPECT_TRUE(lastUntil24Found);
// check that there were 8760 untils
EXPECT_EQ(864, numUntils);
}
TEST_F(EnergyPlusFixture,ForwardTranslatorFuelCell) {
Model model;
Building building = model.getUniqueModelObject<Building>();
//ThermalZone zone1(model);
//ThermalZone zone2(model);
// create default fuelcell
GeneratorFuelCell fuelcell(model);
// get default power module
GeneratorFuelCellPowerModule fCPM = fuelcell.powerModule();
// check default power module curve values
Curve curve = fCPM.efficiencyCurve();
CurveQuadratic curveQ = curve.cast<CurveQuadratic>();
EXPECT_EQ(0.642388, curveQ.coefficient1Constant());
EXPECT_EQ(-0.0001619, curveQ.coefficient2x());
EXPECT_EQ(2.26e-008, curveQ.coefficient3xPOW2());
EXPECT_EQ("Annex42", fCPM.efficiencyCurveMode());
// check default Airsupply
GeneratorFuelCellAirSupply fAS = fuelcell.airSupply();
EXPECT_EQ("AirRatiobyStoics", fAS.airSupplyRateCalculationMode());
EXPECT_EQ(1.0, fAS.stoichiometricRatio());
EXPECT_EQ("NoRecovery", fAS.airIntakeHeatRecoveryMode());
EXPECT_EQ("AmbientAir", fAS.airSupplyConstituentMode());
// check default fuel supply
GeneratorFuelSupply fS = fuelcell.fuelSupply();
// check default water supply
GeneratorFuelCellWaterSupply fWS = fuelcell.waterSupply();
fWS.setWaterTemperatureModelingMode("MainsWaterTemperature");
// check default aux heater
GeneratorFuelCellAuxiliaryHeater fAX = fuelcell.auxiliaryHeater();
// check default heat exchanger
GeneratorFuelCellExhaustGasToWaterHeatExchanger fHX = fuelcell.heatExchanger();
// check default electric storage
GeneratorFuelCellElectricalStorage fES = fuelcell.electricalStorage();
// check default inverter
GeneratorFuelCellInverter fI = fuelcell.inverter();
// check default optional stackcooler
boost::optional<GeneratorFuelCellStackCooler> fSC = fuelcell.stackCooler();
EXPECT_FALSE(fSC);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().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());
// no stack cooler by default
EXPECT_EQ(0u, 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());
//expect site water mains
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Site_WaterMainsTemperature).size());
model.save(toPath("./fuelcell.osm"), true);
workspace.save(toPath("./fuelcell.idf"), true);
}