TEST_F(EnergyPlusFixture,ReverseTranslatorTest_TranslateScheduleCompact) { openstudio::Workspace workspace(openstudio::StrictnessLevel::None,openstudio::IddFileType::EnergyPlus); openstudio::IdfObject idfObject( openstudio::IddObjectType::Schedule_Compact ); idfObject.setString(1,"Fraction"); idfObject.setString(2,"Through: 12/31"); idfObject.setString(3,"For: Weekdays SummerDesignDay"); idfObject.setString(4,"Until: 08:00"); idfObject.setString(5,"0.0"); idfObject.setString(6,"Until: 18:00"); idfObject.setString(7,"1.0"); idfObject.setString(8,"Until: 24:00"); idfObject.setString(9,"0.0"); idfObject.setString(10,"For: Weekends WinterDesignDay"); idfObject.setString(11,"Until: 10:00"); idfObject.setString(12,"0.0"); idfObject.setString(13,"Until: 16:00"); idfObject.setString(14,"1.0"); idfObject.setString(15,"Until: 24:00"); idfObject.setString(16,"0.0"); idfObject.setString(17,"For: Holidays AllOtherDays"); idfObject.setString(18,"Until: 24:00"); idfObject.setString(19,"0.0"); WorkspaceObject epScheduleCompact = workspace.addObject(idfObject).get(); ReverseTranslator trans; ASSERT_NO_THROW(trans.translateWorkspace(workspace)); Model model = trans.translateWorkspace(workspace); ASSERT_EQ(static_cast<unsigned>(1), model.getModelObjects<openstudio::model::ScheduleCompact>().size()); openstudio::model::ScheduleCompact scheduleCompact = model.getModelObjects<openstudio::model::ScheduleCompact>()[0]; EXPECT_EQ(unsigned(20),epScheduleCompact.numFields()); EXPECT_EQ(unsigned(21),scheduleCompact.numFields()); // has handle field ASSERT_EQ(epScheduleCompact.numFields() + 1u,scheduleCompact.numFields()); ASSERT_TRUE(epScheduleCompact.name()); ASSERT_TRUE(scheduleCompact.name()); EXPECT_EQ(epScheduleCompact.name().get(),scheduleCompact.name().get()); for( unsigned i = 1; i < epScheduleCompact.numFields(); i++ ) { boost::optional<std::string> s1 = epScheduleCompact.getString(i); boost::optional<std::string> s2 = scheduleCompact.getString(i+1); ASSERT_TRUE(s1); ASSERT_TRUE(s2); EXPECT_EQ(s1.get(),s2.get()); } }
OptionalModelObject ReverseTranslator::translateInternalMass( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::InternalMass ){ LOG(Error, "WorkspaceObject is not IddObjectType: InternalMass"); return boost::none; } // create the definition openstudio::model::InternalMassDefinition definition(m_model); OptionalString s = workspaceObject.name(); if(s){ definition.setName(*s + " Definition"); } OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::InternalMassFields::ConstructionName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ConstructionBase>()){ definition.setConstruction(modelObject->cast<ConstructionBase>()); } } } OptionalDouble d = workspaceObject.getDouble(openstudio::InternalMassFields::SurfaceArea); if(d){ definition.setSurfaceArea(*d); } // create the instance InternalMass internalMass(definition); s = workspaceObject.name(); if(s){ internalMass.setName(*s); } target = workspaceObject.getTarget(openstudio::InternalMassFields::ZoneName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<Space>()){ internalMass.setSpace(modelObject->cast<Space>()); }else if (modelObject->optionalCast<SpaceType>()){ internalMass.setSpaceType(modelObject->cast<SpaceType>()); } } } return internalMass; }
bool WorkspaceObjectNameGreater::operator()(const WorkspaceObject& a, const WorkspaceObject& b) const { std::string aname; boost::optional<std::string> oaname = a.name(); if (oaname){ aname = *oaname; } std::string bname; boost::optional<std::string> obname = b.name(); if (obname){ bname = *obname; } return istringLess(bname, aname); }
OptionalModelObject ReverseTranslator::translateSiteLocation( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::Site_Location ) { LOG(Error, "WorkspaceObject is not IddObjectType: Site:Location"); return boost::none; } Site site = m_model.getUniqueModelObject<Site>(); OptionalString optS = workspaceObject.name(); if(optS) { site.setName(*optS); } OptionalDouble od = workspaceObject.getDouble(Site_LocationFields::Latitude); if(od) { site.setLatitude(*od); } od = workspaceObject.getDouble(Site_LocationFields::Longitude); if(od) { site.setLongitude(*od); } od = workspaceObject.getDouble(Site_LocationFields::TimeZone); if(od) { site.setTimeZone(*od); } od = workspaceObject.getDouble(Site_LocationFields::Elevation); if(od) { site.setElevation(*od); } return site; }
boost::optional<ModelObject> ReverseTranslator::translateCurveQuadraticLinear( const WorkspaceObject& workspaceObject) { CurveQuadraticLinear curve(m_model); OptionalString s; OptionalDouble d; if ((s = workspaceObject.name())) { curve.setName(*s); } if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient1Constant))) { curve.setCoefficient1Constant(*d); } if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient2x))) { curve.setCoefficient2x(*d); } if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient3x_POW_2))) { curve.setCoefficient3xPOW2(*d); } if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient4y))) { curve.setCoefficient4y(*d); } if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient5x_TIMES_y))) { curve.setCoefficient5xTIMESY(*d); } if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient6x_POW_2_TIMES_y))) { curve.setCoefficient6xPOW2TIMESY(*d); } if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MinimumValueofx))) { curve.setMinimumValueofx(*d); } if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MaximumValueofx))) { curve.setMaximumValueofx(*d); } if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MinimumValueofy))) { curve.setMinimumValueofy(*d); } if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MaximumValueofy))) { curve.setMaximumValueofy(*d); } if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MinimumCurveOutput))) { curve.setMinimumCurveOutput(*d); } if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MaximumCurveOutput))) { curve.setMaximumCurveOutput(*d); } if ((s = workspaceObject.getString(Curve_QuadraticLinearFields::InputUnitTypeforX,false,true))) { curve.setInputUnitTypeforX(*s); } if ((s = workspaceObject.getString(Curve_QuadraticLinearFields::InputUnitTypeforY,false,true))) { curve.setInputUnitTypeforY(*s); } if ((s = workspaceObject.getString(Curve_QuadraticLinearFields::OutputUnitType,false,true))) { curve.setOutputUnitType(*s); } return curve; }
OptionalModelObject ReverseTranslator::translateScheduleDayHourly(const WorkspaceObject & workspaceObject){ if (workspaceObject.iddObject().type() != IddObjectType::Schedule_Day_Hourly){ LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Day:Hourly"); return boost::none; } // create the schedule ScheduleDay scheduleDay(m_model); OptionalString s = workspaceObject.name(); if (s){ scheduleDay.setName(*s); } OptionalWorkspaceObject target = workspaceObject.getTarget(Schedule_Day_HourlyFields::ScheduleTypeLimitsName); if (target){ OptionalModelObject scheduleTypeLimits = translateAndMapWorkspaceObject(*target); if (scheduleTypeLimits){ scheduleDay.setPointer(OS_Schedule_DayFields::ScheduleTypeLimitsName, scheduleTypeLimits->handle()); } } for(unsigned i = 0; i < 24; ++i){ OptionalDouble d = workspaceObject.getDouble(Schedule_Day_HourlyFields::Hour1 + i, true); if (d){ scheduleDay.addValue(openstudio::Time(0,i+1,0,0), *d); } } return scheduleDay; }
boost::optional<ModelObject> ReverseTranslator::translateCurveFunctionalPressureDrop( const WorkspaceObject& workspaceObject ) { CurveFunctionalPressureDrop curve(m_model); OptionalString s; OptionalDouble d; if ((s = workspaceObject.name())) { curve.setName(*s); } if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::Diameter))) { curve.setDiameter(*d); } if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::MinorLossCoefficient))) { curve.setMinorLossCoefficient(*d); } if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::Length))) { curve.setLength(*d); } if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::Roughness))) { curve.setRoughness(*d); } if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::FixedFrictionFactor))) { curve.setFixedFrictionFactor(*d); } return curve; }
OptionalModelObject ReverseTranslator::translateWindowMaterialSimpleGlazingSystem( const WorkspaceObject & workspaceObject ) { OptionalModelObject result; SimpleGlazing simpleGlazing( m_model ); OptionalString optS = workspaceObject.name(); if(optS) { simpleGlazing.setName(*optS); } OptionalDouble d = workspaceObject.getDouble(WindowMaterial_SimpleGlazingSystemFields::UFactor); if(d) { simpleGlazing.setUFactor(*d); } d = workspaceObject.getDouble(WindowMaterial_SimpleGlazingSystemFields::SolarHeatGainCoefficient); if(d) { simpleGlazing.setSolarHeatGainCoefficient(*d); } d = workspaceObject.getDouble(WindowMaterial_SimpleGlazingSystemFields::VisibleTransmittance); if(d) { simpleGlazing.setVisibleTransmittance(*d); } result = simpleGlazing; return result; }
OptionalModelObject ReverseTranslator::translateScheduleCompact( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::Schedule_Compact ) { LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Compact"); return boost::none; } ScheduleCompact scheduleCompact(m_model); OptionalWorkspaceObject target = workspaceObject.getTarget(Schedule_CompactFields::ScheduleTypeLimitsName); if (target){ OptionalModelObject scheduleTypeLimits = translateAndMapWorkspaceObject(*target); if (scheduleTypeLimits){ scheduleCompact.setPointer(OS_Schedule_CompactFields::ScheduleTypeLimitsName, scheduleTypeLimits->handle()); } } if (OptionalString os = workspaceObject.name()) { scheduleCompact.setName(*os); } for (const IdfExtensibleGroup& eg : workspaceObject.extensibleGroups()) { scheduleCompact.pushExtensibleGroup(eg.fields()); } return scheduleCompact; }
OptionalModelObject ReverseTranslator::translateZoneInfiltrationEffectiveLeakageArea( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::ZoneInfiltration_EffectiveLeakageArea ){ LOG(Error, "WorkspaceObject " << workspaceObject.briefDescription() << " is not IddObjectType: SpaceInfiltration_EffectiveLeakageArea"); return boost::none; } // create the instance SpaceInfiltrationEffectiveLeakageArea spaceInfiltrationEffectiveLeakageArea(m_model); OptionalString s = workspaceObject.name(); if(s){ spaceInfiltrationEffectiveLeakageArea.setName(*s); } OptionalWorkspaceObject target = workspaceObject.getTarget(ZoneInfiltration_EffectiveLeakageAreaFields::ZoneName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<Space>()){ spaceInfiltrationEffectiveLeakageArea.setSpace(modelObject->cast<Space>()); }else if (modelObject->optionalCast<SpaceType>()){ spaceInfiltrationEffectiveLeakageArea.setSpaceType(modelObject->cast<SpaceType>()); } } } target = workspaceObject.getTarget(ZoneInfiltration_EffectiveLeakageAreaFields::ScheduleName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){ Schedule schedule(*intermediate); spaceInfiltrationEffectiveLeakageArea.setSchedule(schedule); } } } boost::optional<double> value = workspaceObject.getDouble(ZoneInfiltration_EffectiveLeakageAreaFields::EffectiveAirLeakageArea); if( value ) { spaceInfiltrationEffectiveLeakageArea.setEffectiveAirLeakageArea(value.get()); } value = workspaceObject.getDouble(ZoneInfiltration_EffectiveLeakageAreaFields::StackCoefficient); if( value ) { spaceInfiltrationEffectiveLeakageArea.setStackCoefficient(value.get()); } value = workspaceObject.getDouble(ZoneInfiltration_EffectiveLeakageAreaFields::WindCoefficient); if( value ) { spaceInfiltrationEffectiveLeakageArea.setWindCoefficient(value.get()); } return spaceInfiltrationEffectiveLeakageArea; }
OptionalModelObject ReverseTranslator::translateMaterial( const WorkspaceObject & workspaceObject ) { OptionalModelObject result; if( workspaceObject.iddObject().type() != IddObjectType::Material ) { LOG(Error, "WorkspaceObject is not IddObjectType: Material"); return result; } openstudio::model::StandardOpaqueMaterial mat( m_model ); OptionalString optS = workspaceObject.name(); if(optS) { mat.setName(*optS); } optS = workspaceObject.getString(MaterialFields::Roughness); if(optS) { mat.setRoughness(*optS); } OptionalDouble od = workspaceObject.getDouble( MaterialFields::Thickness ); if(od) { mat.setThickness(*od); } od = workspaceObject.getDouble( MaterialFields::Conductivity ); if(od) { mat.setThermalConductivity(*od); } od = workspaceObject.getDouble( MaterialFields::Density ); if(od) { mat.setDensity(*od); } od = workspaceObject.getDouble( MaterialFields::SpecificHeat ); if(od) { mat.setSpecificHeat(*od); } od = workspaceObject.getDouble( MaterialFields::ThermalAbsorptance ); if(od) { mat.setThermalAbsorptance(od); } od = workspaceObject.getDouble( MaterialFields::SolarAbsorptance ); if(od) { mat.setSolarAbsorptance(od); } od = workspaceObject.getDouble( MaterialFields::VisibleAbsorptance ); if(od) { mat.setVisibleAbsorptance(od); } result = mat; return result; }
OptionalModelObject ReverseTranslator::translateShadingBuildingDetailed( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::Shading_Building_Detailed ){ LOG(Error, "WorkspaceObject is not IddObjectType: Shading:Building:Detailed"); return boost::none; } openstudio::Point3dVector vertices = getVertices(Shading_Building_DetailedFields::NumberofVertices + 1, workspaceObject); boost::optional<ShadingSurface> shadingSurface; try{ shadingSurface = ShadingSurface(vertices, m_model); }catch(const std::exception&){ LOG(Error, "Cannot create ShadingSurface for object: " << workspaceObject); return boost::none; } OptionalString s = workspaceObject.name(); if(s) { shadingSurface->setName(*s); } // look for first site level shading surface group OptionalShadingSurfaceGroup shadingSurfaceGroup; for (const ShadingSurfaceGroup& group : m_model.getConcreteModelObjects<ShadingSurfaceGroup>()){ if (istringEqual("Building", group.shadingSurfaceType())){ shadingSurfaceGroup = group; break; } } // if not found make one if (!shadingSurfaceGroup){ shadingSurfaceGroup = ShadingSurfaceGroup(m_model); shadingSurfaceGroup->setShadingSurfaceType("Building"); } shadingSurface->setShadingSurfaceGroup(*shadingSurfaceGroup); OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::Shading_Building_DetailedFields::TransmittanceScheduleName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){ Schedule schedule(*intermediate); shadingSurface->setTransmittanceSchedule(schedule); } } } return shadingSurface.get(); }
boost::optional<ModelObject> ReverseTranslator::translateCurveSigmoid( const WorkspaceObject& workspaceObject ) { CurveSigmoid curve(m_model); OptionalString s; OptionalDouble d; if ((s = workspaceObject.name())) { curve.setName(*s); } if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient1C1))) { curve.setCoefficient1C1(*d); } if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient2C2))) { curve.setCoefficient2C2(*d); } if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient3C3))) { curve.setCoefficient3C3(*d); } if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient4C4))) { curve.setCoefficient4C4(*d); } if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient5C5))) { curve.setCoefficient5C5(*d); } if ((d = workspaceObject.getDouble(Curve_SigmoidFields::MinimumValueofx))) { curve.setMinimumValueofx(*d); } if ((d = workspaceObject.getDouble(Curve_SigmoidFields::MaximumValueofx))) { curve.setMaximumValueofx(*d); } if ((d = workspaceObject.getDouble(Curve_SigmoidFields::MinimumCurveOutput))) { curve.setMinimumCurveOutput(*d); } if ((d = workspaceObject.getDouble(Curve_SigmoidFields::MaximumCurveOutput))) { curve.setMaximumCurveOutput(*d); } if ((s = workspaceObject.getString(Curve_SigmoidFields::InputUnitTypeforx,false,true))) { curve.setInputUnitTypeforx(*s); } if ((s = workspaceObject.getString(Curve_SigmoidFields::OutputUnitType,false,true))) { curve.setOutputUnitType(*s); } return curve; }
boost::optional<ModelObject> ReverseTranslator::translateCurveCubic( const WorkspaceObject& workspaceObject ) { CurveCubic curve(m_model); OptionalString s; OptionalDouble d; if ((s = workspaceObject.name())) { curve.setName(*s); } if ((d = workspaceObject.getDouble(Curve_CubicFields::Coefficient1Constant))) { curve.setCoefficient1Constant(*d); } if ((d = workspaceObject.getDouble(Curve_CubicFields::Coefficient2x))) { curve.setCoefficient2x(*d); } if ((d = workspaceObject.getDouble(Curve_CubicFields::Coefficient3x_POW_2))) { curve.setCoefficient3xPOW2(*d); } if ((d = workspaceObject.getDouble(Curve_CubicFields::Coefficient4x_POW_3))) { curve.setCoefficient4xPOW3(*d); } if ((d = workspaceObject.getDouble(Curve_CubicFields::MinimumValueofx))) { curve.setMinimumValueofx(*d); } if ((d = workspaceObject.getDouble(Curve_CubicFields::MaximumValueofx))) { curve.setMaximumValueofx(*d); } if ((d = workspaceObject.getDouble(Curve_CubicFields::MinimumCurveOutput))) { curve.setMinimumCurveOutput(*d); } if ((d = workspaceObject.getDouble(Curve_CubicFields::MaximumCurveOutput))) { curve.setMaximumCurveOutput(*d); } if ((s = workspaceObject.getString(Curve_CubicFields::InputUnitTypeforX,false,true))) { curve.setInputUnitTypeforX(*s); } if ((s = workspaceObject.getString(Curve_CubicFields::OutputUnitType,false,true))) { curve.setOutputUnitType(*s); } return curve; }
boost::optional<ModelObject> ReverseTranslator::translateCurveFanPressureRise( const WorkspaceObject& workspaceObject ) { CurveFanPressureRise curve(m_model); OptionalString s; OptionalDouble d; if ((s = workspaceObject.name())) { curve.setName(*s); } if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::Coefficient1C1))) { curve.setCoefficient1C1(*d); } if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::Coefficient2C2))) { curve.setCoefficient2C2(*d); } if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::Coefficient3C3))) { curve.setCoefficient3C3(*d); } if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::Coefficient4C4))) { curve.setCoefficient4C4(*d); } if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MinimumValueofQfan))) { curve.setMinimumValueofQfan(*d); } if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MaximumValueofQfan))) { curve.setMaximumValueofQfan(*d); } if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MinimumValueofPsm))) { curve.setMinimumValueofPsm(*d); } if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MaximumValueofPsm))) { curve.setMaximumValueofPsm(*d); } if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MinimumCurveOutput))) { curve.setMinimumCurveOutput(*d); } if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MaximumCurveOutput))) { curve.setMaximumCurveOutput(*d); } return curve; }
OptionalModelObject ReverseTranslator::translateMaterialNoMass( const WorkspaceObject & workspaceObject ) { OptionalModelObject result; if( workspaceObject.iddObject().type() != IddObjectType::Material_NoMass ) { LOG(Error, "WorkspaceObject is not IddObjectType: Material:NoMass"); return result; } openstudio::model::MasslessOpaqueMaterial MOMat( m_model ); OptionalString optS = workspaceObject.name(); if(optS) { MOMat.setName(*optS); } optS = workspaceObject.getString(Material_NoMassFields::Roughness); if(optS) { MOMat.setRoughness(*optS); } OptionalDouble d = workspaceObject.getDouble( Material_NoMassFields::ThermalResistance ); if(d) { MOMat.setThermalResistance(*d); } d = workspaceObject.getDouble( Material_NoMassFields::ThermalAbsorptance ); if(d) { MOMat.setThermalAbsorptance(*d); } d = workspaceObject.getDouble( Material_NoMassFields::SolarAbsorptance ); if(d) { MOMat.setSolarAbsorptance(*d); } d = workspaceObject.getDouble( Material_NoMassFields::VisibleAbsorptance ); if(d) { MOMat.setVisibleAbsorptance(*d); } result = MOMat; return result; }
OptionalModelObject ReverseTranslator::translateMaterialAirGap( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::Material_AirGap ) { LOG(Error, "WorkspaceObject is not IddObjectType: Material_AirGap"); return boost::none; } openstudio::model::AirGap airGap(m_model); OptionalString s = workspaceObject.name(); if (s) { airGap.setName(*s); } OptionalDouble d = workspaceObject.getDouble(Material_AirGapFields::ThermalResistance); if (d) { airGap.setDouble(OS_Material_AirGapFields::ThermalResistance, *d); } return airGap; }
TEST_F(ModelFixture, ComponentWatcher_BadComponentDataFromWorkspace) { Workspace ws; OptionalWorkspaceObject owo = ws.addObject(IdfObject(IddObjectType::OS_ComponentData)); ASSERT_TRUE(owo); // make component data ok except points to non-existent object WorkspaceObject cd = *owo; OptionalString oName = cd.name(); // should have been set by constructor ASSERT_TRUE(oName); EXPECT_FALSE(oName->empty()); cd.setString(OS_ComponentDataFields::UUID,toString(createUUID())); cd.setString(OS_ComponentDataFields::VersionUUID,toString(createUUID())); StringVector values; values.push_back("My Material"); IdfExtensibleGroup eg = cd.pushExtensibleGroup(values); EXPECT_TRUE(eg.empty()); // Cannot register a bad pointer. EXPECT_EQ(1u,ws.numObjects()); Model model(ws); // expect ComponentWatcher creation to kick out ComponentData EXPECT_EQ(0u,model.numObjects()); }
OptionalModelObject ReverseTranslator::translateZoneList( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::Zone ){ LOG(Error, "WorkspaceObject is not IddObjectType: Zone"); return boost::none; } openstudio::model::SpaceType spaceType( m_model ); OptionalString s = workspaceObject.name(); if(s){ spaceType.setName(*s); } for (const IdfExtensibleGroup& idfGroup : workspaceObject.extensibleGroups()){ WorkspaceExtensibleGroup workspaceGroup = idfGroup.cast<WorkspaceExtensibleGroup>(); OptionalWorkspaceObject target = workspaceGroup.getTarget(0); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<Space>()){ Space space = modelObject->cast<Space>(); if (space.spaceType()){ LOG(Warn, "Overriding previously assigned SpaceType for Space '" << space.name().get() << "'"); } space.setSpaceType(spaceType); } } } } return spaceType; }
OptionalModelObject ReverseTranslator::translateGeneratorMicroTurbine( const WorkspaceObject & workspaceObject ) { OptionalModelObject result,temp; OptionalDouble d; boost::optional<WorkspaceObject> owo; OptionalString optS; // TODO: The availability schedule is in the ElectricLoadCenter:Generators (list) in E+, here it's carried by the generator itself // Should also get the Rated Thermal To Electrical Power Ratio in the list //Generator:MicroTurbine, // Capstone C65, !- Name openstudio::model::GeneratorMicroTurbine mchp( m_model ); // Name optS = workspaceObject.name(); if(optS) { mchp.setName(*optS); } // 65000, !- Reference Electrical Power Output {W} d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceElectricalPowerOutput); if(d) { mchp.setReferenceElectricalPowerOutput(*d); } // 29900, !- Minimum Full Load Electrical Power Output {W} d = workspaceObject.getDouble(Generator_MicroTurbineFields::MinimumFullLoadElectricalPowerOutput); if(d) { mchp.setMinimumFullLoadElectricalPowerOutput(*d); } // 65000, !- Maximum Full Load Electrical Power Output {W} setMaximumFullLoadElectricalPowerOutput d = workspaceObject.getDouble(Generator_MicroTurbineFields::MaximumFullLoadElectricalPowerOutput); if(d) { mchp.setMaximumFullLoadElectricalPowerOutput(*d); } // 0.29, !- Reference Electrical Efficiency Using Lower Heating Value d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceElectricalEfficiencyUsingLowerHeatingValue); if(d) { mchp.setReferenceElectricalEfficiencyUsingLowerHeatingValue(*d); } // 15.0, !- Reference Combustion Air Inlet Temperature {C} d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceCombustionAirInletTemperature); if(d) { mchp.setReferenceCombustionAirInletTemperature(*d); } // 0.00638, !- Reference Combustion Air Inlet Humidity Ratio {kgWater/kgDryAir} d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceCombustionAirInletHumidityRatio); if(d) { mchp.setReferenceCombustionAirInletHumidityRatio(*d); } // 0.0, !- Reference Elevation {m} d = workspaceObject.getDouble(Generator_MicroTurbineFields::MinimumFullLoadElectricalPowerOutput); if(d) { mchp.setMinimumFullLoadElectricalPowerOutput(*d); } // Capstone C65 Power_vs_Temp_Elev, !- Electrical Power Function of Temperature and Elevation Curve Name // BiquadraticCurves if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ElectricalPowerFunctionofTemperatureandElevationCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveBiquadratic> curve = mo->optionalCast<CurveBiquadratic>() ) { mchp.setElectricalPowerFunctionofTemperatureandElevationCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Electrical Power Function of Temperature and Elevation Curve Name"); } } } // Capstone C65 Efficiency_vs_Temp, !- Electrical Efficiency Function of Temperature Curve Name // QuadraticCubicCurves if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ElectricalEfficiencyFunctionofTemperatureCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setElectricalEfficiencyFunctionofTemperatureCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchp.setElectricalEfficiencyFunctionofTemperatureCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Electrical Efficiency Function of Temperature Curve Name"); } } } // Capstone C65 Efficiency_vs_PLR, !- Electrical Efficiency Function of Part Load Ratio Curve Name // QuadraticCubicCurves // setElectricalEfficiencyFunctionofPartLoadRatioCurve if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ElectricalEfficiencyFunctionofPartLoadRatioCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setElectricalEfficiencyFunctionofPartLoadRatioCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchp.setElectricalEfficiencyFunctionofPartLoadRatioCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Electrical Efficiency Function of Part Load Ratio Curve Name"); } } } // NaturalGas, !- Fuel Type optS = workspaceObject.getString(Generator_MicroTurbineFields::FuelType); if(optS) { mchp.setFuelType(*optS); } // 50000, !- Fuel Higher Heating Value {kJ/kg} d = workspaceObject.getDouble(Generator_MicroTurbineFields::FuelHigherHeatingValue); if(d) { mchp.setFuelHigherHeatingValue(*d); } // 45450, !- Fuel Lower Heating Value {kJ/kg} d = workspaceObject.getDouble(Generator_MicroTurbineFields::FuelLowerHeatingValue); if(d) { mchp.setFuelLowerHeatingValue(*d); } // 300, !- Standby Power {W} d = workspaceObject.getDouble(Generator_MicroTurbineFields::StandbyPower); if(d) { mchp.setStandbyPower(*d); } // 4500, !- Ancillary Power {W} d = workspaceObject.getDouble(Generator_MicroTurbineFields::AncillaryPower); if(d) { mchp.setAncillaryPower(*d); } // , !- Ancillary Power Function of Fuel Input Curve Name // QuadraticCurves // mchp.setAncillaryPowerFunctionofFuelInputCurve if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::AncillaryPowerFunctionofFuelInputCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setAncillaryPowerFunctionofFuelInputCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Ancillary Power Function of Fuel Input Curve Name"); } } } // Fields in between (in E+.idd) are moved at the end in the Heat Recovery section // Capstone C65 Combustion Air Inlet Node, !- Combustion Air Inlet Node Name // Capstone C65 Combustion Air Outlet Node, !- Combustion Air Outlet Node Name // 0.489885, !- Reference Exhaust Air Mass Flow Rate {kg/s} d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceExhaustAirMassFlowRate); if(d) { mchp.setReferenceExhaustAirMassFlowRate(*d); } // Capstone C65 ExhAirFlowRate_vs_InletTemp, !- Exhaust Air Flow Rate Function of Temperature Curve Name // QuadraticCubicCurves // mchp.setExhaustAirFlowRateFunctionofTemperatureCurve if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ExhaustAirFlowRateFunctionofTemperatureCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setExhaustAirFlowRateFunctionofTemperatureCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchp.setExhaustAirFlowRateFunctionofTemperatureCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Exhaust Air Flow Rate Function of Temperature Curve Name"); } } } // Capstone C65 ExhAirFlowRate_vs_PLR, !- Exhaust Air Flow Rate Function of Part Load Ratio Curve Name // QuadraticCubicCurves // mchp.setExhaustAirFlowRateFunctionofPartLoadRatioCurve(curve) if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ExhaustAirFlowRateFunctionofPartLoadRatioCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setExhaustAirFlowRateFunctionofPartLoadRatioCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchp.setExhaustAirFlowRateFunctionofPartLoadRatioCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Exhaust Air Flow Rate Function of Part Load Ratio Curve Name"); } } } // 308.9, !- Nominal Exhaust Air Outlet Temperature d = workspaceObject.getDouble(Generator_MicroTurbineFields::NominalExhaustAirOutletTemperature); if(d) { mchp.setNominalExhaustAirOutletTemperature(*d); } // Capstone C65 ExhaustTemp_vs_InletTemp, !- Exhaust Air Temperature Function of Temperature Curve Name // QuadraticCubicCurves // mchp.setExhaustAirTemperatureFunctionofTemperatureCurve(curve) if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ExhaustAirTemperatureFunctionofTemperatureCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setExhaustAirTemperatureFunctionofTemperatureCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchp.setExhaustAirTemperatureFunctionofTemperatureCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Exhaust Air Temperature Function of Temperature Curve Name"); } } } // Capstone C65 ExhaustTemp_vs_PLR; !- Exhaust Air Temperature Function of Part Load Ratio Curve Name // QuadraticCubicCurves // mchp.setExhaustAirTemperatureFunctionofPartLoadRatioCurve(curve) if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ExhaustAirTemperatureFunctionofPartLoadRatioCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchp.setExhaustAirTemperatureFunctionofPartLoadRatioCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchp.setExhaustAirTemperatureFunctionofPartLoadRatioCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Exhaust Air Temperature Function of Part Load Ratio Curve Name"); } } } /// HEAT RECOVERY PORTION // Would need to add that to the plantLoop reverse translator // Capstone C65 Heat Recovery Water Inlet Node, !- Heat Recovery Water Inlet Node Name // Capstone C65 Heat Recovery Water Outlet Node, !- Heat Recovery Water Outlet Node Name // TODO: For now, I trigger the creation is the 'Reference Thermal Efficiency Using Lower Heat Value' is filled. // TODO: I should trigger it based on the `Rated Thermal To Electrical Power Ratio in the list` in the ElectricLoadCenter:Generators (list) // TODO: But in order to do that, the ElectricLoadCenter:Distribution & ElectricLoadCenter:Generators need to have a reverse translator // 0.4975, !- Reference Thermal Efficiency Using Lower Heat Value d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceThermalEfficiencyUsingLowerHeatValue); if(d) { // Create a GeneratorMicroTurbineHeatRecovery module, and assign it to the MicroTurbine // I've Set the Name in the constructor openstudio::model::GeneratorMicroTurbineHeatRecovery mchpHR (m_model, mchp); // Assign the Reference Thermal Efficiency Using Lower Heat Value mchpHR.setReferenceThermalEfficiencyUsingLowerHeatValue(*d); // 60.0, !- Reference Inlet Water Temperature {C} d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceInletWaterTemperature); if(d) { mchpHR.setReferenceInletWaterTemperature(*d); } // PlantControl, !- Heat Recovery Water Flow Operating Mode optS = workspaceObject.getString(Generator_MicroTurbineFields::HeatRecoveryWaterFlowOperatingMode); if(optS) { mchpHR.setHeatRecoveryWaterFlowOperatingMode(*optS); } // 0.00252362, !- Reference Heat Recovery Water Flow Rate {m3/s} d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceHeatRecoveryWaterFlowRate); if(d) { mchpHR.setReferenceHeatRecoveryWaterFlowRate(*d); } // , !- Heat Recovery Water Flow Rate Function of Temperature and Power Curve Name // BiquadraticCurves // mchpHR.setHeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve(); if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::HeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveBiquadratic> curve = mo->optionalCast<CurveBiquadratic>() ) { mchpHR.setHeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Heat Recovery Water Flow Rate Function of Temperature and Power Curve Name"); } } } // Capstone C65 ThermalEff_vs_Temp_Elev, !- Thermal Efficiency Function of Temperature and Elevation Curve Name // BicubicBiquadraticCurves // mchpHR.setThermalEfficiencyFunctionofTemperatureandElevationCurve(); if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ThermalEfficiencyFunctionofTemperatureandElevationCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveBicubic> curve = mo->optionalCast<CurveBicubic>() ) { mchpHR.setThermalEfficiencyFunctionofTemperatureandElevationCurve(curve.get()); } else if( boost::optional<CurveBiquadratic> curve = mo->optionalCast<CurveBiquadratic>() ) { mchpHR.setThermalEfficiencyFunctionofTemperatureandElevationCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Thermal Efficiency Function of Temperature and Elevation Curve Name"); } } } // Capstone C65 HeatRecoveryRate_vs_PLR, !- Heat Recovery Rate Function of Part Load Ratio Curve Name // QuadraticCubicCurves // mchpHR.setHeatRecoveryRateFunctionofPartLoadRatioCurve(); if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::HeatRecoveryRateFunctionofPartLoadRatioCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchpHR.setHeatRecoveryRateFunctionofPartLoadRatioCurve(curve.get()); } else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() ) { mchpHR.setHeatRecoveryRateFunctionofPartLoadRatioCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Heat Recovery Rate Function of Part Load Ratio Curve Name"); } } } // Capstone C65 HeatRecoveryRate_vs_InletTemp, !- Heat Recovery Rate Function of Inlet Water Temperature Curve Name // QuadraticCurves // mchpHR.setHeatRecoveryRateFunctionofInletWaterTemperatureCurve(); if ((owo = workspaceObject.getTarget(Generator_MicroTurbineFields::HeatRecoveryRateFunctionofInletWaterTemperatureCurveName))) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchpHR.setHeatRecoveryRateFunctionofInletWaterTemperatureCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Heat Recovery Rate Function of Part Load Ratio Curve Name"); } } } // Capstone C65 HeatRecoveryRate_vs_WaterFlow, !- Heat Recovery Rate Function of Water Flow Rate Curve Name // QuadraticCurves // mchpHR.setHeatRecoveryRateFunctionofInletWaterFlowRateCurve(); if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::HeatRecoveryRateFunctionofWaterFlowRateCurveName)) ) { if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) ) { if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() ) { mchpHR.setHeatRecoveryRateFunctionofWaterFlowRateCurve(curve.get()); } else { LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Heat Recovery Rate Function of Water Flow Rate Curve Name"); } } } // 0.001577263, !- Minimum Heat Recovery Water Flow Rate {m3/s} d = workspaceObject.getDouble(Generator_MicroTurbineFields::MinimumHeatRecoveryWaterFlowRate); if(d) { mchpHR.setMinimumHeatRecoveryWaterFlowRate(*d); } // 0.003785432, !- Maximum Heat Recovery Water Flow Rate {m3/s} d = workspaceObject.getDouble(Generator_MicroTurbineFields::MaximumHeatRecoveryWaterFlowRate); if(d) { mchpHR.setMaximumHeatRecoveryWaterFlowRate(*d); } // 82.2, !- Maximum Heat Recovery Water Temperature {C} d = workspaceObject.getDouble(Generator_MicroTurbineFields::MaximumHeatRecoveryWaterTemperature); if(d) { mchpHR.setMaximumHeatRecoveryWaterTemperature(*d); } } result=mchp; return result; }
OptionalModelObject ReverseTranslator::translateDesignSpecificationOutdoorAir( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::DesignSpecification_OutdoorAir ){ LOG(Error, "WorkspaceObject is not IddObjectType: DesignSpecification:OutdoorAir"); return boost::none; } OptionalString outdoorAirMethod = workspaceObject.getString(DesignSpecification_OutdoorAirFields::OutdoorAirMethod, true); if (!outdoorAirMethod){ LOG(Error, "No OutdoorAirMethod specified for DesignSpecification:OutdoorAir named '" << workspaceObject.name().get() << "'"); return boost::none; } DesignSpecificationOutdoorAir result(m_model); OptionalString name = workspaceObject.name(); if(name){ result.setName(*name); } result.setOutdoorAirMethod(*outdoorAirMethod); boost::optional<double> flowPerPerson = workspaceObject.getDouble(DesignSpecification_OutdoorAirFields::OutdoorAirFlowperPerson); boost::optional<double> flowPerArea = workspaceObject.getDouble(DesignSpecification_OutdoorAirFields::OutdoorAirFlowperZoneFloorArea); boost::optional<double> flowPerZone = workspaceObject.getDouble(DesignSpecification_OutdoorAirFields::OutdoorAirFlowperZone); boost::optional<double> ach = workspaceObject.getDouble(DesignSpecification_OutdoorAirFields::OutdoorAirFlowAirChangesperHour); if (istringEqual(*outdoorAirMethod, "Flow/Person")){ if (flowPerPerson){ result.setOutdoorAirFlowperPerson(*flowPerPerson); } }else if (istringEqual(*outdoorAirMethod, "Flow/Area")){ if (flowPerArea){ result.setOutdoorAirFlowperFloorArea(*flowPerArea); } }else if (istringEqual(*outdoorAirMethod, "Flow/Zone")){ if (flowPerZone){ result.setOutdoorAirFlowRate(*flowPerZone); } }else if (istringEqual(*outdoorAirMethod, "AirChanges/Hour")){ if (ach){ result.setOutdoorAirFlowRate(*ach); } }else if (istringEqual(*outdoorAirMethod, "Sum") || istringEqual(*outdoorAirMethod, "Maximum")){ if (flowPerPerson){ result.setOutdoorAirFlowperPerson(*flowPerPerson); } if (flowPerArea){ result.setOutdoorAirFlowperFloorArea(*flowPerArea); } if (flowPerZone){ result.setOutdoorAirFlowRate(*flowPerZone); } if (ach){ result.setOutdoorAirFlowRate(*ach); } }else{ LOG(Error, "Unknown OutdoorAirMethod '" << *outdoorAirMethod << "' specified for DesignSpecification:OutdoorAir named '" << workspaceObject.name().get() << "'"); } OptionalWorkspaceObject target = workspaceObject.getTarget(DesignSpecification_OutdoorAirFields::OutdoorAirFlowRateFractionScheduleName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){ Schedule schedule = *intermediate; result.setOutdoorAirFlowRateFractionSchedule(schedule); } } } return result; }
boost::optional<model::ModelObject> ReverseTranslator::translateExteriorLights( const WorkspaceObject& workspaceObject) { if (workspaceObject.iddObject().type() != IddObjectType::Exterior_Lights) { LOG(Error,"WorkspaceObject " << workspaceObject.briefDescription() << " is not of IddObjectType::Exterior_Lights."); return boost::none; } model::ExteriorLightsDefinition definition(m_model); OptionalString s; OptionalDouble d; if ((s = workspaceObject.name())) { definition.setName(*s + " Definition"); } if ((d = workspaceObject.getDouble(Exterior_LightsFields::DesignLevel))){ definition.setDesignLevel(*d); } model::OptionalExteriorLights exteriorLights; model::OptionalSchedule schedule; if (OptionalWorkspaceObject target = workspaceObject.getTarget(Exterior_LightsFields::ScheduleName)) { if (model::OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target)) { schedule = modelObject->optionalCast<model::Schedule>(); } } if (schedule) { try { exteriorLights = model::ExteriorLights(definition,*schedule); } catch (std::exception& e) { LOG(Warn,"Could not reverse translate " << workspaceObject.briefDescription() << " in full, because " << e.what() << "."); } } if (!exteriorLights) { exteriorLights = model::ExteriorLights(definition); } OS_ASSERT(exteriorLights); if ((s = workspaceObject.name())) { exteriorLights->setName(*s); } if ((s = workspaceObject.getString(Exterior_LightsFields::ControlOption,false,true))) { exteriorLights->setControlOption(*s); } if ((s = workspaceObject.getString(Exterior_LightsFields::EndUseSubcategory,false,true))) { exteriorLights->setEndUseSubcategory(*s); } return *exteriorLights; }
OptionalModelObject ReverseTranslator::translateCoilHeatingGas( const WorkspaceObject & workspaceObject ) { OptionalModelObject result,temp; OptionalSchedule schedule; //get the Schedule OptionalWorkspaceObject owo = workspaceObject.getTarget(Coil_Heating_GasFields::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; } try { openstudio::model::CoilHeatingGas coil( m_model, *schedule ); OptionalString optS = workspaceObject.name(); if(optS) { coil.setName(*optS); } OptionalDouble d; d = workspaceObject.getDouble(openstudio::Coil_Heating_GasFields::GasBurnerEfficiency); if(d) { coil.setGasBurnerEfficiency(*d); } d = workspaceObject.getDouble(openstudio::Coil_Heating_GasFields::NominalCapacity); if(d) { coil.setNominalCapacity(*d); } //skip inlet and outlet node names. That should be done FOR us by the AirLoop Translator. d = workspaceObject.getDouble(openstudio::Coil_Heating_GasFields::GasBurnerEfficiency); if(d) { coil.setGasBurnerEfficiency(*d); } d = workspaceObject.getDouble(openstudio::Coil_Heating_GasFields::NominalCapacity); if(d) { coil.setNominalCapacity(*d); } d = workspaceObject.getDouble(openstudio::Coil_Heating_GasFields::ParasiticElectricLoad); if(d) { coil.setParasiticElectricLoad(*d); } d = workspaceObject.getDouble(openstudio::Coil_Heating_GasFields::ParasiticGasLoad); if(d) { coil.setParasiticGasLoad(*d); } result = coil; } catch (std::exception& e) { LOG(Error,"Unable to reverse translate " << workspaceObject.briefDescription() << ", because " << e.what() << "."); return boost::none; } return result; }
OptionalModelObject ReverseTranslator::translateScheduleWeekDaily(const WorkspaceObject & workspaceObject){ if (workspaceObject.iddObject().type() != IddObjectType::Schedule_Week_Daily){ LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Week"); return boost::none; } // create the schedule ScheduleWeek scheduleWeek(m_model); OptionalString s = workspaceObject.name(); if (s){ scheduleWeek.setName(*s); } OptionalWorkspaceObject target = workspaceObject.getTarget(Schedule_Week_DailyFields::SundaySchedule_DayName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ScheduleDay>()){ scheduleWeek.setSundaySchedule(modelObject->cast<ScheduleDay>()); } } } target = workspaceObject.getTarget(Schedule_Week_DailyFields::MondaySchedule_DayName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ScheduleDay>()){ scheduleWeek.setMondaySchedule(modelObject->cast<ScheduleDay>()); } } } target = workspaceObject.getTarget(Schedule_Week_DailyFields::TuesdaySchedule_DayName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ScheduleDay>()){ scheduleWeek.setTuesdaySchedule(modelObject->cast<ScheduleDay>()); } } } target = workspaceObject.getTarget(Schedule_Week_DailyFields::WednesdaySchedule_DayName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ScheduleDay>()){ scheduleWeek.setWednesdaySchedule(modelObject->cast<ScheduleDay>()); } } } target = workspaceObject.getTarget(Schedule_Week_DailyFields::ThursdaySchedule_DayName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ScheduleDay>()){ scheduleWeek.setThursdaySchedule(modelObject->cast<ScheduleDay>()); } } } target = workspaceObject.getTarget(Schedule_Week_DailyFields::FridaySchedule_DayName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ScheduleDay>()){ scheduleWeek.setFridaySchedule(modelObject->cast<ScheduleDay>()); } } } target = workspaceObject.getTarget(Schedule_Week_DailyFields::SaturdaySchedule_DayName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ScheduleDay>()){ scheduleWeek.setSaturdaySchedule(modelObject->cast<ScheduleDay>()); } } } target = workspaceObject.getTarget(Schedule_Week_DailyFields::HolidaySchedule_DayName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ScheduleDay>()){ scheduleWeek.setHolidaySchedule(modelObject->cast<ScheduleDay>()); } } } target = workspaceObject.getTarget(Schedule_Week_DailyFields::SummerDesignDaySchedule_DayName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ScheduleDay>()){ scheduleWeek.setSummerDesignDaySchedule(modelObject->cast<ScheduleDay>()); } } } target = workspaceObject.getTarget(Schedule_Week_DailyFields::WinterDesignDaySchedule_DayName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ScheduleDay>()){ scheduleWeek.setWinterDesignDaySchedule(modelObject->cast<ScheduleDay>()); } } } target = workspaceObject.getTarget(Schedule_Week_DailyFields::CustomDay1Schedule_DayName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ScheduleDay>()){ scheduleWeek.setCustomDay1Schedule(modelObject->cast<ScheduleDay>()); } } } target = workspaceObject.getTarget(Schedule_Week_DailyFields::CustomDay2Schedule_DayName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<ScheduleDay>()){ scheduleWeek.setCustomDay2Schedule(modelObject->cast<ScheduleDay>()); } } } return scheduleWeek; }
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; }
boost::optional<ModelObject> ReverseTranslator::translateWindowMaterialGlazing( const WorkspaceObject& workspaceObject) { OptionalModelObject result; StandardGlazing standardGlazing(m_model); OptionalString optS = workspaceObject.name(); if(optS) { standardGlazing.setName(*optS); } optS = workspaceObject.getString(WindowMaterial_GlazingFields::OpticalDataType); if (optS) { standardGlazing.setOpticalDataType(*optS); } optS = workspaceObject.getString(WindowMaterial_GlazingFields::WindowGlassSpectralDataSetName); if (optS) { standardGlazing.setWindowGlassSpectralDataSetName(*optS); } OptionalDouble d = workspaceObject.getDouble(WindowMaterial_GlazingFields::Thickness); if (d) { standardGlazing.setThickness(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::SolarTransmittanceatNormalIncidence); if (d) { standardGlazing.setSolarTransmittance(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::FrontSideSolarReflectanceatNormalIncidence); if (d) { standardGlazing.setFrontSideSolarReflectanceatNormalIncidence(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::BackSideSolarReflectanceatNormalIncidence); if (d) { standardGlazing.setBackSideSolarReflectanceatNormalIncidence(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::VisibleTransmittanceatNormalIncidence); if (d) { standardGlazing.setVisibleTransmittance(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::FrontSideVisibleReflectanceatNormalIncidence); if (d) { standardGlazing.setFrontSideVisibleReflectanceatNormalIncidence(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::BackSideVisibleReflectanceatNormalIncidence); if (d) { standardGlazing.setBackSideVisibleReflectanceatNormalIncidence(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::InfraredTransmittanceatNormalIncidence); if (d) { standardGlazing.setInfraredTransmittance(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::FrontSideInfraredHemisphericalEmissivity); if (d) { standardGlazing.setFrontSideInfraredHemisphericalEmissivity(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::BackSideInfraredHemisphericalEmissivity); if (d) { standardGlazing.setBackSideInfraredHemisphericalEmissivity(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::Conductivity); if (d) { standardGlazing.setThermalConductivity(*d); } d = workspaceObject.getDouble(WindowMaterial_GlazingFields::DirtCorrectionFactorforSolarandVisibleTransmittance); if (d) { standardGlazing.setDirtCorrectionFactorforSolarandVisibleTransmittance(*d); } optS = workspaceObject.getString(WindowMaterial_GlazingFields::SolarDiffusing); if (optS) { std::string temp=*optS; boost::to_lower(temp); if( temp == "no") { standardGlazing.setSolarDiffusing(false); } else { standardGlazing.setSolarDiffusing(true); } } result = standardGlazing; return result; }
bool operator()(const WorkspaceObject& left, const WorkspaceObject& right) const { OS_ASSERT(left.name()); OS_ASSERT(right.name()); return (istringLess(left.name().get(), right.name().get())); }
OptionalModelObject ReverseTranslator::translateFanConstantVolume( const WorkspaceObject & workspaceObject ) { OptionalModelObject result,temp; OptionalSchedule schedule; OptionalWorkspaceObject owo = workspaceObject.getTarget(Fan_ConstantVolumeFields::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.name().get() <<"Failed to convert iddObjects into model Objects. Maybe they do not exist in model yet"); return result; } openstudio::model::FanConstantVolume fan( m_model, *schedule ); OptionalString optS = workspaceObject.name(); if(optS) { fan.setName(*optS); } //inlet and outlet nodes are set my the HVACAirLoop OptionalDouble d; d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::FanTotalEfficiency); if(d) { fan.setFanEfficiency(*d); } d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::PressureRise); if(d) { fan.setPressureRise(*d); } d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::MaximumFlowRate); if(d) { fan.setMaximumFlowRate(*d); } d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::MotorEfficiency); if(d) { fan.setMotorEfficiency(*d); } d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::MotorInAirstreamFraction); if(d) { fan.setMotorInAirstreamFraction(*d); } optS=workspaceObject.getString(openstudio::Fan_ConstantVolumeFields::EndUseSubcategory); if(optS) { fan.setEndUseSubcategory(*optS); } result=fan; return result; }
OptionalModelObject ReverseTranslator::translateGasEquipment( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::GasEquipment ){ LOG(Error, "WorkspaceObject is not IddObjectType: GasEquipment"); return boost::none; } // create the definition openstudio::model::GasEquipmentDefinition definition(m_model); OptionalString s = workspaceObject.name(); if(s){ definition.setName(*s + " Definition"); } s = workspaceObject.getString(openstudio::GasEquipmentFields::DesignLevelCalculationMethod, true); OS_ASSERT(s); OptionalDouble d; if (istringEqual("EquipmentLevel", *s)){ d = workspaceObject.getDouble(openstudio::GasEquipmentFields::DesignLevel); if (d){ definition.setDesignLevel(*d); }else{ LOG(Error, "EquipmentLevel value not found for workspace object " << workspaceObject); } }else if(istringEqual("Watts/Area", *s)){ d = workspaceObject.getDouble(openstudio::GasEquipmentFields::PowerperZoneFloorArea); if (d){ definition.setWattsperSpaceFloorArea(*d); }else{ LOG(Error, "Watts/Area value not found for workspace object " << workspaceObject); } }else if(istringEqual("Watts/Person", *s)){ d = workspaceObject.getDouble(openstudio::GasEquipmentFields::PowerperPerson); if (d){ definition.setWattsperPerson(*d); }else{ LOG(Error, "Watts/Person value not found for workspace object " << workspaceObject); } }else{ LOG(Error, "Unknown DesignLevelCalculationMethod value for workspace object" << workspaceObject); } d = workspaceObject.getDouble(openstudio::GasEquipmentFields::FractionLatent); if (d){ definition.setFractionLatent(*d); } d = workspaceObject.getDouble(openstudio::GasEquipmentFields::FractionRadiant); if (d){ definition.setFractionRadiant(*d); } d = workspaceObject.getDouble(openstudio::GasEquipmentFields::FractionLost); if (d){ definition.setFractionLost(*d); } d = workspaceObject.getDouble(openstudio::GasEquipmentFields::CarbonDioxideGenerationRate); if (d){ definition.setCarbonDioxideGenerationRate(*d); } // create the instance GasEquipment gasEquipment(definition); s = workspaceObject.name(); if(s){ gasEquipment.setName(*s); } OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::GasEquipmentFields::ZoneorZoneListName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<Space>()){ gasEquipment.setSpace(modelObject->cast<Space>()); }else if (modelObject->optionalCast<SpaceType>()){ gasEquipment.setSpaceType(modelObject->cast<SpaceType>()); } } } target = workspaceObject.getTarget(openstudio::GasEquipmentFields::ScheduleName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){ Schedule schedule(*intermediate); gasEquipment.setSchedule(schedule); } } } s = workspaceObject.getString(openstudio::GasEquipmentFields::EndUseSubcategory); if(s){ gasEquipment.setEndUseSubcategory(*s); } return gasEquipment; }
OptionalModelObject ReverseTranslator::translateOutputIlluminanceMap( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::Output_IlluminanceMap ){ LOG(Error, "WorkspaceObject is not IddObjectType: Output:IlluminanceMap"); return boost::none; } IlluminanceMap illuminanceMap( m_model ); OptionalString s = workspaceObject.name(); if (s){ illuminanceMap.setName(*s); } OptionalWorkspaceObject target = workspaceObject.getTarget(Output_IlluminanceMapFields::ZoneName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target); if (modelObject){ if (modelObject->optionalCast<Space>()){ illuminanceMap.setSpace(modelObject->cast<Space>()); } } } OptionalDouble d = workspaceObject.getDouble(Output_IlluminanceMapFields::Zheight); if (d){ illuminanceMap.setOriginZCoordinate(*d); } d = workspaceObject.getDouble(Output_IlluminanceMapFields::XMinimumCoordinate); if (d){ illuminanceMap.setOriginXCoordinate(*d); OptionalDouble maxX = workspaceObject.getDouble(Output_IlluminanceMapFields::XMaximumCoordinate); if (maxX){ illuminanceMap.setXLength(*maxX - *d); } } OptionalInt i = workspaceObject.getInt(Output_IlluminanceMapFields::NumberofXGridPoints); if (i){ illuminanceMap.setNumberofXGridPoints(*i); } d = workspaceObject.getDouble(Output_IlluminanceMapFields::YMinimumCoordinate); if (d){ illuminanceMap.setOriginYCoordinate(*d); OptionalDouble maxY = workspaceObject.getDouble(Output_IlluminanceMapFields::YMaximumCoordinate); if (maxY){ illuminanceMap.setYLength(*maxY - *d); } } i = workspaceObject.getInt(Output_IlluminanceMapFields::NumberofYGridPoints); if (i){ illuminanceMap.setNumberofYGridPoints(*i); } return illuminanceMap; }