mirror of
https://github.com/OPM/opm-simulators.git
synced 2025-02-25 18:55:30 -06:00
1bf755f5e8
This moves about 300 lines of code out of Main.hpp and, especially, moves the <flow/flow_*.hpp> include statements as well. This, in turn, makes Main::runStatic<>() usable for out-of-tree consumers.
406 lines
12 KiB
C++
406 lines
12 KiB
C++
/*
|
|
Copyright 2013, 2014, 2015 SINTEF ICT, Applied Mathematics.
|
|
Copyright 2014 Dr. Blatt - HPC-Simulation-Software & Services
|
|
Copyright 2015 IRIS AS
|
|
Copyright 2014 STATOIL ASA.
|
|
|
|
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/>.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include <opm/simulators/flow/Main.hpp>
|
|
|
|
#include <flow/flow_blackoil.hpp>
|
|
#include <flow/flow_blackoil_legacyassembly.hpp>
|
|
#include <flow/flow_brine.hpp>
|
|
#include <flow/flow_brine_precsalt_vapwat.hpp>
|
|
#include <flow/flow_brine_saltprecipitation.hpp>
|
|
#include <flow/flow_energy.hpp>
|
|
#include <flow/flow_extbo.hpp>
|
|
#include <flow/flow_foam.hpp>
|
|
#include <flow/flow_gasoil.hpp>
|
|
#include <flow/flow_gasoil_energy.hpp>
|
|
#include <flow/flow_gasoildiffuse.hpp>
|
|
#include <flow/flow_gaswater.hpp>
|
|
#include <flow/flow_gaswater_brine.hpp>
|
|
#include <flow/flow_gaswater_dissolution.hpp>
|
|
#include <flow/flow_gaswater_dissolution_diffuse.hpp>
|
|
#include <flow/flow_gaswater_energy.hpp>
|
|
#include <flow/flow_gaswater_saltprec_energy.hpp>
|
|
#include <flow/flow_gaswater_saltprec_vapwat.hpp>
|
|
#include <flow/flow_gaswater_solvent.hpp>
|
|
#include <flow/flow_micp.hpp>
|
|
#include <flow/flow_oilwater.hpp>
|
|
#include <flow/flow_oilwater_brine.hpp>
|
|
#include <flow/flow_oilwater_polymer.hpp>
|
|
#include <flow/flow_oilwater_polymer_injectivity.hpp>
|
|
#include <flow/flow_onephase.hpp>
|
|
#include <flow/flow_onephase_energy.hpp>
|
|
#include <flow/flow_polymer.hpp>
|
|
#include <flow/flow_solvent.hpp>
|
|
#include <flow/flow_solvent_foam.hpp>
|
|
|
|
#include <cstdlib>
|
|
#include <iostream>
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Implementation of dispatchDynamic_()
|
|
// ---------------------------------------------------------------------------
|
|
|
|
int Opm::Main::dispatchDynamic_()
|
|
{
|
|
const auto& rspec = this->eclipseState_->runspec();
|
|
const auto& phases = rspec.phases();
|
|
|
|
this->setupVanguard();
|
|
|
|
// run the actual simulator
|
|
//
|
|
// TODO: make sure that no illegal combinations like thermal and
|
|
// twophase are requested.
|
|
const bool thermal = eclipseState_->getSimulationConfig().isThermal();
|
|
|
|
// Single-phase case
|
|
if (rspec.micp()) {
|
|
return this->runMICP(phases);
|
|
}
|
|
|
|
// water-only case
|
|
else if (phases.size() == 1 && phases.active(Phase::WATER) && !thermal) {
|
|
return this->runWaterOnly(phases);
|
|
}
|
|
|
|
// water-only case with energy
|
|
else if (phases.size() == 2 && phases.active(Phase::WATER) && thermal) {
|
|
return this->runWaterOnlyEnergy(phases);
|
|
}
|
|
|
|
// Twophase cases
|
|
else if (phases.size() == 2 && !thermal) {
|
|
return this->runTwoPhase(phases);
|
|
}
|
|
|
|
// Polymer case
|
|
else if (phases.active(Phase::POLYMER)) {
|
|
return this->runPolymer(phases);
|
|
}
|
|
|
|
// Foam case
|
|
else if (phases.active(Phase::FOAM) && !phases.active(Phase::SOLVENT)) {
|
|
return this->runFoam();
|
|
}
|
|
|
|
// Solvent case
|
|
else if (phases.active(Phase::SOLVENT)) {
|
|
return this->runSolvent(phases);
|
|
}
|
|
|
|
// Brine case
|
|
else if (phases.active(Phase::BRINE) && !thermal) {
|
|
return this->runBrine(phases);
|
|
}
|
|
|
|
// Extended BO case
|
|
else if (phases.active(Phase::ZFRACTION)) {
|
|
return this->runExtendedBlackOil();
|
|
}
|
|
|
|
// Energy case
|
|
else if (thermal) {
|
|
return this->runThermal(phases);
|
|
}
|
|
|
|
// Blackoil case
|
|
else if (phases.size() == 3) {
|
|
return this->runBlackOil();
|
|
}
|
|
|
|
else {
|
|
if (outputCout_) {
|
|
std::cerr << "No suitable configuration found, valid are "
|
|
<< "Twophase, polymer, foam, brine, solvent, "
|
|
<< "energy, and blackoil.\n";
|
|
}
|
|
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
|
|
int Opm::Main::runMICP(const Phases& phases)
|
|
{
|
|
if (!phases.active(Phase::WATER) || (phases.size() > 2)) {
|
|
if (outputCout_) {
|
|
std::cerr << "No valid configuration is found for MICP simulation, "
|
|
<< "the only valid option is water + MICP\n";
|
|
}
|
|
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return flowMICPMain(this->argc_,
|
|
this->argv_,
|
|
this->outputCout_,
|
|
this->outputFiles_);
|
|
}
|
|
|
|
int Opm::Main::runTwoPhase(const Phases& phases)
|
|
{
|
|
const bool diffusive = eclipseState_->getSimulationConfig().isDiffusive();
|
|
const bool disgasw = eclipseState_->getSimulationConfig().hasDISGASW();
|
|
const bool vapwat = eclipseState_->getSimulationConfig().hasVAPWAT();
|
|
|
|
// oil-gas
|
|
if (phases.active(Phase::OIL) && phases.active(Phase::GAS)) {
|
|
if (diffusive) {
|
|
return flowGasOilDiffuseMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
return flowGasOilMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
// oil-water
|
|
else if (phases.active(Phase::OIL) && phases.active(Phase::WATER)) {
|
|
if (diffusive) {
|
|
if (outputCout_) {
|
|
std::cerr << "The DIFFUSE option is not available for "
|
|
"the two-phase water/oil model.\n";
|
|
}
|
|
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return flowOilWaterMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
// gas-water
|
|
else if (phases.active(Phase::GAS) && phases.active(Phase::WATER)) {
|
|
if (disgasw || vapwat) {
|
|
if (diffusive) {
|
|
return flowGasWaterDissolutionDiffuseMain(argc_, argv_,
|
|
outputCout_,
|
|
outputFiles_);
|
|
}
|
|
|
|
return flowGasWaterDissolutionMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
if (diffusive) {
|
|
if (outputCout_) {
|
|
std::cerr << "The DIFFUSE option is not available for "
|
|
"the two-phase gas/water model without "
|
|
"disgasw or vapwat.\n";
|
|
}
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return flowGasWaterMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
else {
|
|
if (outputCout_) {
|
|
std::cerr << "No suitable configuration found, valid "
|
|
"are Twophase (oilwater, oilgas and gaswater), "
|
|
"polymer, solvent, or blackoil.\n";
|
|
}
|
|
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
|
|
int Opm::Main::runPolymer(const Phases& phases)
|
|
{
|
|
if (! phases.active(Phase::WATER)) {
|
|
if (outputCout_) {
|
|
std::cerr << "No valid configuration is found for polymer "
|
|
"simulation, valid options include "
|
|
"oilwater + polymer and blackoil + polymer\n";
|
|
}
|
|
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
// Need to track the polymer molecular weight
|
|
// for the injectivity study
|
|
if (phases.active(Phase::POLYMW)) {
|
|
// only oil water two phase for now
|
|
assert (phases.size() == 4);
|
|
return flowOilWaterPolymerInjectivityMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
if (phases.size() == 3) { // oil water polymer case
|
|
return flowOilWaterPolymerMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
return flowPolymerMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
int Opm::Main::runFoam()
|
|
{
|
|
return flowFoamMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
int Opm::Main::runWaterOnly(const Phases& phases)
|
|
{
|
|
if (!phases.active(Phase::WATER) || phases.size() != 1) {
|
|
if (outputCout_) {
|
|
std::cerr << "No valid configuration is found for "
|
|
"water-only simulation, valid options include "
|
|
"water, water + thermal\n";
|
|
}
|
|
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return flowWaterOnlyMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
int Opm::Main::runWaterOnlyEnergy(const Phases& phases)
|
|
{
|
|
if (!phases.active(Phase::WATER) || phases.size() != 2) {
|
|
if (outputCout_) {
|
|
std::cerr << "No valid configuration is found for water-only "
|
|
"simulation, valid options include "
|
|
"water, water + thermal\n";
|
|
}
|
|
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return flowWaterOnlyEnergyMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
int Opm::Main::runBrine(const Phases& phases)
|
|
{
|
|
if (! phases.active(Phase::WATER) || phases.size() == 2) {
|
|
if (outputCout_) {
|
|
std::cerr << "No valid configuration is found for brine "
|
|
"simulation, valid options include "
|
|
"oilwater + brine, gaswater + brine "
|
|
"and blackoil + brine\n";
|
|
}
|
|
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (phases.size() == 3) {
|
|
if (phases.active(Phase::OIL)) {
|
|
// oil water brine case
|
|
return flowOilWaterBrineMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
if (phases.active(Phase::GAS)) {
|
|
// gas water brine case
|
|
if (eclipseState_->getSimulationConfig().hasPRECSALT() &&
|
|
eclipseState_->getSimulationConfig().hasVAPWAT())
|
|
{
|
|
// Case with water vaporization into gas phase and salt precipitation
|
|
return flowGasWaterSaltprecVapwatMain(argc_, argv_,
|
|
outputCout_,
|
|
outputFiles_);
|
|
}
|
|
else {
|
|
return flowGasWaterBrineMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
}
|
|
}
|
|
else if (eclipseState_->getSimulationConfig().hasPRECSALT()) {
|
|
if (eclipseState_->getSimulationConfig().hasVAPWAT()) {
|
|
//case with water vaporization into gas phase and salt precipitation
|
|
return flowBrinePrecsaltVapwatMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
else {
|
|
return flowBrineSaltPrecipitationMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
}
|
|
else {
|
|
return flowBrineMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
int Opm::Main::runSolvent(const Phases& phases)
|
|
{
|
|
if (phases.active(Phase::FOAM)) {
|
|
return flowSolventFoamMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
// solvent + gas + water
|
|
if (!phases.active(Phase::OIL) &&
|
|
phases.active(Phase::WATER) &&
|
|
phases.active(Phase::GAS))
|
|
{
|
|
return flowGasWaterSolventMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
// solvent + gas + water + oil
|
|
if (phases.active(Phase::OIL) &&
|
|
phases.active(Phase::WATER) &&
|
|
phases.active(Phase::GAS))
|
|
{
|
|
return flowSolventMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
if (outputCout_) {
|
|
std::cerr << "No valid configuration is found for solvent "
|
|
"simulation, valid options include "
|
|
"gas + water + solvent and gas + oil + water + solvent\n";
|
|
}
|
|
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
int Opm::Main::runExtendedBlackOil()
|
|
{
|
|
return flowExtboMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
int Opm::Main::runThermal(const Phases& phases)
|
|
{
|
|
// oil-gas-thermal
|
|
if (!phases.active(Phase::WATER) &&
|
|
phases.active(Phase::OIL) &&
|
|
phases.active( Phase::GAS))
|
|
{
|
|
return flowGasOilEnergyMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
// water-gas-thermal
|
|
if (!phases.active(Phase::OIL) &&
|
|
phases.active(Phase::WATER) &&
|
|
phases.active(Phase::GAS))
|
|
{
|
|
if (phases.active(Phase::BRINE)) {
|
|
return flowGasWaterSaltprecEnergyMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
return flowGasWaterEnergyMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
return flowEnergyMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
int Opm::Main::runBlackOil()
|
|
{
|
|
if (this->eclipseState_->getSimulationConfig().isDiffusive()) {
|
|
// Use the traditional linearizer, as the TpfaLinearizer does not
|
|
// support the diffusion module yet.
|
|
return flowBlackoilMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|
|
|
|
return flowBlackoilTpfaMain(argc_, argv_, outputCout_, outputFiles_);
|
|
}
|