OptionalModelObject ReverseTranslator::translateBuildingSurfaceDetailed( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::BuildingSurface_Detailed ){ LOG(Error, "WorkspaceObject is not IddObjectType: BuildingSurface:Detailed"); return boost::none; } openstudio::Point3dVector vertices = getVertices(BuildingSurface_DetailedFields::NumberofVertices + 1, workspaceObject); boost::optional<Surface> surface; try{ surface = Surface(vertices, m_model); }catch(const std::exception&){ LOG(Error, "Cannot create Surface for object: " << workspaceObject); return boost::none; } OptionalString s = workspaceObject.name(); if(s) { surface->setName(*s); } OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::BuildingSurface_DetailedFields::ConstructionName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ConstructionBase>()){ surface->setConstruction(modelObject->cast<ConstructionBase>()); } } } target = workspaceObject.getTarget(openstudio::BuildingSurface_DetailedFields::ZoneName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<Space>()){ surface->setSpace(modelObject->cast<Space>()); } } } s = workspaceObject.getString(BuildingSurface_DetailedFields::SurfaceType); if (s) { if (istringEqual("Roof", *s) || istringEqual("Ceiling", *s)){ s = "RoofCeiling"; } surface->setSurfaceType(*s); } //std::string surfaceType = surface->surfaceType(); s = workspaceObject.getString(BuildingSurface_DetailedFields::SunExposure); if (s) { surface->setSunExposure(*s); } s = workspaceObject.getString(BuildingSurface_DetailedFields::WindExposure); if (s) { surface->setWindExposure(*s); } OptionalDouble d = workspaceObject.getDouble(BuildingSurface_DetailedFields::ViewFactortoGround); if (d) { surface->setViewFactortoGround(*d); } target = workspaceObject.getTarget(openstudio::BuildingSurface_DetailedFields::OutsideBoundaryConditionObject); if (target){ if (target->iddObject().type() == IddObjectType::Zone){ // Zone boundary condition OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if(modelObject->optionalCast<Space>()){ Space adjacentSpace = modelObject->cast<Space>(); if (surface->space()){ // insert this surface in the map so subsurface translation can find it m_workspaceToModelMap.insert(std::make_pair(workspaceObject.handle(), surface.get())); // need to translate all sub surfaces here so they will be in adjacent space for (const WorkspaceObject& workspaceSubSurface : workspaceObject.getSources(IddObjectType::FenestrationSurface_Detailed)){ translateAndMapWorkspaceObject(workspaceSubSurface); } // create adjacent surface in other space surface->createAdjacentSurface(adjacentSpace); return surface.get(); } } }else if (target->iddObject().type() == IddObjectType::BuildingSurface_Detailed){ // Surface boundary condition // see if we have already mapped other surface, don't do it here because that is circular if (target->handle() == workspaceObject.handle() ){ // these objects are the same, set boundary condition to adiabatic surface->setOutsideBoundaryCondition("Adiabatic"); return surface.get(); }else{ auto it = m_workspaceToModelMap.find(target->handle()); if( it != m_workspaceToModelMap.end()){ if (it->second.optionalCast<Surface>()){ // this will set other side boundary object on both surfaces Surface adjacentSurface = it->second.cast<Surface>(); surface->setAdjacentSurface(adjacentSurface); return surface.get(); } } } }else{ LOG(Error, "OutsideBoundaryConditionObject not yet mapped for object of type " << target->iddObject().name()); } } s = workspaceObject.getString(BuildingSurface_DetailedFields::OutsideBoundaryCondition); if (s) { surface->setOutsideBoundaryCondition(*s); } return surface.get(); }
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; }