diff --git a/src/energyplus/ReverseTranslator.cpp b/src/energyplus/ReverseTranslator.cpp index 01ac3ba5ed1..f8688a0806c 100644 --- a/src/energyplus/ReverseTranslator.cpp +++ b/src/energyplus/ReverseTranslator.cpp @@ -186,7 +186,14 @@ namespace energyplus { LOG(Trace, "Translating remaining objects."); vector all = m_workspace.objects(); for (auto& elem : all) { - translateAndMapWorkspaceObject(elem); + switch (elem.iddObject().type().value()) { + case openstudio::IddObjectType::Schedule_Week_Daily: { + break; // no-op + } + default: { + translateAndMapWorkspaceObject(elem); + } + } } LOG(Trace, "Translation nominally complete."); diff --git a/src/energyplus/ReverseTranslator/ReverseTranslateScheduleWeekDaily.cpp b/src/energyplus/ReverseTranslator/ReverseTranslateScheduleWeekDaily.cpp index 670913b0ed0..dffcd2d46ad 100644 --- a/src/energyplus/ReverseTranslator/ReverseTranslateScheduleWeekDaily.cpp +++ b/src/energyplus/ReverseTranslator/ReverseTranslateScheduleWeekDaily.cpp @@ -10,7 +10,11 @@ #include "../../model/ScheduleDay.hpp" #include "../../model/ScheduleDay_Impl.hpp" +#include "../../utilities/idf/IdfExtensibleGroup.hpp" +#include "../../utilities/idf/WorkspaceExtensibleGroup.hpp" + #include +#include #include #include "../../utilities/idd/IddEnums.hpp" #include @@ -27,6 +31,18 @@ namespace energyplus { return boost::none; } +/* for (const WorkspaceObject& scheduleYear : m_workspace.getObjectsByType(IddObjectType::Schedule_Year)) { + std::vector extensibleGroups = scheduleYear.extensibleGroups(); + for (const IdfExtensibleGroup& idfGroup : extensibleGroups) { + auto workspaceGroup = idfGroup.cast(); + if (OptionalWorkspaceObject scheduleWeek = workspaceGroup.getTarget(Schedule_YearExtensibleFields::Schedule_WeekName)) { + if (scheduleWeek->nameString() == workspaceObject.nameString()) { + return boost::none; + } + } + } + } */ + // create the schedule ScheduleWeek scheduleWeek(m_model); diff --git a/src/energyplus/ReverseTranslator/ReverseTranslateScheduleYear.cpp b/src/energyplus/ReverseTranslator/ReverseTranslateScheduleYear.cpp index 767d60aeba9..ba457325432 100644 --- a/src/energyplus/ReverseTranslator/ReverseTranslateScheduleYear.cpp +++ b/src/energyplus/ReverseTranslator/ReverseTranslateScheduleYear.cpp @@ -18,6 +18,8 @@ #include "../../model/ScheduleRule_Impl.hpp" #include "../../model/ScheduleDay.hpp" #include "../../model/ScheduleDay_Impl.hpp" +#include "../../model/YearDescription.hpp" +#include "../../model/YearDescription_Impl.hpp" #include "../../utilities/idf/IdfExtensibleGroup.hpp" #include "../../utilities/idf/WorkspaceExtensibleGroup.hpp" @@ -53,6 +55,12 @@ namespace energyplus { return (holidayScheduleDayNames.size() > 1 || summerDesignDayScheduleDayNames.size() > 1 || winterDesignDayScheduleDayNames.size() > 1 || customDay1ScheduleDayNames.size() > 1 || customDay2ScheduleDayNames.size() > 1); } + [[nodiscard]] bool isDefaultDaySchedule() const { + return (holidayScheduleDayNames == summerDesignDayScheduleDayNames + && summerDesignDayScheduleDayNames == winterDesignDayScheduleDayNames + && winterDesignDayScheduleDayNames == customDay1ScheduleDayNames + && customDay1ScheduleDayNames == customDay2ScheduleDayNames); + } }; SpecialDayScheduleNames getSpecialDayScheduleNames(const WorkspaceObject& workspaceObject) { @@ -91,19 +99,19 @@ namespace energyplus { std::string dayTypeLower = openstudio::ascii_to_lower_copy(dayType_.get()); boost::optional scheduleDayName = dayTypeWorkspaceGroup.getString(Schedule_Week_CompactExtensibleFields::Schedule_DayName); - if (dayTypeLower == "holiday") { + if (dayTypeLower.find("holiday") != std::string::npos) { specialDayScheduleNames.holidayScheduleDayNames.emplace(*scheduleDayName); } - if (dayTypeLower == "summerdesignDay") { + if (dayTypeLower.find("summerdesignday") != std::string::npos) { specialDayScheduleNames.summerDesignDayScheduleDayNames.emplace(*scheduleDayName); } - if (dayTypeLower == "winterdesignDay") { + if (dayTypeLower.find("winterdesignday") != std::string::npos) { specialDayScheduleNames.winterDesignDayScheduleDayNames.emplace(*scheduleDayName); } - if (dayTypeLower == "customday1") { + if (dayTypeLower.find("customday1") != std::string::npos) { specialDayScheduleNames.customDay1ScheduleDayNames.emplace(*scheduleDayName); } - if (dayTypeLower == "customday2") { + if (dayTypeLower.find("customday2") != std::string::npos) { specialDayScheduleNames.customDay2ScheduleDayNames.emplace(*scheduleDayName); } } @@ -161,9 +169,12 @@ namespace energyplus { // reverse translate schedule week target = extensibleGroups[i].cast().getTarget(Schedule_YearExtensibleFields::Schedule_WeekName); if (target) { - OptionalModelObject scheduleWeekName = translateAndMapWorkspaceObject(*target); - if (scheduleWeekName) { - scheduleYear.addScheduleWeek(Date(*endMonth, *endDay), scheduleWeekName->cast()); + OptionalModelObject scheduleWeek = translateAndMapWorkspaceObject(*target); + if (scheduleWeek->iddObjectType() == IddObjectType::OS_Schedule_Week) { + scheduleYear.addScheduleWeek(Date(*endMonth, *endDay), scheduleWeek->cast()); + } else { // e.g., Schedule:Week:Compact does not reverse translate + LOG(Error, scheduleWeek->nameString() + " does not translate."); + return boost::none; } } } @@ -173,6 +184,9 @@ namespace energyplus { } else { // Special Days: for each type, not more than one exists (ScheduleRuleset can only accept a single one for each type) + model::YearDescription yd = m_model.getUniqueModelObject(); + openstudio::Date jan1 = yd.makeDate(MonthOfYear::Jan, 1); + ScheduleRuleset scheduleRuleset(m_model); // Name @@ -193,6 +207,9 @@ namespace energyplus { OptionalWorkspaceObject customDay1ScheduleDay; OptionalWorkspaceObject customDay2ScheduleDay; + std::vector dayScheduleNames; + std::vector scheduleRules; + for (const IdfExtensibleGroup& idfGroup : extensibleGroups) { auto workspaceGroup = idfGroup.cast(); @@ -206,13 +223,14 @@ namespace energyplus { Date startDate(*startMonth, *startDay); Date endDate(*endMonth, *endDay); - std::vector dayScheduleNames; - std::vector scheduleRules; + // Moved these up out of this loop so that we don't always create at least one rule for every week. + //std::vector dayScheduleNames; + //std::vector scheduleRules; // Lambda helper, not making it into a function since I need the ReverseTranslator context to call translateAndMapWorkspaceObject and I don't // want to define it into the ReverseTranslator.hpp - auto getOrCreateRule = [this, &scheduleRuleset, &startDate, &endDate, &dayScheduleNames, - &scheduleRules](const boost::optional& scheduleDay, const std::string& scheduleWeekName) { + auto getOrCreateRule = [this, &scheduleRuleset, &startDate, &endDate, &dayScheduleNames, &scheduleRules, &specialDayScheduleNames] + (const boost::optional& scheduleDay, const std::string& scheduleWeekName, const int dayOfWeek = 0) { boost::optional scheduleRule; if (scheduleDay) { @@ -220,21 +238,35 @@ namespace energyplus { auto it = std::find(dayScheduleNames.begin(), dayScheduleNames.end(), scheduleDayName); if (it != dayScheduleNames.end()) { + // this is the previous week's schedule rule scheduleRule = scheduleRules[it - dayScheduleNames.begin()]; - } else { - if (OptionalModelObject mo_daySchedule = translateAndMapWorkspaceObject(*scheduleDay)) { - auto daySchedule = mo_daySchedule->cast(); - // TODO: this clones daySchedule and sets the clone with a different name, which is annoying - - scheduleRule = ScheduleRule(scheduleRuleset, daySchedule); - // LOG(Debug, "Creating a new rule named " << scheduleRule->nameString() << " for " << scheduleWeekName << " with daySchedule" - // << daySchedule.nameString() << ", startDate=" << startDate << ", endDate=" << endDate); - scheduleRule->setName(scheduleWeekName); - scheduleRule->setStartDate(startDate); + if ((dayOfWeek == 6) || ((endDate.monthOfYear().value() == 12) && (endDate.dayOfMonth() == 31))) { + // use this week's endDate if + // - we made it to saturday of this week, or + // - this is the last week scheduleRule->setEndDate(endDate); - - dayScheduleNames.push_back(scheduleDayName); - scheduleRules.push_back(*scheduleRule); + } else { + // this is the new week's startDate + scheduleRule->setEndDate(startDate + dayOfWeek); + } + } else { + auto it2 = std::find(specialDayScheduleNames.holidayScheduleDayNames.begin(), specialDayScheduleNames.holidayScheduleDayNames.end(), scheduleDayName); + if (!(specialDayScheduleNames.isDefaultDaySchedule() && (it2 != specialDayScheduleNames.holidayScheduleDayNames.end()))) { + if (OptionalModelObject mo_daySchedule = translateAndMapWorkspaceObject(*scheduleDay)) { + auto daySchedule = mo_daySchedule->cast(); + + scheduleRule = ScheduleRule(scheduleRuleset, daySchedule, false); + // LOG(Debug, "Creating a new rule named " << scheduleRule->nameString() << " for " << scheduleWeekName << " with daySchedule" + // << daySchedule.nameString() << ", startDate=" << startDate << ", endDate=" << endDate); + //scheduleRule->setName(scheduleWeekName); + scheduleRule->setName(scheduleRuleset.nameString() + " rule"); + scheduleRule->setStartDate(startDate + dayOfWeek); + scheduleRule->setEndDate(endDate); + scheduleRule->setApplyAllDays(false); + + dayScheduleNames.push_back(scheduleDayName); + scheduleRules.push_back(*scheduleRule); + } } } } @@ -252,25 +284,26 @@ namespace energyplus { customDay2ScheduleDay = scheduleWeek->getTarget(Schedule_Week_DailyFields::CustomDay2Schedule_DayName); std::string scheduleWeekDailyName = scheduleWeek->getString(Schedule_Week_DailyFields::Name).get(); - if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::SundaySchedule_DayName), scheduleWeekDailyName)) { + if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::SundaySchedule_DayName), scheduleWeekDailyName, 0)) { + // TODO: if this is the first week, depending on the start day of week and how many week schedules there are, we may actually set this (and monday, etc) to false. schRule_->setApplySunday(true); } - if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::MondaySchedule_DayName), scheduleWeekDailyName)) { + if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::MondaySchedule_DayName), scheduleWeekDailyName, 1)) { schRule_->setApplyMonday(true); } - if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::TuesdaySchedule_DayName), scheduleWeekDailyName)) { + if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::TuesdaySchedule_DayName), scheduleWeekDailyName, 2)) { schRule_->setApplyTuesday(true); } - if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::WednesdaySchedule_DayName), scheduleWeekDailyName)) { + if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::WednesdaySchedule_DayName), scheduleWeekDailyName, 3)) { schRule_->setApplyWednesday(true); } - if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::ThursdaySchedule_DayName), scheduleWeekDailyName)) { + if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::ThursdaySchedule_DayName), scheduleWeekDailyName, 4)) { schRule_->setApplyThursday(true); } - if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::FridaySchedule_DayName), scheduleWeekDailyName)) { + if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::FridaySchedule_DayName), scheduleWeekDailyName, 5)) { schRule_->setApplyFriday(true); } - if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::SaturdaySchedule_DayName), scheduleWeekDailyName)) { + if (auto schRule_ = getOrCreateRule(scheduleWeek->getTarget(Schedule_Week_DailyFields::SaturdaySchedule_DayName), scheduleWeekDailyName, 6)) { schRule_->setApplySaturday(true); } @@ -285,19 +318,19 @@ namespace energyplus { std::string dayTypeLower = openstudio::ascii_to_lower_copy(dayType); OptionalWorkspaceObject scheduleDay = dayTypeWorkspaceGroup.getTarget(Schedule_Week_CompactExtensibleFields::Schedule_DayName); - if (dayTypeLower == "holiday") { + if (dayTypeLower.find("holiday") != std::string::npos) { holidayScheduleDay = scheduleDay; - } else if (dayTypeLower == "summerdesignday") { + } else if (dayTypeLower.find("summerdesignday") != std::string::npos) { summerDesignDayScheduleDay = scheduleDay; - } else if (dayTypeLower == "winterdesignday") { + } else if (dayTypeLower.find("winterdesignday") != std::string::npos) { winterDesignDayScheduleDay = scheduleDay; - } else if (dayTypeLower == "customday1") { + } else if (dayTypeLower.find("customday1") != std::string::npos) { customDay1ScheduleDay = scheduleDay; - } else if (dayTypeLower == "customday2") { + } else if (dayTypeLower.find("customday2") != std::string::npos) { customDay2ScheduleDay = scheduleDay; } else if (auto schRule_ = getOrCreateRule(scheduleDay, scheduleWeekCompactName)) { // TODO: allotherdays not correctly handled here - if (dayTypeLower == "alldays" || dayTypeLower == "allotherdays") { + if ((dayTypeLower.find("alldays") != std::string::npos) || (dayTypeLower.find("allotherdays") != std::string::npos)) { schRule_->setApplySunday(true); schRule_->setApplyMonday(true); schRule_->setApplyTuesday(true); @@ -305,28 +338,28 @@ namespace energyplus { schRule_->setApplyThursday(true); schRule_->setApplyFriday(true); schRule_->setApplySaturday(true); - } else if (dayTypeLower == "weekdays") { + } else if (dayTypeLower.find("weekdays") != std::string::npos) { schRule_->setApplyMonday(true); schRule_->setApplyTuesday(true); schRule_->setApplyWednesday(true); schRule_->setApplyThursday(true); schRule_->setApplyFriday(true); - } else if (dayTypeLower == "weekends") { + } else if (dayTypeLower.find("weekends") != std::string::npos) { schRule_->setApplySunday(true); schRule_->setApplySaturday(true); - } else if (dayTypeLower == "sunday") { + } else if (dayTypeLower.find("sunday") != std::string::npos) { schRule_->setApplySunday(true); - } else if (dayTypeLower == "monday") { + } else if (dayTypeLower.find("monday") != std::string::npos) { schRule_->setApplyMonday(true); - } else if (dayTypeLower == "tuesday") { + } else if (dayTypeLower.find("tuesday") != std::string::npos) { schRule_->setApplyTuesday(true); - } else if (dayTypeLower == "wednesday") { + } else if (dayTypeLower.find("wednesday") != std::string::npos) { schRule_->setApplyWednesday(true); - } else if (dayTypeLower == "thursday") { + } else if (dayTypeLower.find("thursday") != std::string::npos) { schRule_->setApplyThursday(true); - } else if (dayTypeLower == "friday") { + } else if (dayTypeLower.find("friday") != std::string::npos) { schRule_->setApplyFriday(true); - } else if (dayTypeLower == "saturday") { + } else if (dayTypeLower.find("saturday") != std::string::npos) { schRule_->setApplySaturday(true); } } @@ -335,34 +368,43 @@ namespace energyplus { } // End loop on extensible groups // Common path to both Schedule_Week_Daily and Schedule_Week_Compact - if (holidayScheduleDay) { - if (auto mo_ = translateAndMapWorkspaceObject(*holidayScheduleDay)) { - auto scheduleDay = mo_->cast(); - scheduleRuleset.setHolidaySchedule(scheduleDay); + if (specialDayScheduleNames.isDefaultDaySchedule()) { + if (holidayScheduleDay) { + if (auto mo_ = translateAndMapWorkspaceObject(*holidayScheduleDay)) { + auto scheduleDay = mo_->cast(); + scheduleRuleset.setDefaultDaySchedule(scheduleDay); + } } - } - if (summerDesignDayScheduleDay) { - if (auto mo_ = translateAndMapWorkspaceObject(*summerDesignDayScheduleDay)) { - auto scheduleDay = mo_->cast(); - scheduleRuleset.setSummerDesignDaySchedule(scheduleDay); + } else { + if (holidayScheduleDay) { + if (auto mo_ = translateAndMapWorkspaceObject(*holidayScheduleDay)) { + auto scheduleDay = mo_->cast(); + scheduleRuleset.setHolidaySchedule(scheduleDay); + } } - } - if (winterDesignDayScheduleDay) { - if (auto mo_ = translateAndMapWorkspaceObject(*winterDesignDayScheduleDay)) { - auto scheduleDay = mo_->cast(); - scheduleRuleset.setWinterDesignDaySchedule(scheduleDay); + if (summerDesignDayScheduleDay) { + if (auto mo_ = translateAndMapWorkspaceObject(*summerDesignDayScheduleDay)) { + auto scheduleDay = mo_->cast(); + scheduleRuleset.setSummerDesignDaySchedule(scheduleDay); + } } - } - if (customDay1ScheduleDay) { - if (auto mo_ = translateAndMapWorkspaceObject(*customDay1ScheduleDay)) { - auto scheduleDay = mo_->cast(); - scheduleRuleset.setCustomDay1Schedule(scheduleDay); + if (winterDesignDayScheduleDay) { + if (auto mo_ = translateAndMapWorkspaceObject(*winterDesignDayScheduleDay)) { + auto scheduleDay = mo_->cast(); + scheduleRuleset.setWinterDesignDaySchedule(scheduleDay); + } } - } - if (customDay2ScheduleDay) { - if (auto mo_ = translateAndMapWorkspaceObject(*customDay2ScheduleDay)) { - auto scheduleDay = mo_->cast(); - scheduleRuleset.setCustomDay2Schedule(scheduleDay); + if (customDay1ScheduleDay) { + if (auto mo_ = translateAndMapWorkspaceObject(*customDay1ScheduleDay)) { + auto scheduleDay = mo_->cast(); + scheduleRuleset.setCustomDay1Schedule(scheduleDay); + } + } + if (customDay2ScheduleDay) { + if (auto mo_ = translateAndMapWorkspaceObject(*customDay2ScheduleDay)) { + auto scheduleDay = mo_->cast(); + scheduleRuleset.setCustomDay2Schedule(scheduleDay); + } } } return scheduleRuleset; diff --git a/src/energyplus/Test/ScheduleRuleset_GTest.cpp b/src/energyplus/Test/ScheduleRuleset_GTest.cpp index 2b8a46f2644..da4bd2bc435 100644 --- a/src/energyplus/Test/ScheduleRuleset_GTest.cpp +++ b/src/energyplus/Test/ScheduleRuleset_GTest.cpp @@ -27,6 +27,7 @@ #include "../../model/YearDescription.hpp" #include "../../model/YearDescription_Impl.hpp" +#include "../../utilities/idf/IdfFile.hpp" #include "../../utilities/idf/IdfExtensibleGroup.hpp" #include "../../utilities/idf/WorkspaceExtensibleGroup.hpp" #include @@ -34,6 +35,8 @@ #include #include +#include + #include using namespace openstudio::energyplus; @@ -1852,3 +1855,432 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleRuleset_Bug5113_2) { EXPECT_EQ(31, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndDay).get()); } } + +void Run_RoundTrip_IDF_to_IDF(const std::string& filename, Workspace& w) { + w.save(filename + "_1.idf", true); + + ReverseTranslator rt; + Model m = rt.translateWorkspace(w); + + // TODO: temporary code for testing. + // how do we access calendar year from ScheduleRuleset RT? + model::YearDescription yd = m.getUniqueModelObject(); + m.setCalendarYear(2007); + //model::ScheduleRule scheduleRule = m.getModelObjects()[0]; + //scheduleRule.setApplySunday(false); // this is for RoundTrip_IDF_ScheduleRuleset_2_ScheduleWeekDaily + // + + m.save(filename + "_2.osm", true); + + ForwardTranslator ft; + Workspace w2 = ft.translateModel(m); + + w2.save(filename + "_3.idf", true); + + std::vector scheduleYears = w.getObjectsByType(IddObjectType::Schedule_Year); + std::vector scheduleYears2 = w2.getObjectsByType(IddObjectType::Schedule_Year); + EXPECT_EQ(scheduleYears.size(), scheduleYears2.size()); + + std::vector scheduleWeekDailys = w.getObjectsByType(IddObjectType::Schedule_Week_Daily); + std::vector scheduleWeekDailys2 = w2.getObjectsByType(IddObjectType::Schedule_Week_Daily); + EXPECT_EQ(scheduleWeekDailys.size(), scheduleWeekDailys2.size()); + + std::vector scheduleWeekCompacts = w.getObjectsByType(IddObjectType::Schedule_Week_Compact); + std::vector scheduleWeekCompacts2 = w2.getObjectsByType(IddObjectType::Schedule_Week_Compact); + EXPECT_EQ(scheduleWeekCompacts.size(), scheduleWeekCompacts2.size()); + + std::vector scheduleTypeLimitss = w.getObjectsByType(IddObjectType::ScheduleTypeLimits); + std::vector scheduleTypeLimitss2 = w2.getObjectsByType(IddObjectType::ScheduleTypeLimits); + EXPECT_EQ(scheduleTypeLimitss.size(), scheduleTypeLimitss2.size() - 3); // OnOff, OnOff 1, Fractional 1 + + std::vector scheduleDayInterval1s = w.getObjectsByType(IddObjectType::Schedule_Day_Interval); + std::vector scheduleDayInterval1s2 = w2.getObjectsByType(IddObjectType::Schedule_Day_Interval); + EXPECT_EQ(scheduleDayInterval1s.size(), scheduleDayInterval1s2.size()); +} + +TEST_F(EnergyPlusFixture, RoundTrip_IDF_ScheduleRuleset_1_ScheduleWeekDaily) { + Workspace w(StrictnessLevel::Minimal, IddFileType::EnergyPlus); + + IdfObject scheduleTypeLimits(openstudio::IddObjectType::ScheduleTypeLimits); + scheduleTypeLimits.setString(0, "Fractional"); + scheduleTypeLimits.setInt(1, 0); + scheduleTypeLimits.setInt(2, 1); + scheduleTypeLimits.setString(3, "Continuous"); + + IdfObject scheduleDayInterval1(openstudio::IddObjectType::Schedule_Day_Interval); + scheduleDayInterval1.setString(0, "occupants schedule day"); + scheduleDayInterval1.setString(1, "Fractional"); + scheduleDayInterval1.setString(2, "No"); + + IdfExtensibleGroup group1 = scheduleDayInterval1.pushExtensibleGroup(); + group1.setString(0, "05:00"); + group1.setDouble(1, 0.426829268292683); + IdfExtensibleGroup group2 = scheduleDayInterval1.pushExtensibleGroup(); + group2.setString(0, "06:00"); + group2.setDouble(1, 0.719512195121951); + IdfExtensibleGroup group3 = scheduleDayInterval1.pushExtensibleGroup(); + group3.setString(0, "07:00"); + group3.setDouble(1, 1); + + IdfObject scheduleWeekDaily(openstudio::IddObjectType::Schedule_Week_Daily); + scheduleWeekDaily.setString(0, "occupants schedule Week Rule - Jan1-Dec31"); + scheduleWeekDaily.setString(1, "occupants schedule day"); + scheduleWeekDaily.setString(2, "occupants schedule day"); + scheduleWeekDaily.setString(3, "occupants schedule day"); + scheduleWeekDaily.setString(4, "occupants schedule day"); + scheduleWeekDaily.setString(5, "occupants schedule day"); + scheduleWeekDaily.setString(6, "occupants schedule day"); + scheduleWeekDaily.setString(7, "occupants schedule day"); + scheduleWeekDaily.setString(8, "occupants schedule default day"); + scheduleWeekDaily.setString(9, "occupants schedule default day"); + scheduleWeekDaily.setString(10, "occupants schedule default day"); + scheduleWeekDaily.setString(11, "occupants schedule default day"); + scheduleWeekDaily.setString(12, "occupants schedule default day"); + + IdfObject scheduleYear(openstudio::IddObjectType::Schedule_Year); + scheduleYear.setString(0, "occupants schedule"); + scheduleYear.setString(1, "Fractional"); + IdfExtensibleGroup group4 = scheduleYear.pushExtensibleGroup(); + group4.setString(0, "occupants schedule Week Rule - Jan1-Dec31"); + group4.setInt(1, 1); + group4.setInt(2, 1); + group4.setInt(3, 12); + group4.setInt(4, 31); + + IdfObject scheduleDayInterval2(openstudio::IddObjectType::Schedule_Day_Interval); + scheduleDayInterval2.setString(0, "occupants schedule default day"); + scheduleDayInterval2.setString(1, "Fractional"); + scheduleDayInterval2.setString(2, "No"); + IdfExtensibleGroup group5 = scheduleDayInterval2.pushExtensibleGroup(); + group5.setString(0, "24:00"); + group5.setDouble(1, 1); + + w.addObject(scheduleTypeLimits); + w.addObject(scheduleDayInterval1); + w.addObject(scheduleDayInterval2); + w.addObject(scheduleWeekDaily); + w.addObject(scheduleYear); + + Run_RoundTrip_IDF_to_IDF("RoundTrip_ScheduleRuleset", w); +} + +TEST_F(EnergyPlusFixture, RoundTrip_IDF_ScheduleRuleset_2_ScheduleWeekDaily) { + Workspace w(StrictnessLevel::Minimal, IddFileType::EnergyPlus); + + IdfObject scheduleTypeLimits(openstudio::IddObjectType::ScheduleTypeLimits); + scheduleTypeLimits.setString(0, "OnOff"); + scheduleTypeLimits.setInt(1, 0); + scheduleTypeLimits.setInt(2, 1); + scheduleTypeLimits.setString(3, "Discrete"); + scheduleTypeLimits.setString(4, "availability"); + + IdfObject scheduleDayInterval1(openstudio::IddObjectType::Schedule_Day_Interval); + scheduleDayInterval1.setString(0, "natural vent schedule day"); + scheduleDayInterval1.setString(1, "OnOff"); + scheduleDayInterval1.setString(2, "No"); + + IdfExtensibleGroup group1 = scheduleDayInterval1.pushExtensibleGroup(); + group1.setString(0, "24:00"); + group1.setDouble(1, 1); + + IdfObject scheduleWeekDaily1(openstudio::IddObjectType::Schedule_Week_Daily); + scheduleWeekDaily1.setString(0, "natural vent schedule Week Rule - Jan1-Jan6"); + scheduleWeekDaily1.setString(1, "natural vent schedule day"); + scheduleWeekDaily1.setString(2, "natural vent schedule day"); + scheduleWeekDaily1.setString(3, "natural vent schedule default day"); + scheduleWeekDaily1.setString(4, "natural vent schedule day"); + scheduleWeekDaily1.setString(5, "natural vent schedule default day"); + scheduleWeekDaily1.setString(6, "natural vent schedule day"); + scheduleWeekDaily1.setString(7, "natural vent schedule default day"); + scheduleWeekDaily1.setString(8, "natural vent schedule default day"); + scheduleWeekDaily1.setString(9, "natural vent schedule default day"); + scheduleWeekDaily1.setString(10, "natural vent schedule default day"); + scheduleWeekDaily1.setString(11, "natural vent schedule default day"); + scheduleWeekDaily1.setString(12, "natural vent schedule default day"); + + IdfObject scheduleWeekDaily2(openstudio::IddObjectType::Schedule_Week_Daily); + scheduleWeekDaily2.setString(0, "natural vent schedule Week Rule - Jan7-Dec31"); + scheduleWeekDaily2.setString(1, "natural vent schedule default day"); + scheduleWeekDaily2.setString(2, "natural vent schedule day"); + scheduleWeekDaily2.setString(3, "natural vent schedule default day"); + scheduleWeekDaily2.setString(4, "natural vent schedule day"); + scheduleWeekDaily2.setString(5, "natural vent schedule default day"); + scheduleWeekDaily2.setString(6, "natural vent schedule day"); + scheduleWeekDaily2.setString(7, "natural vent schedule default day"); + scheduleWeekDaily2.setString(8, "natural vent schedule default day"); + scheduleWeekDaily2.setString(9, "natural vent schedule default day"); + scheduleWeekDaily2.setString(10, "natural vent schedule default day"); + scheduleWeekDaily2.setString(11, "natural vent schedule default day"); + scheduleWeekDaily2.setString(12, "natural vent schedule default day"); + + IdfObject scheduleYear(openstudio::IddObjectType::Schedule_Year); + scheduleYear.setString(0, "natural vent schedule"); + scheduleYear.setString(1, "OnOff"); + IdfExtensibleGroup group2 = scheduleYear.pushExtensibleGroup(); + group2.setString(0, "natural vent schedule Week Rule - Jan1-Jan6"); + group2.setInt(1, 1); + group2.setInt(2, 1); + group2.setInt(3, 1); + group2.setInt(4, 6); + IdfExtensibleGroup group3 = scheduleYear.pushExtensibleGroup(); + group3.setString(0, "natural vent schedule Week Rule - Jan7-Dec31"); + group3.setInt(1, 1); + group3.setInt(2, 7); + group3.setInt(3, 12); + group3.setInt(4, 31); + + IdfObject scheduleDayInterval2(openstudio::IddObjectType::Schedule_Day_Interval); + scheduleDayInterval2.setString(0, "natural vent schedule default day"); + scheduleDayInterval2.setString(1, "OnOff"); + scheduleDayInterval2.setString(2, "No"); + IdfExtensibleGroup group4 = scheduleDayInterval2.pushExtensibleGroup(); + group4.setString(0, "24:00"); + group4.setDouble(1, 0); + + w.addObject(scheduleTypeLimits); + w.addObject(scheduleDayInterval1); + w.addObject(scheduleDayInterval2); + w.addObject(scheduleWeekDaily1); + w.addObject(scheduleWeekDaily2); + w.addObject(scheduleYear); + + Run_RoundTrip_IDF_to_IDF("RoundTrip_ScheduleRuleset", w); +} + +TEST_F(EnergyPlusFixture, RoundTrip_IDF_ScheduleRuleset_Monthly_ScheduleWeekDaily) { + openstudio::path idfPath = resourcesPath() / toPath("energyplus/ScheduleRuleset/monthly.idf"); + OptionalIdfFile idfFile = IdfFile::load(idfPath, IddFileType::EnergyPlus); + ASSERT_TRUE(idfFile); + Workspace w(*idfFile); + + Run_RoundTrip_IDF_to_IDF("RoundTrip_ScheduleRuleset", w); +} + +TEST_F(EnergyPlusFixture, RoundTrip_IDF_ScheduleRuleset_1_ScheduleWeekCompact) { + Workspace w(StrictnessLevel::Minimal, IddFileType::EnergyPlus); + + IdfObject scheduleTypeLimits(openstudio::IddObjectType::ScheduleTypeLimits); + scheduleTypeLimits.setString(0, "Fraction"); + scheduleTypeLimits.setInt(1, 0); + scheduleTypeLimits.setInt(2, 1); + scheduleTypeLimits.setString(3, "Continuous"); + + IdfObject scheduleDayHourly1(openstudio::IddObjectType::Schedule_Day_Hourly); + scheduleDayHourly1.setString(0, "RefrigeratorDay"); + scheduleDayHourly1.setString(1, "Fraction"); + scheduleDayHourly1.setDouble(2, 0.8); + scheduleDayHourly1.setDouble(3, 0.782696177062374); + scheduleDayHourly1.setDouble(4, 0.765593561368209); + + IdfObject scheduleWeekCompact(openstudio::IddObjectType::Schedule_Week_Compact); + scheduleWeekCompact.setString(0, "RefrigeratorWeek"); + scheduleWeekCompact.setString(1, "For: AllDays"); + scheduleWeekCompact.setString(2, "RefrigeratorDay"); + + IdfObject scheduleYear(openstudio::IddObjectType::Schedule_Year); + scheduleYear.setString(0, "Refrigerator"); + scheduleYear.setString(1, "Fraction"); + IdfExtensibleGroup group4 = scheduleYear.pushExtensibleGroup(); + group4.setString(0, "RefrigeratorWeek"); + group4.setInt(1, 1); + group4.setInt(2, 1); + group4.setInt(3, 12); + group4.setInt(4, 31); + + w.addObject(scheduleTypeLimits); + w.addObject(scheduleDayHourly1); + w.addObject(scheduleWeekCompact); + w.addObject(scheduleYear); + + Run_RoundTrip_IDF_to_IDF("RoundTrip_ScheduleRuleset", w); +} + +TEST_F(EnergyPlusFixture, RoundTrip_IDF_ScheduleYear_2_ScheduleWeekDaily) { + Workspace w(StrictnessLevel::Minimal, IddFileType::EnergyPlus); + + IdfObject scheduleTypeLimits(openstudio::IddObjectType::ScheduleTypeLimits); + scheduleTypeLimits.setString(0, "OnOff"); + scheduleTypeLimits.setInt(1, 0); + scheduleTypeLimits.setInt(2, 1); + scheduleTypeLimits.setString(3, "Discrete"); + scheduleTypeLimits.setString(4, "availability"); + + IdfObject scheduleDayInterval1(openstudio::IddObjectType::Schedule_Day_Interval); + scheduleDayInterval1.setString(0, "natural vent schedule day"); + scheduleDayInterval1.setString(1, "OnOff"); + scheduleDayInterval1.setString(2, "No"); + + IdfExtensibleGroup group1 = scheduleDayInterval1.pushExtensibleGroup(); + group1.setString(0, "24:00"); + group1.setDouble(1, 1); + + IdfObject scheduleWeekDaily1(openstudio::IddObjectType::Schedule_Week_Daily); + scheduleWeekDaily1.setString(0, "natural vent schedule Week Rule - Jan1-Jan6"); + scheduleWeekDaily1.setString(1, "natural vent schedule day"); + scheduleWeekDaily1.setString(2, "natural vent schedule day"); + scheduleWeekDaily1.setString(3, "natural vent schedule default day"); + scheduleWeekDaily1.setString(4, "natural vent schedule day"); + scheduleWeekDaily1.setString(5, "natural vent schedule default day"); + scheduleWeekDaily1.setString(6, "natural vent schedule day"); + scheduleWeekDaily1.setString(7, "natural vent schedule default day"); + scheduleWeekDaily1.setString(8, "natural vent schedule default day"); + scheduleWeekDaily1.setString(9, "natural vent schedule default day"); + scheduleWeekDaily1.setString(10, "natural vent schedule default day"); + scheduleWeekDaily1.setString(11, "natural vent schedule default day"); + scheduleWeekDaily1.setString(12, "natural vent schedule default day"); + + IdfObject scheduleWeekDaily2(openstudio::IddObjectType::Schedule_Week_Daily); + scheduleWeekDaily2.setString(0, "natural vent schedule Week Rule - Jan7-Dec31"); + scheduleWeekDaily2.setString(1, "natural vent schedule default day"); + scheduleWeekDaily2.setString(2, "natural vent schedule day"); + scheduleWeekDaily2.setString(3, "natural vent schedule default day"); + scheduleWeekDaily2.setString(4, "natural vent schedule day"); + scheduleWeekDaily2.setString(5, "natural vent schedule default day"); + scheduleWeekDaily2.setString(6, "natural vent schedule day"); + scheduleWeekDaily2.setString(7, "natural vent schedule default day"); + scheduleWeekDaily2.setString(8, "natural vent schedule default day"); + scheduleWeekDaily2.setString(9, "natural vent schedule default day"); + scheduleWeekDaily2.setString(10, "natural vent schedule day"); // <-- different day schedule + scheduleWeekDaily2.setString(11, "natural vent schedule default day"); + scheduleWeekDaily2.setString(12, "natural vent schedule default day"); + + IdfObject scheduleYear(openstudio::IddObjectType::Schedule_Year); + scheduleYear.setString(0, "natural vent schedule"); + scheduleYear.setString(1, "OnOff"); + IdfExtensibleGroup group2 = scheduleYear.pushExtensibleGroup(); + group2.setString(0, "natural vent schedule Week Rule - Jan1-Jan6"); + group2.setInt(1, 1); + group2.setInt(2, 1); + group2.setInt(3, 1); + group2.setInt(4, 6); + IdfExtensibleGroup group3 = scheduleYear.pushExtensibleGroup(); + group3.setString(0, "natural vent schedule Week Rule - Jan7-Dec31"); + group3.setInt(1, 1); + group3.setInt(2, 7); + group3.setInt(3, 12); + group3.setInt(4, 31); + + IdfObject scheduleDayInterval2(openstudio::IddObjectType::Schedule_Day_Interval); + scheduleDayInterval2.setString(0, "natural vent schedule default day"); + scheduleDayInterval2.setString(1, "OnOff"); + scheduleDayInterval2.setString(2, "No"); + IdfExtensibleGroup group4 = scheduleDayInterval2.pushExtensibleGroup(); + group4.setString(0, "24:00"); + group4.setDouble(1, 0); + + w.addObject(scheduleTypeLimits); + w.addObject(scheduleDayInterval1); + w.addObject(scheduleDayInterval2); + w.addObject(scheduleWeekDaily1); + w.addObject(scheduleWeekDaily2); + w.addObject(scheduleYear); + + Run_RoundTrip_IDF_to_IDF("RoundTrip_ScheduleYear", w); +} + +TEST_F(EnergyPlusFixture, RoundTrip_IDF_ScheduleYear_2_ScheduleWeekCompact) { + Workspace w(StrictnessLevel::Minimal, IddFileType::EnergyPlus); + + IdfObject scheduleTypeLimits(openstudio::IddObjectType::ScheduleTypeLimits); + scheduleTypeLimits.setString(0, "Fraction"); + scheduleTypeLimits.setInt(1, 0); + scheduleTypeLimits.setInt(2, 1); + scheduleTypeLimits.setString(3, "Continuous"); + + IdfObject scheduleDayHourly1(openstudio::IddObjectType::Schedule_Day_Hourly); + scheduleDayHourly1.setString(0, "RefrigeratorDay"); + scheduleDayHourly1.setString(1, "Fraction"); + scheduleDayHourly1.setDouble(2, 0.8); + scheduleDayHourly1.setDouble(3, 0.782696177062374); + scheduleDayHourly1.setDouble(4, 0.765593561368209); + + IdfObject scheduleDayHourly2(openstudio::IddObjectType::Schedule_Day_Hourly); + scheduleDayHourly2.setString(0, "RefrigeratorDay2"); + scheduleDayHourly2.setString(1, "Fraction"); + scheduleDayHourly2.setDouble(2, 0.1); + scheduleDayHourly2.setDouble(3, 0.2); + + IdfObject scheduleWeekCompact1(openstudio::IddObjectType::Schedule_Week_Compact); + scheduleWeekCompact1.setString(0, "RefrigeratorWeek"); + scheduleWeekCompact1.setString(1, "For: WinterDesignDay"); + scheduleWeekCompact1.setString(2, "RefrigeratorDay"); + + IdfObject scheduleWeekCompact2(openstudio::IddObjectType::Schedule_Week_Compact); + scheduleWeekCompact2.setString(0, "RefrigeratorWeek2"); + scheduleWeekCompact2.setString(1, "For: WinterDesignDay"); + scheduleWeekCompact2.setString(2, "RefrigeratorDay2"); // <-- different day schedule + + IdfObject scheduleYear(openstudio::IddObjectType::Schedule_Year); + scheduleYear.setString(0, "Refrigerator"); + scheduleYear.setString(1, "Fraction"); + IdfExtensibleGroup group4 = scheduleYear.pushExtensibleGroup(); + group4.setString(0, "RefrigeratorWeek"); + group4.setInt(1, 1); + group4.setInt(2, 1); + group4.setInt(3, 1); + group4.setInt(4, 6); + IdfExtensibleGroup group5 = scheduleYear.pushExtensibleGroup(); + group5.setString(0, "RefrigeratorWeek2"); + group5.setInt(1, 1); + group5.setInt(2, 7); + group5.setInt(3, 12); + group5.setInt(4, 31); + + w.addObject(scheduleTypeLimits); + w.addObject(scheduleDayHourly1); + w.addObject(scheduleDayHourly2); + w.addObject(scheduleWeekCompact1); + w.addObject(scheduleWeekCompact2); + w.addObject(scheduleYear); + + Run_RoundTrip_IDF_to_IDF("RoundTrip_ScheduleYear", w); +} + +void Run_RoundTrip_OSM_to_OSM(const std::string& filename, Model& m) { + m.save(filename + "_1.osm", true); + + ForwardTranslator ft; + Workspace w = ft.translateModel(m); + + w.save(filename + "_2.idf", true); + + ReverseTranslator rt; + Model m2 = rt.translateWorkspace(w); + + m2.save(filename + "_3.osm", true); + + // TODO: compare model objects +} + +TEST_F(EnergyPlusFixture, RoundTrip_OSM_ScheduleRuleset_1_ScheduleRule) { + Model m; + + ScheduleTypeLimits scheduleTypeLimits(m); + scheduleTypeLimits.setName("Fractional"); + scheduleTypeLimits.setLowerLimitValue(0); + scheduleTypeLimits.setUpperLimitValue(0); + scheduleTypeLimits.setNumericType("Continuous"); + + ScheduleRuleset scheduleRuleset(m); + scheduleRuleset.setName("occupants schedule"); + scheduleRuleset.setScheduleTypeLimits(scheduleTypeLimits); + + ScheduleDay defaultDaySchedule = scheduleRuleset.defaultDaySchedule(); + defaultDaySchedule.setName("occupants schedule default day"); + defaultDaySchedule.setScheduleTypeLimits(scheduleTypeLimits); + + ScheduleRule scheduleRule(scheduleRuleset); + scheduleRule.setName("occupants schedule allday rule"); + scheduleRule.setApplyAllDays(true); + scheduleRule.setStartDate(Date(1, 1)); + scheduleRule.setEndDate(Date(12, 31)); + + ScheduleDay daySchedule = scheduleRule.daySchedule(); + daySchedule.setName("occupants schedule day"); + daySchedule.setScheduleTypeLimits(scheduleTypeLimits); + daySchedule.addValue(Time(0, 5), 0.426829268292683); + daySchedule.addValue(Time(0, 6), 0.719512195121951); + daySchedule.addValue(Time(0, 7), 1); + + Run_RoundTrip_OSM_to_OSM("RoundTrip_ScheduleRuleset", m); +} diff --git a/src/epmodel/Loop/Loop.hpp b/src/epmodel/Loop/Loop.hpp index b9e9962e420..18aeb2dfb2d 100644 --- a/src/epmodel/Loop/Loop.hpp +++ b/src/epmodel/Loop/Loop.hpp @@ -22,7 +22,7 @@ namespace openstudio { class AppGFuelType; class ComponentType; class FuelType; -class IddObjectType; +struct IddObjectType; class IdfObject; namespace epmodel { diff --git a/src/model/ScheduleRule.cpp b/src/model/ScheduleRule.cpp index 9581ac3fd25..fb7323cfc56 100644 --- a/src/model/ScheduleRule.cpp +++ b/src/model/ScheduleRule.cpp @@ -568,18 +568,27 @@ namespace model { OS_ASSERT(result); } - ScheduleRule::ScheduleRule(ScheduleRuleset& scheduleRuleset, const ScheduleDay& daySchedule) + ScheduleRule::ScheduleRule(ScheduleRuleset& scheduleRuleset, const ScheduleDay& daySchedule, bool cloneDaySchedule) : ParentObject(ScheduleRule::iddObjectType(), scheduleRuleset.model()) { OS_ASSERT(getImpl()); bool result = setPointer(OS_Schedule_RuleFields::ScheduleRulesetName, scheduleRuleset.handle()); OS_ASSERT(result); - ModelObject clone = daySchedule.clone(scheduleRuleset.model()); - result = setPointer(OS_Schedule_RuleFields::DayScheduleName, clone.handle()); + OptionalModelObject clone; + if (cloneDaySchedule) { + clone = daySchedule.clone(scheduleRuleset.model()); + result = setPointer(OS_Schedule_RuleFields::DayScheduleName, clone->handle()); + } else { + result = setPointer(OS_Schedule_RuleFields::DayScheduleName, daySchedule.handle()); + } OS_ASSERT(result); if (OptionalScheduleTypeLimits limits = scheduleRuleset.scheduleTypeLimits()) { - clone.cast().setScheduleTypeLimits(*limits); + if (cloneDaySchedule) { + clone->cast().setScheduleTypeLimits(*limits); + } else { + daySchedule.cast().setScheduleTypeLimits(*limits); + } } this->setRuleIndex(std::numeric_limits::max()); diff --git a/src/model/ScheduleRule.hpp b/src/model/ScheduleRule.hpp index b8d94a25382..586378f488a 100644 --- a/src/model/ScheduleRule.hpp +++ b/src/model/ScheduleRule.hpp @@ -38,10 +38,10 @@ namespace model { /// Constructor associates this rule with the given ruleset. This rule is made to be the highest priority rule. /// The given daySchedule is cloned and the new object is owned by (a child of) this rule. - explicit ScheduleRule(ScheduleRuleset& scheduleRuleset, const ScheduleDay& daySchedule); + explicit ScheduleRule(ScheduleRuleset& scheduleRuleset, const ScheduleDay& daySchedule, bool cloneDaySchedule = true); virtual ~ScheduleRule() override = default; - // Default the copy and move operators because the virtual dtor is explicit + // Default the copy and move operators because the virtual ctor is explicit ScheduleRule(const ScheduleRule& other) = default; ScheduleRule(ScheduleRule&& other) = default; ScheduleRule& operator=(const ScheduleRule&) = default; diff --git a/src/model/ScheduleRuleset.cpp b/src/model/ScheduleRuleset.cpp index e93ed5e483d..962dd1ed63f 100644 --- a/src/model/ScheduleRuleset.cpp +++ b/src/model/ScheduleRuleset.cpp @@ -318,6 +318,14 @@ namespace model { return this->isEmpty(OS_Schedule_RulesetFields::CustomDay2ScheduleName); } + bool ScheduleRuleset_Impl::setDefaultDaySchedule(const ScheduleDay& schedule) { + ScheduleDay defaultDaySchedule = this->defaultDaySchedule(); + bool result = setPointer(OS_Schedule_RulesetFields::DefaultDayScheduleName, schedule.handle()); + OS_ASSERT(result); + defaultDaySchedule.remove(); + return result; + } + bool ScheduleRuleset_Impl::setSummerDesignDaySchedule(const ScheduleDay& schedule) { if (OptionalScheduleTypeLimits candidateLimits = schedule.scheduleTypeLimits()) { if (OptionalScheduleTypeLimits parentLimits = scheduleTypeLimits()) { @@ -684,6 +692,11 @@ namespace model { getImpl()->setPointer(OS_Schedule_RulesetFields::DefaultDayScheduleName, defaultDaySchedule.handle()); } + ScheduleRuleset::ScheduleRuleset(const Model& model, const ScheduleDay& defaultDaySchedule) : Schedule(ScheduleRuleset::iddObjectType(), model) { + OS_ASSERT(getImpl()); + getImpl()->setPointer(OS_Schedule_RulesetFields::DefaultDayScheduleName, defaultDaySchedule.handle()); + } + IddObjectType ScheduleRuleset::iddObjectType() { IddObjectType result(IddObjectType::OS_Schedule_Ruleset); return result; @@ -737,6 +750,10 @@ namespace model { return getImpl()->isCustomDay2ScheduleDefaulted(); } + bool ScheduleRuleset::setDefaultDaySchedule(const ScheduleDay& schedule) { + return getImpl()->setDefaultDaySchedule(schedule); + } + bool ScheduleRuleset::setSummerDesignDaySchedule(const ScheduleDay& schedule) { return getImpl()->setSummerDesignDaySchedule(schedule); } diff --git a/src/model/ScheduleRuleset.hpp b/src/model/ScheduleRuleset.hpp index 6237e01bc9c..49fa0c9a18b 100644 --- a/src/model/ScheduleRuleset.hpp +++ b/src/model/ScheduleRuleset.hpp @@ -42,6 +42,8 @@ namespace model { * and assigns it to be the defaultDaySchedule(). */ ScheduleRuleset(const Model& model, double value); + explicit ScheduleRuleset(const Model& model, const ScheduleDay& defaultDaySchedule); + virtual ~ScheduleRuleset() override = default; // Default the copy and move operators because the virtual dtor is explicit ScheduleRuleset(const ScheduleRuleset& other) = default; @@ -95,6 +97,8 @@ namespace model { /** @name Setters */ //@{ + bool setDefaultDaySchedule(const ScheduleDay& schedule); + /// Sets the summer design day schedule if ScheduleTypeLimits are compatible. Calls remove /// on any existing non-default summer design day schedule. Clones schedule and parents the /// clone, but does not call remove on the original schedule. diff --git a/src/model/ScheduleRuleset_Impl.hpp b/src/model/ScheduleRuleset_Impl.hpp index 3748ee88dd4..84b141ed713 100644 --- a/src/model/ScheduleRuleset_Impl.hpp +++ b/src/model/ScheduleRuleset_Impl.hpp @@ -100,6 +100,8 @@ namespace model { /** @name Setters */ //@{ + bool setDefaultDaySchedule(const ScheduleDay& schedule); + /// Sets the summer design day schedule. bool setSummerDesignDaySchedule(const ScheduleDay& schedule);