modified the simulator more general.

opm/polymer/fullyimplicit/SimulatorFullyImplicitTwophase.cpp

@@ -50,18 +50,23 @@
 namespace Opm
 {
 
+
+
     class SimulatorFullyImplicitTwophase::Impl
     {
     public:
         Impl(const parameter::ParameterGroup& param,
              const UnstructuredGrid& grid,
              const IncompPropsAdInterface& props,
+             WellsManager&           wells_manager,
              LinearSolverInterface& linsolver,
-             std::vector<double>& src);
+             std::vector<double>& src,
+             const double* gravity);
 
         SimulatorReport run(SimulatorTimer& timer,
                             TwophaseState& state,
-                            std::vector<double>& src);
+                            std::vector<double>& src,
+                            WellState&     well_state);
 
     private:
 
@@ -71,9 +76,15 @@ namespace Opm
         std::string output_dir_;
         int output_interval_;
         // Parameters for well control
+        bool check_well_controls_;
+        int max_well_control_iterations_;
         // Observed objects.
         const UnstructuredGrid& grid_;
         const IncompPropsAdInterface& props_;
+        WellsManager&           wells_manager_;
+        const Wells* wells_;
+        const std::vector<double>& src_;
+        const double* gravity_;
         // Solvers
         FullyImplicitTwoPhaseSolver solver_;
         // Misc. data
@@ -86,10 +97,12 @@ namespace Opm
     SimulatorFullyImplicitTwophase::SimulatorFullyImplicitTwophase(const parameter::ParameterGroup& param,
                                                                    const UnstructuredGrid& grid,
                                                                    const IncompPropsAdInterface& props,
+                                                                   WellsManager& wells_manager,
                                                                    LinearSolverInterface& linsolver,
-                                                                   std::vector<double>& src)
+                                                                   std::vector<double>& src,
+                                                                   const double* gravity)
     {
-        pimpl_.reset(new Impl(param, grid, props, linsolver, src));
+        pimpl_.reset(new Impl(param, grid, props, wells_manager, linsolver, src, gravity));
     }
 
 
@@ -98,9 +111,10 @@ namespace Opm
 
     SimulatorReport SimulatorFullyImplicitTwophase::run(SimulatorTimer& timer,
                                                         TwophaseState& state,
-                                                        std::vector<double>& src)
+                                                        std::vector<double>& src,
+                                                        WellState&     well_state)
     {
-        return pimpl_->run(timer, state, src);
+        return pimpl_->run(timer, state, src, well_state);
     }
 
 
@@ -133,6 +147,75 @@ namespace Opm
         dm["velocity"] = &cell_velocity;
         Opm::writeVtkData(grid, dm, vtkfile);
     }
