TEST_F(IdfFixture,WorkspaceObjectWatcher_RelationshipFieldChanges_TargetDeleted) { IdfObject object(IddObjectType::Lights); Workspace workspace(StrictnessLevel::Draft, IddFileType::EnergyPlus); OptionalWorkspaceObject owo = workspace.addObject(object); ASSERT_TRUE(owo); WorkspaceObject workspaceObject = *owo; WorkspaceObjectWatcher watcher(workspaceObject); EXPECT_FALSE(watcher.dirty()); OptionalWorkspaceObject oZone = workspace.addObject(IdfObject(IddObjectType::Zone)); ASSERT_TRUE(oZone); EXPECT_TRUE(workspaceObject.setPointer(LightsFields::ZoneorZoneListName, oZone->handle())); EXPECT_TRUE(watcher.dirty()); EXPECT_FALSE(watcher.dataChanged()); EXPECT_FALSE(watcher.nameChanged()); EXPECT_TRUE(watcher.relationshipChanged()); watcher.clearState(); EXPECT_FALSE(watcher.dirty()); EXPECT_FALSE(watcher.dataChanged()); EXPECT_FALSE(watcher.nameChanged()); EXPECT_FALSE(watcher.relationshipChanged()); oZone->remove(); EXPECT_TRUE(watcher.dirty()); EXPECT_FALSE(watcher.dataChanged()); EXPECT_FALSE(watcher.nameChanged()); EXPECT_TRUE(watcher.relationshipChanged()); }
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(EnergyPlusFixture,ReverseTranslator_EmptyIdfFile) { Workspace inWorkspace(StrictnessLevel::Draft,IddFileType::EnergyPlus); ReverseTranslator reverseTranslator; Model model = reverseTranslator.translateWorkspace(inWorkspace); OptionalWorkspaceObject w = inWorkspace.addObject(IdfObject(IddObjectType::Version)); ASSERT_TRUE(w); EXPECT_TRUE(w->setString(VersionFields::VersionIdentifier, "7.0")); model = reverseTranslator.translateWorkspace(inWorkspace); EXPECT_TRUE(w->setString(VersionFields::VersionIdentifier, "5.0")); model = reverseTranslator.translateWorkspace(inWorkspace); }
TEST_F(IdfFixture, WorkspaceObject_Filter_Sources) { Workspace ws; OptionalWorkspaceObject node = ws.addObject(IdfObject(IddObjectType::OS_Node)); OptionalWorkspaceObject node2 = ws.addObject(IdfObject(IddObjectType::OS_Node)); OptionalWorkspaceObject node3 = ws.addObject(IdfObject(IddObjectType::OS_Node)); OptionalWorkspaceObject spm = ws.addObject(IdfObject(IddObjectType::OS_SetpointManager_MixedAir)); EXPECT_TRUE(spm->setPointer(OS_SetpointManager_MixedAirFields::SetpointNodeorNodeListName, node->handle())); EXPECT_TRUE(spm->setPointer(OS_SetpointManager_MixedAirFields::FanInletNodeName,node->handle())); EXPECT_TRUE(spm->setPointer(OS_SetpointManager_MixedAirFields::FanOutletNodeName,node2->handle())); EXPECT_TRUE(spm->setPointer(OS_SetpointManager_MixedAirFields::ReferenceSetpointNodeName,node3->handle())); WorkspaceObjectVector sourcesVector = node->sources(); EXPECT_EQ(1, sourcesVector.size()); sourcesVector = node->getSources(IddObjectType::OS_SetpointManager_MixedAir); EXPECT_EQ(1, sourcesVector.size()); }
TEST_F(EnergyPlusFixture,ReverseTranslator_Zone) { Workspace inWorkspace(StrictnessLevel::None, IddFileType::EnergyPlus); OptionalWorkspaceObject zoneObject = inWorkspace.addObject(IdfObject(IddObjectType::Zone)); ASSERT_TRUE(zoneObject); OptionalWorkspaceObject lightsObject = inWorkspace.addObject(IdfObject(IddObjectType::Lights)); ASSERT_TRUE(lightsObject); EXPECT_TRUE(lightsObject->setPointer(openstudio::LightsFields::ZoneorZoneListName, zoneObject->handle())); ReverseTranslator reverseTranslator; ASSERT_NO_THROW(reverseTranslator.translateWorkspace(inWorkspace)); Model model = reverseTranslator.translateWorkspace(inWorkspace); ASSERT_EQ(static_cast<unsigned>(1), model.getModelObjects<openstudio::model::ThermalZone>().size()); openstudio::model::ThermalZone zone = model.getModelObjects<openstudio::model::ThermalZone>()[0]; ASSERT_EQ(static_cast<unsigned>(1), model.getModelObjects<openstudio::model::Space>().size()); openstudio::model::Space space = model.getModelObjects<openstudio::model::Space>()[0]; ASSERT_EQ(static_cast<unsigned>(1), model.getModelObjects<openstudio::model::Lights>().size()); openstudio::model::Lights lights = model.getModelObjects<openstudio::model::Lights>()[0]; ASSERT_TRUE(lights.space()); EXPECT_TRUE(space.handle() == lights.space()->handle()); ASSERT_TRUE(lights.space()->thermalZone()); EXPECT_TRUE(zone.handle() == lights.space()->thermalZone()->handle()); }
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); }
TEST_F(IdfFixture, WorkspaceObject_FieldSettingWithHiddenPushes) { Workspace scratch(StrictnessLevel::None,IddFileType::EnergyPlus); // Strictness level None std::stringstream text; text << "ZoneHVAC:HighTemperatureRadiant," << std::endl << " MyRadiantSystem," << std::endl << " MyHVACSchedule," << std::endl << " MyCoreZone," << std::endl << " HeatingDesignCapacity," << std::endl << " Autosize," << std::endl << " ," << std::endl << " ," << std::endl << " Electricity;"; OptionalIdfObject oObj = IdfObject::load(text.str()); ASSERT_TRUE(oObj); IdfObject idfObject = *oObj; OptionalWorkspaceObject w1 = scratch.addObject(idfObject); ASSERT_TRUE(w1); OptionalWorkspaceObject tObject = scratch.getObject(w1->handle ()); ASSERT_TRUE(tObject); WorkspaceObject object = *tObject; EXPECT_EQ(static_cast<unsigned>(8),object.numFields()); // create schedule object to point to from non-extensible field text.str(""); text << "Schedule:Compact," << std::endl << " AlwaysOn," << std::endl << " ," << std::endl << " For: AllOtherDays," << std::endl << " Until: 24:00," << std::endl << " 1.0;"; oObj = IdfObject::load(text.str()); ASSERT_TRUE(oObj); idfObject = *oObj; ASSERT_TRUE(idfObject.iddObject().type() == IddObjectType::Schedule_Compact); OptionalWorkspaceObject w2 = scratch.addObject(idfObject); ASSERT_TRUE(w2); EXPECT_TRUE(object.setPointer(14,w2->handle ())); EXPECT_EQ(15u,object.numFields()); tObject = object.getTarget(14); ASSERT_TRUE(tObject); EXPECT_TRUE(tObject->handle() == w2->handle()); // hidden pushing for setting extensible string pointer EXPECT_TRUE(object.setString(16,*(tObject->name()))); // should only work at strictness none tObject = object.getTarget(16); ASSERT_TRUE(tObject); EXPECT_TRUE(tObject->handle() == w2->handle()); EXPECT_EQ(18u,object.numFields()); // hidden pushing for setting extensible double EXPECT_TRUE(object.setDouble(19,0.5)); EXPECT_EQ(20u,object.numFields()); OptionalDouble dValue = object.getDouble(19); ASSERT_TRUE(dValue); EXPECT_NEAR(0.5,*dValue,tol); // SHOULD NOT BE VALID scratch = Workspace(StrictnessLevel::Draft, IddFileType::EnergyPlus); // Non-null data must be valid text.str(""); text << "ZoneHVAC:HighTemperatureRadiant," << std::endl << " MyRadiantSystem," << std::endl << " MyHVACSchedule," << std::endl << " MyCoreZone," << std::endl << " HeatingDesignCapacity," << std::endl << " Autosize," << std::endl << " ," << std::endl << " ," << std::endl << " Electricity;"; oObj = IdfObject::load(text.str()); ASSERT_TRUE(oObj); idfObject = *oObj; w2 = scratch.addObject(idfObject); ASSERT_TRUE(w2); tObject = scratch.getObject(w2->handle()); ASSERT_TRUE(tObject); object = *tObject; // hidden pushing for setting nonextensible double EXPECT_FALSE(object.setDouble(9,1.5)); EXPECT_EQ(8u,object.numFields()); EXPECT_TRUE(object.setDouble(9,0.6)); EXPECT_EQ(10u,object.numFields()); // hidden pushing for setting nonextensible string EXPECT_FALSE(object.setString(12,"bad key")); EXPECT_EQ(10u,object.numFields()); EXPECT_TRUE(object.setString(12,"MeanAirTemperature")); EXPECT_EQ(13u,object.numFields()); // hidden pushing for setting nonextensible pointer EXPECT_TRUE(object.setString(14,"")); EXPECT_EQ(15u,object.numFields()); // hidden pushing for setting extensible string pointer EXPECT_FALSE(object.setString(16,"MySurface")); EXPECT_EQ(15u,object.numFields()); EXPECT_TRUE(object.setString(16,"")); EXPECT_EQ(18u,object.numFields()); // hidden pushing for setting extensible double EXPECT_FALSE(object.setDouble(21,-1.5)); EXPECT_EQ(18u,object.numFields()); EXPECT_TRUE(object.setDouble(19,0.5)); EXPECT_EQ(20u,object.numFields()); }
TEST_F(IdfFixture, WorkspaceObject_Lights_Strictness_Draft) { Workspace workspace(StrictnessLevel::Draft,IddFileType::EnergyPlus); EXPECT_TRUE(workspace.isValid()); OptionalWorkspaceObject w = workspace.addObject(IdfObject(IddObjectType::Lights)); ASSERT_TRUE(w); OptionalWorkspaceObject light = workspace.getObject(w->handle()); ASSERT_TRUE(light); // certain things we can't invalidate EXPECT_TRUE(light->setString(LightsFields::Name, "")); EXPECT_TRUE(light->setDouble(LightsFields::Name, 0)); EXPECT_TRUE(light->setString(LightsFields::ZoneorZoneListName, "")); // PointerType error EXPECT_TRUE(light->setPointer(LightsFields::ZoneorZoneListName, Handle())); // PointerType error EXPECT_TRUE(light->setString(LightsFields::ScheduleName, "")); // PointerType error EXPECT_TRUE(light->setPointer(LightsFields::ScheduleName, Handle())); // PointerType error EXPECT_TRUE(light->setString(LightsFields::DesignLevelCalculationMethod, "")); // this is ok because there is a default EXPECT_FALSE(light->setString(LightsFields::DesignLevelCalculationMethod, "Hi")); // DataType error EXPECT_FALSE(light->setDouble(LightsFields::DesignLevelCalculationMethod, 0)); // DataType error EXPECT_FALSE(light->setString(LightsFields::LightingLevel, "Hi")); // DataType error EXPECT_FALSE(light->setDouble(LightsFields::LightingLevel, -1)); // NumericBound error EXPECT_TRUE(light->setDouble(LightsFields::LightingLevel, 0)); EXPECT_TRUE(light->setDouble(LightsFields::LightingLevel, 1)); EXPECT_TRUE(workspace.isValid(StrictnessLevel::None)); EXPECT_TRUE(workspace.isValid(StrictnessLevel::Draft)); EXPECT_FALSE(workspace.isValid(StrictnessLevel::Final)); }
TEST_F(IdfFixture, WorkspaceObject_Lights_Strictness_None) { Workspace workspace(StrictnessLevel::None,IddFileType::EnergyPlus); EXPECT_TRUE(workspace.isValid()); OptionalWorkspaceObject w = workspace.addObject(IdfObject(IddObjectType::Lights)); ASSERT_TRUE(w); OptionalWorkspaceObject light = workspace.getObject(w->handle()); ASSERT_TRUE(light); // can invalidate all we want EXPECT_TRUE(light->setString(LightsFields::Name, "")); EXPECT_TRUE(light->setDouble(LightsFields::Name, 0)); EXPECT_TRUE(light->setString(LightsFields::ZoneorZoneListName, "")); EXPECT_TRUE(light->setPointer(LightsFields::ZoneorZoneListName, Handle())); EXPECT_TRUE(light->setString(LightsFields::ScheduleName, "")); EXPECT_TRUE(light->setPointer(LightsFields::ScheduleName, Handle())); EXPECT_TRUE(light->setString(LightsFields::DesignLevelCalculationMethod, "")); EXPECT_TRUE(light->setDouble(LightsFields::DesignLevelCalculationMethod, 0)); EXPECT_TRUE(light->setString(LightsFields::LightingLevel, "Hi")); EXPECT_TRUE(light->setDouble(LightsFields::LightingLevel, -1)); EXPECT_TRUE(light->setDouble(LightsFields::LightingLevel, 0)); EXPECT_TRUE(light->setDouble(LightsFields::LightingLevel, 1)); EXPECT_TRUE(workspace.isValid(StrictnessLevel::None)); EXPECT_FALSE(workspace.isValid(StrictnessLevel::Draft)); EXPECT_FALSE(workspace.isValid(StrictnessLevel::Final)); }
OptionalModelObject ReverseTranslator::translateCoilCoolingDXSingleSpeed( const WorkspaceObject & workspaceObject ) { OptionalModelObject result,temp; OptionalSchedule schedule; //get the Schedule OptionalWorkspaceObject owo = workspaceObject.getTarget(Coil_Cooling_DX_SingleSpeedFields::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.briefDescription() <<"Failed to convert iddObject (schedule) into ModelObject. Maybe it does not exist in model yet"); return result; } //collect the curves owo = workspaceObject.getTarget(Coil_Cooling_DX_SingleSpeedFields::TotalCoolingCapacityFunctionofTemperatureCurveName); if(!owo) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " Can't find TotalCoolingCapacityFunctionOfTemperatureCurve."); return result; } if( owo->numSources() > 1 ) { owo = owo->workspace().addObject(owo.get()); } temp= translateAndMapWorkspaceObject( *owo ); if(!temp) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " Can't convert workspace curve into a model curve. "); return result; } boost::optional<Curve> tccfot = temp->optionalCast<Curve>(); if( ! tccfot ) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " curve is wrong type. "); return result; } owo = workspaceObject.getTarget(Coil_Cooling_DX_SingleSpeedFields::EnergyInputRatioFunctionofTemperatureCurveName); if(!owo) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " Can't find EnergyInputRatioFunctionofTemperatureCurveName."); return result; } if( owo->numSources() > 1 ) { owo = owo->workspace().addObject(owo.get()); } temp = translateAndMapWorkspaceObject( *owo ); if(!temp) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " Can't convert workspace curve into a model curve. "); return result; } boost::optional<Curve> eirfot = temp->optionalCast<Curve>(); if( ! eirfot ) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " curve is wrong type. "); return result; } owo = workspaceObject.getTarget(Coil_Cooling_DX_SingleSpeedFields::TotalCoolingCapacityFunctionofFlowFractionCurveName); if(!owo) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " Can't find TotalCoolingCapacityFunctionofFlowFractionCurveName."); return result; } if( owo->numSources() > 1 ) { owo = owo->workspace().addObject(owo.get()); } temp = translateAndMapWorkspaceObject( *owo ); if(!temp) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " Can't convert workspace curve into a model curve. "); return result; } boost::optional<Curve> tccfoff = temp->optionalCast<Curve>(); if( ! tccfoff ) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " curve is wrong type. "); return result; } owo = workspaceObject.getTarget(Coil_Cooling_DX_SingleSpeedFields::EnergyInputRatioFunctionofFlowFractionCurveName); if(!owo) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " Can't find EnergyInputRatioFunctionofFlowFractionCurveName."); return result; } if( owo->numSources() > 1 ) { owo = owo->workspace().addObject(owo.get()); } temp = translateAndMapWorkspaceObject( *owo ); if(!temp) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " Can't convert workspace curve into a model curve. "); return result; } boost::optional<Curve> eirfoff = temp->optionalCast<Curve>(); if( ! eirfoff ) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " curve is wrong type. "); return result; } owo = workspaceObject.getTarget(Coil_Cooling_DX_SingleSpeedFields::PartLoadFractionCorrelationCurveName); if(!owo) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " Can't find PartLoadFractionCorrelationCurveName."); return result; } if( owo->numSources() > 1 ) { owo = owo->workspace().addObject(owo.get()); } temp = translateAndMapWorkspaceObject( *owo ); if(!temp) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " Can't convert workspace curve into a model curve. "); return result; } boost::optional<Curve> plfcc = temp->optionalCast<Curve>(); if( ! plfcc ) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " curve is wrong type. "); return result; } try { CoilCoolingDXSingleSpeed coil(m_model, *schedule, *tccfot, *tccfoff, *eirfot, *eirfoff, *plfcc); OptionalString optS = workspaceObject.name(); if( optS ) { coil.setName( *optS ); } OptionalDouble d = workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::GrossRatedTotalCoolingCapacity); if(d) { coil.setRatedTotalCoolingCapacity(*d); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::GrossRatedSensibleHeatRatio); if(d) { coil.setRatedSensibleHeatRatio(*d); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::GrossRatedCoolingCOP); if(d) { coil.setRatedCOP(*d); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::RatedAirFlowRate); if(d) { coil.setRatedAirFlowRate(*d); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::RatedEvaporatorFanPowerPerVolumeFlowRate); if(d) { coil.setRatedEvaporatorFanPowerPerVolumeFlowRate(*d); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::NominalTimeforCondensateRemovaltoBegin); if(d) { coil.setNominalTimeForCondensateRemovalToBegin(*d); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::RatioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity); if(d) { coil.setRatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity(*d); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::MaximumCyclingRate); if(d) { coil.setMaximumCyclingRate(*d); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::LatentCapacityTimeConstant); if(d) { coil.setLatentCapacityTimeConstant(*d); } optS=workspaceObject.getString(Coil_Cooling_DX_SingleSpeedFields::CondenserAirInletNodeName); if(optS) { coil.setCondenserAirInletNodeName(*optS); } optS = workspaceObject.getString(Coil_Cooling_DX_SingleSpeedFields::CondenserType); if(optS) { coil.setCondenserType(*optS); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserEffectiveness); if(d) { coil.setEvaporativeCondenserEffectiveness(*d); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserAirFlowRate); if(d) { coil.setEvaporativeCondenserAirFlowRate(*d); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserPumpRatedPowerConsumption); if(d) { coil.setEvaporativeCondenserPumpRatedPowerConsumption(*d); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::CrankcaseHeaterCapacity); if(d) { coil.setCrankcaseHeaterCapacity(*d); } d=workspaceObject.getDouble(Coil_Cooling_DX_SingleSpeedFields::MaximumOutdoorDryBulbTemperatureforCrankcaseHeaterOperation); if(d) { coil.setMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(*d); } result=coil; } catch (std::exception& e) { LOG(Error,"Could not reverse translate " << workspaceObject.briefDescription() << ", because " << e.what() << "."); } return result; }
// remove all spaces and add a new one virtual bool run(Model& model, OSRunner& runner, const std::map<std::string, OSArgument>& user_arguments) const { ModelUserScript::run(model,runner,user_arguments); // initializes runner // calls runner.registerAttribute for 'lights_definition' and 'multiplier' if (!runner.validateUserArguments(arguments(model),user_arguments)) { return false; } // lights_definition argument value will be object handle Handle h = toUUID(runner.getStringArgumentValue("lights_definition",user_arguments)); OptionalWorkspaceObject wo = model.getObject(h); if (!wo) { std::stringstream ss; ss << "Object " << toString(h) << " not found in model."; runner.registerError(ss.str()); return false; } OptionalLightsDefinition lightsDef = wo->optionalCast<LightsDefinition>(); if (!lightsDef) { std::stringstream ss; ss << wo->briefDescription() << " is not a LightsDefinition."; runner.registerError(ss.str()); return false; } // save name of lights definition runner.registerValue("lights_definition_name",lightsDef->name().get()); if (!(lightsDef->designLevelCalculationMethod() == "Watts/Area")) { std::stringstream ss; ss << "This measure only applies to lights definitions that are in units of Watts/Area. "; ss << lightsDef->briefDescription() << " is in units of "; ss << lightsDef->designLevelCalculationMethod() << "."; runner.registerAsNotApplicable(ss.str()); return true; } double multiplier = runner.getDoubleArgumentValue("multiplier",user_arguments); if (multiplier < 0.0) { std::stringstream ss; ss << "The lighting power density multiplier must be greater than or equal to 0. "; ss << "Instead, it is " << toString(multiplier) << "."; runner.registerError(ss.str()); return false; } double originalValue = lightsDef->wattsperSpaceFloorArea().get(); double newValue = multiplier * originalValue; lightsDef->setWattsperSpaceFloorArea(newValue); // register effects of this measure // human-readable std::stringstream ss; ss << "The lighting power density of " << lightsDef->briefDescription(); ss << ", which is used by " << lightsDef->quantity() << " instances covering "; ss << lightsDef->floorArea() << " m^2 of floor area, was " << originalValue << "."; runner.registerInitialCondition(ss.str()); ss.str(""); ss << "The lighting power density of " << lightsDef->briefDescription(); ss << " has been changed to " << newValue << "."; runner.registerFinalCondition(ss.str()); ss.str(""); // machine-readable runner.registerValue("lpd_in","Input Lighting Power Density",originalValue,"W/m^2"); runner.registerValue("lpd_out","Output Lighting Power Density",newValue,"W/m^2"); runner.registerValue("lights_definition_num_instances",lightsDef->quantity()); runner.registerValue("lights_definition_floor_area", "Floor Area using this Lights Definition (SI)", lightsDef->floorArea(), "m^2"); runner.registerValue("lights_definition_floor_area_ip", "Floor Area using this Lights Definition (IP)", convert(lightsDef->floorArea(),"m^2","ft^2").get(), "ft^2"); return true; }
OptionalModelObject ReverseTranslator::translateSizingZone( const WorkspaceObject & workspaceObject ) { boost::optional<WorkspaceObject> target = workspaceObject.getTarget(Sizing_ZoneFields::ZoneorZoneListName); std::vector<ThermalZone> thermalZones; if( target ) { // just one thermal zone boost::optional<ModelObject> mo; if (target->iddObject().type() == IddObjectType::Zone) { mo = translateAndMapWorkspaceObject(target.get()); if( mo ) { if( boost::optional<Space> space = mo->optionalCast<Space>() ) { boost::optional<ThermalZone> thermalZone = space->thermalZone(); if (thermalZone) { thermalZones.push_back(*thermalZone); } } } } else if (target->iddObject().type() == IddObjectType::ZoneList) { // get all thermal zones in zone list for (const IdfExtensibleGroup& idfGroup : target->extensibleGroups()) { WorkspaceExtensibleGroup workspaceGroup = idfGroup.cast<WorkspaceExtensibleGroup>(); OptionalWorkspaceObject owo = workspaceGroup.getTarget(0); if (owo) { mo = translateAndMapWorkspaceObject(owo.get()); if( mo ) { if( boost::optional<Space> space = mo->optionalCast<Space>() ) { boost::optional<ThermalZone> thermalZone = space->thermalZone(); if (thermalZone) { thermalZones.push_back(*thermalZone); } } } } } } } if(thermalZones.empty()) { LOG(Error, "Error importing object: " << workspaceObject.briefDescription() << " Can't find associated ThermalZone(s)."); return boost::none; } boost::optional<ModelObject> result; for (ThermalZone thermalZone : thermalZones) { // sizing zone is constructed in thermal zone ctor openstudio::model::SizingZone sizingZone = thermalZone.sizingZone(); // return first sizing zone if (!result) { result = sizingZone; } boost::optional<std::string> s; boost::optional<double> value; // ZoneCoolingDesignSupplyAirTemperature value = workspaceObject.getDouble(Sizing_ZoneFields::ZoneCoolingDesignSupplyAirTemperature); if( value ) { sizingZone.setZoneCoolingDesignSupplyAirTemperature(value.get()); } // ZoneHeatingDesignSupplyAirTemperature value = workspaceObject.getDouble(Sizing_ZoneFields::ZoneHeatingDesignSupplyAirTemperature); if( value ) { sizingZone.setZoneHeatingDesignSupplyAirTemperature(value.get()); } // ZoneCoolingDesignSupplyAirHumidityRatio value = workspaceObject.getDouble(Sizing_ZoneFields::ZoneHeatingDesignSupplyAirHumidityRatio); if( value ) { sizingZone.setZoneHeatingDesignSupplyAirHumidityRatio(value.get()); } // ZoneHeatingDesignSupplyAirHumidityRatio value = workspaceObject.getDouble(Sizing_ZoneFields::ZoneHeatingDesignSupplyAirHumidityRatio); if( value ) { sizingZone.setZoneHeatingDesignSupplyAirHumidityRatio(value.get()); } // DesignSpecificationOutdoorAirObjectName target = workspaceObject.getTarget(Sizing_ZoneFields::DesignSpecificationOutdoorAirObjectName); if (target) { OptionalModelObject mo = translateDesignSpecificationOutdoorAir(*target); if (mo) { if (mo->optionalCast<DesignSpecificationOutdoorAir>()) { std::vector<Space> spaces = thermalZone.spaces(); OS_ASSERT(spaces.size() == 1); spaces[0].setDesignSpecificationOutdoorAir(mo->cast<DesignSpecificationOutdoorAir>()); } } } // ZoneHeatingSizingFactor value = workspaceObject.getDouble(Sizing_ZoneFields::ZoneHeatingSizingFactor); if( value ) { sizingZone.setZoneHeatingSizingFactor(value.get()); } // ZoneCoolingSizingFactor value = workspaceObject.getDouble(Sizing_ZoneFields::ZoneCoolingSizingFactor); if( value ) { sizingZone.setZoneCoolingSizingFactor(value.get()); } // CoolingDesignAirFlowMethod s = workspaceObject.getString(Sizing_ZoneFields::CoolingDesignAirFlowMethod); if( s ) { sizingZone.setCoolingDesignAirFlowMethod(s.get()); } // CoolingDesignAirFlowRate value = workspaceObject.getDouble(Sizing_ZoneFields::CoolingDesignAirFlowRate); if( value ) { sizingZone.setCoolingDesignAirFlowRate(value.get()); } // CoolingMinimumAirFlowperZoneFloorArea value = workspaceObject.getDouble(Sizing_ZoneFields::CoolingMinimumAirFlowperZoneFloorArea); if( value ) { sizingZone.setCoolingMinimumAirFlowperZoneFloorArea(value.get()); } // CoolingMinimumAirFlow value = workspaceObject.getDouble(Sizing_ZoneFields::CoolingMinimumAirFlow); if( value ) { sizingZone.setCoolingMinimumAirFlow(value.get()); } // CoolingMinimumAirFlowFraction value = workspaceObject.getDouble(Sizing_ZoneFields::CoolingMinimumAirFlowFraction); if( value ) { sizingZone.setCoolingMinimumAirFlowFraction(value.get()); } // HeatingDesignAirFlowMethod s = workspaceObject.getString(Sizing_ZoneFields::HeatingDesignAirFlowMethod); if( s ) { sizingZone.setHeatingDesignAirFlowMethod(s.get()); } // HeatingDesignAirFlowRate value = workspaceObject.getDouble(Sizing_ZoneFields::HeatingDesignAirFlowRate); if( value ) { sizingZone.setHeatingDesignAirFlowRate(value.get()); } // HeatingMaximumAirFlowperZoneFloorArea value = workspaceObject.getDouble(Sizing_ZoneFields::HeatingMaximumAirFlowperZoneFloorArea); if( value ) { sizingZone.setHeatingMaximumAirFlowperZoneFloorArea(value.get()); } // HeatingMaximumAirFlow value = workspaceObject.getDouble(Sizing_ZoneFields::HeatingMaximumAirFlow); if( value ) { sizingZone.setHeatingMaximumAirFlow(value.get()); } // HeatingMaximumAirFlowFraction value = workspaceObject.getDouble(Sizing_ZoneFields::HeatingMaximumAirFlowFraction); if( value ) { sizingZone.setHeatingMaximumAirFlowFraction(value.get()); } //DesignSpecification_ZoneAirDistribution boost::optional<WorkspaceObject> _designSpecification = workspaceObject.getTarget(Sizing_ZoneFields::DesignSpecificationZoneAirDistributionObjectName); if( _designSpecification ) { // ZoneAirDistributionEffectivenessinCoolingMode value = _designSpecification->getDouble( DesignSpecification_ZoneAirDistributionFields::ZoneAirDistributionEffectivenessinCoolingMode); if( value ) { sizingZone.setDesignZoneAirDistributionEffectivenessinCoolingMode(value.get()); } // ZoneAirDistributionEffectivenessinHeatingMode value = _designSpecification->getDouble( DesignSpecification_ZoneAirDistributionFields::ZoneAirDistributionEffectivenessinHeatingMode); if( value ) { sizingZone.setDesignZoneAirDistributionEffectivenessinHeatingMode(value.get()); } } } return result; }
TEST_F(IdfFixture,WorkspaceObjectWatcher_RelationshipFieldChanges) { IdfObject object(IddObjectType::DaylightingDevice_Tubular); Workspace workspace(StrictnessLevel::Draft, IddFileType::EnergyPlus); OptionalWorkspaceObject owo = workspace.addObject(object); ASSERT_TRUE(owo); WorkspaceObject tdd = *owo; WorkspaceObjectWatcher watcher(tdd); EXPECT_FALSE(watcher.dirty()); // add zone objects object = IdfObject(IddObjectType::Zone); owo = workspace.addObject(object); ASSERT_TRUE(owo); EXPECT_EQ("Zone 1",owo->name().get()); owo = workspace.addObject(object); ASSERT_TRUE(owo); EXPECT_EQ("Zone 2",owo->name().get()); owo = workspace.addObject(object); ASSERT_TRUE(owo); EXPECT_EQ("Zone 3",owo->name().get()); EXPECT_FALSE(watcher.dirty()); vector<string> vals; vals.push_back("Zone 1"); vals.push_back("1.0"); IdfExtensibleGroup eg = tdd.pushExtensibleGroup(vals); ASSERT_FALSE(eg.empty()); EXPECT_TRUE(watcher.dirty()); EXPECT_TRUE(watcher.dataChanged()); EXPECT_FALSE(watcher.nameChanged()); EXPECT_TRUE(watcher.relationshipChanged()); watcher.clearState(); EXPECT_FALSE(watcher.dirty()); EXPECT_FALSE(watcher.dataChanged()); EXPECT_FALSE(watcher.nameChanged()); EXPECT_FALSE(watcher.relationshipChanged()); EXPECT_TRUE(eg.setString(0,"Zone 2")); EXPECT_TRUE(watcher.dirty()); EXPECT_FALSE(watcher.dataChanged()); EXPECT_FALSE(watcher.nameChanged()); EXPECT_TRUE(watcher.relationshipChanged()); watcher.clearState(); EXPECT_FALSE(watcher.dirty()); EXPECT_FALSE(watcher.dataChanged()); EXPECT_FALSE(watcher.nameChanged()); EXPECT_FALSE(watcher.relationshipChanged()); EXPECT_TRUE(eg.setDouble(1,2.0)); EXPECT_TRUE(watcher.dirty()); EXPECT_TRUE(watcher.dataChanged()); EXPECT_FALSE(watcher.nameChanged()); EXPECT_FALSE(watcher.relationshipChanged()); watcher.clearState(); EXPECT_FALSE(watcher.dirty()); EXPECT_FALSE(watcher.dataChanged()); EXPECT_FALSE(watcher.nameChanged()); EXPECT_FALSE(watcher.relationshipChanged()); }
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::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(); }
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); }