RHPV

msim/src/msim.cpp

@@ -119,6 +119,7 @@ void msim::run_step(const Schedule& schedule, Action::State& action_state, Summa
                           well_data,
                           group_nwrk_data,
                           {},
+                          {},
                           {});
 
         schedule.getUDQConfig( report_step ).eval(report_step, schedule.wellMatcher(report_step), st, udq_state);

opm/output/eclipse/Inplace.hpp

@@ -38,29 +38,34 @@ public:
         OilInGasPhase = 4,
         GasInLiquidPhase = 5,
         GasInGasPhase = 6,
-        PoreVolume = 7
+        PoreVolume = 7,
+        // The Inplace class is implemented in close relation to the
+        // ecloutputblackoilmodule in opm-simulators, ane there are certainly
+        // idiosyncracies here due to that coupling. For instance the three enum
+        // values PressurePV, HydroCarbonPV and PressureHydroCarbonPV are *not*
+        // included in the return value from phases().
+        PressurePV = 8,
+        HydroCarbonPV = 9,
+        PressureHydroCarbonPV = 10
     };
 
     /*
       The purpose of this class is to transport inplace values from the
       simulator code to the summary output code. The code is written very much
-      to fit in with the current implementation in the simulator, in particular
+      to fit in with the current implementation in the simulator. The functions
-      that the add/get functions exist in two varieties is a result of that.
+      which don't accept region_name & region_number arguments should be called
-
+      for totals, i.e. field properties.
-      The functions which don't accept region_name & region_number arguments
-      should be called for totals, i.e. field properties.
     */
 
 
-    void add(const std::string& region, const std::string& tag, std::size_t region_number, double value);
     void add(const std::string& region, Phase phase, std::size_t region_number, double value);
     void add(Phase phase, double value);
-    void add(const std::string& tag, double value);
 
-    double get(const std::string& region, const std::string& tag, std::size_t region_number) const;
     double get(const std::string& region, Phase phase, std::size_t region_number) const;
     double get(Phase phase) const;
-    double get(const std::string& tag) const;
+
+    bool has(const std::string& region, Phase phase, std::size_t region_number) const;
+    bool has(Phase phase) const;
 
     std::size_t max_region() const;
     std::size_t max_region(const std::string& region_name) const;
@@ -71,13 +76,11 @@ public:
       (region_number - 1). This is an incarnation of id <-> index confusion and
       should be replaced with a std::map instead.
     */
-    std::vector<double> get_vector(const std::string& region, const std::string& tag) const;
     std::vector<double> get_vector(const std::string& region, Phase phase) const;
 
     static const std::vector<Phase>& phases();
 private:
     std::unordered_map<std::string, std::unordered_map<Phase, std::unordered_map<std::size_t, double>>> phase_values;
-    std::unordered_map<std::string, std::unordered_map<std::string, std::unordered_map<std::size_t, double>>> tag_values;
 };
 
 

opm/output/eclipse/Summary.hpp

@@ -68,6 +68,7 @@ public:
               const data::GroupAndNetworkValues& group_and_nwrk_solution,
               GlobalProcessParameters            single_values,
               const Inplace&                     initial_inplace,
+              const Inplace&                     inplace,
               const RegionParameters&            region_values = {},
               const BlockValues&                 block_values  = {},
               const data::Aquifers&              aquifers_values = {}) const;

src/opm/output/eclipse/Inplace.cpp

@@ -31,10 +31,6 @@ static const std::string FIELD_NAME = std::string{"FIELD"};
 static const std::size_t FIELD_ID   = 0;
 }
 
-void Inplace::add(const std::string& region, const std::string& tag, std::size_t region_id, double value) {
-    this->tag_values[region][tag][region_id] = value;
-}
-
 void Inplace::add(const std::string& region, Inplace::Phase phase, std::size_t region_id, double value) {
     this->phase_values[region][phase][region_id] = value;
 }