+
+
+    static void outputStateMatlab(const UnstructuredGrid& grid,
+                                  const Opm::TwophaseState& state,
+                                  const int step,
+                                  const std::string& output_dir)
+    {
+        Opm::DataMap dm;
+        dm["saturation"] = &state.saturation();
+        dm["pressure"] = &state.pressure();
+        std::vector<double> cell_velocity;
+        Opm::estimateCellVelocity(grid, state.faceflux(), cell_velocity);
+        dm["velocity"] = &cell_velocity;
+
+        // Write data (not grid) in Matlab format
+        for (Opm::DataMap::const_iterator it = dm.begin(); it != dm.end(); ++it) {
+            std::ostringstream fname;
+            fname << output_dir << "/" << it->first;
+            boost::filesystem::path fpath = fname.str();
+            try {
+                create_directories(fpath);
+            }
+            catch (...) {
+                OPM_THROW(std::runtime_error, "Creating directories failed: " << fpath);
+            }
+            fname << "/" << std::setw(3) << std::setfill('0') << step << ".txt";
+            std::ofstream file(fname.str().c_str());
+            if (!file) {
+                OPM_THROW(std::runtime_error, "Failed to open " << fname.str());
+            }
+            file.precision(15);
+            const std::vector<double>& d = *(it->second);
+            std::copy(d.begin(), d.end(), std::ostream_iterator<double>(file, "\n"));
+        }
+    }
+
+    static void outputWellStateMatlab(const Opm::WellState& well_state,
+                                  const int step,
+                                  const std::string& output_dir)
+    {
+        Opm::DataMap dm;
+        dm["bhp"] = &well_state.bhp();
+        dm["wellrates"] = &well_state.wellRates();
+
+        // Write data (not grid) in Matlab format
+        for (Opm::DataMap::const_iterator it = dm.begin(); it != dm.end(); ++it) {
+            std::ostringstream fname;
+            fname << output_dir << "/" << it->first;
+            boost::filesystem::path fpath = fname.str();
+            try {
+                create_directories(fpath);
+            }
+            catch (...) {
+                OPM_THROW(std::runtime_error,"Creating directories failed: " << fpath);
+            }
+            fname << "/" << std::setw(3) << std::setfill('0') << step << ".txt";
+            std::ofstream file(fname.str().c_str());
+            if (!file) {
+                OPM_THROW(std::runtime_error,"Failed to open " << fname.str());
+            }
+            file.precision(15);
+            const std::vector<double>& d = *(it->second);
+            std::copy(d.begin(), d.end(), std::ostream_iterator<double>(file, "\n"));
+        }
+    }
+
+
+
+    
 /*
     static void outputWaterCut(const Opm::Watercut& watercut,
                                const std::string& output_dir)
@@ -145,20 +228,36 @@ namespace Opm
         }
         watercut.write(os);
     }
-    
+    static void outputWellReport(const Opm::WellReport& wellreport,
-   */ 
+                                 const std::string& output_dir)
-    
+    {
+        // Write well report.
+        std::string fname = output_dir  + "/wellreport.txt";
+        std::ofstream os(fname.c_str());
+        if (!os) {
+            OPM_THROW(std::runtime_error, "Failed to open " << fname);
+        }
+        wellreport.write(os);
+    }
+  */  
     
     
     
     SimulatorFullyImplicitTwophase::Impl::Impl(const parameter::ParameterGroup& param,
                                                const UnstructuredGrid& grid,
                                                const IncompPropsAdInterface& props,
+                                               WellsManager&    wells_manager,
                                                LinearSolverInterface& linsolver,
-                                               std::vector<double>& src)
+                                               std::vector<double>& src,
+                                               const double* gravity)
         : grid_(grid),
           props_(props),
-          solver_(grid_, props_, linsolver)
+          wells_manager_(wells_manager),
+          wells_ (wells_manager.c_wells()),
+          src_ (src),
+          gravity_(gravity),
+          solver_(grid_, props_, *wells_manager.c_wells(), linsolver, gravity_)
+
     {
         // For output.
         output_ = param.getDefault("output", true);
@@ -175,6 +274,9 @@ namespace Opm
             }
             output_interval_ = param.getDefault("output_interval", 1);
         }
+        // Well control related init.
+        check_well_controls_ = param.getDefault("check_well_controls", false);
+        max_well_control_iterations_ = param.getDefault("max_well_control_iterations", 10);
 
         // Misc init.
         const int num_cells = grid.number_of_cells;
@@ -184,16 +286,16 @@ namespace Opm
         }
     }
 
