Merge pull request #72 from andlaus/parser-integrate-read_pvt_and_grid

Parser integrate: read pvt and grid

examples/sim_2p_comp_ad.cpp

@@ -46,6 +46,9 @@
 #include <opm/core/simulator/WellState.hpp>
 #include <opm/autodiff/SimulatorCompressibleAd.hpp>
 
+#include <opm/parser/eclipse/Deck/Deck.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+
 #include <boost/scoped_ptr.hpp>
 #include <boost/filesystem.hpp>
 
@@ -98,14 +101,17 @@ try
     if (use_deck) {
         std::string deck_filename = param.get<std::string>("deck_filename");
         deck.reset(new EclipseGridParser(deck_filename));
+        Opm::ParserPtr newParser(new Opm::Parser() );
+        Opm::DeckConstPtr newParserDeck = newParser->parseFile( deck_filename );
+
         // Grid init
-        grid.reset(new GridManager(*deck));
+        grid.reset(new GridManager(newParserDeck));
         // Rock and fluid init
-        props.reset(new BlackoilPropertiesFromDeck(*deck, *grid->c_grid(), param));
+        props.reset(new BlackoilPropertiesFromDeck(newParserDeck, *grid->c_grid(), param));
         // check_well_controls = param.getDefault("check_well_controls", false);
         // max_well_control_iterations = param.getDefault("max_well_control_iterations", 10);
         // Rock compressibility.
-        rock_comp.reset(new RockCompressibility(*deck));
+        rock_comp.reset(new RockCompressibility(newParserDeck));
         // Gravity.
         gravity[2] = deck->hasField("NOGRAV") ? 0.0 : unit::gravity;
         // Init state variables (saturation and pressure).

examples/sim_fibo_ad.cpp

@@ -16,11 +16,7 @@
   You should have received a copy of the GNU General Public License
   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
 */
-
-
-#if HAVE_CONFIG_H
 #include "config.h"
-#endif // HAVE_CONFIG_H
 
 #include <opm/core/pressure/FlowBCManager.hpp>
 
@@ -49,10 +45,13 @@
 #include <opm/autodiff/BlackoilPropsAdFromDeck.hpp>
 #include <opm/core/utility/share_obj.hpp>
 
-#include <boost/scoped_ptr.hpp>
+#include <opm/parser/eclipse/Deck/Deck.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 
+#include <memory>
 #include <algorithm>
 #include <iostream>
 #include <vector>
@@ -90,30 +89,66 @@ try
         OPM_THROW(std::runtime_error, "This program must be run with an input deck. "
                   "Specify the deck with deck_filename=deckname.data (for example).");
     }
-    boost::scoped_ptr<EclipseGridParser> deck;
+    std::shared_ptr<GridManager> grid;
-    boost::scoped_ptr<GridManager> grid;
+    std::shared_ptr<BlackoilPropertiesInterface> props;
-    boost::scoped_ptr<BlackoilPropertiesInterface> props;
+    std::shared_ptr<BlackoilPropsAdInterface> new_props;
-    boost::scoped_ptr<BlackoilPropsAdInterface> new_props;
+    std::shared_ptr<RockCompressibility> rock_comp;
-    boost::scoped_ptr<RockCompressibility> rock_comp;
     BlackoilState state;
     // bool check_well_controls = false;
     // int max_well_control_iterations = 0;
     double gravity[3] = { 0.0 };
     std::string deck_filename = param.get<std::string>("deck_filename");
-    deck.reset(new EclipseGridParser(deck_filename));
-    // Grid init
-    grid.reset(new GridManager(*deck));
 
-    Opm::EclipseWriter outputWriter(param, share_obj(*deck), share_obj(*grid->c_grid()));
+#define USE_NEW_PARSER 1
+#if USE_NEW_PARSER
+    Opm::ParserPtr newParser(new Opm::Parser() );
+    Opm::DeckConstPtr newParserDeck = newParser->parseFile( deck_filename );
+
+#warning "HACK: required until the SimulationTimer, WellsManager and the EclipseWriter don't require the old parser anymore"
+    std::shared_ptr<EclipseGridParser> deck;
+    deck.reset(new EclipseGridParser(deck_filename));
+#else
+    std::shared_ptr<EclipseGridParser> deck;
+    deck.reset(new EclipseGridParser(deck_filename));
+#endif
+
+    // Grid init
+#if USE_NEW_PARSER
+    grid.reset(new GridManager(newParserDeck));
+#else
+    grid.reset(new GridManager(*deck));
+#endif
+
+#warning "HACK: required until the SimulationTimer, WellsManager and the EclipseWriter don't require the old parser anymore"
+#if 0 // USE_NEW_PARSER
+    Opm::EclipseWriter outputWriter(param, newParserDeck, share_obj(*grid->c_grid()));
+#else
+    Opm::EclipseWriter outputWriter(param, deck, share_obj(*grid->c_grid()));
+#endif
+
     // Rock and fluid init
