Os 4.0 dev ScheduleRuleset

src/energyplus/ReverseTranslator.cpp

@@ -186,7 +186,14 @@ namespace energyplus {
     LOG(Trace, "Translating remaining objects.");
     vector<WorkspaceObject> 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.");

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 <utilities/idd/Schedule_Week_Daily_FieldEnums.hxx>
+#include <utilities/idd/Schedule_Year_FieldEnums.hxx>
 #include <utilities/idd/OS_Schedule_Week_FieldEnums.hxx>
 #include "../../utilities/idd/IddEnums.hpp"
 #include <utilities/idd/IddEnums.hxx>
@@ -27,6 +31,18 @@ namespace energyplus {
       return boost::none;
     }
 
+/*     for (const WorkspaceObject& scheduleYear : m_workspace.getObjectsByType(IddObjectType::Schedule_Year)) {
+      std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYear.extensibleGroups();
+      for (const IdfExtensibleGroup& idfGroup : extensibleGroups) {
+        auto workspaceGroup = idfGroup.cast<WorkspaceExtensibleGroup>();
+        if (OptionalWorkspaceObject scheduleWeek = workspaceGroup.getTarget(Schedule_YearExtensibleFields::Schedule_WeekName)) {
+          if (scheduleWeek->nameString() == workspaceObject.nameString()) {
+            return boost::none;
+          }
+        }
+      }
+    } */
+
     // create the schedule
     ScheduleWeek scheduleWeek(m_model);
 

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 {

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<detail::ScheduleRule_Impl>());
 
     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<ScheduleDay>().setScheduleTypeLimits(*limits);
+      if (cloneDaySchedule) {
+        clone->cast<ScheduleDay>().setScheduleTypeLimits(*limits);
+      } else {
+        daySchedule.cast<ScheduleDay>().setScheduleTypeLimits(*limits);
+      }
     }
 
     this->setRuleIndex(std::numeric_limits<int>::max());

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;

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<detail::ScheduleRuleset_Impl>()->setPointer(OS_Schedule_RulesetFields::DefaultDayScheduleName, defaultDaySchedule.handle());
   }
 
+  ScheduleRuleset::ScheduleRuleset(const Model& model, const ScheduleDay& defaultDaySchedule) : Schedule(ScheduleRuleset::iddObjectType(), model) {
+    OS_ASSERT(getImpl<detail::ScheduleRuleset_Impl>());
+    getImpl<detail::ScheduleRuleset_Impl>()->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<detail::ScheduleRuleset_Impl>()->isCustomDay2ScheduleDefaulted();
   }
 
+  bool ScheduleRuleset::setDefaultDaySchedule(const ScheduleDay& schedule) {
+    return getImpl<detail::ScheduleRuleset_Impl>()->setDefaultDaySchedule(schedule);
+  }
+
   bool ScheduleRuleset::setSummerDesignDaySchedule(const ScheduleDay& schedule) {
     return getImpl<detail::ScheduleRuleset_Impl>()->setSummerDesignDaySchedule(schedule);
   }

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.

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);