boost::optional<ModelObject> ReverseTranslator::translateCurveExponent( const WorkspaceObject& workspaceObject ) { CurveExponent curve(m_model); OptionalString s; OptionalDouble d; if ((s = workspaceObject.name())) { curve.setName(*s); } if ((d = workspaceObject.getDouble(Curve_ExponentFields::Coefficient1Constant))) { curve.setCoefficient1Constant(*d); } if ((d = workspaceObject.getDouble(Curve_ExponentFields::Coefficient2Constant))) { curve.setCoefficient2Constant(*d); } if ((d = workspaceObject.getDouble(Curve_ExponentFields::Coefficient3Constant))) { curve.setCoefficient3Constant(*d); } if ((d = workspaceObject.getDouble(Curve_ExponentFields::MinimumValueofx))) { curve.setMinimumValueofx(*d); } if ((d = workspaceObject.getDouble(Curve_ExponentFields::MaximumValueofx))) { curve.setMaximumValueofx(*d); } if ((d = workspaceObject.getDouble(Curve_ExponentFields::MinimumCurveOutput))) { curve.setMinimumCurveOutput(*d); } if ((d = workspaceObject.getDouble(Curve_ExponentFields::MaximumCurveOutput))) { curve.setMaximumCurveOutput(*d); } if ((s = workspaceObject.getString(Curve_ExponentFields::InputUnitTypeforX,false,true))) { curve.setInputUnitTypeforX(*s); } if ((s = workspaceObject.getString(Curve_ExponentFields::OutputUnitType,false,true))) { curve.setOutputUnitType(*s); } return curve; }
boost::optional<ModelObject> ReverseTranslator::translateCurveRectangularHyperbola1( const WorkspaceObject& workspaceObject ) { CurveRectangularHyperbola1 curve(m_model); OptionalString s; OptionalDouble d; if ((s = workspaceObject.name())) { curve.setName(*s); } if ((d = workspaceObject.getDouble(Curve_RectangularHyperbola1Fields::Coefficient1C1))) { curve.setCoefficient1C1(*d); } if ((d = workspaceObject.getDouble(Curve_RectangularHyperbola1Fields::Coefficient2C2))) { curve.setCoefficient2C2(*d); } if ((d = workspaceObject.getDouble(Curve_RectangularHyperbola1Fields::Coefficient3C3))) { curve.setCoefficient3C3(*d); } if ((d = workspaceObject.getDouble(Curve_RectangularHyperbola1Fields::MinimumValueofx))) { curve.setMinimumValueofx(*d); } if ((d = workspaceObject.getDouble(Curve_RectangularHyperbola1Fields::MaximumValueofx))) { curve.setMaximumValueofx(*d); } if ((d = workspaceObject.getDouble(Curve_RectangularHyperbola1Fields::MinimumCurveOutput))) { curve.setMinimumCurveOutput(*d); } if ((d = workspaceObject.getDouble(Curve_RectangularHyperbola1Fields::MaximumCurveOutput))) { curve.setMaximumCurveOutput(*d); } if ((s = workspaceObject.getString(Curve_RectangularHyperbola1Fields::InputUnitTypeforx,false,true))) { curve.setInputUnitTypeforx(*s); } if ((s = workspaceObject.getString(Curve_RectangularHyperbola1Fields::OutputUnitType,false,true))) { curve.setOutputUnitType(*s); } return curve; }
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_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); }
OptionalModelObject ReverseTranslator::translateOutputMeterMeterFileOnly( const WorkspaceObject & workspaceObject ) { openstudio::model::Meter meter( m_model ); OptionalString s = workspaceObject.getString(Output_Meter_MeterFileOnlyFields::Name); if(s){ meter.setName(*s); } s = workspaceObject.getString(Output_Meter_MeterFileOnlyFields::ReportingFrequency); if(s){ meter.setReportingFrequency(*s); } meter.setMeterFileOnly(true); meter.setCumulative(false); return meter; }
TEST_F(EnergyPlusFixture,ReverseTranslatorTest_TranslateScheduleCompact) { openstudio::Workspace workspace(openstudio::StrictnessLevel::None,openstudio::IddFileType::EnergyPlus); openstudio::IdfObject idfObject( openstudio::IddObjectType::Schedule_Compact ); idfObject.setString(1,"Fraction"); idfObject.setString(2,"Through: 12/31"); idfObject.setString(3,"For: Weekdays SummerDesignDay"); idfObject.setString(4,"Until: 08:00"); idfObject.setString(5,"0.0"); idfObject.setString(6,"Until: 18:00"); idfObject.setString(7,"1.0"); idfObject.setString(8,"Until: 24:00"); idfObject.setString(9,"0.0"); idfObject.setString(10,"For: Weekends WinterDesignDay"); idfObject.setString(11,"Until: 10:00"); idfObject.setString(12,"0.0"); idfObject.setString(13,"Until: 16:00"); idfObject.setString(14,"1.0"); idfObject.setString(15,"Until: 24:00"); idfObject.setString(16,"0.0"); idfObject.setString(17,"For: Holidays AllOtherDays"); idfObject.setString(18,"Until: 24:00"); idfObject.setString(19,"0.0"); WorkspaceObject epScheduleCompact = workspace.addObject(idfObject).get(); ReverseTranslator trans; ASSERT_NO_THROW(trans.translateWorkspace(workspace)); Model model = trans.translateWorkspace(workspace); ASSERT_EQ(static_cast<unsigned>(1), model.getModelObjects<openstudio::model::ScheduleCompact>().size()); openstudio::model::ScheduleCompact scheduleCompact = model.getModelObjects<openstudio::model::ScheduleCompact>()[0]; EXPECT_EQ(unsigned(20),epScheduleCompact.numFields()); EXPECT_EQ(unsigned(21),scheduleCompact.numFields()); // has handle field ASSERT_EQ(epScheduleCompact.numFields() + 1u,scheduleCompact.numFields()); ASSERT_TRUE(epScheduleCompact.name()); ASSERT_TRUE(scheduleCompact.name()); EXPECT_EQ(epScheduleCompact.name().get(),scheduleCompact.name().get()); for( unsigned i = 1; i < epScheduleCompact.numFields(); i++ ) { boost::optional<std::string> s1 = epScheduleCompact.getString(i); boost::optional<std::string> s2 = scheduleCompact.getString(i+1); ASSERT_TRUE(s1); ASSERT_TRUE(s2); EXPECT_EQ(s1.get(),s2.get()); } }
OptionalModelObject ReverseTranslator::translateOutputEnergyManagementSystem(const WorkspaceObject & workspaceObject) { openstudio::model::OutputEnergyManagementSystem outputEMS = m_model.getUniqueModelObject<openstudio::model::OutputEnergyManagementSystem>(); OptionalString s = workspaceObject.getString(Output_EnergyManagementSystemFields::ActuatorAvailabilityDictionaryReporting); if(s) { outputEMS.setActuatorAvailabilityDictionaryReporting(*s); } s = workspaceObject.getString(Output_EnergyManagementSystemFields::InternalVariableAvailabilityDictionaryReporting); if (s) { outputEMS.setInternalVariableAvailabilityDictionaryReporting(*s); } s = workspaceObject.getString(Output_EnergyManagementSystemFields::EMSRuntimeLanguageDebugOutputLevel); if (s) { outputEMS.setEMSRuntimeLanguageDebugOutputLevel(*s); } return outputEMS; }
TEST_F(EnergyPlusFixture, ForwardTranslator_ExternalInterfaceFunctionalMockupUnitExportFromVariable) { Model model; std::string outputVariableIndexKeyName = "outputVariableIndexKeyName"; std::string outputVariableName = "outputVariableName"; std::string fMUVariableName = "fMUVariableName"; ExternalInterfaceFunctionalMockupUnitExportFromVariable variable(model, outputVariableIndexKeyName, outputVariableName, fMUVariableName); ForwardTranslator forwardTranslator; Workspace workspace = forwardTranslator.translateModel(model); EXPECT_EQ(0u, forwardTranslator.errors().size()); EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ExternalInterface_FunctionalMockupUnitExport_From_Variable).size()); WorkspaceObject object = workspace.getObjectsByType(IddObjectType::ExternalInterface_FunctionalMockupUnitExport_From_Variable)[0]; ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitExport_From_VariableFields::Output_VariableIndexKeyName, false)); EXPECT_EQ(outputVariableIndexKeyName, object.getString(ExternalInterface_FunctionalMockupUnitExport_From_VariableFields::Output_VariableIndexKeyName, false).get()); ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitExport_From_VariableFields::Output_VariableName, false)); EXPECT_EQ(outputVariableName, object.getString(ExternalInterface_FunctionalMockupUnitExport_From_VariableFields::Output_VariableName, false).get()); ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitExport_From_VariableFields::FMUVariableName, false)); EXPECT_EQ(fMUVariableName, object.getString(ExternalInterface_FunctionalMockupUnitExport_From_VariableFields::FMUVariableName, false).get()); model.save(toPath("./ExternalInterfaceFunctionalMockupUnitExportFromVariable.osm"), true); workspace.save(toPath("./ExternalInterfaceFunctionalMockupUnitExportFromVariable.idf"), true); }
OptionalModelObject ReverseTranslator::translateRunPeriodControlDaylightSavingTime( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::RunPeriodControl_DaylightSavingTime ) { LOG(Error, "WorkspaceObject is not IddObjectType: RunPeriodControl_DaylightSavingTime"); return boost::none; } RunPeriodControlDaylightSavingTime dst = m_model.getUniqueModelObject<RunPeriodControlDaylightSavingTime>(); OptionalString s = workspaceObject.getString(RunPeriodControl_DaylightSavingTimeFields::StartDate); if(s){ dst.setStartDate(*s); } s = workspaceObject.getString(RunPeriodControl_DaylightSavingTimeFields::EndDate); if(s) { dst.setEndDate(*s); } return dst; }
TEST_F(IdfFixture, WorkspaceObject_Building) { Workspace workspace(epIdfFile, StrictnessLevel::Draft); WorkspaceObjectVector buildings = workspace.getObjectsByType(IddObjectType::Building); ASSERT_EQ(static_cast<size_t>(1), buildings.size()); WorkspaceObject building = buildings[0]; /* Building, Building, !- Name 30., !- North Axis {deg} City, !- Terrain 0.04, !- Loads Convergence Tolerance Value 0.4, !- Temperature Convergence Tolerance Value {deltaC} FullExterior, !- Solar Distribution 25; !- Maximum Number of Warmup Days */ OptionalString buildingName = building.getString(BuildingFields::Name); ASSERT_TRUE(buildingName); EXPECT_EQ("Building", *buildingName); OptionalString northAxisString = building.getString(BuildingFields::NorthAxis); ASSERT_TRUE(northAxisString); EXPECT_EQ("30.", *northAxisString); OptionalDouble northAxis = building.getDouble(BuildingFields::NorthAxis); ASSERT_TRUE(northAxis); EXPECT_DOUBLE_EQ(30.0, *northAxis); OptionalString terrain = building.getString(BuildingFields::Terrain); ASSERT_TRUE(terrain); EXPECT_EQ("City", *terrain); OptionalUnsigned maximumNumberofWarmupDays = building.getUnsigned(BuildingFields::MaximumNumberofWarmupDays); ASSERT_TRUE(maximumNumberofWarmupDays); EXPECT_EQ(static_cast<unsigned>(25), *maximumNumberofWarmupDays); }
OptionalModelObject ReverseTranslator::translateOutputVariable( const WorkspaceObject & workspaceObject ) { OptionalString s = workspaceObject.getString(Output_VariableFields::VariableName); if(!s){ return boost::none; } openstudio::model::OutputVariable outputVariable( *s, m_model ); s = workspaceObject.getString(Output_VariableFields::KeyValue); if(s){ outputVariable.setKeyValue(*s); } s = workspaceObject.getString(Output_VariableFields::VariableName); if(s){ outputVariable.setVariableName(*s); } s = workspaceObject.getString(Output_VariableFields::ReportingFrequency); if(s){ outputVariable.setReportingFrequency(*s); } OptionalWorkspaceObject target = workspaceObject.getTarget(Output_VariableFields::ScheduleName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject( *target ); if (modelObject){ OptionalSchedule schedule = modelObject->optionalCast<Schedule>(); if (schedule){ outputVariable.setSchedule(*schedule); } } } return outputVariable; }
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_ExternalInterfaceFunctionalMockupUnitExportToActuator) { 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"; ExternalInterfaceFunctionalMockupUnitExportToActuator fanActuator(fan, ComponentType, fanControlType, "Fan FMU name", 10); ForwardTranslator forwardTranslator; Workspace workspace = forwardTranslator.translateModel(model); EXPECT_EQ(0u, forwardTranslator.errors().size()); EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::ExternalInterface_FunctionalMockupUnitExport_To_Actuator).size()); WorkspaceObject object = workspace.getObjectsByType(IddObjectType::ExternalInterface_FunctionalMockupUnitExport_To_Actuator)[0]; ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::Name, false)); EXPECT_EQ("External Interface Functional Mockup Unit Export To Actuator 1", object.getString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::Name, false).get()); ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::ActuatedComponentUniqueName, false)); EXPECT_EQ(fan.nameString(), object.getString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::ActuatedComponentUniqueName, false).get()); ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::ActuatedComponentType, false)); EXPECT_EQ(ComponentType, object.getString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::ActuatedComponentType, false).get()); ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::ActuatedComponentControlType, false)); EXPECT_EQ(fanControlType, object.getString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::ActuatedComponentControlType, false).get()); ASSERT_TRUE(object.getString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::FMUVariableName, false)); EXPECT_EQ("Fan FMU name", object.getString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::FMUVariableName, false).get()); ASSERT_TRUE(object.getDouble(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::InitialValue, false)); EXPECT_EQ(10.0, object.getDouble(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::InitialValue, false).get()); model.save(toPath("./ExternalInterfaceFunctionalMockupUnitExportToActuator.osm"), true); workspace.save(toPath("./ExternalInterfaceFunctionalMockupUnitExportToActuator.idf"), true); }
TEST_F(EnergyPlusFixture,ForwardTranslator_Building) { Model model; Building building = model.getUniqueModelObject<Building>(); building.setName("Building"); EXPECT_TRUE(building.isNorthAxisDefaulted()); ForwardTranslator forwardTranslator; Workspace workspace = forwardTranslator.translateModel(model); ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Building).size()); ASSERT_EQ(0u, 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)); }
OptionalModelObject ReverseTranslator::translateZoneAirHeatBalanceAlgorithm( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::ZoneAirHeatBalanceAlgorithm ) { LOG(Error, "WorkspaceObject is not IddObjectType: ZoneAirHeatBalanceAlgorithm"); return boost::none; } ZoneAirHeatBalanceAlgorithm mo = m_model.getUniqueModelObject<ZoneAirHeatBalanceAlgorithm>(); boost::optional<std::string> s = workspaceObject.getString(ZoneAirHeatBalanceAlgorithmFields::Algorithm); if( s ) { mo.setString(OS_ZoneAirHeatBalanceAlgorithmFields::Algorithm,s.get()); } return mo; }
boost::optional<ModelObject> ReverseTranslator::translateSurfaceConvectionAlgorithmInside( const WorkspaceObject & workspaceObject) { if( workspaceObject.iddObject().type() != IddObjectType::SurfaceConvectionAlgorithm_Inside ) { LOG(Error, "WorkspaceObject is not IddObjectType: SurfaceConvectionAlgorithm_Inside"); return boost::none; } InsideSurfaceConvectionAlgorithm mo = m_model.getUniqueModelObject<InsideSurfaceConvectionAlgorithm>(); if(OptionalString s = workspaceObject.getString(SurfaceConvectionAlgorithm_InsideFields::Algorithm)) { mo.setAlgorithm(s.get()); } return mo; }
OptionalModelObject ReverseTranslator::translateMaterialNoMass( const WorkspaceObject & workspaceObject ) { OptionalModelObject result; if( workspaceObject.iddObject().type() != IddObjectType::Material_NoMass ) { LOG(Error, "WorkspaceObject is not IddObjectType: Material:NoMass"); return result; } openstudio::model::MasslessOpaqueMaterial MOMat( m_model ); OptionalString optS = workspaceObject.name(); if(optS) { MOMat.setName(*optS); } optS = workspaceObject.getString(Material_NoMassFields::Roughness); if(optS) { MOMat.setRoughness(*optS); } OptionalDouble d = workspaceObject.getDouble( Material_NoMassFields::ThermalResistance ); if(d) { MOMat.setThermalResistance(*d); } d = workspaceObject.getDouble( Material_NoMassFields::ThermalAbsorptance ); if(d) { MOMat.setThermalAbsorptance(*d); } d = workspaceObject.getDouble( Material_NoMassFields::SolarAbsorptance ); if(d) { MOMat.setSolarAbsorptance(*d); } d = workspaceObject.getDouble( Material_NoMassFields::VisibleAbsorptance ); if(d) { MOMat.setVisibleAbsorptance(*d); } result = MOMat; return result; }
TEST_F(EnergyPlusFixture,ForwardTranslator_Building3) { Model model; Building building = model.getUniqueModelObject<Building>(); building.setName("Building"); building.setNorthAxis(20); building.setNominalFloortoFloorHeight(5); Site site = model.getUniqueModelObject<Site>(); site.setTerrain("Ocean"); SimulationControl simulationControl = model.getUniqueModelObject<SimulationControl>(); simulationControl.setLoadsConvergenceToleranceValue(0.2); simulationControl.setTemperatureConvergenceToleranceValue(0.2); simulationControl.setSolarDistribution("FullInteriorAndExteriorWithReflections"); simulationControl.setMaximumNumberofWarmupDays(2); ForwardTranslator forwardTranslator; Workspace workspace = forwardTranslator.translateModel(model); ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Building).size()); ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Site_Location).size()); ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::SimulationControl).size()); WorkspaceObject object = workspace.getObjectsByType(IddObjectType::Building)[0]; ASSERT_TRUE(object.getString(BuildingFields::Name)); EXPECT_EQ("Building", object.getString(BuildingFields::Name).get()); ASSERT_TRUE(object.getDouble(BuildingFields::NorthAxis)); EXPECT_EQ(20, object.getDouble(BuildingFields::NorthAxis).get()); ASSERT_TRUE(object.getString(BuildingFields::Terrain)); EXPECT_EQ("Ocean", object.getString(BuildingFields::Terrain).get()); ASSERT_TRUE(object.getDouble(BuildingFields::LoadsConvergenceToleranceValue)); EXPECT_EQ(0.2, object.getDouble(BuildingFields::LoadsConvergenceToleranceValue).get()); ASSERT_TRUE(object.getDouble(BuildingFields::TemperatureConvergenceToleranceValue)); EXPECT_EQ(0.2, object.getDouble(BuildingFields::TemperatureConvergenceToleranceValue).get()); ASSERT_TRUE(object.getString(BuildingFields::SolarDistribution)); EXPECT_EQ("FullInteriorAndExteriorWithReflections", object.getString(BuildingFields::SolarDistribution).get()); ASSERT_TRUE(object.getInt(BuildingFields::MaximumNumberofWarmupDays)); EXPECT_EQ(2, object.getInt(BuildingFields::MaximumNumberofWarmupDays).get()); }
OptionalModelObject ReverseTranslator::translateEnergyManagementSystemSubroutine(const WorkspaceObject & workspaceObject) { if (workspaceObject.iddObject().type() != IddObjectType::EnergyManagementSystem_Subroutine) { LOG(Error, "WorkspaceObject is not IddObjectType: EnergyManagementSystem_Subroutine"); return boost::none; } OptionalString s = workspaceObject.getString(EnergyManagementSystem_SubroutineFields::Name); if (!s) { LOG(Error, "WorkspaceObject EnergyManagementSystem_Subroutine has no Name"); return boost::none; } // Make sure we translate the objects that can be referenced here for (const WorkspaceObject& workspaceObject : m_workspace.objects()) { // Note: JM 2018-08-17 // I think an EMS:Subroutine can reference another EMS:Subroutine, we might get problems from that: // The one that is being referenced would need be translated before the one that references before the name/uuid substitution happen. // But it's harder to control that order*, and this is really an edge case though, so not handling it. // * Can't add this condition without getting into a loop: // (workspaceObject.iddObject().type() == IddObjectType::EnergyManagementSystem_Subroutine) if ( // These I'm sure we do need. (workspaceObject.iddObject().type() == IddObjectType::EnergyManagementSystem_Actuator) || (workspaceObject.iddObject().type() == IddObjectType::EnergyManagementSystem_Sensor) || (workspaceObject.iddObject().type() == IddObjectType::EnergyManagementSystem_ConstructionIndexVariable) || (workspaceObject.iddObject().type() == IddObjectType::EnergyManagementSystem_CurveOrTableIndexVariable) || (workspaceObject.iddObject().type() == IddObjectType::EnergyManagementSystem_GlobalVariable) || (workspaceObject.iddObject().type() == IddObjectType::EnergyManagementSystem_InternalVariable) || (workspaceObject.iddObject().type() == IddObjectType::EnergyManagementSystem_TrendVariable) ) { translateAndMapWorkspaceObject(workspaceObject); } } openstudio::model::EnergyManagementSystemSubroutine emsProgram(m_model); emsProgram.setName(*s); // Get all model objects that can be referenced int he EMS Program so we can do name / uid substitution const std::vector<IddObjectType> validIddObjectTypes{ IddObjectType::OS_EnergyManagementSystem_Subroutine, IddObjectType::OS_EnergyManagementSystem_Actuator, IddObjectType::OS_EnergyManagementSystem_Sensor, IddObjectType::OS_EnergyManagementSystem_ConstructionIndexVariable, IddObjectType::OS_EnergyManagementSystem_CurveOrTableIndexVariable, IddObjectType::OS_EnergyManagementSystem_GlobalVariable, IddObjectType::OS_EnergyManagementSystem_InternalVariable, IddObjectType::OS_EnergyManagementSystem_TrendVariable }; std::vector<model::ModelObject> modelObjects; for (const model::ModelObject& mo: m_model.modelObjects()) { if( std::find(validIddObjectTypes.begin(), validIddObjectTypes.end(), mo.iddObjectType()) != validIddObjectTypes.end() ) { modelObjects.push_back(mo); } } // Now, we should do the actual name/uid substitution on all lines of the program size_t pos, len; std::string newline, uid; unsigned n = workspaceObject.numExtensibleGroups(); OptionalString line; // Loop on each line of the program for (unsigned i = 0; i < n; ++i) { line = workspaceObject.getExtensibleGroup(i).cast<WorkspaceExtensibleGroup>().getString(EnergyManagementSystem_SubroutineExtensibleFields::ProgramLine); if (line) { newline = line.get(); // Split line to get 'tokens' and look for ModelObject names // splitEMSLineToTokens returns already sanitized tokens (excludes reserved keywords, blank ones, functions, removes parenthesis, etc) std::vector<std::string> tokens = splitEMSLineToTokens(newline); for (std::string& token: tokens) { for (const model::ModelObject& mo: modelObjects) { // Check if program item is the name of a model object boost::optional<std::string> _name = mo.name(); if ( _name && (_name.get() == token) ) { // replace model object's name with its handle pos = newline.find(token); len = token.length(); uid = toString(mo.handle()); newline.replace(pos, len, uid); // Now that we have done the replacement, no need to keep looping. // Plus, we should break out of the nested loop and go to the next "j" // Otherwise pos could become giberish if there's another object named the same // since it won't be able to find the already-replaced string (this shouldn't happen though) break; } } // end loop on all modelObjects } // end loop on all results in line emsProgram.addLine(newline); } // end if(line) } // End loop on each line of the program return emsProgram; }
OptionalModelObject ReverseTranslator::translateSetpointManagerMixedAir( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::SetpointManager_MixedAir ) { LOG(Error, "WorkspaceObject is not IddObjectType: SetpointManager_MixedAir"); return boost::none; } bool nodeFound = false; if( boost::optional<std::string> setpointNodeName = workspaceObject.getString(SetpointManager_MixedAirFields::SetpointNodeorNodeListName) ) { boost::optional<Node> setpointNode = m_model.getModelObjectByName<Node>(setpointNodeName.get()); if( setpointNode ) { nodeFound = true; } } if( ! nodeFound ) { LOG(Error, workspaceObject.briefDescription() << " is not attached to a node in the model"); return boost::none; } SetpointManagerMixedAir mo(m_model); boost::optional<std::string> s = workspaceObject.getString(SetpointManager_MixedAirFields::Name); if( s ) { mo.setName(s.get()); } s = workspaceObject.getString(SetpointManager_MixedAirFields::ReferenceSetpointNodeName); if( s ) { boost::optional<Node> node = m_model.getModelObjectByName<Node>(s.get()); if( node ) { mo.setReferenceSetpointNode(node.get()); } } s = workspaceObject.getString(SetpointManager_MixedAirFields::FanInletNodeName); if( s ) { boost::optional<Node> node = m_model.getModelObjectByName<Node>(s.get()); if( node ) { mo.setFanInletNode(node.get()); } } s = workspaceObject.getString(SetpointManager_MixedAirFields::FanOutletNodeName); if( s ) { boost::optional<Node> node = m_model.getModelObjectByName<Node>(s.get()); if( node ) { mo.setFanOutletNode(node.get()); } } s = workspaceObject.getString(SetpointManager_MixedAirFields::SetpointNodeorNodeListName); if( s ) { boost::optional<Node> node = m_model.getModelObjectByName<Node>(s.get()); if( node ) { mo.addToNode(node.get()); } } if( mo.setpointNode() ) { return mo; } else { return boost::none; } }
boost::optional<ModelObject> ReverseTranslator::translateWindowMaterialGlazing( const WorkspaceObject& workspaceObject) { OptionalModelObject result; StandardGlazing standardGlazing(m_model); OptionalString optS = workspaceObject.name(); if(optS) { standardGlazing.setName(*optS); } optS = workspaceObject.getString(WindowMaterial_GlazingFields::OpticalDataType); if (optS) { standardGlazing.setOpticalDataType(*optS); } optS = workspaceObject.getString(WindowMaterial_GlazingFields::WindowGlassSpectralDataSetName); if (optS) { standardGlazing.setWindowGlassSpectralDataSetName(*optS); } OptionalDouble d = workspaceObject.getDouble(WindowMaterial_GlazingFields::Thickness); if (d) { standardGlazing.setThickness(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::SolarTransmittanceatNormalIncidence); if (d) { standardGlazing.setSolarTransmittance(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::FrontSideSolarReflectanceatNormalIncidence); if (d) { standardGlazing.setFrontSideSolarReflectanceatNormalIncidence(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::BackSideSolarReflectanceatNormalIncidence); if (d) { standardGlazing.setBackSideSolarReflectanceatNormalIncidence(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::VisibleTransmittanceatNormalIncidence); if (d) { standardGlazing.setVisibleTransmittance(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::FrontSideVisibleReflectanceatNormalIncidence); if (d) { standardGlazing.setFrontSideVisibleReflectanceatNormalIncidence(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::BackSideVisibleReflectanceatNormalIncidence); if (d) { standardGlazing.setBackSideVisibleReflectanceatNormalIncidence(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::InfraredTransmittanceatNormalIncidence); if (d) { standardGlazing.setInfraredTransmittance(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::FrontSideInfraredHemisphericalEmissivity); if (d) { standardGlazing.setFrontSideInfraredHemisphericalEmissivity(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::BackSideInfraredHemisphericalEmissivity); if (d) { standardGlazing.setBackSideInfraredHemisphericalEmissivity(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::Conductivity); if (d) { standardGlazing.setThermalConductivity(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::DirtCorrectionFactorforSolarandVisibleTransmittance); if (d) { standardGlazing.setDirtCorrectionFactorforSolarandVisibleTransmittance(*d); } optS = workspaceObject.getString(WindowMaterial_GlazingFields::SolarDiffusing); if (optS) { std::string temp=*optS; boost::to_lower(temp); if( temp == "no") { standardGlazing.setSolarDiffusing(false); } else { standardGlazing.setSolarDiffusing(true); } } result = standardGlazing; return result; }
OptionalModelObject ReverseTranslator::translateSizingPeriodDesignDay( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::SizingPeriod_DesignDay ) { LOG(Error, "WorkspaceObject is not IddObjectType: SizingPeriod_DesignDay"); return boost::none; } DesignDay designDay(m_model); // Name boost::optional<std::string> s = workspaceObject.getString(SizingPeriod_DesignDayFields::Name); if( s ){ designDay.setName(s.get()); }else{ LOG(Error, "SizingPeriod:DesignDay missing required field Name"); } // Month boost::optional<int> i = workspaceObject.getInt(SizingPeriod_DesignDayFields::Month); if( i ){ designDay.setMonth( i.get() ); }else{ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Month"); } // Day of Month i = workspaceObject.getInt(SizingPeriod_DesignDayFields::DayofMonth); if( i ){ designDay.setDayOfMonth(i.get()); }else{ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Day of Month"); } // Day Type s = workspaceObject.getString(SizingPeriod_DesignDayFields::DayType); if( s ){ designDay.setDayType(s.get()); }else{ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Day Type"); } // Maximum Dry-Bulb Temperature boost::optional<double> value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::MaximumDryBulbTemperature); if( value ){ designDay.setMaximumDryBulbTemperature(value.get()); }else{ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Maximum Dry Bulb Temperature"); } // Dry-Bulb Temperature Range Modifier Type s = workspaceObject.getString(SizingPeriod_DesignDayFields::DryBulbTemperatureRangeModifierType); if( s ){ designDay.setDryBulbTemperatureRangeModifierType(s.get()); } std::string dryBulbTemperatureRangeModifierType = designDay.dryBulbTemperatureRangeModifierType(); // Daily Dry-Bulb Temperature Range if (!istringEqual(dryBulbTemperatureRangeModifierType, "DifferenceSchedule")){ value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::DailyDryBulbTemperatureRange); if( value ){ designDay.setDailyDryBulbTemperatureRange(value.get()); } } // Dry-Bulb Temperature Range Modifier Schedule Name if (istringEqual(dryBulbTemperatureRangeModifierType, "MultiplierSchedule") || istringEqual(dryBulbTemperatureRangeModifierType, "DifferenceSchedule")){ boost::optional<WorkspaceObject> wo = workspaceObject.getTarget(SizingPeriod_DesignDayFields::DryBulbTemperatureRangeModifierDayScheduleName); if( wo ){ boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(wo.get()); if( mo ){ if(boost::optional<ScheduleDay> schedule = mo->optionalCast<ScheduleDay>()){ designDay.setDryBulbTemperatureRangeModifierSchedule(*schedule); } } } if (!designDay.dryBulbTemperatureRangeModifierSchedule()){ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Maximum Dry Bulb Temperature"); } } // Humidity Condition Type s = workspaceObject.getString(SizingPeriod_DesignDayFields::HumidityConditionType); if( s ){ if (istringEqual(*s, "RelativeHumiditySchedule")){ s = "Schedule"; } designDay.setHumidityIndicatingType(s.get()); } std::string humidityIndicatingType = designDay.humidityIndicatingType(); // Wetbulb or DewPoint at Maximum Dry-Bulb if (istringEqual(humidityIndicatingType, "Wetbulb") || istringEqual(humidityIndicatingType, "Dewpoint") || istringEqual(humidityIndicatingType, "WetBulbProfileMultiplierSchedule") || istringEqual(humidityIndicatingType, "WetBulbProfileDifferenceSchedule") || istringEqual(humidityIndicatingType, "WetBulbProfileDefaultMultipliers")){ value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::WetbulborDewPointatMaximumDryBulb); if( value ){ // units for this field are C designDay.setHumidityIndicatingConditionsAtMaximumDryBulb(value.get()); }else{ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Wetbulb or Dew Point at Maximum Dry Bulb"); } } // Humidity Condition Day Schedule Name if (istringEqual(humidityIndicatingType, "RelativeHumiditySchedule") || istringEqual(humidityIndicatingType, "WetBulbProfileMultiplierSchedule") || istringEqual(humidityIndicatingType, "WetBulbProfileDifferenceSchedule") || istringEqual(humidityIndicatingType, "RelativeHumiditySchedule")){ boost::optional<WorkspaceObject> wo = workspaceObject.getTarget(SizingPeriod_DesignDayFields::HumidityConditionDayScheduleName); if( wo ){ boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(wo.get()); if( mo ){ boost::optional<ScheduleDay> schedule = mo->optionalCast<ScheduleDay>(); if( schedule ){ designDay.setHumidityIndicatingDaySchedule(schedule.get()); } } } if (!designDay.humidityIndicatingDaySchedule()){ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Humidity Indicating Day Schedule Name"); } } // Humidity Ratio at Maximum Dry-Bulb if (istringEqual(humidityIndicatingType, "HumidityRatio")){ // units for this field are kgWater/kgDryAir value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::HumidityRatioatMaximumDryBulb); if( value ){ designDay.setHumidityIndicatingConditionsAtMaximumDryBulb(value.get()); }else{ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Humidity Ratio at Maximum Dry Bulb"); } } // Enthalpy at Maximum Dry-Bulb if (istringEqual(humidityIndicatingType, "Enthalpy")){ // units for this field are J/kg value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::EnthalpyatMaximumDryBulb); if( value ){ designDay.setHumidityIndicatingConditionsAtMaximumDryBulb(value.get()); }else{ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Enthalpy at Maximum Dry Bulb"); } } // Daily Wet-Bulb Temperature Range if (istringEqual(humidityIndicatingType, "WetbulbProfileMultiplierSchedule") || istringEqual(humidityIndicatingType, "WetBulbProfileDefaultMultipliers")){ value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::DailyWetBulbTemperatureRange); if (value) { designDay.setDailyWetBulbTemperatureRange(*value); }else{ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Daily Wet Bulb Temperature Range"); } } // Barometric Pressure value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::BarometricPressure); if( value ){ designDay.setBarometricPressure(value.get()); } // Site Wind Speed value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::WindSpeed); if( value ){ designDay.setWindSpeed(value.get()); }else{ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Site Wind Speed"); } // Site Wind Direction value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::WindDirection); if( value ){ designDay.setWindDirection(value.get()); }else{ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Site Wind Direction"); } // Rain Indicator s = workspaceObject.getString(SizingPeriod_DesignDayFields::RainIndicator); if( s ){ if( istringEqual(*s, "Yes") ){ designDay.setRainIndicator(true); }else{ designDay.setRainIndicator(false); } } // Snow Indicator s = workspaceObject.getString(SizingPeriod_DesignDayFields::SnowIndicator); if( s ){ if( istringEqual(*s, "Yes") ){ designDay.setSnowIndicator(true); }else{ designDay.setSnowIndicator(false); } } // Site Daylight Saving Time Status s = workspaceObject.getString(SizingPeriod_DesignDayFields::DaylightSavingTimeIndicator); if( s ){ if( istringEqual(*s, "Yes") ){ designDay.setDaylightSavingTimeIndicator(true); }else{ designDay.setDaylightSavingTimeIndicator(false); } } // Solar Model Indicator s = workspaceObject.getString(SizingPeriod_DesignDayFields::SolarModelIndicator); if( s ){ designDay.setSolarModelIndicator(s.get()); } std::string solarModelIndicator = designDay.solarModelIndicator(); // Beam Solar Day Schedule Name and Site Diffuse Solar Radiation Rate per Area Radiation Rate per Area Day Schedule Name if (istringEqual(solarModelIndicator, "Schedule")){ // Beam Solar Day Schedule Name boost::optional<WorkspaceObject> wo = workspaceObject.getTarget(SizingPeriod_DesignDayFields::BeamSolarDayScheduleName); if( wo ){ boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(wo.get()); if( mo ){ boost::optional<ScheduleDay> schedule = mo->optionalCast<ScheduleDay>(); if( schedule ){ designDay.setBeamSolarDaySchedule(schedule.get()); } } } if (!designDay.beamSolarDaySchedule()){ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Beam Solar Day Schedule Name"); } // Site Diffuse Solar Radiation Rate per Area Radiation Rate per Area Day Schedule Name wo = workspaceObject.getTarget(SizingPeriod_DesignDayFields::DiffuseSolarDayScheduleName); if( wo ){ boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(wo.get()); if( mo ){ boost::optional<ScheduleDay> schedule = mo->optionalCast<ScheduleDay>(); if( schedule ){ designDay.setDiffuseSolarDaySchedule(schedule.get()); } } } if (!designDay.diffuseSolarDaySchedule()){ LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Diffuse Solar Schedule Name"); } } if (istringEqual(solarModelIndicator, "ASHRAETau")){ // ASHRAE Clear Sky Optical Depth for Beam Irradiance (taub) value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::ASHRAEClearSkyOpticalDepthforBeamIrradiance_taub_); if (value) { designDay.setAshraeTaub(*value); } // ASHRAE Clear Sky Optical Depth for Diffuse Irradiance (taud) value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::ASHRAEClearSkyOpticalDepthforDiffuseIrradiance_taud_); if (value) { designDay.setAshraeTaud(*value); } } // Sky Clearness if (istringEqual(solarModelIndicator, "ASHRAEClearSky") || istringEqual(solarModelIndicator, "ZhangHuang")){ value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::SkyClearness); if( value ){ designDay.setSkyClearness(value.get()); } } return designDay; }
OptionalModelObject ReverseTranslator::translateGeneratorMicroTurbine( const WorkspaceObject & workspaceObject ) { OptionalModelObject result,temp; OptionalDouble d; boost::optional<WorkspaceObject> owo; OptionalString optS; // TODO: The availability schedule is in the ElectricLoadCenter:Generators (list) in E+, here it's carried by the generator itself // Should also get the Rated Thermal To Electrical Power Ratio in the list //Generator:MicroTurbine, // Capstone C65, !- Name openstudio::model::GeneratorMicroTurbine mchp( m_model ); // Name optS = workspaceObject.name(); if(optS) { mchp.setName(*optS); } // 65000, !- Reference Electrical Power Output {W} d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceElectricalPowerOutput); if(d) { mchp.setReferenceElectricalPowerOutput(*d); } // 29900, !- Minimum Full Load Electrical Power Output {W} d = workspaceObject.getDouble(Generator_MicroTurbineFields::MinimumFullLoadElectricalPowerOutput); if(d) { mchp.setMinimumFullLoadElectricalPowerOutput(*d); } // 65000, !- Maximum Full Load Electrical Power Output {W} setMaximumFullLoadElectricalPowerOutput d = workspaceObject.getDouble(Generator_MicroTurbineFields::MaximumFullLoadElectricalPowerOutput); if(d) { mchp.setMaximumFullLoadElectricalPowerOutput(*d); } // 0.29, !- Reference Electrical Efficiency Using Lower Heating Value d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceElectricalEfficiencyUsingLowerHeatingValue); if(d) { mchp.setReferenceElectricalEfficiencyUsingLowerHeatingValue(*d); } // 15.0, !- Reference Combustion Air Inlet Temperature {C} d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceCombustionAirInletTemperature); if(d) { mchp.setReferenceCombustionAirInletTemperature(*d); } // 0.00638, !- Reference Combustion Air Inlet Humidity Ratio {kgWater/kgDryAir} d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceCombustionAirInletHumidityRatio); if(d) { mchp.setReferenceCombustionAirInletHumidityRatio(*d); } // 0.0, !- Reference Elevation {m} d = workspaceObject.getDouble(Generator_MicroTurbineFields::MinimumFullLoadElectricalPowerOutput); if(d) { mchp.setMinimumFullLoadElectricalPowerOutput(*d); } // Capstone C65 Power_vs_Temp_Elev, !- Electrical Power Function of Temperature and Elevation Curve Name // BiquadraticCurves if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ElectricalPowerFunctionofTemperatureandElevationCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveBiquadratic> curve = mo->optionalCast<CurveBiquadratic>() ) { mchp.setElectricalPowerFunctionofTemperatureandElevationCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Electrical Power Function of Temperature and Elevation Curve Name"); } } } // Capstone C65 Efficiency_vs_Temp, !- Electrical Efficiency Function of Temperature Curve Name // QuadraticCubicCurves if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ElectricalEfficiencyFunctionofTemperatureCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setElectricalEfficiencyFunctionofTemperatureCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchp.setElectricalEfficiencyFunctionofTemperatureCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Electrical Efficiency Function of Temperature Curve Name"); } } } // Capstone C65 Efficiency_vs_PLR, !- Electrical Efficiency Function of Part Load Ratio Curve Name // QuadraticCubicCurves // setElectricalEfficiencyFunctionofPartLoadRatioCurve if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ElectricalEfficiencyFunctionofPartLoadRatioCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setElectricalEfficiencyFunctionofPartLoadRatioCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchp.setElectricalEfficiencyFunctionofPartLoadRatioCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Electrical Efficiency Function of Part Load Ratio Curve Name"); } } } // NaturalGas, !- Fuel Type optS = workspaceObject.getString(Generator_MicroTurbineFields::FuelType); if(optS) { mchp.setFuelType(*optS); } // 50000, !- Fuel Higher Heating Value {kJ/kg} d = workspaceObject.getDouble(Generator_MicroTurbineFields::FuelHigherHeatingValue); if(d) { mchp.setFuelHigherHeatingValue(*d); } // 45450, !- Fuel Lower Heating Value {kJ/kg} d = workspaceObject.getDouble(Generator_MicroTurbineFields::FuelLowerHeatingValue); if(d) { mchp.setFuelLowerHeatingValue(*d); } // 300, !- Standby Power {W} d = workspaceObject.getDouble(Generator_MicroTurbineFields::StandbyPower); if(d) { mchp.setStandbyPower(*d); } // 4500, !- Ancillary Power {W} d = workspaceObject.getDouble(Generator_MicroTurbineFields::AncillaryPower); if(d) { mchp.setAncillaryPower(*d); } // , !- Ancillary Power Function of Fuel Input Curve Name // QuadraticCurves // mchp.setAncillaryPowerFunctionofFuelInputCurve if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::AncillaryPowerFunctionofFuelInputCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setAncillaryPowerFunctionofFuelInputCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Ancillary Power Function of Fuel Input Curve Name"); } } } // Fields in between (in E+.idd) are moved at the end in the Heat Recovery section // Capstone C65 Combustion Air Inlet Node, !- Combustion Air Inlet Node Name // Capstone C65 Combustion Air Outlet Node, !- Combustion Air Outlet Node Name // 0.489885, !- Reference Exhaust Air Mass Flow Rate {kg/s} d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceExhaustAirMassFlowRate); if(d) { mchp.setReferenceExhaustAirMassFlowRate(*d); } // Capstone C65 ExhAirFlowRate_vs_InletTemp, !- Exhaust Air Flow Rate Function of Temperature Curve Name // QuadraticCubicCurves // mchp.setExhaustAirFlowRateFunctionofTemperatureCurve if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ExhaustAirFlowRateFunctionofTemperatureCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setExhaustAirFlowRateFunctionofTemperatureCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchp.setExhaustAirFlowRateFunctionofTemperatureCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Exhaust Air Flow Rate Function of Temperature Curve Name"); } } } // Capstone C65 ExhAirFlowRate_vs_PLR, !- Exhaust Air Flow Rate Function of Part Load Ratio Curve Name // QuadraticCubicCurves // mchp.setExhaustAirFlowRateFunctionofPartLoadRatioCurve(curve) if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ExhaustAirFlowRateFunctionofPartLoadRatioCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setExhaustAirFlowRateFunctionofPartLoadRatioCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchp.setExhaustAirFlowRateFunctionofPartLoadRatioCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Exhaust Air Flow Rate Function of Part Load Ratio Curve Name"); } } } // 308.9, !- Nominal Exhaust Air Outlet Temperature d = workspaceObject.getDouble(Generator_MicroTurbineFields::NominalExhaustAirOutletTemperature); if(d) { mchp.setNominalExhaustAirOutletTemperature(*d); } // Capstone C65 ExhaustTemp_vs_InletTemp, !- Exhaust Air Temperature Function of Temperature Curve Name // QuadraticCubicCurves // mchp.setExhaustAirTemperatureFunctionofTemperatureCurve(curve) if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ExhaustAirTemperatureFunctionofTemperatureCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setExhaustAirTemperatureFunctionofTemperatureCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchp.setExhaustAirTemperatureFunctionofTemperatureCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Exhaust Air Temperature Function of Temperature Curve Name"); } } } // Capstone C65 ExhaustTemp_vs_PLR; !- Exhaust Air Temperature Function of Part Load Ratio Curve Name // QuadraticCubicCurves // mchp.setExhaustAirTemperatureFunctionofPartLoadRatioCurve(curve) if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ExhaustAirTemperatureFunctionofPartLoadRatioCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setExhaustAirTemperatureFunctionofPartLoadRatioCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchp.setExhaustAirTemperatureFunctionofPartLoadRatioCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Exhaust Air Temperature Function of Part Load Ratio Curve Name"); } } } /// HEAT RECOVERY PORTION // Would need to add that to the plantLoop reverse translator // Capstone C65 Heat Recovery Water Inlet Node, !- Heat Recovery Water Inlet Node Name // Capstone C65 Heat Recovery Water Outlet Node, !- Heat Recovery Water Outlet Node Name // TODO: For now, I trigger the creation is the 'Reference Thermal Efficiency Using Lower Heat Value' is filled. // TODO: I should trigger it based on the `Rated Thermal To Electrical Power Ratio in the list` in the ElectricLoadCenter:Generators (list) // TODO: But in order to do that, the ElectricLoadCenter:Distribution & ElectricLoadCenter:Generators need to have a reverse translator // 0.4975, !- Reference Thermal Efficiency Using Lower Heat Value d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceThermalEfficiencyUsingLowerHeatValue); if(d) { // Create a GeneratorMicroTurbineHeatRecovery module, and assign it to the MicroTurbine // I've Set the Name in the constructor openstudio::model::GeneratorMicroTurbineHeatRecovery mchpHR (m_model, mchp); // Assign the Reference Thermal Efficiency Using Lower Heat Value mchpHR.setReferenceThermalEfficiencyUsingLowerHeatValue(*d); // 60.0, !- Reference Inlet Water Temperature {C} d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceInletWaterTemperature); if(d) { mchpHR.setReferenceInletWaterTemperature(*d); } // PlantControl, !- Heat Recovery Water Flow Operating Mode optS = workspaceObject.getString(Generator_MicroTurbineFields::HeatRecoveryWaterFlowOperatingMode); if(optS) { mchpHR.setHeatRecoveryWaterFlowOperatingMode(*optS); } // 0.00252362, !- Reference Heat Recovery Water Flow Rate {m3/s} d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceHeatRecoveryWaterFlowRate); if(d) { mchpHR.setReferenceHeatRecoveryWaterFlowRate(*d); } // , !- Heat Recovery Water Flow Rate Function of Temperature and Power Curve Name // BiquadraticCurves // mchpHR.setHeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve(); if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::HeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveBiquadratic> curve = mo->optionalCast<CurveBiquadratic>() ) { mchpHR.setHeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Heat Recovery Water Flow Rate Function of Temperature and Power Curve Name"); } } } // Capstone C65 ThermalEff_vs_Temp_Elev, !- Thermal Efficiency Function of Temperature and Elevation Curve Name // BicubicBiquadraticCurves // mchpHR.setThermalEfficiencyFunctionofTemperatureandElevationCurve(); if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ThermalEfficiencyFunctionofTemperatureandElevationCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveBicubic> curve = mo->optionalCast<CurveBicubic>() ) { mchpHR.setThermalEfficiencyFunctionofTemperatureandElevationCurve(curve.get()); } else if( boost::optional<CurveBiquadratic> curve = mo->optionalCast<CurveBiquadratic>() ) { mchpHR.setThermalEfficiencyFunctionofTemperatureandElevationCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Thermal Efficiency Function of Temperature and Elevation Curve Name"); } } } // Capstone C65 HeatRecoveryRate_vs_PLR, !- Heat Recovery Rate Function of Part Load Ratio Curve Name // QuadraticCubicCurves // mchpHR.setHeatRecoveryRateFunctionofPartLoadRatioCurve(); if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::HeatRecoveryRateFunctionofPartLoadRatioCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchpHR.setHeatRecoveryRateFunctionofPartLoadRatioCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchpHR.setHeatRecoveryRateFunctionofPartLoadRatioCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Heat Recovery Rate Function of Part Load Ratio Curve Name"); } } } // Capstone C65 HeatRecoveryRate_vs_InletTemp, !- Heat Recovery Rate Function of Inlet Water Temperature Curve Name // QuadraticCurves // mchpHR.setHeatRecoveryRateFunctionofInletWaterTemperatureCurve(); if ((owo = workspaceObject.getTarget(Generator_MicroTurbineFields::HeatRecoveryRateFunctionofInletWaterTemperatureCurveName))) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchpHR.setHeatRecoveryRateFunctionofInletWaterTemperatureCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Heat Recovery Rate Function of Part Load Ratio Curve Name"); } } } // Capstone C65 HeatRecoveryRate_vs_WaterFlow, !- Heat Recovery Rate Function of Water Flow Rate Curve Name // QuadraticCurves // mchpHR.setHeatRecoveryRateFunctionofInletWaterFlowRateCurve(); if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::HeatRecoveryRateFunctionofWaterFlowRateCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchpHR.setHeatRecoveryRateFunctionofWaterFlowRateCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Heat Recovery Rate Function of Water Flow Rate Curve Name"); } } } // 0.001577263, !- Minimum Heat Recovery Water Flow Rate {m3/s} d = workspaceObject.getDouble(Generator_MicroTurbineFields::MinimumHeatRecoveryWaterFlowRate); if(d) { mchpHR.setMinimumHeatRecoveryWaterFlowRate(*d); } // 0.003785432, !- Maximum Heat Recovery Water Flow Rate {m3/s} d = workspaceObject.getDouble(Generator_MicroTurbineFields::MaximumHeatRecoveryWaterFlowRate); if(d) { mchpHR.setMaximumHeatRecoveryWaterFlowRate(*d); } // 82.2, !- Maximum Heat Recovery Water Temperature {C} d = workspaceObject.getDouble(Generator_MicroTurbineFields::MaximumHeatRecoveryWaterTemperature); if(d) { mchpHR.setMaximumHeatRecoveryWaterTemperature(*d); } } result=mchp; return result; }
OptionalModelObject ReverseTranslator::translateEnergyManagementSystemOutputVariable(const WorkspaceObject & workspaceObject) { if (workspaceObject.iddObject().type() != IddObjectType::EnergyManagementSystem_OutputVariable) { LOG(Error, "WorkspaceObject is not IddObjectType: EnergyManagementSystem_OutputVariable"); return boost::none; } //make sure all other objects are translated first except below for (const WorkspaceObject& workspaceObject : m_workspace.objects()) { if ((workspaceObject.iddObject().type() != IddObjectType::EnergyManagementSystem_Program) && (workspaceObject.iddObject().type() != IddObjectType::EnergyManagementSystem_Subroutine) && (workspaceObject.iddObject().type() != IddObjectType::EnergyManagementSystem_ProgramCallingManager) && (workspaceObject.iddObject().type() != IddObjectType::EnergyManagementSystem_MeteredOutputVariable) && (workspaceObject.iddObject().type() != IddObjectType::EnergyManagementSystem_OutputVariable)) { translateAndMapWorkspaceObject(workspaceObject); } } OptionalString s = workspaceObject.getString(EnergyManagementSystem_OutputVariableFields::Name); if (!s) { LOG(Error, "EnergyManagementSystem_OutputVariable has no Name"); return boost::none; } openstudio::model::EnergyManagementSystemOutputVariable emsOutputVariable(m_model); emsOutputVariable.setName(*s); s = workspaceObject.getString(EnergyManagementSystem_OutputVariableFields::EMSVariableName); if (!s) { LOG(Error, emsOutputVariable.nameString() + ": EMSVariableName not set"); return boost::none; } else { Workspace workspace = workspaceObject.workspace(); //look for GlobalVariables, translate and check if there is a name match since GV's dont have name field. boost::optional<WorkspaceObject> wsObject = workspace.getObjectByTypeAndName(IddObjectType::EnergyManagementSystem_GlobalVariable, *s); //for (WorkspaceObject& wsObject : workspace.getObjectsByType(IddObjectType::EnergyManagementSystem_GlobalVariable)) { if (wsObject) { boost::optional<model::ModelObject> modelObject = translateAndMapWorkspaceObject(wsObject.get()); if (modelObject) { if (modelObject.get().cast<EnergyManagementSystemGlobalVariable>().name() == s) { emsOutputVariable.setEMSVariableName(*s); } } } //look for name match on other (EMS) objects. for (WorkspaceObject& wsObject : workspace.getObjectsByName(*s)) { boost::optional<model::ModelObject> modelObject = translateAndMapWorkspaceObject(wsObject); if (modelObject) { emsOutputVariable.setEMSVariableName(*s); break; } } } s = workspaceObject.getString(EnergyManagementSystem_OutputVariableFields::UpdateFrequency); if (!s) { LOG(Error, emsOutputVariable.nameString() + ": UpdateFrequency not set"); return boost::none; } else { emsOutputVariable.setUpdateFrequency(*s); } s = workspaceObject.getString(EnergyManagementSystem_OutputVariableFields::TypeofDatainVariable); if (!s) { LOG(Error, emsOutputVariable.nameString() + ": TypeofDatainVariable not set"); return boost::none; } else { emsOutputVariable.setTypeOfDataInVariable(*s); } s = workspaceObject.getString(EnergyManagementSystem_OutputVariableFields::Units); if (s) { emsOutputVariable.setUnits(*s); } s = workspaceObject.getString(EnergyManagementSystem_OutputVariableFields::EMSProgramorSubroutineName); if (s) { Workspace workspace = workspaceObject.workspace(); for (WorkspaceObject& wsObject : workspace.getObjectsByName(*s)) { boost::optional<model::ModelObject> modelObject = translateAndMapWorkspaceObject(wsObject); if (modelObject) { if (modelObject.get().iddObjectType() == IddObjectType::OS_EnergyManagementSystem_Program) { emsOutputVariable.setEMSProgramOrSubroutineName(modelObject.get().cast<EnergyManagementSystemProgram>()); } else if (modelObject.get().iddObjectType() == IddObjectType::OS_EnergyManagementSystem_Subroutine) { emsOutputVariable.setEMSProgramOrSubroutineName(modelObject.get().cast<EnergyManagementSystemSubroutine>()); } return emsOutputVariable; } } } return emsOutputVariable; }
OptionalModelObject ReverseTranslator::translateDesignSpecificationOutdoorAir( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::DesignSpecification_OutdoorAir ){ LOG(Error, "WorkspaceObject is not IddObjectType: DesignSpecification:OutdoorAir"); return boost::none; } OptionalString outdoorAirMethod = workspaceObject.getString(DesignSpecification_OutdoorAirFields::OutdoorAirMethod, true); if (!outdoorAirMethod){ LOG(Error, "No OutdoorAirMethod specified for DesignSpecification:OutdoorAir named '" << workspaceObject.name().get() << "'"); return boost::none; } DesignSpecificationOutdoorAir result(m_model); OptionalString name = workspaceObject.name(); if(name){ result.setName(*name); } result.setOutdoorAirMethod(*outdoorAirMethod); boost::optional<double> flowPerPerson = workspaceObject.getDouble(DesignSpecification_OutdoorAirFields::OutdoorAirFlowperPerson); boost::optional<double> flowPerArea = workspaceObject.getDouble(DesignSpecification_OutdoorAirFields::OutdoorAirFlowperZoneFloorArea); boost::optional<double> flowPerZone = workspaceObject.getDouble(DesignSpecification_OutdoorAirFields::OutdoorAirFlowperZone); boost::optional<double> ach = workspaceObject.getDouble(DesignSpecification_OutdoorAirFields::OutdoorAirFlowAirChangesperHour); if (istringEqual(*outdoorAirMethod, "Flow/Person")){ if (flowPerPerson){ result.setOutdoorAirFlowperPerson(*flowPerPerson); } }else if (istringEqual(*outdoorAirMethod, "Flow/Area")){ if (flowPerArea){ result.setOutdoorAirFlowperFloorArea(*flowPerArea); } }else if (istringEqual(*outdoorAirMethod, "Flow/Zone")){ if (flowPerZone){ result.setOutdoorAirFlowRate(*flowPerZone); } }else if (istringEqual(*outdoorAirMethod, "AirChanges/Hour")){ if (ach){ result.setOutdoorAirFlowRate(*ach); } }else if (istringEqual(*outdoorAirMethod, "Sum") || istringEqual(*outdoorAirMethod, "Maximum")){ if (flowPerPerson){ result.setOutdoorAirFlowperPerson(*flowPerPerson); } if (flowPerArea){ result.setOutdoorAirFlowperFloorArea(*flowPerArea); } if (flowPerZone){ result.setOutdoorAirFlowRate(*flowPerZone); } if (ach){ result.setOutdoorAirFlowRate(*ach); } }else{ LOG(Error, "Unknown OutdoorAirMethod '" << *outdoorAirMethod << "' specified for DesignSpecification:OutdoorAir named '" << workspaceObject.name().get() << "'"); } OptionalWorkspaceObject target = workspaceObject.getTarget(DesignSpecification_OutdoorAirFields::OutdoorAirFlowRateFractionScheduleName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){ Schedule schedule = *intermediate; result.setOutdoorAirFlowRateFractionSchedule(schedule); } } } return result; }
OptionalModelObject ReverseTranslator::translateEvaporativeFluidCoolerSingleSpeed( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::EvaporativeFluidCooler_SingleSpeed ) { LOG(Error, "WorkspaceObject is not IddObjectType: EvaporativeFluidCooler_SingleSpeed"); return boost::none; } boost::optional<EvaporativeFluidCoolerSingleSpeed> evapCooler; evapCooler = EvaporativeFluidCoolerSingleSpeed( m_model ); if( evapCooler ) { boost::optional<double> value; boost::optional<std::string> s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::Name); if( s ) { evapCooler->setName(s.get()); } // DesignAirFlowRate value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRate); s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRate); if( value ) { evapCooler->setDesignAirFlowRate(value.get()); } else if( s && istringEqual(s.get(),"Autosize") ) { evapCooler->autosizeDesignAirFlowRate(); } else if( s && istringEqual(s.get(),"Autocalculate") ) { evapCooler->autosizeDesignAirFlowRate(); } // FanPoweratDesignAirFlowRate value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRateFanPower); s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRateFanPower); if( value ) { evapCooler->setFanPoweratDesignAirFlowRate(value.get()); } else if( s && istringEqual(s.get(),"Autosize") ) { evapCooler->autosizeFanPoweratDesignAirFlowRate(); } else if( s && istringEqual(s.get(),"Autocalculate") ) { evapCooler->autosizeFanPoweratDesignAirFlowRate(); } // DesignSprayWaterFlowRate value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignSprayWaterFlowRate); if( value ) { evapCooler->setDesignSprayWaterFlowRate(value.get()); } // PerformanceInputMethod s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::PerformanceInputMethod); if( s ) { evapCooler->setPerformanceInputMethod(s.get()); } // StandardDesignCapacity value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::StandardDesignCapacity); if( value ) { evapCooler->setStandardDesignCapacity(value.get()); } // UfactorTimesAreaValueatDesignAirFlowRate value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRateUfactorTimesAreaValue); s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRateUfactorTimesAreaValue); if( value ) { evapCooler->setUfactorTimesAreaValueatDesignAirFlowRate(value.get()); } else if( s && istringEqual(s.get(),"Autosize") ) { evapCooler->autosizeUfactorTimesAreaValueatDesignAirFlowRate(); } else if( s && istringEqual(s.get(),"Autocalculate") ) { evapCooler->autosizeUfactorTimesAreaValueatDesignAirFlowRate(); } // DesignWaterFlowRate value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignWaterFlowRate); s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::DesignWaterFlowRate); if( value ) { evapCooler->setDesignWaterFlowRate(value.get()); } else if( s && istringEqual(s.get(),"Autosize") ) { evapCooler->autosizeDesignWaterFlowRate(); } else if( s && istringEqual(s.get(),"Autocalculate") ) { evapCooler->autosizeDesignWaterFlowRate(); } // UserSpecifiedDesignCapacity value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::UserSpecifiedDesignCapacity); if( value ) { evapCooler->setUserSpecifiedDesignCapacity(value.get()); } // DesignEnteringWaterTemperature value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignEnteringWaterTemperature); if( value ) { evapCooler->setDesignEnteringWaterTemperature(value.get()); } // DesignEnteringAirTemperature value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignEnteringAirTemperature); if( value ) { evapCooler->setDesignEnteringAirTemperature(value.get()); } // DesignEnteringAirWetbulbTemperature value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignEnteringAirWetbulbTemperature); if( value ) { evapCooler->setDesignEnteringAirWetbulbTemperature(value.get()); } // CapacityControl s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::CapacityControl); if( s ) { evapCooler->setCapacityControl(s.get()); } // SizingFactor value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::SizingFactor); if( value ) { evapCooler->setSizingFactor(value.get()); } // EvaporationLossMode s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::EvaporationLossMode); if( s ) { evapCooler->setEvaporationLossMode(s.get()); } // EvaporationLossFactor value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::EvaporationLossFactor); if( value ) { evapCooler->setEvaporationLossFactor(value.get()); } // DriftLossPercent value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DriftLossPercent); if( value ) { evapCooler->setDriftLossPercent(value.get()); } // BlowdownCalculationMode s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::BlowdownCalculationMode); if( s ) { evapCooler->setBlowdownCalculationMode(s.get()); } // BlowdownConcentrationRatio value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::BlowdownConcentrationRatio); if( value ) { evapCooler->setBlowdownConcentrationRatio(value.get()); } boost::optional<WorkspaceObject> _schedule; // BlowdownMakeupWaterUsageScheduleName _schedule = workspaceObject.getTarget(EvaporativeFluidCooler_SingleSpeedFields::BlowdownMakeupWaterUsageScheduleName); if( _schedule ) { boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(_schedule.get()); if( mo ) { if( boost::optional<Schedule> schedule = mo->optionalCast<Schedule>() ) { evapCooler->setBlowdownMakeupWaterUsageSchedule(schedule.get()); } } } return evapCooler.get(); } else { LOG(Error, "Unknown error translating " << workspaceObject.briefDescription()); return boost::none; } }
OptionalModelObject ReverseTranslator::translateSetpointManagerSingleZoneReheat( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::SetpointManager_SingleZone_Reheat ) { LOG(Error, "WorkspaceObject is not IddObjectType: SetpointManager_SingleZone_Reheat"); return boost::none; } bool nodeFound = false; if( boost::optional<std::string> setpointNodeName = workspaceObject.getString(SetpointManager_SingleZone_ReheatFields::SetpointNodeorNodeListName) ) { boost::optional<Node> setpointNode = m_model.getModelObjectByName<Node>(setpointNodeName.get()); if( setpointNode ) { nodeFound = true; } } if( ! nodeFound ) { LOG(Error, workspaceObject.briefDescription() << " is not attached to a node in the model"); return boost::none; } SetpointManagerSingleZoneReheat mo(m_model); boost::optional<std::string> s = workspaceObject.getString(SetpointManager_SingleZone_ReheatFields::Name); if( s ) { mo.setName(s.get()); } boost::optional<double> value = workspaceObject.getDouble(SetpointManager_SingleZone_ReheatFields::MinimumSupplyAirTemperature); if( value ) { mo.setMinimumSupplyAirTemperature(value.get()); } value = workspaceObject.getDouble(SetpointManager_SingleZone_ReheatFields::MaximumSupplyAirTemperature); if( value ) { mo.setMaximumSupplyAirTemperature(value.get()); } s = workspaceObject.getString(SetpointManager_SingleZone_ReheatFields::ControlZoneName); if( s ) { boost::optional<ModelObject> modelObject; boost::optional<Space> space; if( boost::optional<WorkspaceObject> _zone = workspaceObject.workspace().getObjectByTypeAndName(IddObjectType::Zone,s.get()) ) { modelObject = translateAndMapWorkspaceObject(_zone.get()); } if( modelObject ) { if( (space = modelObject->optionalCast<Space>()) ) { if( boost::optional<ThermalZone> thermalZone = space->thermalZone() ) { mo.setControlZone(thermalZone.get()); } } } } s = workspaceObject.getString(SetpointManager_SingleZone_ReheatFields::SetpointNodeorNodeListName); if( s ) { if( boost::optional<Node> node = m_model.getModelObjectByName<Node>(s.get()) ) { mo.addToNode(node.get()); } } if( mo.setpointNode() ) { return mo; } else { return boost::none; } }
boost::optional<ModelObject> ReverseTranslator::translateCurveBicubic( const WorkspaceObject& workspaceObject) { CurveBicubic curve(m_model); OptionalString s; OptionalDouble d; if((s = workspaceObject.name())) { curve.setName(*s); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::Coefficient1Constant))) { curve.setCoefficient1Constant(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::Coefficient2x))) { curve.setCoefficient2x(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::Coefficient3x_POW_2))) { curve.setCoefficient3xPOW2(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::Coefficient4y))) { curve.setCoefficient4y(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::Coefficient5y_POW_2))) { curve.setCoefficient5yPOW2(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::Coefficient6x_TIMES_y))) { curve.setCoefficient6xTIMESY(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::Coefficient7x_POW_3))) { curve.setCoefficient7xPOW3(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::Coefficient8y_POW_3))) { curve.setCoefficient8yPOW3(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::Coefficient9x_POW_2_TIMES_y))) { curve.setCoefficient9xPOW2TIMESY(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::Coefficient10x_TIMES_y_POW_2))) { curve.setCoefficient10xTIMESYPOW2(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::MinimumValueofx))) { curve.setMinimumValueofx(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::MaximumValueofx))) { curve.setMaximumValueofx(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::MinimumValueofy))) { curve.setMinimumValueofy(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::MaximumValueofy))) { curve.setMaximumValueofy(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::MinimumCurveOutput))) { curve.setMinimumCurveOutput(*d); } if ((d = workspaceObject.getDouble(Curve_BicubicFields::MaximumCurveOutput))) { curve.setMaximumCurveOutput(*d); } if ((s = workspaceObject.getString(Curve_BicubicFields::InputUnitTypeforX,false,true))) { curve.setInputUnitTypeforX(*s); } if ((s = workspaceObject.getString(Curve_BicubicFields::InputUnitTypeforY,false,true))) { curve.setInputUnitTypeforY(*s); } if ((s = workspaceObject.getString(Curve_BicubicFields::OutputUnitType,false,true))) { curve.setOutputUnitType(*s); } return curve; }
OptionalModelObject ReverseTranslator::translateAirTerminalSingleDuctVAVReheat( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::AirTerminal_SingleDuct_VAV_Reheat ) { LOG(Error, "WorkspaceObject is not IddObjectType: AirTerminal_SingleDuct_VAV_Reheat"); return boost::none; } boost::optional<WorkspaceObject> wo = workspaceObject.getTarget(AirTerminal_SingleDuct_VAV_ReheatFields::AvailabilityScheduleName); boost::optional<Schedule> schedule; boost::optional<HVACComponent> coil; boost::optional<AirTerminalSingleDuctVAVReheat> airTerminal; if( wo ) { boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(wo.get()); if( mo ) { if( ! (schedule = mo->optionalCast<Schedule>()) ) { LOG(Error, workspaceObject.briefDescription() << " does not have an associated availability schedule"); return boost::none; } } } wo = workspaceObject.getTarget(AirTerminal_SingleDuct_VAV_ReheatFields::ReheatCoilName); if( wo ) { boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(wo.get()); if( mo ) { if( ! coil ) { coil = mo->optionalCast<CoilHeatingGas>(); } } } if( schedule && coil ) { airTerminal = AirTerminalSingleDuctVAVReheat( m_model,schedule.get(),coil.get() ); } if( airTerminal ) { boost::optional<double> value; boost::optional<std::string> s = workspaceObject.getString(AirTerminal_SingleDuct_VAV_ReheatFields::Name); if( s ) { airTerminal->setName(s.get()); } // MaximumAirFlowRate value = workspaceObject.getDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumAirFlowRate); s = workspaceObject.getString(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumAirFlowRate); if( value ) { airTerminal->setMaximumAirFlowRate(value.get()); } else if( s && istringEqual(s.get(),"Autosize") ) { airTerminal->autosizeMaximumAirFlowRate(); } else if( s && istringEqual(s.get(),"Autocalculate") ) { airTerminal->autosizeMaximumAirFlowRate(); } // ZoneMinimumAirFlowInputMethod s = workspaceObject.getString(AirTerminal_SingleDuct_VAV_ReheatFields::ZoneMinimumAirFlowInputMethod); if( s ) { airTerminal->setZoneMinimumAirFlowMethod(s.get()); } // ConstantMinimumAirFlowFraction value = workspaceObject.getDouble(AirTerminal_SingleDuct_VAV_ReheatFields::ConstantMinimumAirFlowFraction); if( value ) { airTerminal->setConstantMinimumAirFlowFraction(value.get()); } // FixedMinimumAirFlowRate value = workspaceObject.getDouble(AirTerminal_SingleDuct_VAV_ReheatFields::FixedMinimumAirFlowRate); if( value ) { airTerminal->setFixedMinimumAirFlowRate(value.get()); } boost::optional<WorkspaceObject> _schedule; // MinimumAirFlowFractionScheduleName _schedule = workspaceObject.getTarget(AirTerminal_SingleDuct_VAV_ReheatFields::MinimumAirFlowFractionScheduleName); if( _schedule ) { boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(_schedule.get()); if( mo ) { if( boost::optional<Schedule> schedule = mo->optionalCast<Schedule>() ) { airTerminal->setMinimumAirFlowFractionSchedule(schedule.get()); } } } // MaximumHotWaterorSteamFlowRate value = workspaceObject.getDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumHotWaterorSteamFlowRate); s = workspaceObject.getString(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumHotWaterorSteamFlowRate); if( value ) { airTerminal->setMaximumHotWaterOrSteamFlowRate(value.get()); } else if( s && istringEqual(s.get(),"Autosize") ) { airTerminal->autosizeMaximumHotWaterOrSteamFlowRate(); } else if( s && istringEqual(s.get(),"Autocalculate") ) { airTerminal->autosizeMaximumHotWaterOrSteamFlowRate(); } // MinimumHotWaterorSteamFlowRate value = workspaceObject.getDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MinimumHotWaterorSteamFlowRate); if( value ) { airTerminal->setMinimumHotWaterOrStreamFlowRate(value.get()); } // ConvergenceTolerance value = workspaceObject.getDouble(AirTerminal_SingleDuct_VAV_ReheatFields::ConvergenceTolerance); if( value ) { airTerminal->setConvergenceTolerance(value.get()); } // DamperHeatingAction s = workspaceObject.getString(AirTerminal_SingleDuct_VAV_ReheatFields::DamperHeatingAction); if( s ) { airTerminal->setDamperHeatingAction(s.get()); } // MaximumFlowPerZoneFloorAreaDuringReheat value = workspaceObject.getDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumFlowperZoneFloorAreaDuringReheat); s = workspaceObject.getString(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumFlowperZoneFloorAreaDuringReheat); if( value ) { airTerminal->setMaximumFlowPerZoneFloorAreaDuringReheat(value.get()); } else if( s && istringEqual(s.get(),"Autosize") ) { airTerminal->autosizeMaximumFlowPerZoneFloorAreaDuringReheat(); } else if( s && istringEqual(s.get(),"Autocalculate") ) { airTerminal->autosizeMaximumFlowPerZoneFloorAreaDuringReheat(); } // MaximumFlowFractionDuringReheat value = workspaceObject.getDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumFlowFractionDuringReheat); s = workspaceObject.getString(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumFlowFractionDuringReheat); if( value ) { airTerminal->setMaximumFlowFractionDuringReheat(value.get()); } else if( s && istringEqual(s.get(),"Autosize") ) { airTerminal->autosizeMaximumFlowFractionDuringReheat(); } else if( s && istringEqual(s.get(),"Autocalculate") ) { airTerminal->autosizeMaximumFlowFractionDuringReheat(); } // MaximumReheatAirTemperature value = workspaceObject.getDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumReheatAirTemperature); if( value ) { airTerminal->setMaximumReheatAirTemperature(value.get()); } return airTerminal.get(); } else { LOG(Error, "Unknown error translating " << workspaceObject.briefDescription()); return boost::none; } }
OptionalModelObject ReverseTranslator::translateFanConstantVolume( const WorkspaceObject & workspaceObject ) { OptionalModelObject result,temp; OptionalSchedule schedule; OptionalWorkspaceObject owo = workspaceObject.getTarget(Fan_ConstantVolumeFields::AvailabilityScheduleName); if(!owo) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " Can't find Schedule: "); return result; } temp = translateAndMapWorkspaceObject( *owo); if(temp) { schedule = temp->optionalCast<Schedule>(); } if( !schedule ) { LOG(Error, "Error importing object: " << workspaceObject.name().get() <<"Failed to convert iddObjects into model Objects. Maybe they do not exist in model yet"); return result; } openstudio::model::FanConstantVolume fan( m_model, *schedule ); OptionalString optS = workspaceObject.name(); if(optS) { fan.setName(*optS); } //inlet and outlet nodes are set my the HVACAirLoop OptionalDouble d; d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::FanTotalEfficiency); if(d) { fan.setFanEfficiency(*d); } d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::PressureRise); if(d) { fan.setPressureRise(*d); } d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::MaximumFlowRate); if(d) { fan.setMaximumFlowRate(*d); } d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::MotorEfficiency); if(d) { fan.setMotorEfficiency(*d); } d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::MotorInAirstreamFraction); if(d) { fan.setMotorInAirstreamFraction(*d); } optS=workspaceObject.getString(openstudio::Fan_ConstantVolumeFields::EndUseSubcategory); if(optS) { fan.setEndUseSubcategory(*optS); } result=fan; return result; }