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