-
-
-
     SimulatorReport SimulatorFullyImplicitTwophase::Impl::run(SimulatorTimer& timer,
                                                               TwophaseState& state,
-                                                              std::vector<double>& src)
+                                                              std::vector<double>& src,
+                                                              WellState& well_state)
     {
+
         // Initialisation.
         std::vector<double> porevol;
-        computePorevolume(grid_, props_.porosity(), porevol);
+        Opm::computePorevolume(grid_, props_.porosity(), porevol);
+
         // const double tot_porevol_init = std::accumulate(porevol.begin(), porevol.end(), 0.0);
         std::vector<double> initial_porevol = porevol;
 
@@ -203,14 +305,27 @@ namespace Opm
         Opm::time::StopWatch step_timer;
         Opm::time::StopWatch total_timer;
         total_timer.start();
+#if 0
         // These must be changed for three-phase.
+        double init_surfvol[2] = { 0.0 };
+        double inplace_surfvol[2] = { 0.0 };
+        double tot_injected[2] = { 0.0 };
+        double tot_produced[2] = { 0.0 };
+        Opm::computeSaturatedVol(porevol, state.surfacevol(), init_surfvol);
+        Opm::Watercut watercut;
+        watercut.push(0.0, 0.0, 0.0);
+#endif
         std::vector<double> fractional_flows;
+        std::vector<double> well_resflows_phase;
+        if (wells_) {
+            well_resflows_phase.resize((wells_->number_of_phases)*(wells_->number_of_wells), 0.0);
+        }
         std::fstream tstep_os;
         if (output_) {
             std::string filename = output_dir_ + "/step_timing.param";
             tstep_os.open(filename.c_str(), std::fstream::out | std::fstream::app);
         }
-        for (; !timer.done(); ++timer) {
+        while (!timer.done()) {
             // Report timestep and (optionally) write state to disk.
             step_timer.start();
             timer.report(std::cout);
@@ -218,34 +333,125 @@ namespace Opm
                 if (output_vtk_) {
                     outputStateVtk(grid_, state, timer.currentStepNum(), output_dir_);
                 }
+                outputStateMatlab(grid_, state, timer.currentStepNum(), output_dir_);
+                outputWellStateMatlab(well_state,timer.currentStepNum(), output_dir_);
+
             }
-   
+
             SimulatorReport sreport;
 
-            // Run solver.
+            bool well_control_passed = !check_well_controls_;
-            solver_timer.start();
+            int well_control_iteration = 0;
-            std::vector<double> initial_pressure = state.pressure();
+            do {
-            solver_.step(timer.currentStepLength(), state, src);
+                // Run solver.
+                solver_timer.start();
+                std::vector<double> initial_pressure = state.pressure();
+                solver_.step(timer.currentStepLength(), state, src, well_state);
 
-            // Stop timer and report.
+                // Stop timer and report.
-            solver_timer.stop();
+                solver_timer.stop();
-            const double st = solver_timer.secsSinceStart();
+                const double st = solver_timer.secsSinceStart();
-            std::cout << "Fully implicit solver took:  " << st << " seconds." << std::endl;
+                std::cout << "Fully implicit solver took:  " << st << " seconds." << std::endl;
-            stime += st;
-            sreport.pressure_time = st;
 
+                stime += st;
+                sreport.pressure_time = st;
+
+                // Optionally, check if well controls are satisfied.
+                if (check_well_controls_) {
+                    Opm::computePhaseFlowRatesPerWell(*wells_,
+                                                      well_state.perfRates(),
+                                                      fractional_flows,
+                                                      well_resflows_phase);
+                    std::cout << "Checking well conditions." << std::endl;
+                    // For testing we set surface := reservoir
+                    well_control_passed = wells_manager_.conditionsMet(well_state.bhp(), well_resflows_phase, well_resflows_phase);
+                    ++well_control_iteration;
+                    if (!well_control_passed && well_control_iteration > max_well_control_iterations_) {
+                        OPM_THROW(std::runtime_error, "Could not satisfy well conditions in " << max_well_control_iterations_ << " tries.");
+                    }
+                    if (!well_control_passed) {
+                        std::cout << "Well controls not passed, solving again." << std::endl;
+                    } else {
+                        std::cout << "Well conditions met." << std::endl;
+                    }
+                }
+            } while (!well_control_passed);
+
+            // Update pore volumes if rock is compressible.
+            initial_porevol = porevol;
+
+            // The reports below are geared towards two phases only.
+#if 0
+            // Report mass balances.
+            double injected[2] = { 0.0 };
+            double produced[2] = { 0.0 };
+            Opm::computeInjectedProduced(props_, state, transport_src, stepsize,
+                                         injected, produced);
+            Opm::computeSaturatedVol(porevol, state.surfacevol(), inplace_surfvol);
+            tot_injected[0] += injected[0];
+            tot_injected[1] += injected[1];
+            tot_produced[0] += produced[0];
+            tot_produced[1] += produced[1];
+            std::cout.precision(5);
+            const int width = 18;
+            std::cout << "\nMass balance report.\n";
+            std::cout << "    Injected surface volumes:      "
+                      << std::setw(width) << injected[0]
+                      << std::setw(width) << injected[1] << std::endl;
+            std::cout << "    Produced surface volumes:      "
+                      << std::setw(width) << produced[0]
+                      << std::setw(width) << produced[1] << std::endl;
+            std::cout << "    Total inj surface volumes:     "
+                      << std::setw(width) << tot_injected[0]
+                      << std::setw(width) << tot_injected[1] << std::endl;
+            std::cout << "    Total prod surface volumes:    "
+                      << std::setw(width) << tot_produced[0]
+                      << std::setw(width) << tot_produced[1] << std::endl;
+            const double balance[2] = { init_surfvol[0] - inplace_surfvol[0] - tot_produced[0] + tot_injected[0],
+                                        init_surfvol[1] - inplace_surfvol[1] - tot_produced[1] + tot_injected[1] };
+            std::cout << "    Initial - inplace + inj - prod: "
+                      << std::setw(width) << balance[0]
+                      << std::setw(width) << balance[1]
+                      << std::endl;
+            std::cout << "    Relative mass error:            "
+                      << std::setw(width) << balance[0]/(init_surfvol[0] + tot_injected[0])
+                      << std::setw(width) << balance[1]/(init_surfvol[1] + tot_injected[1])
+                      << std::endl;
+            std::cout.precision(8);
+
+            // Make well reports.
+            watercut.push(timer.currentTime() + timer.currentStepLength(),
+                          produced[0]/(produced[0] + produced[1]),
+                          tot_produced[0]/tot_porevol_init);
+            if (wells_) {
+                wellreport.push(props_, *wells_,
+                                state.pressure(), state.surfacevol(), state.saturation(),
+                                timer.currentTime() + timer.currentStepLength(),
+                                well_state.bhp(), well_state.perfRates());
+            }
+#endif
             sreport.total_time =  step_timer.secsSinceStart();
             if (output_) {
                 sreport.reportParam(tstep_os);
-            }
-        }
 
-        if (output_) {
+                if (output_vtk_) {
-            if (output_vtk_) {
+                    outputStateVtk(grid_, state, timer.currentStepNum(), output_dir_);
-                outputStateVtk(grid_, state, timer.currentStepNum(), output_dir_);
+                }
+                outputStateMatlab(grid_, state, timer.currentStepNum(), output_dir_);
+                outputWellStateMatlab(well_state,timer.currentStepNum(), output_dir_);
+#if 0
+                outputWaterCut(watercut, output_dir_);
+                if (wells_) {
+                    outputWellReport(wellreport, output_dir_);
+                }
+#endif
+                tstep_os.close();
             }
-     //       outputWaterCut(watercut, output_dir_);
+
-            tstep_os.close();
+            // advance to next timestep before reporting at this location
+            ++timer;
+
+            // write an output file for later inspection
         }
 
         total_timer.stop();
@@ -258,4 +464,7 @@ namespace Opm
     }
 
 
+
+
+
 } // namespace Opm

opm/polymer/fullyimplicit/SimulatorFullyImplicitTwophase.hpp

@@ -32,6 +32,8 @@ namespace Opm
     class LinearSolverInterface;
     class SimulatorTimer;
     class TwophaseState;
+    class WellsManager;
+    class WellState;
     struct SimulatorReport;
 
     /// Class collecting all necessary components for a two-phase simulation.
@@ -60,8 +62,10 @@ namespace Opm
         SimulatorFullyImplicitTwophase(const parameter::ParameterGroup& param,
                                        const UnstructuredGrid& grid,
                                        const IncompPropsAdInterface& props,
+                                       WellsManager&                 wells_manager,
                                        LinearSolverInterface& linsolver,
-                                       std::vector<double>& src);
+                                       std::vector<double>& src,
+                                       const double* gravity);
 
         /// Run the simulation.
         /// This will run succesive timesteps until timer.done() is true. It will
@@ -72,7 +76,8 @@ namespace Opm
         /// \return                    simulation report, with timing data
         SimulatorReport run(SimulatorTimer& timer,
                             TwophaseState& state,
-                            std::vector<double>& src);
+                            std::vector<double>& src,
+                            WellState&     well_state);
 
     private:
         class Impl;