+#if USE_NEW_PARSER
+    props.reset(new BlackoilPropertiesFromDeck(newParserDeck, *grid->c_grid(), param));
+    new_props.reset(new BlackoilPropsAdFromDeck(newParserDeck, *grid->c_grid()));
+#else
     props.reset(new BlackoilPropertiesFromDeck(*deck, *grid->c_grid(), param));
     new_props.reset(new BlackoilPropsAdFromDeck(*deck, *grid->c_grid()));
+#endif
+
     // check_well_controls = param.getDefault("check_well_controls", false);
     // max_well_control_iterations = param.getDefault("max_well_control_iterations", 10);
     // Rock compressibility.
+#if USE_NEW_PARSER
+    rock_comp.reset(new RockCompressibility(newParserDeck));
+#else
     rock_comp.reset(new RockCompressibility(*deck));
+#endif
     // Gravity.
+#if USE_NEW_PARSER
+    gravity[2] = newParserDeck->hasKeyword("NOGRAV") ? 0.0 : unit::gravity;
+#else
     gravity[2] = deck->hasField("NOGRAV") ? 0.0 : unit::gravity;
+#endif
     // Init state variables (saturation and pressure).
     if (param.has("init_saturation")) {
         initStateBasic(*grid->c_grid(), *props, param, gravity[2], state);
@@ -129,7 +164,11 @@ try
             }
         }
     } else {
+#if USE_NEW_PARSER
+        initBlackoilStateFromDeck(*grid->c_grid(), *props, newParserDeck, gravity[2], state);
+#else
         initBlackoilStateFromDeck(*grid->c_grid(), *props, *deck, gravity[2], state);
+#endif
     }
 
     bool use_gravity = (gravity[0] != 0.0 || gravity[1] != 0.0 || gravity[2] != 0.0);

opm/autodiff/BlackoilPropsAdFromDeck.cpp

@@ -32,9 +32,13 @@
 #include <opm/core/utility/ErrorMacros.hpp>
 #include <opm/core/utility/Units.hpp>
 
+#include <opm/parser/eclipse/Deck/Deck.hpp>
+#include <opm/parser/eclipse/Utility/PvdoTable.hpp>
+#include <opm/parser/eclipse/Utility/PvtgTable.hpp>
+#include <opm/parser/eclipse/Utility/PvdcoTable.hpp>
+
 namespace Opm
 {
-
     // Making these typedef to make the code more readable.
     typedef BlackoilPropsAdFromDeck::ADB ADB;
     typedef BlackoilPropsAdFromDeck::V V;
@@ -106,7 +110,8 @@ namespace Opm
             if (deck.hasField("PVDG")) {
                 if (samples > 0) {
                     props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtDeadSpline(deck.getPVDG().pvdg_, samples));
-                } else {
+                }
+                else {
                     props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtDead(deck.getPVDG().pvdg_));
                 }
              } else if (deck.hasField("PVTG")) {
@@ -129,6 +134,99 @@ namespace Opm
     }
 
 
