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); }