@@ -43,26 +39,6 @@ void Inplace::add(Inplace::Phase phase, double value) {
     this->add( FIELD_NAME, phase, FIELD_ID, value );
 }
 
-void Inplace::add(const std::string& tag, double value) {
-    this->add( FIELD_NAME, tag, FIELD_ID, value );
-}
-
-double Inplace::get(const std::string& region, const std::string& tag, std::size_t region_id) const {
-    auto region_iter = this->tag_values.find(region);
-    if (region_iter == this->tag_values.end())
-        throw std::logic_error(fmt::format("No such region: {}", region));
-
-    auto tag_iter = region_iter->second.find(tag);
-    if (tag_iter == region_iter->second.end())
-        throw std::logic_error(fmt::format("No such tag: {}:{}", region, tag));
-
-    auto value_iter = tag_iter->second.find(region_id);
-    if (value_iter == tag_iter->second.end())
-        throw std::logic_error(fmt::format("No such region id: {}:{}:{}", region, tag, region_id));
-
-    return value_iter->second;
-}
-
 double Inplace::get(const std::string& region, Inplace::Phase phase, std::size_t region_id) const {
     auto region_iter = this->phase_values.find(region);
     if (region_iter == this->phase_values.end())
@@ -83,8 +59,24 @@ double Inplace::get(Inplace::Phase phase) const {
     return this->get(FIELD_NAME, phase, FIELD_ID);
 }
 
-double Inplace::get(const std::string& tag) const {
+bool Inplace::has(const std::string& region, Phase phase, std::size_t region_id) const {
-    return this->get(FIELD_NAME, tag, FIELD_ID);
+    auto region_iter = this->phase_values.find(region);
+    if (region_iter == this->phase_values.end())
+        return false;
+
+    auto phase_iter = region_iter->second.find(phase);
+    if (phase_iter == region_iter->second.end())
+        return false;
+
+    auto value_iter = phase_iter->second.find(region_id);
+    if (value_iter == phase_iter->second.end())
+        return false;
+
+    return true;
+}
+
+bool Inplace::has(Phase phase) const {
+    return this->has(FIELD_NAME, phase, FIELD_ID);
 }
 
 namespace {
@@ -108,41 +100,20 @@ std::size_t Inplace::max_region() const {
         }
     }
 
-    for (const auto& [_, string_map] : this->tag_values) {
-        (void)_;
-        for (const auto& [__, region_map] : string_map) {
-            (void)__;
-            max_value = std::max(max_value, region_max(region_map));
-        }
-    }
     return max_value;
 }
 
 std::size_t Inplace::max_region(const std::string& region_name) const {
     std::optional<std::size_t> max_value;
-    {
+    const auto& region_iter = this->phase_values.find(region_name);
-        const auto& region_iter = this->phase_values.find(region_name);
+    if (region_iter != this->phase_values.end()) {
-        if (region_iter != this->phase_values.end()) {
+        max_value = 0;
-            max_value = 0;
+        for (const auto& [_, region_map] : region_iter->second) {
-            for (const auto& [_, region_map] : region_iter->second) {
+            (void)_;
-                (void)_;
+            max_value = std::max(*max_value, region_max(region_map));
-                max_value = std::max(*max_value, region_max(region_map));
-            }
         }
     }
 
-    {
-        const auto& region_iter = this->tag_values.find(region_name);
-        if (region_iter != this->tag_values.end()) {
-            if (!max_value.has_value())
-                max_value = 0;
-
-            for (const auto& [_, region_map] : region_iter->second) {
-                (void)_;
-                max_value = std::max(*max_value, region_max(region_map));
-            }
-        }
-    }
     if (!max_value.has_value())
         throw std::logic_error(fmt::format("No such region: {}", region_name));
 
@@ -160,15 +131,6 @@ std::vector<double> Inplace::get_vector(const std::string& region, Phase phase)
     return v;
 }
 
-std::vector<double> Inplace::get_vector(const std::string& region, const std::string& tag) const {
-    std::vector<double> v(this->max_region(region), 0);
-    const auto& region_map = this->tag_values.at(region).at(tag);
-    for (const auto& [region_id, value] : region_map)
-        v[region_id - 1] = value;
-
-    return v;
-}
-
 
 const std::vector<Inplace::Phase>& Inplace::phases() {
     static const std::vector<Phase> phases_ = {

src/opm/output/eclipse/Summary.cpp

@@ -49,7 +49,7 @@
 #include <opm/output/data/GuideRateValue.hpp>
 #include <opm/output/data/Wells.hpp>
 #include <opm/output/data/Aquifer.hpp>
-
+#include <opm/output/eclipse/Inplace.hpp>
 #include <opm/output/eclipse/RegionCache.hpp>
 
 #include <fmt/format.h>
@@ -407,6 +407,7 @@ struct fn_args {
     const Opm::EclipseGrid& grid;
     const std::vector< std::pair< std::string, double > > eff_factors;
     const Opm::Inplace& initial_inplace;
+    const Opm::Inplace& inplace;
     const Opm::UnitSystem& unit_system;
 };
 
@@ -926,6 +927,16 @@ quantity region_rate( const fn_args& args ) {
         return { -sum, rate_unit< phase >() };
 }
 
+quantity rhpv(const fn_args& args) {
+    const auto& inplace = args.inplace;
+    const auto& region_name = std::get<std::string>(*args.extra_data);
+    if (inplace.has( region_name, Opm::Inplace::Phase::HydroCarbonPV, args.num ))
+        return { inplace.get( region_name, Opm::Inplace::Phase::HydroCarbonPV, args.num ), measure::volume };
+    else
+        return {0, measure::volume};
+}
+
+
 template < rt phase, bool outputProducer = true, bool outputInjector = true>
 inline quantity potential_rate( const fn_args& args ) {
     double sum = 0.0;
@@ -1565,6 +1576,7 @@ static const std::unordered_map< std::string, ofun > funs = {
     { "ROPT"  , mul( region_rate< rt::oil, producer >, duration ) },
     { "RGPT"  , mul( region_rate< rt::gas, producer >, duration ) },
     { "RWPT"  , mul( region_rate< rt::wat, producer >, duration ) },
+    { "RHPV"  , rhpv },
     //Multisegment well segment data
     { "SOFR", srate< rt::oil > },
     { "SWFR", srate< rt::wat > },
@@ -1853,6 +1865,7 @@ namespace Evaluator {
         const Opm::data::WellRates& wellSol;
         const Opm::data::GroupAndNetworkValues& grpNwrkSol;
         const std::map<std::string, double>& single;
+        const Opm::Inplace inplace;
         const std::map<std::string, std::vector<double>>& region;
         const std::map<std::pair<std::string, int>, double>& block;
         const Opm::data::Aquifers& aquifers;
@@ -1904,7 +1917,7 @@ namespace Evaluator {
                 std::max(0, this->node_.number),
                 this->node_.fip_region,
                 st, simRes.wellSol, simRes.grpNwrkSol, input.reg, input.grid,
-                std::move(efac.factors), input.initial_inplace, input.sched.getUnits()
+                std::move(efac.factors), input.initial_inplace, simRes.inplace, input.sched.getUnits()
             };
 
             const auto& usys = input.es.getUnits();
@@ -2449,7 +2462,8 @@ namespace Evaluator {
             {}, "", 0.0, 0, std::max(0, this->node_->number),
             this->node_->fip_region,
             this->st_, {}, {}, reg, this->grid_,
-            {}, {}, Opm::UnitSystem(Opm::UnitSystem::UnitType::UNIT_TYPE_METRIC)};
+            {}, {}, {}, Opm::UnitSystem(Opm::UnitSystem::UnitType::UNIT_TYPE_METRIC)
+        };
 
         const auto prm = this->paramFunction_(args);
 
@@ -2699,6 +2713,7 @@ public:
               const data::GroupAndNetworkValues& grp_nwrk_solution,
               GlobalProcessParameters&           single_values,
               const Inplace&                     initial_inplace,
+              const Opm::Inplace&                inplace,
               const RegionParameters&            region_values,
               const BlockValues&                 block_values,
               const data::Aquifers&              aquifer_values,
@@ -2808,6 +2823,7 @@ eval(const int                          sim_step,
      const data::GroupAndNetworkValues& grp_nwrk_solution,
      GlobalProcessParameters&           single_values,
      const Inplace&                     initial_inplace,
+     const Opm::Inplace&                inplace,
      const RegionParameters&            region_values,
      const BlockValues&                 block_values,
      const data::Aquifers&              aquifer_values,
@@ -2824,7 +2840,7 @@ eval(const int                          sim_step,
     };
 
     const Evaluator::SimulatorResults simRes {
-        well_solution, grp_nwrk_solution, single_values, region_values, block_values, aquifer_values
+        well_solution, grp_nwrk_solution, single_values, inplace, region_values, block_values, aquifer_values
     };
 
     for (auto& evalPtr : this->outputParameters_.getEvaluators()) {
@@ -3206,6 +3222,7 @@ void Summary::eval(SummaryState&                      st,
                    const data::GroupAndNetworkValues& grp_nwrk_solution,
                    GlobalProcessParameters            single_values,
                    const Inplace&                     initial_inplace,
+                   const Inplace&                     inplace,
                    const RegionParameters&            region_values,
                    const BlockValues&                 block_values,
                    const Opm::data::Aquifers&         aquifer_values) const
@@ -3222,8 +3239,9 @@ void Summary::eval(SummaryState&                      st,
      * wells, groups, connections &c in the Schedule object. */
     const auto sim_step = std::max( 0, report_step - 1 );
 
-    this->pImpl_->eval(sim_step, secs_elapsed, well_solution,
+    this->pImpl_->eval(sim_step, secs_elapsed,
-                       grp_nwrk_solution, single_values, initial_inplace,
+                       well_solution, grp_nwrk_solution, single_values,
+                       initial_inplace, inplace,
                        region_values, block_values, aquifer_values, st);
 }
 

tests/test_Inplace.cpp

@@ -38,21 +38,15 @@ BOOST_AUTO_TEST_CASE(TESTInplace) {
 
     oip.add("FIPNUM", Inplace::Phase::OIL, 3, 100);
     oip.add("FIPNUM", Inplace::Phase::OIL, 6, 50);
-    oip.add("FIPNUM", "StringID", 5, 200);
 
 
     BOOST_CHECK_EQUAL( oip.get("FIPNUM", Inplace::Phase::OIL, 3) , 100);
     BOOST_CHECK_EQUAL( oip.get("FIPNUM", Inplace::Phase::OIL, 6) , 50);
-    BOOST_CHECK_EQUAL( oip.get("FIPNUM", "StringID", 5) , 200);
 
     BOOST_CHECK_THROW( oip.get("FIPNUM", Inplace::Phase::OIL, 4), std::exception);
     BOOST_CHECK_THROW( oip.get("FIPNUM", Inplace::Phase::GAS, 3), std::exception);
     BOOST_CHECK_THROW( oip.get("FIPX", Inplace::Phase::OIL, 3)  , std::exception);
 
-    BOOST_CHECK_THROW( oip.get("FIPNUM", "StringID", 4), std::exception);
-    BOOST_CHECK_THROW( oip.get("FIPNUM", "XXX", 3), std::exception);
-    BOOST_CHECK_THROW( oip.get("FIPX", "StringID", 3)  , std::exception);
-
 
     BOOST_CHECK_EQUAL( oip.max_region(), 6);
     BOOST_CHECK_EQUAL( oip.max_region("FIPNUM"), 6);
@@ -77,7 +71,4 @@ BOOST_AUTO_TEST_CASE(TESTInplace) {
     std::vector<double> e1 = {0,0,100,0,0,50};
     BOOST_CHECK( v1 == e1 );
 
-    auto v2 = oip.get_vector("FIPNUM", "StringID");
-    std::vector<double> e2 = {0,0,0,0,200,0};
-    BOOST_CHECK( v2 == e2 );
 }

tests/test_Summary.cpp

@@ -468,13 +468,13 @@ BOOST_AUTO_TEST_CASE(well_keywords) {
     SummaryState st(std::chrono::system_clock::now());
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule , cfg.name );
-    writer.eval(st, 0, 0*day, cfg.wells, cfg.grp_nwrk, {}, {});
+    writer.eval(st, 0, 0*day, cfg.wells, cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 0);
 
-    writer.eval(st, 1, 1*day, cfg.wells, cfg.grp_nwrk, {}, {});
+    writer.eval(st, 1, 1*day, cfg.wells, cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
 
-    writer.eval(st, 2, 2*day, cfg.wells, cfg.grp_nwrk, {}, {});
+    writer.eval(st, 2, 2*day, cfg.wells, cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 2);
     writer.write();
 
@@ -693,11 +693,11 @@ BOOST_AUTO_TEST_CASE(udq_keywords) {
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule , cfg.name );
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 0);
-    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
-    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 2);
     writer.write();
 
@@ -718,13 +718,13 @@ BOOST_AUTO_TEST_CASE(group_keywords) {
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 0);
 
-    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
 
-    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 2);
 
     writer.write();
@@ -875,11 +875,11 @@ BOOST_AUTO_TEST_CASE(group_group) {
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 0);
-    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
-    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 2);
     writer.write();
 
@@ -931,11 +931,11 @@ BOOST_AUTO_TEST_CASE(connection_kewords) {
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 0);
-    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
-    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 2);
     writer.write();
 
@@ -1005,13 +1005,13 @@ BOOST_AUTO_TEST_CASE(DATE) {
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
-    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 2);
-    writer.eval( st, 3, 18 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 3, 18 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 3);
-    writer.eval( st, 4, 22 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 4, 22 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 4);
     writer.write();
 
@@ -1042,11 +1042,11 @@ BOOST_AUTO_TEST_CASE(field_keywords) {
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 0);
-    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
-    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 2);
     writer.write();
 
@@ -1179,11 +1179,11 @@ BOOST_AUTO_TEST_CASE(report_steps_time) {
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval( st, 1, 2 *  day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 2 *  day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
-    writer.eval( st, 1, 5 *  day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 5 *  day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
-    writer.eval( st, 2, 10 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 2, 10 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 2);
     writer.write();
 
@@ -1206,11 +1206,11 @@ BOOST_AUTO_TEST_CASE(skip_unknown_var) {
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval( st, 1, 2 *  day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 2 *  day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
-    writer.eval( st, 1, 5 *  day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 5 *  day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
-    writer.eval( st, 2, 10 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 2, 10 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 2);
     writer.write();
 
@@ -1317,11 +1317,11 @@ BOOST_AUTO_TEST_CASE(region_vars) {
     {
         out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
         SummaryState st(std::chrono::system_clock::now());
-        writer.eval( st, 1, 2 *  day, cfg.wells, cfg.grp_nwrk, {}, {}, region_values);
+        writer.eval( st, 1, 2 *  day, cfg.wells, cfg.grp_nwrk, {}, {}, {}, region_values);
         writer.add_timestep( st, 1);
-        writer.eval( st, 1, 5 *  day, cfg.wells, cfg.grp_nwrk, {}, {}, region_values);
+        writer.eval( st, 1, 5 *  day, cfg.wells, cfg.grp_nwrk, {}, {}, {}, region_values);
         writer.add_timestep( st, 1);
-        writer.eval( st, 2, 10 * day, cfg.wells, cfg.grp_nwrk, {}, {}, region_values);
+        writer.eval( st, 2, 10 * day, cfg.wells, cfg.grp_nwrk, {}, {}, {}, region_values);
         writer.add_timestep( st, 2);
         writer.write();
     }
@@ -1368,11 +1368,11 @@ BOOST_AUTO_TEST_CASE(region_production) {
     {
         out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
         SummaryState st(std::chrono::system_clock::now());
-        writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+        writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
         writer.add_timestep( st, 0);
-        writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+        writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
         writer.add_timestep( st, 1);
-        writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+        writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
         writer.add_timestep( st, 2);
         writer.write();
     }
@@ -1400,11 +1400,11 @@ BOOST_AUTO_TEST_CASE(region_injection) {
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 0);
-    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
-    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 2);
     writer.write();
 
@@ -1458,15 +1458,15 @@ BOOST_AUTO_TEST_CASE(BLOCK_VARIABLES) {
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {},{}, {}, block_values);
+    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {},{}, {}, {}, block_values);
     writer.add_timestep( st, 0);
-    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {},{}, {}, block_values);
+    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {},{}, {}, {}, block_values);
     writer.add_timestep( st, 1);
-    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {},{}, {}, block_values);
+    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {},{}, {}, {}, block_values);
     writer.add_timestep( st, 2);
-    writer.eval( st, 3, 2 * day, cfg.wells , cfg.grp_nwrk, {},{}, {}, block_values);
+    writer.eval( st, 3, 2 * day, cfg.wells , cfg.grp_nwrk, {},{}, {}, {}, block_values);
     writer.add_timestep( st, 3);
-    writer.eval( st, 4, 2 * day, cfg.wells , cfg.grp_nwrk, {},{}, {}, block_values);
+    writer.eval( st, 4, 2 * day, cfg.wells , cfg.grp_nwrk, {},{}, {}, {}, block_values);
     writer.add_timestep( st, 4);
     writer.write();
 
@@ -1519,13 +1519,13 @@ BOOST_AUTO_TEST_CASE(NODE_VARIABLES) {
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 0);
 
-    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
 
-    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 2);
 
     writer.write();
@@ -1577,11 +1577,11 @@ BOOST_AUTO_TEST_CASE(MISC) {
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule , cfg.name );
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 0);
-    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
-    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {});
+    writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 2);
     writer.write();
 
@@ -1597,19 +1597,19 @@ BOOST_AUTO_TEST_CASE(EXTRA) {
     {
         out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule , cfg.name );
         SummaryState st(std::chrono::system_clock::now());
-        writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, { {"TCPU" , 0 }}, {});
+        writer.eval( st, 0, 0 * day, cfg.wells , cfg.grp_nwrk, { {"TCPU" , 0 }}, {}, {});
         writer.add_timestep( st, 0);
-        writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, { {"TCPU" , 1 }}, {});
+        writer.eval( st, 1, 1 * day, cfg.wells , cfg.grp_nwrk, { {"TCPU" , 1 }}, {}, {});
         writer.add_timestep( st, 1);
-        writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, { {"TCPU" , 2}}, {});
+        writer.eval( st, 2, 2 * day, cfg.wells , cfg.grp_nwrk, { {"TCPU" , 2}}, {}, {});
         writer.add_timestep( st, 2);
 
         /* Add a not-recognized key; that is OK */
-        BOOST_CHECK_NO_THROW(  writer.eval( st, 3, 3 * day, cfg.wells , cfg.grp_nwrk, { {"MISSING" , 2 }}, {}));
+        BOOST_CHECK_NO_THROW(  writer.eval( st, 3, 3 * day, cfg.wells , cfg.grp_nwrk, { {"MISSING" , 2 }}, {}, {}));
         BOOST_CHECK_NO_THROW(  writer.add_timestep( st, 3));
 
         /* Override a NOT MISC variable - ignored. */
-        writer.eval( st, 4, 4 * day, cfg.wells, cfg.grp_nwrk, {}, {});
+        writer.eval( st, 4, 4 * day, cfg.wells, cfg.grp_nwrk, {}, {}, {});
         writer.add_timestep( st, 4);
         writer.write();
     }
@@ -1728,11 +1728,11 @@ BOOST_AUTO_TEST_CASE(efficiency_factor) {
 
         out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule, cfg.name );
         SummaryState st(std::chrono::system_clock::now());
-        writer.eval( st, 0, 0 * day, cfg.wells, cfg.grp_nwrk, {}, {});
+        writer.eval( st, 0, 0 * day, cfg.wells, cfg.grp_nwrk, {}, {}, {});
         writer.add_timestep( st, 0);
-        writer.eval( st, 1, 1 * day, cfg.wells, cfg.grp_nwrk, {}, {});
+        writer.eval( st, 1, 1 * day, cfg.wells, cfg.grp_nwrk, {}, {}, {});
         writer.add_timestep( st, 1);
-        writer.eval( st, 2, 2 * day, cfg.wells, cfg.grp_nwrk, {}, {});
+        writer.eval( st, 2, 2 * day, cfg.wells, cfg.grp_nwrk, {}, {}, {});
         writer.add_timestep( st, 2);
         writer.write();
         auto res = readsum( cfg.name );
@@ -1975,11 +1975,11 @@ namespace {
         };
 
       SummaryState st(std::chrono::system_clock::now());
-      smry.eval(st, 0, 0*day, config.wells, config.grp_nwrk, {}, {});
+      smry.eval(st, 0, 0*day, config.wells, config.grp_nwrk, {}, {}, {});
       smry.add_timestep(st, 0);
-      smry.eval(st, 1, 1*day, config.wells, config.grp_nwrk, {}, {});
+      smry.eval(st, 1, 1*day, config.wells, config.grp_nwrk, {}, {}, {});
       smry.add_timestep(st, 1);
-      smry.eval(st, 2, 2*day, config.wells, config.grp_nwrk, {}, {});
+      smry.eval(st, 2, 2*day, config.wells, config.grp_nwrk, {}, {}, {});
       smry.add_timestep(st, 2);
 
       return st;
@@ -2975,11 +2975,11 @@ BOOST_AUTO_TEST_CASE(Write_Read)
     };
 
     SummaryState st(std::chrono::system_clock::now());
