mirror of
https://github.com/OPM/opm-simulators.git
synced 2025-02-25 18:55:30 -06:00
Remove old 2p simulator.
This commit is contained in:
Atgeirr Flø Rasmussen
parent
6481e32caa
commit
8ad9c979f8
@ -67,7 +67,6 @@ list (APPEND MAIN_SOURCE_FILES
|
|||||||
opm/simulators/flow_ebos_solvent.cpp
|
opm/simulators/flow_ebos_solvent.cpp
|
||||||
opm/simulators/ensureDirectoryExists.cpp
|
opm/simulators/ensureDirectoryExists.cpp
|
||||||
opm/simulators/SimulatorCompressibleTwophase.cpp
|
opm/simulators/SimulatorCompressibleTwophase.cpp
|
||||||
opm/simulators/SimulatorIncompTwophase.cpp
|
|
||||||
opm/simulators/WellSwitchingLogger.cpp
|
opm/simulators/WellSwitchingLogger.cpp
|
||||||
opm/simulators/vtk/writeVtkData.cpp
|
opm/simulators/vtk/writeVtkData.cpp
|
||||||
opm/simulators/timestepping/TimeStepControl.cpp
|
opm/simulators/timestepping/TimeStepControl.cpp
|
||||||
@ -118,7 +117,6 @@ list (APPEND EXAMPLE_SOURCE_FILES
|
|||||||
examples/flow_reorder.cpp
|
examples/flow_reorder.cpp
|
||||||
examples/flow_sequential.cpp
|
examples/flow_sequential.cpp
|
||||||
examples/flow.cpp
|
examples/flow.cpp
|
||||||
examples/sim_2p_incomp.cpp
|
|
||||||
examples/sim_2p_incomp_ad.cpp
|
examples/sim_2p_incomp_ad.cpp
|
||||||
examples/sim_2p_comp_reorder.cpp
|
examples/sim_2p_comp_reorder.cpp
|
||||||
examples/sim_simple.cpp
|
examples/sim_simple.cpp
|
||||||
@ -257,7 +255,6 @@ list (APPEND PUBLIC_HEADER_FILES
|
|||||||
opm/simulators/ensureDirectoryExists.hpp
|
opm/simulators/ensureDirectoryExists.hpp
|
||||||
opm/simulators/ParallelFileMerger.hpp
|
opm/simulators/ParallelFileMerger.hpp
|
||||||
opm/simulators/SimulatorCompressibleTwophase.hpp
|
opm/simulators/SimulatorCompressibleTwophase.hpp
|
||||||
opm/simulators/SimulatorIncompTwophase.hpp
|
|
||||||
opm/simulators/thresholdPressures.hpp
|
opm/simulators/thresholdPressures.hpp
|
||||||
opm/simulators/WellSwitchingLogger.hpp
|
opm/simulators/WellSwitchingLogger.hpp
|
||||||
opm/simulators/vtk/writeVtkData.hpp
|
opm/simulators/vtk/writeVtkData.hpp
|
||||||
|
|||||||
@ -1,321 +0,0 @@
|
|||||||
/*
|
|
||||||
Copyright 2012 SINTEF ICT, Applied Mathematics.
|
|
||||||
|
|
||||||
This file is part of the Open Porous Media project (OPM).
|
|
||||||
|
|
||||||
OPM is free software: you can redistribute it and/or modify
|
|
||||||
it under the terms of the GNU General Public License as published by
|
|
||||||
the Free Software Foundation, either version 3 of the License, or
|
|
||||||
(at your option) any later version.
|
|
||||||
|
|
||||||
OPM is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
GNU General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU General Public License
|
|
||||||
along with OPM. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#ifdef HAVE_CONFIG_H
|
|
||||||
#include "config.h"
|
|
||||||
#endif // HAVE_CONFIG_H
|
|
||||||
|
|
||||||
#include <opm/core/pressure/FlowBCManager.hpp>
|
|
||||||
|
|
||||||
#include <opm/core/grid.h>
|
|
||||||
#include <opm/core/grid/GridManager.hpp>
|
|
||||||
#include <opm/core/wells.h>
|
|
||||||
#include <opm/core/wells/WellsManager.hpp>
|
|
||||||
#include <opm/common/ErrorMacros.hpp>
|
|
||||||
#include <opm/core/simulator/initState.hpp>
|
|
||||||
#include <opm/core/simulator/SimulatorReport.hpp>
|
|
||||||
#include <opm/simulators/timestepping/SimulatorTimer.hpp>
|
|
||||||
#include <opm/core/utility/miscUtilities.hpp>
|
|
||||||
#include <opm/core/utility/parameters/ParameterGroup.hpp>
|
|
||||||
|
|
||||||
#include <opm/core/props/IncompPropertiesBasic.hpp>
|
|
||||||
#include <opm/core/props/IncompPropertiesFromDeck.hpp>
|
|
||||||
#include <opm/core/props/rock/RockCompressibility.hpp>
|
|
||||||
|
|
||||||
#include <opm/core/linalg/LinearSolverFactory.hpp>
|
|
||||||
|
|
||||||
#include <opm/core/simulator/TwophaseState.hpp>
|
|
||||||
#include <opm/core/simulator/WellState.hpp>
|
|
||||||
#include <opm/simulators/SimulatorIncompTwophase.hpp>
|
|
||||||
#include <opm/simulators/ensureDirectoryExists.hpp>
|
|
||||||
|
|
||||||
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
|
|
||||||
#include <opm/parser/eclipse/Parser/Parser.hpp>
|
|
||||||
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
|
|
||||||
|
|
||||||
|
|
||||||
#include <memory>
|
|
||||||
#include <boost/filesystem.hpp>
|
|
||||||
|
|
||||||
#include <algorithm>
|
|
||||||
#include <iostream>
|
|
||||||
#include <vector>
|
|
||||||
#include <numeric>
|
|
||||||
#include <fstream>
|
|
||||||
|
|
||||||
namespace
|
|
||||||
{
|
|
||||||
void warnIfUnusedParams(const Opm::ParameterGroup& param)
|
|
||||||
{
|
|
||||||
if (param.anyUnused()) {
|
|
||||||
std::cout << "-------------------- Unused parameters: --------------------\n";
|
|
||||||
param.displayUsage();
|
|
||||||
std::cout << "----------------------------------------------------------------" << std::endl;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} // anon namespace
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// ----------------- Main program -----------------
|
|
||||||
int
|
|
||||||
main(int argc, char** argv)
|
|
||||||
try
|
|
||||||
{
|
|
||||||
using namespace Opm;
|
|
||||||
|
|
||||||
OpmLog::setupSimpleDefaultLogging(false, true, 10);
|
|
||||||
std::cout << "\n================ Test program for incompressible two-phase flow ===============\n\n";
|
|
||||||
ParameterGroup param(argc, argv, false);
|
|
||||||
std::cout << "--------------- Reading parameters ---------------" << std::endl;
|
|
||||||
|
|
||||||
#if ! HAVE_SUITESPARSE_UMFPACK_H
|
|
||||||
// This is an extra check to intercept a potentially invalid request for the
|
|
||||||
// implicit transport solver as early as possible for the user.
|
|
||||||
{
|
|
||||||
const bool use_reorder = param.getDefault("use_reorder", true);
|
|
||||||
if (!use_reorder) {
|
|
||||||
OPM_THROW(std::runtime_error, "Cannot use implicit transport solver without UMFPACK. "
|
|
||||||
"Either reconfigure opm-core with SuiteSparse/UMFPACK support and recompile, "
|
|
||||||
"or use the reordering solver (use_reorder=true).");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// If we have a "deck_filename", grid and props will be read from that.
|
|
||||||
bool use_deck = param.has("deck_filename");
|
|
||||||
std::shared_ptr< EclipseState > eclipseState;
|
|
||||||
std::shared_ptr< Schedule > schedule;
|
|
||||||
std::unique_ptr<GridManager> grid;
|
|
||||||
std::unique_ptr<IncompPropertiesInterface> props;
|
|
||||||
std::unique_ptr<RockCompressibility> rock_comp;
|
|
||||||
std::unique_ptr<TwophaseState> state;
|
|
||||||
// bool check_well_controls = false;
|
|
||||||
// int max_well_control_iterations = 0;
|
|
||||||
double gravity[3] = { 0.0 };
|
|
||||||
if (use_deck) {
|
|
||||||
Parser parser;
|
|
||||||
ParseContext parseContext;
|
|
||||||
parseContext.update(ParseContext::PARSE_MISSING_DIMS_KEYWORD, InputError::WARN);
|
|
||||||
|
|
||||||
std::string deck_filename = param.get<std::string>("deck_filename");
|
|
||||||
auto deck = parser.parseFile(deck_filename , parseContext);
|
|
||||||
eclipseState.reset( new EclipseState(deck, parseContext));
|
|
||||||
schedule.reset( new Schedule(deck,
|
|
||||||
eclipseState->getInputGrid(),
|
|
||||||
eclipseState->get3DProperties(),
|
|
||||||
eclipseState->runspec().phases(),
|
|
||||||
parseContext));
|
|
||||||
// Grid init
|
|
||||||
grid.reset(new GridManager(eclipseState->getInputGrid()));
|
|
||||||
{
|
|
||||||
const UnstructuredGrid& ug_grid = *(grid->c_grid());
|
|
||||||
// Rock and fluid init
|
|
||||||
props.reset(new IncompPropertiesFromDeck(deck, *eclipseState, ug_grid));
|
|
||||||
|
|
||||||
state.reset( new TwophaseState( UgGridHelpers::numCells( ug_grid ) , UgGridHelpers::numFaces( ug_grid )));
|
|
||||||
|
|
||||||
// Rock compressibility.
|
|
||||||
rock_comp.reset(new RockCompressibility(*eclipseState));
|
|
||||||
// Gravity.
|
|
||||||
gravity[2] = deck.hasKeyword("NOGRAV") ? 0.0 : unit::gravity;
|
|
||||||
// Init state variables (saturation and pressure).
|
|
||||||
if (param.has("init_saturation")) {
|
|
||||||
initStateBasic(ug_grid, *props, param, gravity[2], *state);
|
|
||||||
} else {
|
|
||||||
initStateFromDeck(ug_grid, *props, deck, gravity[2], *state);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// Grid init.
|
|
||||||
const int nx = param.getDefault("nx", 100);
|
|
||||||
const int ny = param.getDefault("ny", 100);
|
|
||||||
const int nz = param.getDefault("nz", 1);
|
|
||||||
const double dx = param.getDefault("dx", 1.0);
|
|
||||||
const double dy = param.getDefault("dy", 1.0);
|
|
||||||
const double dz = param.getDefault("dz", 1.0);
|
|
||||||
grid.reset(new GridManager(nx, ny, nz, dx, dy, dz));
|
|
||||||
{
|
|
||||||
const UnstructuredGrid& ug_grid = *(grid->c_grid());
|
|
||||||
|
|
||||||
// Rock and fluid init.
|
|
||||||
props.reset(new IncompPropertiesBasic(param, ug_grid.dimensions, UgGridHelpers::numCells( ug_grid )));
|
|
||||||
|
|
||||||
state.reset( new TwophaseState( UgGridHelpers::numCells( ug_grid ) , UgGridHelpers::numFaces( ug_grid )));
|
|
||||||
// Rock compressibility.
|
|
||||||
rock_comp.reset(new RockCompressibility(param));
|
|
||||||
// Gravity.
|
|
||||||
gravity[2] = param.getDefault("gravity", 0.0);
|
|
||||||
// Init state variables (saturation and pressure).
|
|
||||||
initStateBasic(ug_grid, *props, param, gravity[2], *state);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Warn if gravity but no density difference.
|
|
||||||
bool use_gravity = (gravity[0] != 0.0 || gravity[1] != 0.0 || gravity[2] != 0.0);
|
|
||||||
if (use_gravity) {
|
|
||||||
if (props->density()[0] == props->density()[1]) {
|
|
||||||
std::cout << "**** Warning: nonzero gravity, but zero density difference." << std::endl;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
const double *grav = use_gravity ? &gravity[0] : 0;
|
|
||||||
|
|
||||||
// Initialising src
|
|
||||||
int num_cells = grid->c_grid()->number_of_cells;
|
|
||||||
std::vector<double> src(num_cells, 0.0);
|
|
||||||
if (use_deck) {
|
|
||||||
// Do nothing, wells will be the driving force, not source terms.
|
|
||||||
} else {
|
|
||||||
// Compute pore volumes, in order to enable specifying injection rate
|
|
||||||
// terms of total pore volume.
|
|
||||||
std::vector<double> porevol;
|
|
||||||
if (rock_comp->isActive()) {
|
|
||||||
computePorevolume(*grid->c_grid(), props->porosity(), *rock_comp, state->pressure(), porevol);
|
|
||||||
} else {
|
|
||||||
computePorevolume(*grid->c_grid(), props->porosity(), porevol);
|
|
||||||
}
|
|
||||||
const double tot_porevol_init = std::accumulate(porevol.begin(), porevol.end(), 0.0);
|
|
||||||
const double default_injection = use_gravity ? 0.0 : 0.1;
|
|
||||||
const double flow_per_sec = param.getDefault<double>("injected_porevolumes_per_day", default_injection)
|
|
||||||
*tot_porevol_init/unit::day;
|
|
||||||
src[0] = flow_per_sec;
|
|
||||||
src[num_cells - 1] = -flow_per_sec;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Boundary conditions.
|
|
||||||
FlowBCManager bcs;
|
|
||||||
if (param.getDefault("use_pside", false)) {
|
|
||||||
int pside = param.get<int>("pside");
|
|
||||||
double pside_pressure = param.get<double>("pside_pressure");
|
|
||||||
bcs.pressureSide(*grid->c_grid(), FlowBCManager::Side(pside), pside_pressure);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Linear solver.
|
|
||||||
LinearSolverFactory linsolver(param);
|
|
||||||
|
|
||||||
// Write parameters used for later reference.
|
|
||||||
bool output = param.getDefault("output", true);
|
|
||||||
std::ofstream epoch_os;
|
|
||||||
std::string output_dir;
|
|
||||||
if (output) {
|
|
||||||
output_dir =
|
|
||||||
param.getDefault("output_dir", std::string("output"));
|
|
||||||
ensureDirectoryExists(output_dir);
|
|
||||||
std::string filename = output_dir + "/epoch_timing.param";
|
|
||||||
epoch_os.open(filename.c_str(), std::fstream::trunc | std::fstream::out);
|
|
||||||
// open file to clean it. The file is appended to in SimulatorTwophase
|
|
||||||
filename = output_dir + "/step_timing.param";
|
|
||||||
std::fstream step_os(filename.c_str(), std::fstream::trunc | std::fstream::out);
|
|
||||||
step_os.close();
|
|
||||||
param.writeParam(output_dir + "/simulation.param");
|
|
||||||
}
|
|
||||||
|
|
||||||
SimulatorReport rep;
|
|
||||||
if (!use_deck) {
|
|
||||||
std::cout << "\n\n================ Starting main simulation loop ===============\n"
|
|
||||||
<< " (number of report steps: 1)\n\n" << std::flush;
|
|
||||||
// Simple simulation without a deck.
|
|
||||||
WellsManager wells; // no wells.
|
|
||||||
SimulatorIncompTwophase simulator(param,
|
|
||||||
*grid->c_grid(),
|
|
||||||
*props,
|
|
||||||
rock_comp->isActive() ? rock_comp.get() : 0,
|
|
||||||
wells,
|
|
||||||
src,
|
|
||||||
bcs.c_bcs(),
|
|
||||||
linsolver,
|
|
||||||
grav);
|
|
||||||
SimulatorTimer simtimer;
|
|
||||||
simtimer.init(param);
|
|
||||||
warnIfUnusedParams(param);
|
|
||||||
WellState well_state;
|
|
||||||
well_state.init(0, *state);
|
|
||||||
rep = simulator.run(simtimer, *state, well_state);
|
|
||||||
} else {
|
|
||||||
// With a deck, we may have more epochs etc.
|
|
||||||
const auto& timeMap = schedule->getTimeMap();
|
|
||||||
|
|
||||||
std::cout << "\n\n================ Starting main simulation loop ===============\n"
|
|
||||||
<< " (number of report steps: "
|
|
||||||
<< timeMap.numTimesteps() << ")\n\n" << std::flush;
|
|
||||||
WellState well_state;
|
|
||||||
int step = 0;
|
|
||||||
SimulatorTimer simtimer;
|
|
||||||
// Use timer for last epoch to obtain total time.
|
|
||||||
simtimer.init(timeMap);
|
|
||||||
const double total_time = simtimer.totalTime();
|
|
||||||
// for (size_t reportStepIdx = 0; reportStepIdx < timeMap->numTimesteps(); ++reportStepIdx) {
|
|
||||||
size_t reportStepIdx = 0; // Only handle a single, unchanging well setup.
|
|
||||||
{
|
|
||||||
// Update the timer.
|
|
||||||
simtimer.setCurrentStepNum(step);
|
|
||||||
simtimer.setTotalTime(total_time);
|
|
||||||
|
|
||||||
// Report on start of report step.
|
|
||||||
// std::cout << "\n\n-------------- Starting report step " << reportStepIdx << " --------------"
|
|
||||||
// << "\n (number of time steps: "
|
|
||||||
// << simtimer.numSteps() - step << ")\n\n" << std::flush;
|
|
||||||
|
|
||||||
// Create new wells, well_state
|
|
||||||
WellsManager wells(*eclipseState, *schedule, reportStepIdx , *grid->c_grid());
|
|
||||||
// @@@ HACK: we should really make a new well state and
|
|
||||||
// properly transfer old well state to it every report step,
|
|
||||||
// since number of wells may change etc.
|
|
||||||
if (reportStepIdx == 0) {
|
|
||||||
well_state.init(wells.c_wells(), *state);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create and run simulator.
|
|
||||||
SimulatorIncompTwophase simulator(param,
|
|
||||||
*grid->c_grid(),
|
|
||||||
*props,
|
|
||||||
rock_comp->isActive() ? rock_comp.get() : 0,
|
|
||||||
wells,
|
|
||||||
src,
|
|
||||||
bcs.c_bcs(),
|
|
||||||
linsolver,
|
|
||||||
grav);
|
|
||||||
if (reportStepIdx == 0) {
|
|
||||||
warnIfUnusedParams(param);
|
|
||||||
}
|
|
||||||
SimulatorReport epoch_rep = simulator.run(simtimer, *state, well_state);
|
|
||||||
if (output) {
|
|
||||||
epoch_rep.reportParam(epoch_os);
|
|
||||||
}
|
|
||||||
// Update total timing report and remember step number.
|
|
||||||
rep += epoch_rep;
|
|
||||||
step = simtimer.currentStepNum();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
std::cout << "\n\n================ End of simulation ===============\n\n";
|
|
||||||
rep.report(std::cout);
|
|
||||||
|
|
||||||
if (output) {
|
|
||||||
std::string filename = output_dir + "/walltime.param";
|
|
||||||
std::fstream tot_os(filename.c_str(),std::fstream::trunc | std::fstream::out);
|
|
||||||
rep.reportParam(tot_os);
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
catch (const std::exception &e) {
|
|
||||||
std::cerr << "Program threw an exception: " << e.what() << "\n";
|
|
||||||
throw;
|
|
||||||
}
|
|
||||||
@ -1,632 +0,0 @@
|
|||||||
/*
|
|
||||||
Copyright 2012 SINTEF ICT, Applied Mathematics.
|
|
||||||
|
|
||||||
This file is part of the Open Porous Media project (OPM).
|
|
||||||
|
|
||||||
OPM is free software: you can redistribute it and/or modify
|
|
||||||
it under the terms of the GNU General Public License as published by
|
|
||||||
the Free Software Foundation, either version 3 of the License, or
|
|
||||||
(at your option) any later version.
|
|
||||||
|
|
||||||
OPM is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
GNU General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU General Public License
|
|
||||||
along with OPM. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifdef HAVE_CONFIG_H
|
|
||||||
#include "config.h"
|
|
||||||
#endif // HAVE_CONFIG_H
|
|
||||||
|
|
||||||
#include <opm/simulators/SimulatorIncompTwophase.hpp>
|
|
||||||
#include <opm/core/utility/NullStream.hpp>
|
|
||||||
#include <opm/core/utility/parameters/ParameterGroup.hpp>
|
|
||||||
#include <opm/common/ErrorMacros.hpp>
|
|
||||||
|
|
||||||
#include <opm/core/pressure/IncompTpfa.hpp>
|
|
||||||
|
|
||||||
#include <opm/core/grid.h>
|
|
||||||
#include <opm/core/wells.h>
|
|
||||||
#include <opm/core/pressure/flow_bc.h>
|
|
||||||
|
|
||||||
#include <opm/core/simulator/SimulatorReport.hpp>
|
|
||||||
#include <opm/simulators/timestepping/SimulatorTimer.hpp>
|
|
||||||
#include <opm/core/utility/DataMap.hpp>
|
|
||||||
#include <opm/core/utility/StopWatch.hpp>
|
|
||||||
#include <opm/simulators/vtk/writeVtkData.hpp>
|
|
||||||
#include <opm/core/utility/miscUtilities.hpp>
|
|
||||||
#include <opm/core/utility/Event.hpp>
|
|
||||||
|
|
||||||
#include <opm/core/wells/WellsManager.hpp>
|
|
||||||
#include <opm/core/well_controls.h>
|
|
||||||
#include <opm/core/wells.h>
|
|
||||||
|
|
||||||
#include <opm/core/props/IncompPropertiesInterface.hpp>
|
|
||||||
#include <opm/core/props/rock/RockCompressibility.hpp>
|
|
||||||
|
|
||||||
#include <opm/core/simulator/TwophaseState.hpp>
|
|
||||||
#include <opm/core/simulator/WellState.hpp>
|
|
||||||
#include <opm/core/transport/reorder/TransportSolverTwophaseReorder.hpp>
|
|
||||||
#include <opm/core/transport/implicit/TransportSolverTwophaseImplicit.hpp>
|
|
||||||
#include <opm/simulators/ensureDirectoryExists.hpp>
|
|
||||||
|
|
||||||
|
|
||||||
#include <boost/filesystem.hpp>
|
|
||||||
#include <memory>
|
|
||||||
|
|
||||||
#include <iostream>
|
|
||||||
#include <numeric>
|
|
||||||
#include <fstream>
|
|
||||||
|
|
||||||
|
|
||||||
namespace Opm
|
|
||||||
{
|
|
||||||
|
|
||||||
struct SimulatorIncompTwophase::Impl
|
|
||||||
{
|
|
||||||
Impl(const ParameterGroup& param,
|
|
||||||
const UnstructuredGrid& grid,
|
|
||||||
const IncompPropertiesInterface& props,
|
|
||||||
const RockCompressibility* rock_comp_props,
|
|
||||||
WellsManager& wells_manager,
|
|
||||||
const std::vector<double>& src,
|
|
||||||
const FlowBoundaryConditions* bcs,
|
|
||||||
LinearSolverInterface& linsolver,
|
|
||||||
const double* gravity);
|
|
||||||
|
|
||||||
SimulatorReport run(SimulatorTimer& timer,
|
|
||||||
TwophaseState& state,
|
|
||||||
WellState& well_state);
|
|
||||||
|
|
||||||
// Data.
|
|
||||||
// Parameters for output.
|
|
||||||
std::ostream* log_;
|
|
||||||
bool output_;
|
|
||||||
bool output_vtk_;
|
|
||||||
std::string output_dir_;
|
|
||||||
int output_interval_;
|
|
||||||
// Parameters for well control
|
|
||||||
bool check_well_controls_;
|
|
||||||
int max_well_control_iterations_;
|
|
||||||
// Parameters for transport solver.
|
|
||||||
int num_transport_substeps_;
|
|
||||||
bool use_reorder_;
|
|
||||||
bool use_segregation_split_;
|
|
||||||
// Observed objects.
|
|
||||||
const UnstructuredGrid& grid_;
|
|
||||||
const IncompPropertiesInterface& props_;
|
|
||||||
const RockCompressibility* rock_comp_props_;
|
|
||||||
WellsManager& wells_manager_;
|
|
||||||
const Wells* wells_;
|
|
||||||
const std::vector<double>& src_;
|
|
||||||
const FlowBoundaryConditions* bcs_;
|
|
||||||
// Solvers
|
|
||||||
IncompTpfa psolver_;
|
|
||||||
std::unique_ptr<TransportSolverTwophaseInterface> tsolver_;
|
|
||||||
// Misc. data
|
|
||||||
std::vector<int> allcells_;
|
|
||||||
|
|
||||||
// list of hooks that are notified when a timestep completes
|
|
||||||
EventSource timestep_completed_;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
SimulatorIncompTwophase::SimulatorIncompTwophase(const ParameterGroup& param,
|
|
||||||
const UnstructuredGrid& grid,
|
|
||||||
const IncompPropertiesInterface& props,
|
|
||||||
const RockCompressibility* rock_comp_props,
|
|
||||||
WellsManager& wells_manager,
|
|
||||||
const std::vector<double>& src,
|
|
||||||
const FlowBoundaryConditions* bcs,
|
|
||||||
LinearSolverInterface& linsolver,
|
|
||||||
const double* gravity)
|
|
||||||
{
|
|
||||||
pimpl_.reset(new Impl(param, grid, props, rock_comp_props, wells_manager, src, bcs, linsolver, gravity));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
SimulatorReport SimulatorIncompTwophase::run(SimulatorTimer& timer,
|
|
||||||
TwophaseState& state,
|
|
||||||
WellState& well_state)
|
|
||||||
{
|
|
||||||
return pimpl_->run(timer, state, well_state);
|
|
||||||
}
|
|
||||||
|
|
||||||
// connect the hook to the signal in the implementation class
|
|
||||||
Event& SimulatorIncompTwophase::timestep_completed () {
|
|
||||||
return pimpl_->timestep_completed_;
|
|
||||||
}
|
|
||||||
|
|
||||||
// empty default implementation, but provided in module; it is dangerous ta have
|
|
||||||
// this inlined in clients from the header, because then it can't be updated!
|
|
||||||
void SimulatorIncompTwophase::sync () {
|
|
||||||
}
|
|
||||||
|
|
||||||
static void reportVolumes(std::ostream &os, double satvol[2], double tot_porevol_init,
|
|
||||||
double tot_injected[2], double tot_produced[2],
|
|
||||||
double injected[2], double produced[2],
|
|
||||||
double init_satvol[2])
|
|
||||||
{
|
|
||||||
os.precision(5);
|
|
||||||
const int width = 18;
|
|
||||||
os << "\nVolume balance report (all numbers relative to total pore volume).\n";
|
|
||||||
os << " Saturated volumes: "
|
|
||||||
<< std::setw(width) << satvol[0]/tot_porevol_init
|
|
||||||
<< std::setw(width) << satvol[1]/tot_porevol_init << std::endl;
|
|
||||||
os << " Injected volumes: "
|
|
||||||
<< std::setw(width) << injected[0]/tot_porevol_init
|
|
||||||
<< std::setw(width) << injected[1]/tot_porevol_init << std::endl;
|
|
||||||
os << " Produced volumes: "
|
|
||||||
<< std::setw(width) << produced[0]/tot_porevol_init
|
|
||||||
<< std::setw(width) << produced[1]/tot_porevol_init << std::endl;
|
|
||||||
os << " Total inj volumes: "
|
|
||||||
<< std::setw(width) << tot_injected[0]/tot_porevol_init
|
|
||||||
<< std::setw(width) << tot_injected[1]/tot_porevol_init << std::endl;
|
|
||||||
os << " Total prod volumes: "
|
|
||||||
<< std::setw(width) << tot_produced[0]/tot_porevol_init
|
|
||||||
<< std::setw(width) << tot_produced[1]/tot_porevol_init << std::endl;
|
|
||||||
os << " In-place + prod - inj: "
|
|
||||||
<< std::setw(width) << (satvol[0] + tot_produced[0] - tot_injected[0])/tot_porevol_init
|
|
||||||
<< std::setw(width) << (satvol[1] + tot_produced[1] - tot_injected[1])/tot_porevol_init << std::endl;
|
|
||||||
os << " Init - now - pr + inj: "
|
|
||||||
<< std::setw(width) << (init_satvol[0] - satvol[0] - tot_produced[0] + tot_injected[0])/tot_porevol_init
|
|
||||||
<< std::setw(width) << (init_satvol[1] - satvol[1] - tot_produced[1] + tot_injected[1])/tot_porevol_init
|
|
||||||
<< std::endl;
|
|
||||||
os.precision(8);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// 17.03.2016 Temporarily removed while moving functionality to opm-output
|
|
||||||
static void outputStateVtk(const UnstructuredGrid& grid,
|
|
||||||
const Opm::TwophaseState& state,
|
|
||||||
const int step,
|
|
||||||
const std::string& output_dir)
|
|
||||||
{
|
|
||||||
// Write data in VTK format.
|
|
||||||
std::ostringstream vtkfilename;
|
|
||||||
vtkfilename << output_dir << "/vtk_files";
|
|
||||||
ensureDirectoryExists(vtkfilename.str());
|
|
||||||
vtkfilename << "/output-" << std::setw(3) << std::setfill('0') << step << ".vtu";
|
|
||||||
std::ofstream vtkfile(vtkfilename.str().c_str());
|
|
||||||
if (!vtkfile) {
|
|
||||||
OPM_THROW(std::runtime_error, "Failed to open " << vtkfilename.str());
|
|
||||||
}
|
|
||||||
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;
|
|
||||||
Opm::writeVtkData(grid, dm, vtkfile);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void outputVectorMatlab(const std::string& name,
|
|
||||||
const std::vector<int>& vec,
|
|
||||||
const int step,
|
|
||||||
const std::string& output_dir)
|
|
||||||
{
|
|
||||||
std::ostringstream fname;
|
|
||||||
fname << output_dir << "/" << name;
|
|
||||||
ensureDirectoryExists(fname.str());
|
|
||||||
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());
|
|
||||||
}
|
|
||||||
std::copy(vec.begin(), vec.end(), std::ostream_iterator<double>(file, "\n"));
|
|
||||||
}
|
|
||||||
|
|
||||||
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;
|
|
||||||
ensureDirectoryExists(fname.str());
|
|
||||||
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)
|
|
||||||
{
|
|
||||||
// Write water cut curve.
|
|
||||||
std::string fname = output_dir + "/watercut.txt";
|
|
||||||
std::ofstream os(fname.c_str());
|
|
||||||
if (!os) {
|
|
||||||
OPM_THROW(std::runtime_error, "Failed to open " << fname);
|
|
||||||
}
|
|
||||||
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);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static bool allNeumannBCs(const FlowBoundaryConditions* bcs)
|
|
||||||
{
|
|
||||||
if (bcs == NULL) {
|
|
||||||
return true;
|
|
||||||
} else {
|
|
||||||
return std::find(bcs->type, bcs->type + bcs->nbc, BC_PRESSURE)
|
|
||||||
== bcs->type + bcs->nbc;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static bool allRateWells(const Wells* wells)
|
|
||||||
{
|
|
||||||
if (wells == NULL) {
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
const int nw = wells->number_of_wells;
|
|
||||||
for (int w = 0; w < nw; ++w) {
|
|
||||||
const WellControls* wc = wells->ctrls[w];
|
|
||||||
if (well_controls_well_is_open( wc )) {
|
|
||||||
if (well_controls_get_current_type(wc) == BHP) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
SimulatorIncompTwophase::Impl::Impl(const ParameterGroup& param,
|
|
||||||
const UnstructuredGrid& grid,
|
|
||||||
const IncompPropertiesInterface& props,
|
|
||||||
const RockCompressibility* rock_comp_props,
|
|
||||||
WellsManager& wells_manager,
|
|
||||||
const std::vector<double>& src,
|
|
||||||
const FlowBoundaryConditions* bcs,
|
|
||||||
LinearSolverInterface& linsolver,
|
|
||||||
const double* gravity)
|
|
||||||
: use_reorder_(param.getDefault("use_reorder", true)),
|
|
||||||
use_segregation_split_(param.getDefault("use_segregation_split", false)),
|
|
||||||
grid_(grid),
|
|
||||||
props_(props),
|
|
||||||
rock_comp_props_(rock_comp_props),
|
|
||||||
wells_manager_(wells_manager),
|
|
||||||
wells_(wells_manager.c_wells()),
|
|
||||||
src_(src),
|
|
||||||
bcs_(bcs),
|
|
||||||
psolver_(grid, props, rock_comp_props, linsolver,
|
|
||||||
param.getDefault("nl_pressure_residual_tolerance", 0.0),
|
|
||||||
param.getDefault("nl_pressure_change_tolerance", 1.0),
|
|
||||||
param.getDefault("nl_pressure_maxiter", 10),
|
|
||||||
gravity, wells_manager.c_wells(), src, bcs)
|
|
||||||
{
|
|
||||||
// Initialize transport solver.
|
|
||||||
if (use_reorder_) {
|
|
||||||
tsolver_.reset(new Opm::TransportSolverTwophaseReorder(grid,
|
|
||||||
props,
|
|
||||||
use_segregation_split_ ? gravity : NULL,
|
|
||||||
param.getDefault("nl_tolerance", 1e-9),
|
|
||||||
param.getDefault("nl_maxiter", 30)));
|
|
||||||
|
|
||||||
} else {
|
|
||||||
if (rock_comp_props && rock_comp_props->isActive()) {
|
|
||||||
OPM_THROW(std::runtime_error, "The implicit pressure solver cannot handle rock compressibility.");
|
|
||||||
}
|
|
||||||
if (use_segregation_split_) {
|
|
||||||
OPM_THROW(std::runtime_error, "The implicit pressure solver is not set up to use segregation splitting.");
|
|
||||||
}
|
|
||||||
std::vector<double> porevol;
|
|
||||||
computePorevolume(grid, props.porosity(), porevol);
|
|
||||||
tsolver_.reset(new Opm::TransportSolverTwophaseImplicit(grid,
|
|
||||||
props,
|
|
||||||
porevol,
|
|
||||||
gravity,
|
|
||||||
psolver_.getHalfTrans(),
|
|
||||||
param));
|
|
||||||
}
|
|
||||||
|
|
||||||
// For output.
|
|
||||||
log_ = param.getDefault("quiet", false) ? &Opm::null_stream : &std::cout;
|
|
||||||
output_ = param.getDefault("output", true);
|
|
||||||
if (output_) {
|
|
||||||
output_vtk_ = param.getDefault("output_vtk", true);
|
|
||||||
output_dir_ = param.getDefault("output_dir", std::string("output"));
|
|
||||||
// Ensure that output dir exists
|
|
||||||
ensureDirectoryExists(output_dir_);
|
|
||||||
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);
|
|
||||||
|
|
||||||
// Transport related init.
|
|
||||||
num_transport_substeps_ = param.getDefault("num_transport_substeps", 1);
|
|
||||||
|
|
||||||
// Misc init.
|
|
||||||
const int num_cells = grid.number_of_cells;
|
|
||||||
allcells_.resize(num_cells);
|
|
||||||
for (int cell = 0; cell < num_cells; ++cell) {
|
|
||||||
allcells_[cell] = cell;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
SimulatorReport SimulatorIncompTwophase::Impl::run(SimulatorTimer& timer,
|
|
||||||
TwophaseState& state,
|
|
||||||
WellState& well_state)
|
|
||||||
{
|
|
||||||
std::vector<double> transport_src;
|
|
||||||
|
|
||||||
// Initialisation.
|
|
||||||
std::vector<double> porevol;
|
|
||||||
if (rock_comp_props_ && rock_comp_props_->isActive()) {
|
|
||||||
computePorevolume(grid_, props_.porosity(), *rock_comp_props_, state.pressure(), porevol);
|
|
||||||
} else {
|
|
||||||
computePorevolume(grid_, props_.porosity(), porevol);
|
|
||||||
}
|
|
||||||
const double tot_porevol_init = std::accumulate(porevol.begin(), porevol.end(), 0.0);
|
|
||||||
std::vector<double> initial_porevol = porevol;
|
|
||||||
|
|
||||||
// Main simulation loop.
|
|
||||||
Opm::time::StopWatch pressure_timer;
|
|
||||||
double ptime = 0.0;
|
|
||||||
Opm::time::StopWatch transport_timer;
|
|
||||||
double ttime = 0.0;
|
|
||||||
Opm::time::StopWatch callback_timer;
|
|
||||||
double time_in_callbacks = 0.0;
|
|
||||||
Opm::time::StopWatch step_timer;
|
|
||||||
Opm::time::StopWatch total_timer;
|
|
||||||
total_timer.start();
|
|
||||||
double init_satvol[2] = { 0.0 };
|
|
||||||
double satvol[2] = { 0.0 };
|
|
||||||
double tot_injected[2] = { 0.0 };
|
|
||||||
double tot_produced[2] = { 0.0 };
|
|
||||||
Opm::computeSaturatedVol(porevol, state.saturation(), init_satvol);
|
|
||||||
*log_ << "\nInitial saturations are " << init_satvol[0]/tot_porevol_init
|
|
||||||
<< " " << init_satvol[1]/tot_porevol_init << std::endl;
|
|
||||||
Opm::Watercut watercut;
|
|
||||||
watercut.push(0.0, 0.0, 0.0);
|
|
||||||
Opm::WellReport wellreport;
|
|
||||||
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);
|
|
||||||
wellreport.push(props_, *wells_, state.saturation(), 0.0, well_state.bhp(), well_state.perfRates());
|
|
||||||
}
|
|
||||||
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);
|
|
||||||
}
|
|
||||||
while (!timer.done()) {
|
|
||||||
// Report timestep and (optionally) write state to disk.
|
|
||||||
step_timer.start();
|
|
||||||
timer.report(*log_);
|
|
||||||
if (output_ && (timer.currentStepNum() % output_interval_ == 0)) {
|
|
||||||
if (output_vtk_) {
|
|
||||||
outputStateVtk(grid_, state, timer.currentStepNum(), output_dir_);
|
|
||||||
}
|
|
||||||
outputStateMatlab(grid_, state, timer.currentStepNum(), output_dir_);
|
|
||||||
if (use_reorder_) {
|
|
||||||
// This use of dynamic_cast is not ideal, but should be safe.
|
|
||||||
outputVectorMatlab(std::string("reorder_it"),
|
|
||||||
dynamic_cast<const TransportSolverTwophaseReorder&>(*tsolver_).getReorderIterations(),
|
|
||||||
timer.currentStepNum(), output_dir_);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
SimulatorReport sreport;
|
|
||||||
|
|
||||||
// Solve pressure equation.
|
|
||||||
if (check_well_controls_) {
|
|
||||||
computeFractionalFlow(props_, allcells_, state.saturation(), fractional_flows);
|
|
||||||
wells_manager_.applyExplicitReinjectionControls(well_resflows_phase, well_resflows_phase);
|
|
||||||
}
|
|
||||||
bool well_control_passed = !check_well_controls_;
|
|
||||||
int well_control_iteration = 0;
|
|
||||||
do {
|
|
||||||
// Run solver.
|
|
||||||
pressure_timer.start();
|
|
||||||
std::vector<double> initial_pressure = state.pressure();
|
|
||||||
psolver_.solve(timer.currentStepLength(), state, well_state);
|
|
||||||
|
|
||||||
// Renormalize pressure if rock is incompressible, and
|
|
||||||
// there are no pressure conditions (bcs or wells).
|
|
||||||
// It is deemed sufficient for now to renormalize
|
|
||||||
// using geometric volume instead of pore volume.
|
|
||||||
if ((rock_comp_props_ == NULL || !rock_comp_props_->isActive())
|
|
||||||
&& allNeumannBCs(bcs_) && allRateWells(wells_)) {
|
|
||||||
// Compute average pressures of previous and last
|
|
||||||
// step, and total volume.
|
|
||||||
double av_prev_press = 0.0;
|
|
||||||
double av_press = 0.0;
|
|
||||||
double tot_vol = 0.0;
|
|
||||||
const int num_cells = grid_.number_of_cells;
|
|
||||||
for (int cell = 0; cell < num_cells; ++cell) {
|
|
||||||
av_prev_press += initial_pressure[cell]*grid_.cell_volumes[cell];
|
|
||||||
av_press += state.pressure()[cell]*grid_.cell_volumes[cell];
|
|
||||||
tot_vol += grid_.cell_volumes[cell];
|
|
||||||
}
|
|
||||||
// Renormalization constant
|
|
||||||
const double ren_const = (av_prev_press - av_press)/tot_vol;
|
|
||||||
for (int cell = 0; cell < num_cells; ++cell) {
|
|
||||||
state.pressure()[cell] += ren_const;
|
|
||||||
}
|
|
||||||
const int num_wells = (wells_ == NULL) ? 0 : wells_->number_of_wells;
|
|
||||||
for (int well = 0; well < num_wells; ++well) {
|
|
||||||
well_state.bhp()[well] += ren_const;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Stop timer and report.
|
|
||||||
pressure_timer.stop();
|
|
||||||
double pt = pressure_timer.secsSinceStart();
|
|
||||||
*log_ << "Pressure solver took: " << pt << " seconds." << std::endl;
|
|
||||||
ptime += pt;
|
|
||||||
sreport.pressure_time = pt;
|
|
||||||
|
|
||||||
// Optionally, check if well controls are satisfied.
|
|
||||||
if (check_well_controls_) {
|
|
||||||
Opm::computePhaseFlowRatesPerWell(*wells_,
|
|
||||||
well_state.perfRates(),
|
|
||||||
fractional_flows,
|
|
||||||
well_resflows_phase);
|
|
||||||
*log_ << "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) {
|
|
||||||
*log_ << "Well controls not passed, solving again." << std::endl;
|
|
||||||
} else {
|
|
||||||
*log_ << "Well conditions met." << std::endl;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} while (!well_control_passed);
|
|
||||||
|
|
||||||
// Update pore volumes if rock is compressible.
|
|
||||||
if (rock_comp_props_ && rock_comp_props_->isActive()) {
|
|
||||||
initial_porevol = porevol;
|
|
||||||
computePorevolume(grid_, props_.porosity(), *rock_comp_props_, state.pressure(), porevol);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Process transport sources (to include bdy terms and well flows).
|
|
||||||
Opm::computeTransportSource(grid_, src_, state.faceflux(), 1.0,
|
|
||||||
wells_, well_state.perfRates(), transport_src);
|
|
||||||
|
|
||||||
// Solve transport.
|
|
||||||
transport_timer.start();
|
|
||||||
double stepsize = timer.currentStepLength();
|
|
||||||
if (num_transport_substeps_ != 1) {
|
|
||||||
stepsize /= double(num_transport_substeps_);
|
|
||||||
*log_ << "Making " << num_transport_substeps_ << " transport substeps." << std::endl;
|
|
||||||
}
|
|
||||||
double injected[2] = { 0.0 };
|
|
||||||
double produced[2] = { 0.0 };
|
|
||||||
for (int tr_substep = 0; tr_substep < num_transport_substeps_; ++tr_substep) {
|
|
||||||
tsolver_->solve(&initial_porevol[0], &transport_src[0], stepsize, state);
|
|
||||||
|
|
||||||
double substep_injected[2] = { 0.0 };
|
|
||||||
double substep_produced[2] = { 0.0 };
|
|
||||||
Opm::computeInjectedProduced(props_, state.saturation(), transport_src, stepsize,
|
|
||||||
substep_injected, substep_produced);
|
|
||||||
injected[0] += substep_injected[0];
|
|
||||||
injected[1] += substep_injected[1];
|
|
||||||
produced[0] += substep_produced[0];
|
|
||||||
produced[1] += substep_produced[1];
|
|
||||||
if (use_reorder_ && use_segregation_split_) {
|
|
||||||
// Again, unfortunate but safe use of dynamic_cast.
|
|
||||||
// Possible solution: refactor gravity solver to its own class.
|
|
||||||
dynamic_cast<TransportSolverTwophaseReorder&>(*tsolver_)
|
|
||||||
.solveGravity(&initial_porevol[0], stepsize, state);
|
|
||||||
}
|
|
||||||
watercut.push(timer.simulationTimeElapsed() + timer.currentStepLength(),
|
|
||||||
produced[0]/(produced[0] + produced[1]),
|
|
||||||
tot_produced[0]/tot_porevol_init);
|
|
||||||
if (wells_) {
|
|
||||||
wellreport.push(props_, *wells_, state.saturation(),
|
|
||||||
timer.simulationTimeElapsed() + timer.currentStepLength(),
|
|
||||||
well_state.bhp(), well_state.perfRates());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
transport_timer.stop();
|
|
||||||
double tt = transport_timer.secsSinceStart();
|
|
||||||
sreport.transport_time = tt;
|
|
||||||
*log_ << "Transport solver took: " << tt << " seconds." << std::endl;
|
|
||||||
ttime += tt;
|
|
||||||
// Report volume balances.
|
|
||||||
Opm::computeSaturatedVol(porevol, state.saturation(), satvol);
|
|
||||||
tot_injected[0] += injected[0];
|
|
||||||
tot_injected[1] += injected[1];
|
|
||||||
tot_produced[0] += produced[0];
|
|
||||||
tot_produced[1] += produced[1];
|
|
||||||
reportVolumes(*log_, satvol, tot_porevol_init,
|
|
||||||
tot_injected, tot_produced,
|
|
||||||
injected, produced,
|
|
||||||
init_satvol);
|
|
||||||
sreport.total_time = step_timer.secsSinceStart();
|
|
||||||
if (output_) {
|
|
||||||
sreport.reportParam(tstep_os);
|
|
||||||
}
|
|
||||||
|
|
||||||
// advance the timer to the end of the timestep *before* notifying
|
|
||||||
// the client that the timestep is done
|
|
||||||
++timer;
|
|
||||||
|
|
||||||
// notify all clients that we are done with the timestep
|
|
||||||
callback_timer.start ();
|
|
||||||
timestep_completed_.signal ();
|
|
||||||
callback_timer.stop ();
|
|
||||||
time_in_callbacks += callback_timer.secsSinceStart ();
|
|
||||||
}
|
|
||||||
|
|
||||||
if (output_) {
|
|
||||||
if (output_vtk_) {
|
|
||||||
outputStateVtk(grid_, state, timer.currentStepNum(), output_dir_);
|
|
||||||
}
|
|
||||||
outputStateMatlab(grid_, state, timer.currentStepNum(), output_dir_);
|
|
||||||
if (use_reorder_) {
|
|
||||||
// This use of dynamic_cast is not ideal, but should be safe.
|
|
||||||
outputVectorMatlab(std::string("reorder_it"),
|
|
||||||
dynamic_cast<const TransportSolverTwophaseReorder&>(*tsolver_).getReorderIterations(),
|
|
||||||
timer.currentStepNum(), output_dir_);
|
|
||||||
}
|
|
||||||
outputWaterCut(watercut, output_dir_);
|
|
||||||
if (wells_) {
|
|
||||||
outputWellReport(wellreport, output_dir_);
|
|
||||||
}
|
|
||||||
tstep_os.close();
|
|
||||||
}
|
|
||||||
|
|
||||||
total_timer.stop();
|
|
||||||
|
|
||||||
SimulatorReport report;
|
|
||||||
report.pressure_time = ptime;
|
|
||||||
report.transport_time = ttime;
|
|
||||||
report.total_time = total_timer.secsSinceStart() - time_in_callbacks;
|
|
||||||
return report;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
} // namespace Opm
|
|
||||||
@ -1,144 +0,0 @@
|
|||||||
/*
|
|
||||||
Copyright 2012 SINTEF ICT, Applied Mathematics.
|
|
||||||
|
|
||||||
This file is part of the Open Porous Media project (OPM).
|
|
||||||
|
|
||||||
OPM is free software: you can redistribute it and/or modify
|
|
||||||
it under the terms of the GNU General Public License as published by
|
|
||||||
the Free Software Foundation, either version 3 of the License, or
|
|
||||||
(at your option) any later version.
|
|
||||||
|
|
||||||
OPM is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
GNU General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU General Public License
|
|
||||||
along with OPM. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef OPM_SIMULATORINCOMPTWOPHASE_HEADER_INCLUDED
|
|
||||||
#define OPM_SIMULATORINCOMPTWOPHASE_HEADER_INCLUDED
|
|
||||||
|
|
||||||
#include <memory>
|
|
||||||
#include <vector>
|
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
struct UnstructuredGrid;
|
|
||||||
struct Wells;
|
|
||||||
struct FlowBoundaryConditions;
|
|
||||||
|
|
||||||
namespace Opm
|
|
||||||
{
|
|
||||||
class ParameterGroup;
|
|
||||||
class IncompPropertiesInterface;
|
|
||||||
class RockCompressibility;
|
|
||||||
class WellsManager;
|
|
||||||
class LinearSolverInterface;
|
|
||||||
class SimulatorTimer;
|
|
||||||
class TwophaseState;
|
|
||||||
class WellState;
|
|
||||||
struct SimulatorReport;
|
|
||||||
struct Event;
|
|
||||||
|
|
||||||
/// Class collecting all necessary components for a two-phase simulation.
|
|
||||||
class SimulatorIncompTwophase
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
/// Initialise from parameters and objects to observe.
|
|
||||||
/// \param[in] param parameters, this class accepts the following:
|
|
||||||
/// parameter (default) effect
|
|
||||||
/// -----------------------------------------------------------
|
|
||||||
/// output (true) write output to files?
|
|
||||||
/// output_dir ("output") output directoty
|
|
||||||
/// output_interval (1) output every nth step
|
|
||||||
/// nl_pressure_residual_tolerance (0.0) pressure solver residual tolerance (in Pascal)
|
|
||||||
/// nl_pressure_change_tolerance (1.0) pressure solver change tolerance (in Pascal)
|
|
||||||
/// nl_pressure_maxiter (10) max nonlinear iterations in pressure
|
|
||||||
/// nl_maxiter (30) max nonlinear iterations in transport
|
|
||||||
/// nl_tolerance (1e-9) transport solver absolute residual tolerance
|
|
||||||
/// num_transport_substeps (1) number of transport steps per pressure step
|
|
||||||
/// use_segregation_split (false) solve for gravity segregation (if false,
|
|
||||||
/// segregation is ignored).
|
|
||||||
///
|
|
||||||
/// \param[in] grid grid data structure
|
|
||||||
/// \param[in] props fluid and rock properties
|
|
||||||
/// \param[in] rock_comp_props if non-null, rock compressibility properties
|
|
||||||
/// \param[in] well_manager well manager, may manage no (null) wells
|
|
||||||
/// \param[in] src source terms
|
|
||||||
/// \param[in] bcs boundary conditions, treat as all noflow if null
|
|
||||||
/// \param[in] linsolver linear solver
|
|
||||||
/// \param[in] gravity if non-null, gravity vector
|
|
||||||
SimulatorIncompTwophase(const ParameterGroup& param,
|
|
||||||
const UnstructuredGrid& grid,
|
|
||||||
const IncompPropertiesInterface& props,
|
|
||||||
const RockCompressibility* rock_comp_props,
|
|
||||||
WellsManager& wells_manager,
|
|
||||||
const std::vector<double>& src,
|
|
||||||
const FlowBoundaryConditions* bcs,
|
|
||||||
LinearSolverInterface& linsolver,
|
|
||||||
const double* gravity);
|
|
||||||
|
|
||||||
/// Run the simulation.
|
|
||||||
/// This will run succesive timesteps until timer.done() is true. It will
|
|
||||||
/// modify the reservoir and well states.
|
|
||||||
/// \param[in,out] timer governs the requested reporting timesteps
|
|
||||||
/// \param[in,out] state state of reservoir: pressure, fluxes
|
|
||||||
/// \param[in,out] well_state state of wells: bhp, perforation rates
|
|
||||||
/// \return simulation report, with timing data
|
|
||||||
SimulatorReport run(SimulatorTimer& timer,
|
|
||||||
TwophaseState& state,
|
|
||||||
WellState& well_state);
|
|
||||||
|
|
||||||
/// Event that is signaled every time the simulator has completed a
|
|
||||||
/// a timestep.
|
|
||||||
///
|
|
||||||
/// Register a callback with this event to do processing at the end
|
|
||||||
/// of every timestep, for instance to do reporting.
|
|
||||||
///
|
|
||||||
/// \note
|
|
||||||
/// If you want to know the current timestep, the callback must
|
|
||||||
/// also monitor the timer object which was passed to run().
|
|
||||||
///
|
|
||||||
/// \example
|
|
||||||
/// \code{.cpp}
|
|
||||||
/// struct Foo {
|
|
||||||
/// void bar () { cout << "Called!" << endl; }
|
|
||||||
/// };
|
|
||||||
///
|
|
||||||
/// SimulatorIncompTwophase sim (...);
|
|
||||||
/// Foo f;
|
|
||||||
/// sim.timestep_completed ().add <Foo, &Foo::bar> (f);
|
|
||||||
/// sim.run (...);
|
|
||||||
/// \endcode
|
|
||||||
///
|
|
||||||
/// \note
|
|
||||||
/// Registered callbacks should call the sync() method before
|
|
||||||
/// accessing the state that was passed into the run() method.
|
|
||||||
///
|
|
||||||
/// \see Opm::SimulatorIncompTwophase::sync
|
|
||||||
Event& timestep_completed ();
|
|
||||||
|
|
||||||
/// Notify the simulator that a callback has an interest in reading
|
|
||||||
/// for reporting purposes the contents of the state argument that
|
|
||||||
/// was passed to the run() method. The simulator will then flush
|
|
||||||
/// any internal state which is currently not reflected in it.
|
|
||||||
///
|
|
||||||
/// \note
|
|
||||||
/// This should only be called from within a notification which has
|
|
||||||
/// been setup with timestep_completed(). Avoid calling this method
|
|
||||||
/// outside of run().
|
|
||||||
///
|
|
||||||
/// \see Opm::SimulatorIncompTwophase::run,
|
|
||||||
/// Opm::SimulatorIncompTwophase::timestep_completed
|
|
||||||
void sync ();
|
|
||||||
|
|
||||||
private:
|
|
||||||
struct Impl;
|
|
||||||
// Using shared_ptr instead of unique_ptr since unique_ptr requires complete type for Impl.
|
|
||||||
std::shared_ptr<Impl> pimpl_;
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace Opm
|
|
||||||
|
|
||||||
#endif // OPM_SIMULATORINCOMPTWOPHASE_HEADER_INCLUDED
|
|
||||||
Loading…
Reference in New Issue
Block a user