+    /// Constructor wrapping an opm-core black oil interface.
+    BlackoilPropsAdFromDeck::BlackoilPropsAdFromDeck(Opm::DeckConstPtr newParserDeck,
+                                                     const UnstructuredGrid& grid,
+                                                     const bool init_rock)
+    {
+        if (init_rock){
+            rock_.init(newParserDeck, grid);
+        }
+
+        const int region_number = 0;
+
+        phase_usage_ = phaseUsageFromDeck(newParserDeck);
+
+        // Surface densities. Accounting for different orders in eclipse and our code.
+        if (newParserDeck->hasKeyword("DENSITY")) {
+            const auto keyword = newParserDeck->getKeyword("DENSITY");
+            const auto record = keyword->getRecord(region_number);
+            enum { ECL_oil = 0, ECL_water = 1, ECL_gas = 2 };
+            if (phase_usage_.phase_used[Aqua]) {
+                densities_[phase_usage_.phase_pos[Aqua]]   = record->getItem("WATER")->getSIDouble(0);
+            }
+            if (phase_usage_.phase_used[Vapour]) {
+                densities_[phase_usage_.phase_pos[Vapour]] = record->getItem("GAS")->getSIDouble(0);
+            }
+            if (phase_usage_.phase_used[Liquid]) {
+                densities_[phase_usage_.phase_pos[Liquid]] = record->getItem("OIL")->getSIDouble(0);
+            }
+        } else {
+            OPM_THROW(std::runtime_error, "Input is missing DENSITY\n");
+        }
+
+        // Set the properties.
+        props_.resize(phase_usage_.num_phases);
+        // Water PVT
+        if (phase_usage_.phase_used[Aqua]) {
+            if (newParserDeck->hasKeyword("PVTW")) {
+                Opm::PvtwTable pvtwTable(newParserDeck->getKeyword("PVTW"), region_number);
+
+                props_[phase_usage_.phase_pos[Aqua]].reset(new SinglePvtConstCompr(pvtwTable));
+            } else {
+                // Eclipse 100 default.
+                props_[phase_usage_.phase_pos[Aqua]].reset(new SinglePvtConstCompr(0.5*Opm::prefix::centi*Opm::unit::Poise));
+            }
+        }
+
+        // Oil PVT
+        if (phase_usage_.phase_used[Liquid]) {
+            if (newParserDeck->hasKeyword("PVDO")) {
+                Opm::PvdoTable pvdoTable(newParserDeck->getKeyword("PVDO"), region_number);
+
+                props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtDead(pvdoTable));
+            }
+            else if (newParserDeck->hasKeyword("PVTO")) {
+                Opm::PvtoTable pvtoTable(newParserDeck->getKeyword("PVTO"), /*tableIdx=*/0);
+
+                props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtLiveOil(pvtoTable));
+            } else if (newParserDeck->hasKeyword("PVCDO")) {
+                Opm::PvdcoTable pvdcoTable(newParserDeck->getKeyword("PVDCO"), region_number);
+
+                props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtConstCompr(pvdcoTable));
+            } else {
+                OPM_THROW(std::runtime_error, "Input is missing PVDO or PVTO\n");
+            }
+        }
+
+        // Gas PVT
+        if (phase_usage_.phase_used[Vapour]) {
+            if (newParserDeck->hasKeyword("PVDG")) {
+                Opm::PvdoTable pvdgTable(newParserDeck->getKeyword("PVDG"), region_number);
+
+                props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtDead(pvdgTable));
+            } else if (newParserDeck->hasKeyword("PVTG")) {
+                Opm::PvtgTable pvtgTable(newParserDeck->getKeyword("PVTG"), /*tableIdx=*/0);
+
+                props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtLiveGas(pvtgTable));
+            } else {
+                OPM_THROW(std::runtime_error, "Input is missing PVDG or PVTG\n");
+            }
+        }
+
+        SaturationPropsFromDeck<SatFuncGwsegNonuniform>* ptr
+            = new SaturationPropsFromDeck<SatFuncGwsegNonuniform>();
+        satprops_.reset(ptr);
+        ptr->init(newParserDeck, grid, -1);
+
+        if (phase_usage_.num_phases != satprops_->numPhases()) {
+            OPM_THROW(std::runtime_error, "BlackoilPropsAdFromDeck::BlackoilPropsAdFromDeck() - "
+                  "Inconsistent number of phases in pvt data (" << phase_usage_.num_phases
+                  << ") and saturation-dependent function data (" << satprops_->numPhases() << ").");
+        }
+    }
+
+
     ////////////////////////////
     //      Rock interface    //
     ////////////////////////////

opm/autodiff/BlackoilPropsAdFromDeck.hpp

@@ -22,11 +22,14 @@
 
 #include <opm/autodiff/BlackoilPropsAdInterface.hpp>
 #include <opm/autodiff/AutoDiffBlock.hpp>
+
 #include <opm/core/props/BlackoilPhases.hpp>
 #include <opm/core/props/satfunc/SaturationPropsFromDeck.hpp>
 #include <opm/core/io/eclipse/EclipseGridParser.hpp>
 #include <opm/core/props/rock/RockFromDeck.hpp>
 
+#include <opm/parser/eclipse/Deck/Deck.hpp>
+
 #include <boost/shared_ptr.hpp>
 #include <boost/scoped_ptr.hpp>
 
@@ -52,6 +55,11 @@ namespace Opm
                                 const UnstructuredGrid& grid,
                                 const bool init_rock = true );
 
+        /// Constructor wrapping an opm-core black oil interface.
+        BlackoilPropsAdFromDeck(Opm::DeckConstPtr newParserDeck,
+                                const UnstructuredGrid& grid,
+                                const bool init_rock = true );
+
         ////////////////////////////
         //      Rock interface    //
         ////////////////////////////