Add Wellorder member to ScheduleState and serialize()

opm/parser/eclipse/EclipseState/Schedule/ScheduleState.hpp

@@ -32,6 +32,7 @@
 #include <opm/parser/eclipse/EclipseState/Schedule/OilVaporizationProperties.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/Events.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
+#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellOrder.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/Well/WListManager.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/MessageLimits.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/Group/GConSump.hpp>
@@ -134,6 +135,10 @@ namespace Opm {
         const UDQActive& udq_active() const;
         void udq_active(UDQActive udq_active);
 
+        const WellOrder& well_order() const;
+        void well_order(const std::string& well);
+        void well_order(WellOrder well_order);
+
         template<class Serializer>
         void serializeOp(Serializer& serializer) {
             serializer(m_start_time);
@@ -146,6 +151,7 @@ namespace Opm {
             m_wellgroup_events.serializeOp(serializer);
             serializer.vector(m_geo_keywords);
             m_message_limits.serializeOp(serializer);
+            serializer(m_well_order);
             serializer(m_whistctl_mode);
             serializer(m_wtest_config);
             serializer(m_gconsale);
@@ -173,6 +179,7 @@ namespace Opm {
         std::vector<DeckKeyword> m_geo_keywords;
         MessageLimits m_message_limits;
         Well::ProducerCMode m_whistctl_mode = Well::ProducerCMode::CMODE_UNDEFINED;
+        std::shared_ptr<WellOrder> m_well_order;
         std::shared_ptr<WellTestConfig> m_wtest_config;
         std::shared_ptr<GConSale> m_gconsale;
         std::shared_ptr<GConSump> m_gconsump;

opm/parser/eclipse/EclipseState/Schedule/Well/WellOrder.hpp

@@ -35,7 +35,6 @@ namespace Opm {
 class WellOrder {
 public:
     using Map = std::unordered_map<std::string, std::size_t>;
-    using Vector = std::vector<std::string>;
     WellOrder() = default;
     explicit WellOrder(const std::vector<std::string>& wells);
     void add(const std::string& well);
@@ -43,16 +42,21 @@ public:
     const std::vector<std::string>& wells() const;
     bool has(const std::string& wname) const;
 
+    template<class Serializer>
+    void serializeOp(Serializer& serializer) {
+        serializer.template map<Map, false>(m_wells1);
+        serializer(m_wells2);
+    }
 
     static WellOrder serializeObject();
 
     bool operator==(const WellOrder& other) const;
-    Vector::const_iterator begin() const;
-    Vector::const_iterator end() const;
+    std::vector<std::string>::const_iterator begin() const;
+    std::vector<std::string>::const_iterator end() const;
 
 private:
     Map m_wells1;
-    Vector m_wells2;
+    std::vector<std::string> m_wells2;
 };
 
 }

src/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp

@@ -1884,6 +1884,7 @@ void Schedule::create_first(const std::chrono::system_clock::time_point& start_t
     sched_state.rpt_config( RPTConfig() );
     sched_state.actions( Action::Actions() );
     sched_state.udq_active( UDQActive() );
+    sched_state.well_order( WellOrder() );
     this->addGroup("FIELD", 0);
 }
 

src/opm/parser/eclipse/EclipseState/Schedule/ScheduleState.cpp

@@ -355,4 +355,18 @@ void ScheduleState::udq_active(UDQActive udq_active) {
     this->m_udq_active = std::make_shared<UDQActive>( std::move(udq_active) );
 }
 
+const WellOrder& ScheduleState::well_order() const {
+    return *this->m_well_order;
+}
+
+void ScheduleState::well_order(WellOrder well_order) {
+    this->m_well_order = std::make_shared<WellOrder>( std::move(well_order) );
+}
+
+void ScheduleState::well_order(const std::string& well) {
+    auto well_order = *this->m_well_order;
+    well_order.add( well );
+    this->m_well_order = std::make_shared<WellOrder>( std::move(well_order) );
+}
+
 }