-    writer.eval(st, 0, 0*day, config.wells, config.grp_nwrk, {}, {});
+    writer.eval(st, 0, 0*day, config.wells, config.grp_nwrk, {}, {}, {});
     writer.add_timestep(st, 0);
-    writer.eval(st, 1, 1*day, config.wells, config.grp_nwrk, {}, {});
+    writer.eval(st, 1, 1*day, config.wells, config.grp_nwrk, {}, {}, {});
     writer.add_timestep(st, 1);
-    writer.eval(st, 2, 2*day, config.wells, config.grp_nwrk, {}, {});
+    writer.eval(st, 2, 2*day, config.wells, config.grp_nwrk, {}, {}, {});
     writer.add_timestep(st, 2);
     writer.write();
 

tests/test_Summary_Group.cpp

@@ -259,10 +259,10 @@ BOOST_AUTO_TEST_CASE(group_keywords) {
     SummaryState st(std::chrono::system_clock::now());
 
     out::Summary writer( cfg.es, cfg.config, cfg.grid, cfg.schedule , cfg.name );
-    writer.eval(st, 0, 0*day, cfg.wells, cfg.grp_nwrk, {}, {});
+    writer.eval(st, 0, 0*day, cfg.wells, cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 0);
 
-    writer.eval(st, 1, 1*day, cfg.wells, cfg.grp_nwrk, {}, {});
+    writer.eval(st, 1, 1*day, cfg.wells, cfg.grp_nwrk, {}, {}, {});
     writer.add_timestep( st, 1);
 
     writer.write();