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