OptionalModelObject ReverseTranslator::translateCoilSystemCoolingDX( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::CoilSystem_Cooling_DX ) { LOG(Error, "WorkspaceObject is not IddObjectType: CoilSystem:Cooling:DX"); return boost::none; } Workspace workspace = workspaceObject.workspace(); boost::optional<std::string> coolingCoilObjectType; boost::optional<std::string> coolingCoilName; coolingCoilObjectType = workspaceObject.getString(CoilSystem_Cooling_DXFields::CoolingCoilObjectType); coolingCoilName = workspaceObject.getString(CoilSystem_Cooling_DXFields::CoolingCoilName); boost::optional<WorkspaceObject> wo; if( coolingCoilObjectType && coolingCoilName ) { wo = workspace.getObjectByTypeAndName(IddObjectType(coolingCoilObjectType.get()),coolingCoilName.get()); } if( wo ) { return translateAndMapWorkspaceObject(wo.get()); } else { return boost::none; } }
OptionalModelObject ReverseTranslator::translateEnergyManagementSystemConstructionIndexVariable(const WorkspaceObject & workspaceObject) { if (workspaceObject.iddObject().type() != IddObjectType::EnergyManagementSystem_ConstructionIndexVariable) { LOG(Error, "WorkspaceObject is not IddObjectType: EnergyManagementSystem_ConstructionIndexVariable"); return boost::none; } OptionalString s1 = workspaceObject.getString(EnergyManagementSystem_ConstructionIndexVariableFields::Name); if(!s1){ LOG(Error, "WorkspaceObject EnergyManagementSystem_ConstructionIndexVariable has no Name"); return boost::none; } OptionalString s = workspaceObject.getString(EnergyManagementSystem_ConstructionIndexVariableFields::ConstructionObjectName); if (!s) { LOG(Error, workspaceObject.nameString() + ": has no ConstructionObjectName"); return boost::none; } Workspace workspace = workspaceObject.workspace(); if (s) { //std::vector<WorkspaceObject> wsObjects = workspace.getObjectsByTypeAndName(IddObjectType::Construction, *s); std::vector<WorkspaceObject> wsObjects = workspace.getObjectsByName(*s); if (wsObjects.size() > 1) { LOG(Error, workspaceObject.nameString() + ": Construction is not unique. More than 1 object with that name."); return boost::none; } if (wsObjects.size() == 0) { LOG(Error, workspaceObject.nameString() + ": Construction not found."); return boost::none; } else { boost::optional<model::ModelObject> modelObject = translateAndMapWorkspaceObject(wsObjects[0]); if (modelObject) { openstudio::model::EnergyManagementSystemConstructionIndexVariable emsConstructionIndexVariable(m_model); emsConstructionIndexVariable.setName(*s1); emsConstructionIndexVariable.setConstructionObject(modelObject.get()); return emsConstructionIndexVariable; } } } return boost::none; }
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::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; } }
OptionalModelObject ReverseTranslator::translateZone( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::Zone ){ LOG(Error, "WorkspaceObject is not IddObjectType: Zone"); return boost::none; } // this function creates a space and a thermal zone, it returns the space. If you want the // thermal zone you can reliably dereference the result of space.thermalZone(). openstudio::model::ThermalZone thermalZone( m_model ); openstudio::model::Space space( m_model ); space.setThermalZone(thermalZone); boost::optional<std::string> idfZoneName; OptionalString s = workspaceObject.name(); if(s){ space.setName(*s); thermalZone.setName(*s + " Thermal Zone"); idfZoneName = *s; } OptionalDouble d = workspaceObject.getDouble(ZoneFields::DirectionofRelativeNorth); if(d){ space.setDirectionofRelativeNorth(*d); } d=workspaceObject.getDouble(ZoneFields::XOrigin); if(d){ space.setXOrigin(*d); } d=workspaceObject.getDouble(ZoneFields::YOrigin); if(d){ space.setYOrigin(*d); } d=workspaceObject.getDouble(ZoneFields::ZOrigin); if(d){ space.setZOrigin(*d); } OptionalInt i = workspaceObject.getInt(ZoneFields::Type); if(i){ // no-op } i = workspaceObject.getInt(ZoneFields::Multiplier); if(i){ thermalZone.setMultiplier(*i); } d = workspaceObject.getDouble(ZoneFields::CeilingHeight); if(d){ thermalZone.setCeilingHeight(*d); } d=workspaceObject.getDouble(ZoneFields::Volume); if(d){ thermalZone.setVolume(*d); } s = workspaceObject.getString(ZoneFields::ZoneInsideConvectionAlgorithm); if(s){ thermalZone.setZoneInsideConvectionAlgorithm(*s); } s = workspaceObject.getString(ZoneFields::ZoneOutsideConvectionAlgorithm); if(s){ thermalZone.setZoneOutsideConvectionAlgorithm(*s); } s = workspaceObject.getString(ZoneFields::PartofTotalFloorArea); if(s){ if(istringEqual("Yes",*s)) { space.setPartofTotalFloorArea(true); } else { space.setPartofTotalFloorArea(false); } } // Thermostat // If the zone in the idf file does not have a name, there is no use in even trying to find a thermostat if( idfZoneName ) { Workspace workspace = workspaceObject.workspace(); std::vector<WorkspaceObject> _zoneControlThermostats; _zoneControlThermostats = workspace.getObjectsByType(IddObjectType::ZoneControl_Thermostat); for( const auto & _zoneControlThermostat : _zoneControlThermostats ) { if( boost::optional<std::string> zoneName = _zoneControlThermostat.getString( ZoneControl_ThermostatFields::ZoneorZoneListName ) ) { bool zoneControlThermostatfound = false; if( zoneName.get() == idfZoneName ) { zoneControlThermostatfound = true; } else if( boost::optional<WorkspaceObject> _zoneList = workspace.getObjectByTypeAndName(IddObjectType::ZoneList,zoneName.get()) ) { std::vector<IdfExtensibleGroup> zoneListGroup = _zoneList->extensibleGroups(); for( const auto & zoneListElem : zoneListGroup ) { boost::optional<std::string> zoneListZoneName = zoneListElem.getString(ZoneListExtensibleFields::ZoneName); if( zoneListZoneName ) { if( zoneListZoneName.get() == idfZoneName ) { zoneControlThermostatfound = true; } break; } } } if( zoneControlThermostatfound ) { std::vector<IdfExtensibleGroup> extensibleGroups = _zoneControlThermostat.extensibleGroups(); for( const auto & extensibleGroup : extensibleGroups ) { boost::optional<std::string> thermostatType = extensibleGroup.getString(ZoneControl_ThermostatExtensibleFields::ControlObjectType); boost::optional<std::string> thermostatName = extensibleGroup.getString(ZoneControl_ThermostatExtensibleFields::ControlName); if( thermostatName && thermostatType ) { boost::optional<WorkspaceObject> _thermostat = workspace.getObjectByTypeAndName(IddObjectType(thermostatType.get()),thermostatName.get()); if( _thermostat ) { boost::optional<ModelObject> thermostat = translateAndMapWorkspaceObject(_thermostat.get()); if( thermostat ) { if( boost::optional<ThermostatSetpointDualSetpoint> thermostatSetpointDualSetpoint = thermostat->optionalCast<ThermostatSetpointDualSetpoint>() ) { thermalZone.setThermostatSetpointDualSetpoint(thermostatSetpointDualSetpoint.get()); } } } } } break; } } } } // Zone Equipment /* if( idfZoneName ) { std::vector<WorkspaceObject> zoneHVACEquipmentConnections; zoneHVACEquipmentConnections = workspaceObject.workspace().getObjectsByType(IddObjectType::ZoneHVAC_EquipmentConnections); for( std::vector<WorkspaceObject>::iterator it = zoneHVACEquipmentConnections.begin(); it != zoneHVACEquipmentConnections.end(); it++ ) { s = it->getString(ZoneHVAC_EquipmentConnectionsFields::ZoneName); if( s && istringEqual(s.get(),idfZoneName.get()) ) { boost::optional<WorkspaceObject> _zoneEquipmentList = it->getTarget(ZoneHVAC_EquipmentConnectionsFields::ZoneConditioningEquipmentListName); if( _zoneEquipmentList ) { translateAndMapWorkspaceObject(_zoneEquipmentList.get()); } break; } } } */ return space; }
OptionalModelObject ReverseTranslator::translateAirLoopHVACOutdoorAirSystem( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::AirLoopHVAC_OutdoorAirSystem ) { LOG(Error, "WorkspaceObject is not IddObjectType: AirLoopHVAC_OutdoorAirSystem"); return boost::none; } Workspace _workspace = workspaceObject.workspace(); boost::optional<WorkspaceObject> _controllerList; boost::optional<WorkspaceObject> _controllerOutdoorAir; boost::optional<std::string> controllerName; boost::optional<std::string> controllerType; boost::optional<ControllerOutdoorAir> oaController; _controllerList = workspaceObject.getTarget(AirLoopHVAC_OutdoorAirSystemFields::ControllerListName); if( _controllerList ) { for( int i = 1; _controllerList->getString(i); i = i + 2 ) { controllerType = _controllerList->getString(i); controllerName = _controllerList->getString(i + 1); if( controllerType ) { if( istringEqual(controllerType.get(),"Controller:OutdoorAir") ) { break; } } } } if( controllerName && controllerType ) { boost::optional<WorkspaceObject> wo = _workspace.getObjectByTypeAndName(IddObjectType(controllerType.get()),controllerName.get()); if( wo ) { boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(wo.get()); if( mo ) { oaController = mo->optionalCast<ControllerOutdoorAir>(); } } } if( oaController ) { AirLoopHVACOutdoorAirSystem mo(m_model,oaController.get()); boost::optional<std::string> name = workspaceObject.getString(AirLoopHVAC_OutdoorAirSystemFields::Name); if( name ) { mo.setName(name.get()); } Node outboardOANode = mo.outboardOANode().get(); boost::optional<WorkspaceObject> _oaEquipmentList; boost::optional<WorkspaceObject> _outdoorAirMixer; std::vector<WorkspaceObject> equipmentVector; _oaEquipmentList = workspaceObject.getTarget(AirLoopHVAC_OutdoorAirSystemFields::OutdoorAirEquipmentListName); if( _oaEquipmentList ) { for( int i = 1; _oaEquipmentList->getString(i); i = i + 2 ) { boost::optional<std::string> equipmentName; boost::optional<std::string> equipmentType; equipmentType = _oaEquipmentList->getString(i); equipmentName = _oaEquipmentList->getString(i + 1); if( equipmentName && equipmentType ) { boost::optional<WorkspaceObject> wo = _workspace.getObjectByTypeAndName(IddObjectType(equipmentType.get()),equipmentName.get()); if( wo ) { equipmentVector.push_back(wo.get()); if( wo->iddObject().type() == IddObjectType::OutdoorAir_Mixer ) { _outdoorAirMixer = wo; } } } } if( _outdoorAirMixer ) { boost::optional<std::string> mixerOAInletNodeName = _outdoorAirMixer->getString(OutdoorAir_MixerFields::OutdoorAirStreamNodeName); boost::optional<std::string> mixerOAReliefNodeName = _outdoorAirMixer->getString(OutdoorAir_MixerFields::ReliefAirStreamNodeName); if( mixerOAInletNodeName ) { mo.outdoorAirModelObject()->cast<Node>().setName(mixerOAInletNodeName.get()); } if( mixerOAReliefNodeName ) { mo.reliefAirModelObject()->cast<Node>().setName(mixerOAReliefNodeName.get()); } boost::optional<std::string> oaStreamInletNodeName; boost::optional<std::string> oaStreamOutletNodeName; oaStreamInletNodeName = _outdoorAirMixer->getString(OutdoorAir_MixerFields::OutdoorAirStreamNodeName); while( oaStreamInletNodeName ) { boost::optional<ModelObject> oaComponentModelObject; boost::optional<std::string> newOAStreamInletNodeName; for( std::vector<WorkspaceObject>::iterator it = equipmentVector.begin(); it < equipmentVector.end(); it++ ) { switch(it->iddObject().type().value()) { case openstudio::IddObjectType::EvaporativeCooler_Direct_ResearchSpecial : { oaStreamOutletNodeName = it->getString(EvaporativeCooler_Direct_ResearchSpecialFields::AirOutletNodeName); if( oaStreamOutletNodeName ) { if( istringEqual(oaStreamOutletNodeName.get(),oaStreamInletNodeName.get()) ) { newOAStreamInletNodeName = it->getString(EvaporativeCooler_Direct_ResearchSpecialFields::AirInletNodeName); oaComponentModelObject = translateAndMapWorkspaceObject(*it); } } break; } default : { break; } } if( newOAStreamInletNodeName ) { break; } } oaStreamInletNodeName = newOAStreamInletNodeName; if( oaComponentModelObject ) { bool success = false; if( boost::optional<HVACComponent> hvacComponent = oaComponentModelObject->optionalCast<HVACComponent>() ) { success = hvacComponent->addToNode(outboardOANode); if( success ) { if( boost::optional<StraightComponent> straightComponent = hvacComponent->optionalCast<StraightComponent>() ) { if( oaStreamInletNodeName ) { straightComponent->inletModelObject()->cast<Node>().setName(oaStreamInletNodeName.get()); } if( oaStreamOutletNodeName ) { straightComponent->outletModelObject()->cast<Node>().setName(oaStreamOutletNodeName.get()); } } } } if( ! success ) { oaComponentModelObject->remove(); } } } } } return mo; } else { return boost::none; } }
OptionalModelObject ReverseTranslator::translateZoneHVACEquipmentList( const WorkspaceObject & workspaceObject ) { if(workspaceObject.iddObject().type() != IddObjectType::ZoneHVAC_EquipmentList){ LOG(Error, "WorkspaceObject is not IddObjectType: ZoneHVAC:EquipmentList"); return boost::none; } boost::optional<openstudio::model::ThermalZone> thermalZone; std::vector<WorkspaceObject> zoneHVACEquipmentConnections = workspaceObject.getSources(IddObjectType::ZoneHVAC_EquipmentConnections); if (zoneHVACEquipmentConnections.size() == 0){ LOG(Error,"No ZoneHVAC:EquipmentConnections object associated with a zone. Check that IDF file is correct."); return boost::none; }else if (zoneHVACEquipmentConnections.size() > 1){ LOG(Error,"More than 1 ZoneHVAC:EquipmentConnections objects associated with a zone. Check that IDF file is correct."); return boost::none; } for( const auto & zoneHVACEquipmentConnection : zoneHVACEquipmentConnections ) { if( boost::optional<std::string> name = zoneHVACEquipmentConnection.getString(ZoneHVAC_EquipmentConnectionsFields::ZoneName) ) { boost::optional<model::Space> space = m_model.getModelObjectByName<model::Space>(name.get()); if( space ) { thermalZone = space->thermalZone(); } } } // get extensible groups for zone HVAC equipment list std::vector<IdfExtensibleGroup> extensibleGroups = workspaceObject.extensibleGroups(); // loop over extensible groups unsigned n = extensibleGroups.size(); for (unsigned i = 0; i < n; ++i){ // define variables boost::optional<openstudio::model::ZoneHVACComponent> zoneHVACComponent; // get zone equipment object type and zone equipment object name from extensible group boost::optional<std::string> zoneEquipmentObjectType = extensibleGroups[i].getString(ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentObjectType); boost::optional<std::string> zoneEquipmentName = extensibleGroups[i].getString(ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentName); // get zone equipment workspace object by type and name if (zoneEquipmentObjectType && zoneEquipmentName){ OptionalWorkspaceObject zoneEquipmentWorkspaceObject = workspaceObject.workspace().getObjectByTypeAndName(IddObjectType(*zoneEquipmentObjectType),*zoneEquipmentName); // translate zone equipment workspace object if (zoneEquipmentWorkspaceObject){ OptionalModelObject zoneEquipmentModelObject = translateAndMapWorkspaceObject(*zoneEquipmentWorkspaceObject); // cast zone equipment model object to zone HVAC component if (zoneEquipmentModelObject){ zoneHVACComponent = zoneEquipmentModelObject->optionalCast<ZoneHVACComponent>(); } } } // add to thermal zone if (zoneHVACComponent && thermalZone){ zoneHVACComponent->addToThermalZone(*thermalZone); } } return boost::none; }
void WorkspaceWatcher::onObjectRemove(const WorkspaceObject& removedObject) { OS_ASSERT(removedObject.initialized()); OS_ASSERT(removedObject.workspace().isMember(removedObject.handle())); }
void WorkspaceWatcher::onObjectAdd(const WorkspaceObject& addedObject) { OS_ASSERT(addedObject.initialized()); OS_ASSERT(addedObject.workspace().isMember(addedObject.handle())); }
OptionalModelObject ReverseTranslator::translateAirLoopHVAC( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::AirLoopHVAC ) { LOG(Error, "WorkspaceObject is not IddObjectType: AirLoopHVAC"); return boost::none; } OptionalModelObject result; boost::optional<double> val; boost::optional<std::string> optionalString; Workspace _workspace = workspaceObject.workspace(); openstudio::model::AirLoopHVAC airLoopHVAC( m_model ); boost::optional<std::string> supplyInletNodeName = workspaceObject.getString(AirLoopHVACFields::SupplySideInletNodeName); boost::optional<std::string> supplyOutletNodeName = workspaceObject.getString(AirLoopHVACFields::SupplySideOutletNodeNames); boost::optional<std::string> demandInletNodeName = workspaceObject.getString(AirLoopHVACFields::DemandSideInletNodeNames); boost::optional<std::string> demandOutletNodeName = workspaceObject.getString(AirLoopHVACFields::DemandSideOutletNodeName); Node supplyInletNode = airLoopHVAC.supplyInletNode(); Node supplyOutletNode = airLoopHVAC.supplyOutletNode(); Node demandInletNode = airLoopHVAC.demandInletNode(); Node demandOutletNode = airLoopHVAC.demandOutletNode(); if( supplyInletNodeName ) { supplyInletNode.setName(supplyInletNodeName.get()); } if( supplyOutletNodeName ) { supplyOutletNode.setName(supplyOutletNodeName.get()); } if( demandInletNodeName ) { demandInletNode.setName(demandInletNodeName.get()); } if( demandOutletNodeName ) { demandOutletNode.setName(demandOutletNodeName.get()); } optionalString = workspaceObject.getString(AirLoopHVACFields::Name); if( optionalString ) { airLoopHVAC.setName(optionalString.get()); } optionalString = workspaceObject.getString(AirLoopHVACFields::DesignSupplyAirFlowRate); if( optionalString && istringEqual(optionalString.get(),"AutoSize") ) { airLoopHVAC.autosizeDesignSupplyAirFlowRate(); } else if( (val = workspaceObject.getDouble(AirLoopHVACFields::DesignSupplyAirFlowRate)) ) { airLoopHVAC.setDesignSupplyAirFlowRate(val.get()); } // Go find the supply branch. // Currently only supporting one supply branch. // Dual ducts are not supported. OptionalWorkspaceObject _supplyBranchList; OptionalWorkspaceObject _supplyBranch; _supplyBranchList = workspaceObject.getTarget(AirLoopHVACFields::BranchListName); if( _supplyBranchList ) { _supplyBranch = _supplyBranchList->getExtensibleGroup(0).cast<WorkspaceExtensibleGroup>().getTarget(BranchListExtensibleFields::BranchName); if( ! _supplyBranch ) { LOG(Error, _supplyBranchList->briefDescription() << ": Missing supply branch"); } else { // March through the equipment on the supply branch and convert them. for( unsigned i = 0; ! _supplyBranch->getExtensibleGroup(i).empty(); i++ ) { WorkspaceExtensibleGroup eg = _supplyBranch->getExtensibleGroup(i).cast<WorkspaceExtensibleGroup>(); boost::optional<std::string> componentName = eg.getString(BranchExtensibleFields::ComponentName); boost::optional<std::string> componentType = eg.getString(BranchExtensibleFields::ComponentObjectType); boost::optional<std::string> componentInletNodeName = eg.getString(BranchExtensibleFields::ComponentInletNodeName); boost::optional<std::string> componentOutletNodeName = eg.getString(BranchExtensibleFields::ComponentOutletNodeName); boost::optional<WorkspaceObject> wo; OptionalNode node; OptionalModelObject targetModelObject; if( componentName && (componentName.get() != "") && componentType && (componentType.get() != "") ) { IddObjectType iddType(componentType.get()); wo = _workspace.getObjectByTypeAndName(iddType,componentName.get()); } if( wo ) { targetModelObject = translateAndMapWorkspaceObject( wo.get() ); if( !targetModelObject) { LOG(Error, "Error importing object: " << wo->briefDescription() ); continue; } if( OptionalHVACComponent hvacComponent = targetModelObject->optionalCast<HVACComponent>() ) { Node node = airLoopHVAC.supplyOutletNode(); if( hvacComponent->addToNode(node) ) { if( boost::optional<StraightComponent> straightComponent = hvacComponent->optionalCast<StraightComponent>() ) { Node outletNode = straightComponent->outletModelObject()->cast<Node>(); Node inletNode = straightComponent->inletModelObject()->cast<Node>(); if( componentOutletNodeName ) { outletNode.setName(componentOutletNodeName.get()); } if( componentInletNodeName ) { inletNode.setName(componentInletNodeName.get()); } } else if( boost::optional<AirLoopHVACOutdoorAirSystem> oaSystem = hvacComponent->optionalCast<AirLoopHVACOutdoorAirSystem>() ) { Node outletNode = oaSystem->mixedAirModelObject()->cast<Node>(); Node inletNode = oaSystem->returnAirModelObject()->cast<Node>(); if( componentOutletNodeName ) { outletNode.setName(componentOutletNodeName.get()); } if( componentInletNodeName ) { inletNode.setName(componentInletNodeName.get()); } } } } } else { LOG(Error, _supplyBranch->briefDescription() << ": Missing object listed at ComponentName " << i); } } } } else { LOG( Error, workspaceObject.briefDescription() << ": Missing supply branch list, " << "Supply equipment will be incomplete"); } // March through the zone on the demand side and add branches for them. if( demandOutletNodeName ) { // Find the zone mixer for this air loop std::vector<WorkspaceObject> _airLoopHVACZoneMixers; _airLoopHVACZoneMixers = workspaceObject.workspace().getObjectsByType(IddObjectType::AirLoopHVAC_ZoneMixer); boost::optional<WorkspaceObject> _airLoopHVACZoneMixer; for( const auto & elem : _airLoopHVACZoneMixers ) { boost::optional<std::string> mixerOutletNodeName; mixerOutletNodeName = elem.getString(AirLoopHVAC_ZoneMixerFields::OutletNodeName); if( mixerOutletNodeName && mixerOutletNodeName.get() == demandOutletNodeName.get() ) { _airLoopHVACZoneMixer = elem; break; } } if( _airLoopHVACZoneMixer ) { for( int i = 2; _airLoopHVACZoneMixer->getString(i); i++ ) { std::vector<WorkspaceObject> _zoneHVACEquipmentConnections; std::string mixerInletNodeName = _airLoopHVACZoneMixer->getString(i).get(); _zoneHVACEquipmentConnections = _workspace.getObjectsByType(IddObjectType::ZoneHVAC_EquipmentConnections); for( const auto & _zoneHVACEquipmentConnection : _zoneHVACEquipmentConnections ) { OptionalString returnAirNodeName = _zoneHVACEquipmentConnection.getString(ZoneHVAC_EquipmentConnectionsFields::ZoneReturnAirNodeName); OptionalString inletAirNodeName = _zoneHVACEquipmentConnection.getString(ZoneHVAC_EquipmentConnectionsFields::ZoneAirInletNodeorNodeListName); OptionalString zoneName = _zoneHVACEquipmentConnection.getString(ZoneHVAC_EquipmentConnectionsFields::ZoneName); OptionalString zoneEquipListName = _zoneHVACEquipmentConnection.getString(ZoneHVAC_EquipmentConnectionsFields::ZoneConditioningEquipmentListName); OptionalWorkspaceObject _zone; OptionalWorkspaceObject _zoneEquipmentList; OptionalWorkspaceObject _zoneEquipment; OptionalWorkspaceObject _airTerminal; if( returnAirNodeName && returnAirNodeName.get() == mixerInletNodeName && zoneName && zoneEquipListName ) { _zone = _workspace.getObjectByTypeAndName(IddObjectType::Zone,*zoneName); _zoneEquipmentList = _workspace.getObjectByTypeAndName(IddObjectType::ZoneHVAC_EquipmentList,zoneEquipListName.get()); if( ! _zone ) { LOG( Error, airLoopHVAC.briefDescription() << " is connected to a zone that does not exist." ); break; } if( ! _zoneEquipmentList ) { LOG( Error, _zone->briefDescription() << " does not have a zone equipment list, but it is attached to a loop." ); break; } for( int j = 1; (optionalString = _zoneEquipmentList->getString(j)); j = j + 4 ) { boost::optional<std::string> zoneEquipmentName = _zoneEquipmentList->getString(j+1) ; // Possible Zone Equipment // // ZoneHVAC:AirDistributionUnit // AirTerminal:SingleDuct:Uncontrolled // ZoneHVAC:EnergyRecoveryVentilator // ZoneHVAC:FourPipeFanCoil // ZoneHVAC:OutdoorAirUnit // ZoneHVAC:PackagedTerminalAirConditioner // ZoneHVAC:PackagedTerminalHeatPump // ZoneHVAC:UnitHeater // ZoneHVAC:UnitVentilator // ZoneHVAC:VentilatedSlab // ZoneHVAC:WaterToAirHeatPump // ZoneHVAC:WindowAirConditioner // ZoneHVAC:Baseboard:RadiantConvective:Electric // ZoneHVAC:Baseboard:RadiantConvective:Water // ZoneHVAC:Baseboard:RadiantConvective:Steam // ZoneHVAC:Baseboard:Convective:Electric // ZoneHVAC:Baseboard:Convective:Water // ZoneHVAC:HighTemperatureRadiant // ZoneHVAC:LowTemperatureRadiant:VariableFlow // ZoneHVAC:LowTemperatureRadiant:ConstantFlow // ZoneHVAC:LowTemperatureRadiant:Electric // ZoneHVAC:Dehumidifier:DX // ZoneHVAC:IdealLoadsAirSystem // Fan:ZoneExhaust // WaterHeater:HeatPump // if( zoneEquipmentName ) { if( istringEqual(optionalString.get(),"AirTerminal:SingleDuct:Uncontrolled") ) { _airTerminal = _workspace.getObjectByTypeAndName(IddObjectType::AirTerminal_SingleDuct_Uncontrolled,zoneEquipmentName.get()); break; } else if( istringEqual(optionalString.get(),"ZoneHVAC:AirDistributionUnit") ) { boost::optional<WorkspaceObject> _airDistributionUnit = _workspace.getObjectByTypeAndName(IddObjectType::ZoneHVAC_AirDistributionUnit,zoneEquipmentName.get()); if( _airDistributionUnit ) { boost::optional<std::string> airUnitName; boost::optional<std::string> airUnitType; airUnitType = _airDistributionUnit->getString(ZoneHVAC_AirDistributionUnitFields::AirTerminalObjectType); airUnitName = _airDistributionUnit->getString(ZoneHVAC_AirDistributionUnitFields::AirTerminalName); if( airUnitName && airUnitType ) { _airTerminal = _workspace.getObjectByTypeAndName(IddObjectType(airUnitType.get()),airUnitName.get()); } } break; } } } OptionalModelObject airTerminalModelObject; OptionalSpace space; OptionalStraightComponent straightComponent; OptionalThermalZone thermalZone; if( _airTerminal ) { airTerminalModelObject = translateAndMapWorkspaceObject( _airTerminal.get() ); } if( _zone ) { if( OptionalModelObject mo = translateAndMapWorkspaceObject( _zone.get() ) ) { space = mo->optionalCast<Space>(); } } if( space ) { thermalZone = space->thermalZone(); } if( airTerminalModelObject ) { straightComponent = airTerminalModelObject->optionalCast<StraightComponent>(); } bool success = false; if( straightComponent && thermalZone ) { success = airLoopHVAC.addBranchForZone(thermalZone.get(),straightComponent.get()); } else if( thermalZone ) { Model m; success = airLoopHVAC.addBranchForZone(thermalZone.get(),boost::none); } if( success ) { if( inletAirNodeName ) { thermalZone->inletPortList().airLoopHVACModelObject()->cast<Node>().setName(inletAirNodeName.get()); } if( returnAirNodeName ) { thermalZone->returnAirModelObject()->cast<Node>().setName(returnAirNodeName.get()); } } } } } } } return airLoopHVAC; }