bool LifeCycleCostUsePriceEscalation_Impl::setYearEscalation(unsigned index, double num) { IdfExtensibleGroup eg = getExtensibleGroup(index); if (!eg.empty()) { return eg.setDouble(OS_LifeCycleCost_UsePriceEscalationExtensibleFields::YearEscalation,num); } else { StringVector values(1u); eg = insertExtensibleGroup(index,values); if (!eg.empty()) { return eg.setDouble(OS_LifeCycleCost_UsePriceEscalationExtensibleFields::YearEscalation,num); } } return false; }
boost::optional<std::string> UtilityCost_Computation_Impl::computeStep(unsigned index) const { IdfExtensibleGroup eg = getExtensibleGroup(index); if (!eg.empty()) { return eg.getString(OS_UtilityCost_ComputationExtensibleFields::ComputeStep,true); } return boost::none; }
TEST_F(ModelFixture, ComponentWatcher_InComponent) { // create Component. ComponentWatcher should work here too (since Component is Model) Model model; DesignDay designDay(model); EXPECT_EQ(1u,model.numObjects()); Component designDayComponent = designDay.createComponent(); EXPECT_EQ(2u,designDayComponent.numObjects()); ComponentData cd = designDayComponent.componentData(); UUID versionUUID = cd.versionUUID(); designDay = designDayComponent.primaryObject().cast<DesignDay>(); // data changes ok--changes version EXPECT_TRUE(designDay.setName("My Design Day")); EXPECT_NE(versionUUID,cd.versionUUID()); versionUUID = cd.versionUUID(); // trying to assign contents results in refresh of contents IdfExtensibleGroup eg = cd.getExtensibleGroup(0); ASSERT_FALSE(eg.empty()); std::string originalValue = eg.getString(0).get(); EXPECT_FALSE(eg.setString(0,"Material")); EXPECT_TRUE(cd.initialized()); EXPECT_EQ(2u,designDayComponent.numObjects()); EXPECT_EQ(originalValue,eg.getString(0).get()); }
boost::optional<std::string> UtilityCost_Charge_Block_Impl::blockCostPerUnitValueOrVariableName(unsigned index) const { IdfExtensibleGroup eg = getExtensibleGroup(index); if (!eg.empty()) { return eg.getString(OS_UtilityCost_Charge_BlockExtensibleFields::BlockCostperUnitValueorVariableName,true); } return boost::none; }
bool LayeredConstruction_Impl::insertLayer(unsigned layerIndex, const Material& material) { OS_ASSERT(material.model() == model()); layerIndex = mf_clearNullLayers(layerIndex); unsigned n = numLayers(); MaterialVector layers = this->layers(); MaterialVector::iterator layersBegin = layers.begin(); MaterialVector::iterator layersEnd = layers.end(); MaterialVector::iterator insertAtIt = layersBegin; while ((static_cast<unsigned>(insertAtIt - layersBegin) < layerIndex) && (insertAtIt != layersEnd)) { ++insertAtIt; } layers.insert(insertAtIt, material); OS_ASSERT(layers.size() == ++n); if ((model().strictnessLevel() < StrictnessLevel::Final) || LayeredConstruction::layersAreValid(layers)) { IdfExtensibleGroup idfGroup = insertExtensibleGroup(layerIndex,StringVector()); OS_ASSERT(!idfGroup.empty()); ModelExtensibleGroup group = idfGroup.cast<ModelExtensibleGroup>(); bool ok = group.setPointer(0,material.handle()); OS_ASSERT(ok); return true; } return false; }
boost::optional<double> LifeCycleCostUsePriceEscalation_Impl::yearEscalation(unsigned index) const { IdfExtensibleGroup eg = getExtensibleGroup(index); if (!eg.empty()) { return eg.getDouble(OS_LifeCycleCost_UsePriceEscalationExtensibleFields::YearEscalation,true); } return boost::none; }
ClimateZone ClimateZones_Impl::getClimateZone(unsigned index) const { IdfExtensibleGroup eg = getExtensibleGroup(index); if (eg.empty()) { std::shared_ptr<ClimateZones_Impl> p; return ClimateZone(p,numFields()); } return eg.cast<ClimateZone>(); }
boost::optional<std::string> PeopleDefinition_Impl::getThermalComfortModelType(int i) const { OptionalString result; if (i < numThermalComfortModelTypes()) { IdfExtensibleGroup eg = getExtensibleGroup(i); OS_ASSERT(!eg.empty()); result = eg.getString(OS_People_DefinitionExtensibleFields::ThermalComfortModelType,true); } return result; }
bool ComponentData_Impl::registerObject(const ModelObject& object) { IdfExtensibleGroup eg = pushExtensibleGroup(StringVector()); bool result = !eg.empty(); if (result) { ModelExtensibleGroup meg = eg.cast<ModelExtensibleGroup>(); result = result && meg.setPointer(OS_ComponentDataExtensibleFields::NameofObject, object.handle()); } return result; }
bool UtilityCost_Computation_Impl::setComputeStep(unsigned index, const std::string& str) { IdfExtensibleGroup eg = getExtensibleGroup(index); if (!eg.empty()) { return eg.setString(OS_UtilityCost_ComputationExtensibleFields::ComputeStep,str); } else { StringVector values(1u,str); return !insertExtensibleGroup(index,values).empty(); } OS_ASSERT(false); return false; }
bool UtilityCost_Charge_Block_Impl::setBlockCostPerUnitValueOrVariableName(unsigned index, const std::string& str) { IdfExtensibleGroup eg = getExtensibleGroup(index); if (!eg.empty()) { return eg.setString(OS_UtilityCost_Charge_BlockExtensibleFields::BlockCostperUnitValueorVariableName,str); } else { StringVector values(2u); values[OS_UtilityCost_Charge_BlockExtensibleFields::BlockCostperUnitValueorVariableName] = str; return !insertExtensibleGroup(index,values).empty(); } OS_ASSERT(false); return false; }
bool EnergyManagementSystemProgramCallingManager_Impl::setProgram(const EnergyManagementSystemProgram& program, unsigned index) { //add program to {index} of vector of programs bool result = false; auto groups = extensibleGroups(); unsigned sizeOfGroup = numExtensibleGroups(); if (index <= sizeOfGroup) { IdfExtensibleGroup idfGroup = insertExtensibleGroup(index, StringVector()); OS_ASSERT(!idfGroup.empty()); ModelExtensibleGroup group = idfGroup.cast<ModelExtensibleGroup>(); result = group.setPointer(0, program.handle()); } return result; }
TEST_F(ModelFixture, ComponentWatcher_FromScratch) { // create schedule component Model justASchedule; ScheduleTypeLimits typeLimits(justASchedule); typeLimits.setName("Fraction"); typeLimits.setLowerLimitValue(0.0); typeLimits.setUpperLimitValue(1.0); typeLimits.setNumericType("Continuous"); ScheduleCompact schedule(justASchedule); EXPECT_TRUE(schedule.setPointer(OS_Schedule_CompactFields::ScheduleTypeLimitsName, typeLimits.handle())); Component scheduleComponent = schedule.createComponent(); // create model with Lights objects and insert schedule component Model justLights; LightsDefinition lightsDefinition(justLights); Lights light1(lightsDefinition); OptionalComponentData ocd = justLights.insertComponent(scheduleComponent); // get ComponentData object ASSERT_TRUE(ocd); ComponentData componentData = *ocd; UUID versionUUID = componentData.versionUUID(); // setting lighting schedule does not invalidate schedule component, or change its version UUID OptionalScheduleCompact oSchedule = componentData.primaryComponentObject().optionalCast<ScheduleCompact>(); ASSERT_TRUE(oSchedule); schedule = *oSchedule; EXPECT_TRUE(light1.setSchedule(schedule)); ASSERT_TRUE(componentData.initialized()); EXPECT_EQ(versionUUID,componentData.versionUUID()); // changing data field in componentObject does not invalidate schedule component, but does change version UUID StringVector values; values.push_back("Through: 12/31"); IdfExtensibleGroup eg = componentData.primaryComponentObject().pushExtensibleGroup(values); EXPECT_FALSE(eg.empty()); ASSERT_TRUE(componentData.initialized()); EXPECT_NE(versionUUID,componentData.versionUUID()); versionUUID = componentData.versionUUID(); // changing type limits used by schedule in component invalidates the component Handle h = componentData.handle(); EXPECT_TRUE(justLights.isMember(h)); ScheduleTypeLimits newTypeLimits = typeLimits.clone(justLights).cast<ScheduleTypeLimits>(); EXPECT_FALSE(newTypeLimits.handle() == typeLimits.handle()); EXPECT_TRUE(schedule.setPointer(OS_Schedule_CompactFields::ScheduleTypeLimitsName,newTypeLimits.handle())); EXPECT_FALSE(componentData.initialized()); EXPECT_FALSE(justLights.isMember(h)); }
bool PeopleDefinition_Impl::setThermalComfortModelType( int i, const std::string& thermalComfortModelType) { int n = numThermalComfortModelTypes(); if (i == n) { return pushThermalComfortModelType(thermalComfortModelType); } if (i < n) { IdfExtensibleGroup eg = getExtensibleGroup(i); OS_ASSERT(!eg.empty()); return eg.setString(OS_People_DefinitionExtensibleFields::ThermalComfortModelType, thermalComfortModelType); } return false; }
TEST_F(ModelFixture, ComponentWatcher_ComponentData_Interactions) { // create osm file that contains ComponentData Model model; DesignDay designDay(model); EXPECT_EQ(1u,model.numObjects()); Component designDayComponent = designDay.createComponent(); ComponentData componentData = designDayComponent.componentData(); UUID uuid = componentData.uuid(); UUID versionUUID = componentData.versionUUID(); EXPECT_FALSE(versionUUID.isNull()); model = Model(); EXPECT_EQ(0u,model.numObjects()); OptionalComponentData ocd = model.insertComponent(designDayComponent); ASSERT_TRUE(ocd); EXPECT_EQ(2u,model.numObjects()); // simple insert should not change component UUIDs. componentData = *ocd; EXPECT_EQ(uuid,componentData.uuid()); EXPECT_EQ(versionUUID,componentData.versionUUID()); // changing data fields of component objects causes version id to change componentData.primaryComponentObject().cast<DesignDay>().setMaximumDryBulbTemperature(50.0); EXPECT_EQ(uuid,componentData.uuid()); EXPECT_NE(versionUUID,componentData.versionUUID()); versionUUID = componentData.versionUUID(); // trying to change contents field to an invalid value directly is not allowed IdfExtensibleGroup eg = componentData.getExtensibleGroup(0); ASSERT_FALSE(eg.empty()); std::string originalValue = eg.getString(0).get(); EXPECT_EQ("Sizing Period Design Day 1",originalValue); EXPECT_FALSE(eg.setString(0,"My Material")); EXPECT_TRUE(componentData.initialized()); EXPECT_EQ(2u,model.numObjects()); EXPECT_EQ(originalValue,eg.getString(0).get()); // ComponentData.remove() is okay (should automatically delete the ComponentWatcher) ocd = model.insertComponent(designDayComponent); ASSERT_TRUE(ocd); // should find original DesignDay and reinstantiate ComponentData EXPECT_EQ(2u,model.numObjects()); componentData = *ocd; ASSERT_TRUE(componentData.initialized()); EXPECT_FALSE(componentData.remove().empty()); EXPECT_EQ(static_cast<unsigned>(1),model.numObjects()); }
bool ScheduleDay_Impl::addValue(const openstudio::Time& untilTime, double value) { if (untilTime.totalMinutes() <= 0.5 || untilTime.totalDays() > 1.0) { return false; } int untilHours = untilTime.hours() + 24*untilTime.days(); int untilMinutes = untilTime.minutes() + floor((untilTime.seconds()/60.0) + 0.5); if (untilMinutes >= 60){ untilHours += 1; untilMinutes += -60; } // use set to determine whether to overwrite or insert, and where std::set<openstudio::Time> times; std::pair<std::set<openstudio::Time>::const_iterator,bool> insertResult; for (const openstudio::Time& time : this->times()) { insertResult = times.insert(time); OS_ASSERT(insertResult.second); } insertResult = times.insert(untilTime); unsigned index = std::distance<std::set<openstudio::Time>::const_iterator>(times.begin(),insertResult.first); OS_ASSERT(index <= numExtensibleGroups()); bool result(true); if (insertResult.second) { // new time--insert an extensible group std::vector<std::string> groupValues; groupValues.push_back(boost::lexical_cast<std::string>(untilHours)); groupValues.push_back(boost::lexical_cast<std::string>(untilMinutes)); groupValues.push_back(toString(value)); IdfExtensibleGroup group = insertExtensibleGroup(index, groupValues); OS_ASSERT(!group.empty()); } else { // time already exists, overwrite value IdfExtensibleGroup group = getExtensibleGroup(index); result = group.setDouble(OS_Schedule_DayExtensibleFields::ValueUntilTime,value); } return result; }
ClimateZone ClimateZones_Impl::appendClimateZone(const std::string& institution, const std::string documentName, unsigned year, const std::string& value) { StringVector values; values.push_back(institution); values.push_back(documentName); std::stringstream ss; ss << year; values.push_back(ss.str()); values.push_back(value); IdfExtensibleGroup eg = pushExtensibleGroup(values); if (eg.empty()) { std::shared_ptr<ClimateZones_Impl> p; return ClimateZone(p,numFields()); } return eg.cast<ClimateZone>(); }
ModelObject ComponentData_Impl::getComponentObject(unsigned objectIndex) const { if (objectIndex >= numComponentObjects()) { LOG_AND_THROW("objectIndex = " << objectIndex << " >= numComponentObjects() = " << numComponentObjects() << "."); } IdfExtensibleGroup eg = getExtensibleGroup(objectIndex); if (eg.empty()) { LOG_AND_THROW("Cannot retrieve IdfExtensibleGroup at objectIndex = " << objectIndex); } ModelExtensibleGroup componentObjectData = eg.cast<ModelExtensibleGroup>(); OptionalModelObject omo = componentObjectData.getModelObjectTarget<ModelObject>( OS_ComponentDataExtensibleFields::NameofObject); if (!omo) { LOG_AND_THROW("Cannot retrieve ModelObject at objectIndex = " << objectIndex); } return *omo; }
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()); }
boost::optional<IdfObject> ForwardTranslator::translateScheduleRuleset( ScheduleRuleset & modelObject ) { IdfObject scheduleYear( openstudio::IddObjectType::Schedule_Year ); std::string scheduleYearName = modelObject.name().get(); scheduleYear.setName(scheduleYearName); boost::optional<ScheduleTypeLimits> scheduleTypeLimits = modelObject.scheduleTypeLimits(); if (scheduleTypeLimits){ boost::optional<IdfObject> idfObject = translateAndMapModelObject(*scheduleTypeLimits); if (idfObject){ scheduleYear.setString(Schedule_YearFields::ScheduleTypeLimitsName, idfObject->name().get()); } } try { ScheduleDay defaultDaySchedule = modelObject.defaultDaySchedule(); ScheduleDay summerDesignDaySchedule = modelObject.summerDesignDaySchedule(); ScheduleDay winterDesignDaySchedule = modelObject.winterDesignDaySchedule(); // initialize day of week schedules ScheduleDay sundaySchedule = defaultDaySchedule; ScheduleDay mondaySchedule = defaultDaySchedule; ScheduleDay tuesdaySchedule = defaultDaySchedule; ScheduleDay wednesdaySchedule = defaultDaySchedule; ScheduleDay thursdaySchedule = defaultDaySchedule; ScheduleDay fridaySchedule = defaultDaySchedule; ScheduleDay saturdaySchedule = defaultDaySchedule; // these are not yet exposed ScheduleDay holidayDaySchedule = defaultDaySchedule; ScheduleDay customDay1Schedule = defaultDaySchedule; ScheduleDay customDay2Schedule = defaultDaySchedule; // loop over entire year model::YearDescription yd = modelObject.model().getUniqueModelObject<model::YearDescription>(); openstudio::Date jan1 = yd.makeDate(MonthOfYear::Jan, 1); openstudio::Date dec31 = yd.makeDate(MonthOfYear::Dec, 31); // this is the current date we are at in the year openstudio::Date date = jan1; // this is the week schedule for the week ending on the last saturday before the current date boost::optional<WeekScheduleStruct> weekSchedule; // this is the week schedule for the week before weekSchedule boost::optional<WeekScheduleStruct> lastWeekSchedule; // this is the saturday on which lastWeekSchedule ends openstudio::Date lastDate; // iterate over the schedule for each day of the year std::vector<ScheduleDay> daySchedules = modelObject.getDaySchedules(jan1, dec31); for (ScheduleDay& daySchedule : daySchedules){ // translate the day schedule translateAndMapModelObject(daySchedule); // set day of week schedule switch(date.dayOfWeek().value()){ case DayOfWeek::Sunday: sundaySchedule = daySchedule; break; case DayOfWeek::Monday: mondaySchedule = daySchedule; break; case DayOfWeek::Tuesday: tuesdaySchedule = daySchedule; break; case DayOfWeek::Wednesday: wednesdaySchedule = daySchedule; break; case DayOfWeek::Thursday: thursdaySchedule = daySchedule; break; case DayOfWeek::Friday: fridaySchedule = daySchedule; break; case DayOfWeek::Saturday: saturdaySchedule = daySchedule; break; default: OS_ASSERT(false); } // update week schedules each saturday if((date.dayOfWeek().value() == DayOfWeek::Saturday)){ // set last week schedule before we overwrite week schedule lastDate = date - Time(7); lastWeekSchedule = weekSchedule; // set the week schedule weekSchedule = WeekScheduleStruct(); weekSchedule->sundaySchedule = sundaySchedule.name().get(); weekSchedule->mondaySchedule = mondaySchedule.name().get(); weekSchedule->tuesdaySchedule = tuesdaySchedule.name().get(); weekSchedule->wednesdaySchedule = wednesdaySchedule.name().get(); weekSchedule->thursdaySchedule = thursdaySchedule.name().get(); weekSchedule->fridaySchedule = fridaySchedule.name().get(); weekSchedule->saturdaySchedule = saturdaySchedule.name().get(); weekSchedule->holidayDaySchedule = holidayDaySchedule.name().get(); weekSchedule->summerDesignDaySchedule = summerDesignDaySchedule.name().get(); weekSchedule->winterDesignDaySchedule = winterDesignDaySchedule.name().get(); weekSchedule->customDay1Schedule = customDay1Schedule.name().get(); weekSchedule->customDay2Schedule = customDay2Schedule.name().get(); // check if this schedule is equal to last week schedule if (weekSchedule && lastWeekSchedule && ( !(weekSchedule.get() == lastWeekSchedule.get()) )){ // if not write out last week schedule // get last extensible group, if any, to find start date otherwise use jan1 openstudio::Date startDate; std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYear.extensibleGroups(); if (extensibleGroups.empty()){ startDate = jan1; }else{ // day after last end date boost::optional<int> startMonth = extensibleGroups.back().getInt(3,true); OS_ASSERT(startMonth); boost::optional<int> startDay = extensibleGroups.back().getInt(4,true); OS_ASSERT(startDay); startDate = yd.makeDate(*startMonth, *startDay) + Time(1); } OS_ASSERT(startDate <= lastDate); // Name the schedule week lastWeekSchedule->setName(scheduleYearName, startDate, lastDate); // add the values std::vector<std::string> values; values.push_back(lastWeekSchedule->name); values.push_back(boost::lexical_cast<std::string>(startDate.monthOfYear().value())); values.push_back(boost::lexical_cast<std::string>(startDate.dayOfMonth())); values.push_back(boost::lexical_cast<std::string>(lastDate.monthOfYear().value())); values.push_back(boost::lexical_cast<std::string>(lastDate.dayOfMonth())); IdfExtensibleGroup test = scheduleYear.pushExtensibleGroup(values); OS_ASSERT(!test.empty()); // Write the schedule m_idfObjects.push_back(lastWeekSchedule->toIdfObject()); } } // if last day of year update and write out current week schedule if (date == dec31){ // we may now think of date as being the next saturday on or after 12/31 // set last week schedule before we overwrite week schedule lastDate = date - Time(1); while (lastDate.dayOfWeek().value() != DayOfWeek::Saturday){ lastDate = lastDate - Time(1); lastWeekSchedule = weekSchedule; } // set the week schedule, some of these dates may extend past 12/31 weekSchedule = WeekScheduleStruct(); weekSchedule->sundaySchedule = sundaySchedule.name().get(); weekSchedule->mondaySchedule = mondaySchedule.name().get(); weekSchedule->tuesdaySchedule = tuesdaySchedule.name().get(); weekSchedule->wednesdaySchedule = wednesdaySchedule.name().get(); weekSchedule->thursdaySchedule = thursdaySchedule.name().get(); weekSchedule->fridaySchedule = fridaySchedule.name().get(); weekSchedule->saturdaySchedule = saturdaySchedule.name().get(); weekSchedule->holidayDaySchedule = holidayDaySchedule.name().get(); weekSchedule->summerDesignDaySchedule = summerDesignDaySchedule.name().get(); weekSchedule->winterDesignDaySchedule = winterDesignDaySchedule.name().get(); weekSchedule->customDay1Schedule = customDay1Schedule.name().get(); weekSchedule->customDay2Schedule = customDay2Schedule.name().get(); // check if this schedule is equal to last week schedule if (weekSchedule && lastWeekSchedule && ( !(weekSchedule.get() == lastWeekSchedule.get()) )){ // if not write out last week schedule // get last extensible group, if any, to find start date otherwise use jan1 openstudio::Date startDate; std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYear.extensibleGroups(); if (extensibleGroups.empty()){ startDate = jan1; }else{ // day after last end date boost::optional<int> startMonth = extensibleGroups.back().getInt(3,true); OS_ASSERT(startMonth); boost::optional<int> startDay = extensibleGroups.back().getInt(4,true); OS_ASSERT(startDay); startDate = yd.makeDate(*startMonth, *startDay) + Time(1); } OS_ASSERT(startDate <= lastDate); // Name the schedule week lastWeekSchedule->setName(scheduleYearName, startDate, lastDate); // add the values std::vector<std::string> values; values.push_back(lastWeekSchedule->name); values.push_back(boost::lexical_cast<std::string>(startDate.monthOfYear().value())); values.push_back(boost::lexical_cast<std::string>(startDate.dayOfMonth())); values.push_back(boost::lexical_cast<std::string>(lastDate.monthOfYear().value())); values.push_back(boost::lexical_cast<std::string>(lastDate.dayOfMonth())); IdfExtensibleGroup test = scheduleYear.pushExtensibleGroup(values); OS_ASSERT(!test.empty()); // Write the schedule m_idfObjects.push_back(lastWeekSchedule->toIdfObject()); } // write out the last week schedule // get last extensible group, if any, to find start date otherwise use jan1 openstudio::Date startDate; std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYear.extensibleGroups(); if (extensibleGroups.empty()){ startDate = jan1; }else{ // day after last end date boost::optional<int> startMonth = extensibleGroups.back().getInt(3,true); OS_ASSERT(startMonth); boost::optional<int> startDay = extensibleGroups.back().getInt(4,true); OS_ASSERT(startDay); startDate = yd.makeDate(*startMonth, *startDay) + Time(1); } OS_ASSERT(startDate <= date); // Name the schedule week weekSchedule->setName(scheduleYearName, startDate, date); // add the values std::vector<std::string> values; values.push_back(weekSchedule->name); values.push_back(boost::lexical_cast<std::string>(startDate.monthOfYear().value())); values.push_back(boost::lexical_cast<std::string>(startDate.dayOfMonth())); values.push_back(boost::lexical_cast<std::string>(date.monthOfYear().value())); values.push_back(boost::lexical_cast<std::string>(date.dayOfMonth())); IdfExtensibleGroup test = scheduleYear.pushExtensibleGroup(values); OS_ASSERT(!test.empty()); // Write the schedule m_idfObjects.push_back(weekSchedule->toIdfObject()); } // increment date date += Time(1); } } catch (std::exception& e) { LOG(Error,"Unable to translate " << modelObject.briefDescription() << " to EnergyPlus IDF, because " << e.what() << "."); return boost::none; } m_idfObjects.push_back(scheduleYear); m_map.insert(std::make_pair(modelObject.handle(), scheduleYear)); // translate day schedules ScheduleDay defaultDaySchedule = modelObject.defaultDaySchedule(); ScheduleDay summerDesignDaySchedule = modelObject.summerDesignDaySchedule(); ScheduleDay winterDesignDaySchedule = modelObject.winterDesignDaySchedule(); translateAndMapModelObject(defaultDaySchedule); translateAndMapModelObject(summerDesignDaySchedule); translateAndMapModelObject(winterDesignDaySchedule); // translate schedule rules, these are returned in order for (ScheduleRule scheduleRule : modelObject.scheduleRules()){ ScheduleDay daySchedule = scheduleRule.daySchedule(); translateAndMapModelObject(daySchedule); } return scheduleYear; }
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()); }
boost::optional<IdfObject> ForwardTranslator::translateAirLoopHVACOutdoorAirSystem( AirLoopHVACOutdoorAirSystem & modelObject ) { OptionalString s; IdfObject idfObject(IddObjectType::AirLoopHVAC_OutdoorAirSystem); m_idfObjects.push_back(idfObject); // Name std::string name = modelObject.name().get(); idfObject.setString(openstudio::AirLoopHVAC_OutdoorAirSystemFields::Name,name); // Controller List IdfObject controllerListIdf(IddObjectType::AirLoopHVAC_ControllerList); controllerListIdf.setName(name + " Controller List"); controllerListIdf.clearExtensibleGroups(); m_idfObjects.push_back(controllerListIdf); ControllerOutdoorAir controllerOutdoorAir = modelObject.getControllerOutdoorAir(); boost::optional<IdfObject> temp = translateAndMapModelObject(controllerOutdoorAir); s = controllerListIdf.name(); if(s) { idfObject.setString(openstudio::AirLoopHVAC_OutdoorAirSystemFields::ControllerListName,*s); } s = temp->iddObject().name(); StringVector groupFields(2u); bool addGroup(false); if(s) { groupFields[0] = *s; addGroup = true; } s = temp->name(); if(s) { groupFields[1] = *s; addGroup = true; } if (addGroup) { IdfExtensibleGroup eg = controllerListIdf.pushExtensibleGroup(groupFields); OS_ASSERT(!eg.empty()); } // Field: Availability Manager List Name ////////////////////////////////// IdfObject availabilityManagerListIdf(IddObjectType::AvailabilityManagerAssignmentList); availabilityManagerListIdf.setName(name + " Availability Manager"); m_idfObjects.push_back(availabilityManagerListIdf); IdfObject availabilityManagerScheduledIdf = IdfObject(openstudio::IddObjectType::AvailabilityManager_Scheduled); availabilityManagerScheduledIdf.createName(); m_idfObjects.push_back(availabilityManagerScheduledIdf); Schedule alwaysOn = modelObject.model().alwaysOnDiscreteSchedule(); IdfObject alwaysOnIdf = translateAndMapModelObject(alwaysOn).get(); s = availabilityManagerListIdf.getString(openstudio::AvailabilityManagerAssignmentListFields::Name); if(s) { idfObject.setString(openstudio::AirLoopHVAC_OutdoorAirSystemFields::AvailabilityManagerListName,*s); } availabilityManagerListIdf.setString(1 + openstudio::AvailabilityManagerAssignmentListExtensibleFields::AvailabilityManagerObjectType, availabilityManagerScheduledIdf.iddObject().name()); availabilityManagerListIdf.setString(1 + openstudio::AvailabilityManagerAssignmentListExtensibleFields::AvailabilityManagerName, availabilityManagerScheduledIdf.name().get()); availabilityManagerScheduledIdf.setString(openstudio::AvailabilityManager_ScheduledFields::ScheduleName,alwaysOnIdf.name().get()); // OA Node List s = modelObject.outboardOANode()->name(); IdfObject oaNodeListIdf(openstudio::IddObjectType::OutdoorAir_NodeList); if(s) { oaNodeListIdf.setString(0,*s); } m_idfObjects.push_back(oaNodeListIdf); /////////////////////////////////////////////////////////////////////////// // Field: Outdoor Air Equipment List Name ///////////////////////////////// IdfObject equipmentListIdf(IddObjectType::AirLoopHVAC_OutdoorAirSystem_EquipmentList); equipmentListIdf.setName(name + " Equipment List"); m_idfObjects.push_back(equipmentListIdf); IdfObject outdoorAirMixerIdf(IddObjectType::OutdoorAir_Mixer); outdoorAirMixerIdf.setName(name + " Outdoor Air Mixer"); m_idfObjects.push_back(outdoorAirMixerIdf); s = modelObject.mixedAirModelObject()->name(); if(s) { outdoorAirMixerIdf.setString(OutdoorAir_MixerFields::MixedAirNodeName,*s); } s = modelObject.outdoorAirModelObject()->name(); if(s) { outdoorAirMixerIdf.setString(OutdoorAir_MixerFields::OutdoorAirStreamNodeName,*s); } s = modelObject.reliefAirModelObject()->name(); if(s) { outdoorAirMixerIdf.setString(OutdoorAir_MixerFields::ReliefAirStreamNodeName,*s); } s = modelObject.returnAirModelObject()->name(); if(s) { outdoorAirMixerIdf.setString(OutdoorAir_MixerFields::ReturnAirStreamNodeName,*s); } s = outdoorAirMixerIdf.iddObject().name(); equipmentListIdf.setString(1,*s); s = outdoorAirMixerIdf.name(); equipmentListIdf.setString(2,*s); ModelObjectVector oaModelObjects = modelObject.oaComponents(); ModelObjectVector::iterator oaIt; unsigned i = 3; for( oaIt = oaModelObjects.begin(); oaIt != oaModelObjects.end(); ++oaIt ) { if( ! oaIt->optionalCast<Node>() ) { s = stripOS2(oaIt->iddObject().name()); if(s) equipmentListIdf.setString(i,*s); i++; s = oaIt->name(); if(s) equipmentListIdf.setString(i,*s); i++; } } s = equipmentListIdf.name(); if(s) { idfObject.setString(openstudio::AirLoopHVAC_OutdoorAirSystemFields::OutdoorAirEquipmentListName,*s); } for( oaIt = oaModelObjects.begin(); oaIt != oaModelObjects.end(); ++oaIt ) { translateAndMapModelObject(*oaIt); } return boost::optional<IdfObject>(idfObject); }
boost::optional<IdfObject> ForwardTranslator::translateSubSurface( model::SubSurface & modelObject ) { IdfObject idfObject(openstudio::IddObjectType::FenestrationSurface_Detailed); idfObject.setString(FenestrationSurface_DetailedFields::Name, modelObject.name().get()); std::string subSurfaceType = modelObject.subSurfaceType(); if (istringEqual("FixedWindow", subSurfaceType)){ subSurfaceType = "Window"; }else if (istringEqual("OperableWindow", subSurfaceType)){ subSurfaceType = "Window"; }else if (istringEqual("OverheadDoor", subSurfaceType)){ subSurfaceType = "Door"; }else if (istringEqual("Skylight", subSurfaceType)){ subSurfaceType = "Window"; } boost::optional<ConstructionBase> construction = modelObject.construction(); if (construction){ idfObject.setString(FenestrationSurface_DetailedFields::ConstructionName, construction->name().get()); if (subSurfaceType == "Door" && construction->isFenestration()){ LOG(Warn, "SubSurface '" << modelObject.name().get() << "' uses fenestration construction, changing SubSurfaceType to Door"); subSurfaceType = "GlassDoor"; } else if (subSurfaceType == "GlassDoor" && !construction->isFenestration()){ LOG(Warn, "SubSurface '" << modelObject.name().get() << "' uses non-fenestration construction, changing SubSurfaceType to GlassDoor"); subSurfaceType = "Door"; } } idfObject.setString(FenestrationSurface_DetailedFields::SurfaceType, subSurfaceType); boost::optional<Surface> surface = modelObject.surface(); if (surface){ idfObject.setString(FenestrationSurface_DetailedFields::BuildingSurfaceName, surface->name().get()); } boost::optional<SubSurface> adjacentSubSurface = modelObject.adjacentSubSurface(); if (adjacentSubSurface){ idfObject.setString(FenestrationSurface_DetailedFields::OutsideBoundaryConditionObject, adjacentSubSurface->name().get()); } boost::optional<double> viewFactortoGround = modelObject.viewFactortoGround(); if (viewFactortoGround){ idfObject.setDouble(FenestrationSurface_DetailedFields::ViewFactortoGround, *viewFactortoGround); } boost::optional<ShadingControl> shadingControl = modelObject.shadingControl(); if (shadingControl){ idfObject.setString(FenestrationSurface_DetailedFields::ShadingControlName, shadingControl->name().get()); } boost::optional<WindowPropertyFrameAndDivider> frameAndDivider = modelObject.windowPropertyFrameAndDivider(); openstudio::Vector3d offset(0, 0, 0); if (frameAndDivider){ if (!frameAndDivider->isOutsideRevealDepthDefaulted()){ offset = -frameAndDivider->outsideRevealDepth() * modelObject.outwardNormal(); } idfObject.setString(FenestrationSurface_DetailedFields::FrameandDividerName, frameAndDivider->name().get()); } if(!modelObject.isMultiplierDefaulted()){ idfObject.setDouble(FenestrationSurface_DetailedFields::Multiplier, modelObject.multiplier()); } idfObject.clearExtensibleGroups(); for (const Point3d& point : modelObject.vertices()){ IdfExtensibleGroup group = idfObject.pushExtensibleGroup(); if (group.empty()) { LOG(Error,"Currently unable to translate " << modelObject.briefDescription() << ", because it has more vertices than allowed by EnergyPlus."); return boost::none; } Point3d newPoint = point + offset; group.setDouble(0, newPoint.x()); group.setDouble(1, newPoint.y()); group.setDouble(2, newPoint.z()); } m_idfObjects.push_back(idfObject); return idfObject; }