TEST_F(IdfFixture,WorkspaceObject_Construction) {
// get vector of IdfFile objects as fodder for tests
IdfObjectVector idfObjects = epIdfFile.objects();
OptionalWorkspaceObject w;
OptionalHandleVector hv;
// construct empty workspace, and set Idd to be EnergyPlusIdd
StrictnessLevel level(StrictnessLevel::Draft);
IddFileType fileType(IddFileType::EnergyPlus);
Workspace ws(level,fileType);
// add object with no pointers. should be successful.
w = ws.addObject(idfObjects[0]); // Building
ASSERT_TRUE(w); // should return OptionalHandle instead
OptionalWorkspaceObject object = ws.getObject(w->handle());
ASSERT_TRUE(object);
EXPECT_TRUE(object->iddObject().type() == openstudio::IddObjectType::Building);
// add object with pointer, and do not include pointed to object. should be successful, but
// pointer should be null. object.canBeSource() should be true.
// add object with pointer, and do include pointed to object. should be successful, and
// following pointer should yield target object. source should be source, target should be
// target.
}
boost::optional<IddObjectType> WorkspaceObjectOrder_Impl::getIddObjectType(
const Handle& handle) const
{
OS_ASSERT(m_objectGetter);
OptionalWorkspaceObject object = m_objectGetter(handle);
if (object) { return object->iddObject().type(); }
else { return boost::none; }
}
TEST_F(IdfFixture, WorkspaceObject_Lights) {
Workspace workspace(epIdfFile, StrictnessLevel::Draft);
OptionalWorkspaceObject light = workspace.getObjectByTypeAndName(IddObjectType::Lights, "SPACE1-1 Lights 1");
ASSERT_TRUE(light);
OptionalString lightsZoneName = light->getString(LightsFields::ZoneorZoneListName);
ASSERT_TRUE(lightsZoneName);
OptionalString lightsScheduleName = light->getString(LightsFields::ScheduleName);
ASSERT_TRUE(lightsScheduleName);
OptionalWorkspaceObject zone = light->getTarget(LightsFields::ZoneorZoneListName);
ASSERT_TRUE(zone);
OptionalString zoneName = zone->getString(ZoneFields::Name);
ASSERT_TRUE(zoneName);
EXPECT_EQ(*lightsZoneName, *zoneName);
OptionalWorkspaceObject schedule = light->getTarget(LightsFields::ScheduleName);
ASSERT_TRUE(schedule);
EXPECT_EQ(IddObjectType::Schedule_Compact, schedule->iddObject().type().value());
OptionalString scheduleName = schedule->getString(Schedule_CompactFields::Name);
ASSERT_TRUE(scheduleName);
EXPECT_EQ(*lightsScheduleName, *scheduleName);
// now change name of zone and schedule and make sure string reference in light change as well
EXPECT_TRUE(zone->setString(ZoneFields::Name, "New Zone Name"));
zoneName = zone->getString(ZoneFields::Name);
ASSERT_TRUE(zoneName);
EXPECT_EQ("New Zone Name", *zoneName);
lightsZoneName = light->getString(LightsFields::ZoneorZoneListName);
ASSERT_TRUE(lightsZoneName);
EXPECT_EQ(*lightsZoneName, *zoneName);
EXPECT_TRUE(zone->createName());
zoneName = zone->getString(ZoneFields::Name);
ASSERT_TRUE(zoneName);
EXPECT_EQ("Zone 1",*zoneName);
lightsZoneName = light->getString(LightsFields::ZoneorZoneListName);
ASSERT_TRUE(lightsZoneName);
EXPECT_EQ(*lightsZoneName, *zoneName);
EXPECT_TRUE(schedule->setString(Schedule_CompactFields::Name, "New Schedule Name"));
scheduleName = schedule->getString(Schedule_CompactFields::Name);
ASSERT_TRUE(scheduleName);
EXPECT_EQ("New Schedule Name", *scheduleName);
lightsScheduleName = light->getString(LightsFields::ScheduleName);
ASSERT_TRUE(lightsScheduleName);
EXPECT_EQ(*lightsScheduleName, *scheduleName);
}
TEST_F(IdfFixture, WorkspaceObject_GetStringAfterSetStringAddsFields)
{
// construct empty workspace, and set Idd to be EnergyPlusIdd
StrictnessLevel level(StrictnessLevel::Draft);
IddFileType fileType(IddFileType::EnergyPlus);
Workspace ws(level,fileType);
OptionalWorkspaceObject w;
IdfObject idfObj(IddObjectType::SurfaceProperty_ConvectionCoefficients);
w = ws.addObject(idfObj);
EXPECT_TRUE(w->numNonextensibleFields()==3);
EXPECT_TRUE(w->setString(w->iddObject().numFields()-1,""));
EXPECT_TRUE(w->numNonextensibleFields()==11);
OptionalString s4 = w->getString(4,true);
EXPECT_TRUE(s4);
OptionalString s10 = w->getString(10,true);
EXPECT_TRUE(s10);
}
OptionalModelObject ReverseTranslator::translateFenestrationSurfaceDetailed( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::FenestrationSurface_Detailed ){
LOG(Error, "WorkspaceObject is not IddObjectType: Site:FenestrationSurface_Detailed");
return boost::none;
}
openstudio::Point3dVector vertices = getVertices(FenestrationSurface_DetailedFields::NumberofVertices + 1, workspaceObject);
boost::optional<SubSurface> subSurface;
try{
subSurface = SubSurface(vertices, m_model);
}catch(const std::exception&){
LOG(Error, "Cannot create SubSurface for object: " << workspaceObject);
return boost::none;
}
OptionalString s = workspaceObject.name();
if(s) {
subSurface->setName(*s);
}
OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::FenestrationSurface_DetailedFields::ConstructionName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ConstructionBase>()){
subSurface->setConstruction(modelObject->cast<ConstructionBase>());
}
}
}
target = workspaceObject.getTarget(openstudio::FenestrationSurface_DetailedFields::BuildingSurfaceName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<Surface>()){
subSurface->setSurface(modelObject->cast<Surface>());
}
}
}
// needs to be after .setSurface.
s = workspaceObject.getString(FenestrationSurface_DetailedFields::SurfaceType);
if (s) {
if (istringEqual("Window", *s)){
s = "FixedWindow";
boost::optional<Surface> surface = subSurface->surface();
if (surface){
if ((surface->surfaceType() == "RoofCeiling") &&
(surface->outsideBoundaryCondition() == "Outdoors")){
s = "Skylight";
}
}
}
subSurface->setSubSurfaceType(*s);
}
target = workspaceObject.getTarget(openstudio::FenestrationSurface_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>();
OptionalSurface surface = subSurface->surface();
if (surface && surface->space()){
Space space = surface->space().get();
if (surface->adjacentSurface()){
Surface adjacentSurface = surface->adjacentSurface().get();
if (adjacentSurface.space() && adjacentSpace.handle() == adjacentSurface.space()->handle()){
Transformation transformation = adjacentSpace.transformation().inverse()*surface->space()->transformation();
// duplicate subsurface in other space
SubSurface adjacentSubSurface = subSurface->clone(m_model).cast<SubSurface>();
adjacentSubSurface.setName(subSurface->name().get() + " Reversed");
std::reverse(vertices.begin(), vertices.end());
adjacentSubSurface.setVertices(transformation*vertices);
adjacentSubSurface.setSurface(adjacentSurface);
subSurface->setAdjacentSubSurface(adjacentSubSurface);
return subSurface.get();
}
}
}
}
}else if (target->iddObject().type() == IddObjectType::FenestrationSurface_Detailed){
// SubSurface boundary condition
// see if we have already mapped other sub surface, don't do it here because that is circular
auto it = m_workspaceToModelMap.find(target->handle());
if( it != m_workspaceToModelMap.end()){
if (it->second.optionalCast<SubSurface>()){
// this will set other side boundary object on both surfaces
SubSurface adjacentSubSurface = it->second.cast<SubSurface>();
subSurface->setAdjacentSubSurface(adjacentSubSurface);
return subSurface.get();
}
}
}else{
LOG(Error, "OutsideBoundaryConditionObject not yet mapped for object of type " << target->iddObject().name());
}
}
// DLM: should these be before control paths that return above?
OptionalDouble d = workspaceObject.getDouble(FenestrationSurface_DetailedFields::ViewFactortoGround);
if (d) {
subSurface->setViewFactortoGround(*d);
}
target = workspaceObject.getTarget(openstudio::FenestrationSurface_DetailedFields::ShadingControlName);
if (target){
LOG(Warn, "Shading Control Name not yet mapped for FenestrationSurface:Detailed");
}
target = workspaceObject.getTarget(openstudio::FenestrationSurface_DetailedFields::FrameandDividerName);
if (target){
LOG(Warn, "Frame and Divider Name not yet mapped for FenestrationSurface:Detailed");
}
OptionalInt i = workspaceObject.getInt(FenestrationSurface_DetailedFields::Multiplier);
if (i) {
subSurface->setMultiplier(*i);
}
return subSurface.get();
}
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();
}
