24#ifndef OPM_BLACKOILMODEL_HEADER_INCLUDED
25#define OPM_BLACKOILMODEL_HEADER_INCLUDED
27#include <fmt/format.h>
29#include <opm/common/ErrorMacros.hpp>
30#include <opm/common/Exceptions.hpp>
31#include <opm/common/OpmLog/OpmLog.hpp>
33#include <opm/input/eclipse/EclipseState/EclipseState.hpp>
34#include <opm/input/eclipse/EclipseState/Tables/TableManager.hpp>
36#include <opm/simulators/aquifers/AquiferGridUtils.hpp>
37#include <opm/simulators/aquifers/BlackoilAquiferModel.hpp>
38#include <opm/simulators/flow/BlackoilModelNldd.hpp>
39#include <opm/simulators/flow/BlackoilModelParameters.hpp>
40#include <opm/simulators/flow/countGlobalCells.hpp>
42#include <opm/simulators/flow/NonlinearSolver.hpp>
43#include <opm/simulators/flow/RSTConv.hpp>
44#include <opm/simulators/timestepping/AdaptiveTimeStepping.hpp>
45#include <opm/simulators/timestepping/ConvergenceReport.hpp>
46#include <opm/simulators/timestepping/SimulatorReport.hpp>
47#include <opm/simulators/timestepping/SimulatorTimer.hpp>
49#include <opm/simulators/wells/BlackoilWellModel.hpp>
51#include <opm/simulators/utils/ComponentName.hpp>
52#include <opm/simulators/utils/DeferredLoggingErrorHelpers.hpp>
53#include <opm/simulators/utils/ParallelCommunication.hpp>
54#include <opm/simulators/utils/phaseUsageFromDeck.hpp>
56#include <dune/common/timer.hh>
58#include <fmt/format.h>
76namespace Opm::Properties {
80struct FlowProblem {
using InheritsFrom = std::tuple<FlowBaseProblemBlackoil, BlackOilModel>; };
85template<
class TypeTag>
87{
static constexpr bool value =
true; };
89template<
class TypeTag>
91{
static constexpr bool value =
false; };
93template<
class TypeTag>
99template<
class TypeTag>
101{
static constexpr bool value =
false; };
103template<
class TypeTag>
105{
static constexpr bool value =
false; };
107template<
class TypeTag>
109{
static constexpr bool value =
true; };
111template<
class TypeTag>
113{
static constexpr bool value =
false; };
115template<
class TypeTag>
117{
static constexpr bool value =
false; };
119template<
class TypeTag>
121{
static constexpr bool value =
false; };
123template<
class TypeTag>
125{
static constexpr bool value =
false; };
127template<
class TypeTag>
129{
static constexpr bool value =
false; };
131template<
class TypeTag>
133{
static constexpr bool value =
false; };
135template<
class TypeTag>
137{
static constexpr bool value =
true; };
139template<
class TypeTag>
143template<
class TypeTag>
147template<
class TypeTag>
149{
static constexpr bool value =
false; };
161 template <
class TypeTag>
180 static constexpr int numEq = Indices::numEq;
181 static constexpr int contiSolventEqIdx = Indices::contiSolventEqIdx;
182 static constexpr int contiZfracEqIdx = Indices::contiZfracEqIdx;
183 static constexpr int contiPolymerEqIdx = Indices::contiPolymerEqIdx;
184 static constexpr int contiEnergyEqIdx = Indices::contiEnergyEqIdx;
185 static constexpr int contiPolymerMWEqIdx = Indices::contiPolymerMWEqIdx;
186 static constexpr int contiFoamEqIdx = Indices::contiFoamEqIdx;
187 static constexpr int contiBrineEqIdx = Indices::contiBrineEqIdx;
188 static constexpr int contiMicrobialEqIdx = Indices::contiMicrobialEqIdx;
189 static constexpr int contiOxygenEqIdx = Indices::contiOxygenEqIdx;
190 static constexpr int contiUreaEqIdx = Indices::contiUreaEqIdx;
191 static constexpr int contiBiofilmEqIdx = Indices::contiBiofilmEqIdx;
192 static constexpr int contiCalciteEqIdx = Indices::contiCalciteEqIdx;
193 static constexpr int solventSaturationIdx = Indices::solventSaturationIdx;
194 static constexpr int zFractionIdx = Indices::zFractionIdx;
195 static constexpr int polymerConcentrationIdx = Indices::polymerConcentrationIdx;
196 static constexpr int polymerMoleWeightIdx = Indices::polymerMoleWeightIdx;
197 static constexpr int temperatureIdx = Indices::temperatureIdx;
198 static constexpr int foamConcentrationIdx = Indices::foamConcentrationIdx;
199 static constexpr int saltConcentrationIdx = Indices::saltConcentrationIdx;
200 static constexpr int microbialConcentrationIdx = Indices::microbialConcentrationIdx;
201 static constexpr int oxygenConcentrationIdx = Indices::oxygenConcentrationIdx;
202 static constexpr int ureaConcentrationIdx = Indices::ureaConcentrationIdx;
203 static constexpr int biofilmConcentrationIdx = Indices::biofilmConcentrationIdx;
204 static constexpr int calciteConcentrationIdx = Indices::calciteConcentrationIdx;
206 using VectorBlockType = Dune::FieldVector<Scalar, numEq>;
207 using MatrixBlockType =
typename SparseMatrixAdapter::MatrixBlock;
208 using Mat =
typename SparseMatrixAdapter::IstlMatrix;
209 using BVector = Dune::BlockVector<VectorBlockType>;
229 : simulator_(simulator)
230 , grid_(simulator_.vanguard().grid())
234 ,
rst_conv_(simulator_.problem().eclWriter()->collectOnIORank().localIdxToGlobalIdxMapping(),
237 , current_relaxation_(1.0)
238 , dx_old_(simulator_.model().numGridDof())
242 convergence_reports_.reserve(300);
246 OpmLog::info(
"Using Non-Linear Domain Decomposition solver (nldd).");
248 nlddSolver_ = std::make_unique<BlackoilModelNldd<TypeTag>>(*this);
251 OpmLog::info(
"Using Newton nonlinear solver.");
259 bool isParallel()
const
260 {
return grid_.comm().size() > 1; }
263 const EclipseState& eclState()
const
264 {
return simulator_.vanguard().eclState(); }
276 simulator_.model().updateFailed();
278 simulator_.model().advanceTimeLevel();
287 simulator_.model().newtonMethod().setIterationIndex(0);
289 simulator_.problem().beginTimeStep();
291 unsigned numDof = simulator_.model().numGridDof();
292 wasSwitched_.resize(numDof);
293 std::fill(wasSwitched_.begin(), wasSwitched_.end(),
false);
296 OpmLog::error(
"Equation scaling not supported");
304 report.pre_post_time +=
perfTimer.stop();
308 if (FluidSystem::phaseIsActive(
phaseIdx)) {
309 const unsigned sIdx = FluidSystem::solventComponentIndex(
phaseIdx);
310 return Indices::canonicalToActiveComponentIndex(
sIdx);
315 const auto& schedule = simulator_.vanguard().schedule();
318 {getIdx(FluidSystem::oilPhaseIdx),
319 getIdx(FluidSystem::gasPhaseIdx),
320 getIdx(FluidSystem::waterPhaseIdx),
340 report.total_linearizations = 1;
345 report.assemble_time +=
perfTimer.stop();
348 report.assemble_time +=
perfTimer.stop();
349 failureReport_ += report;
361 ConvergenceReport::Severity severity =
convrep.severityOfWorstFailure();
362 convergence_reports_.back().report.push_back(std::move(
convrep));
365 if (severity == ConvergenceReport::Severity::NotANumber) {
366 failureReport_ += report;
368 }
else if (severity == ConvergenceReport::Severity::TooLarge) {
369 failureReport_ += report;
371 }
else if (severity == ConvergenceReport::Severity::ConvergenceMonitorFailure) {
372 failureReport_ += report;
388 template <
class NonlinearSolverType>
396 residual_norms_history_.clear();
397 total_penaltyCard_.reset();
398 prev_above_tolerance_ = 0;
399 prev_distance_ = std::numeric_limits<double>::infinity();
400 current_relaxation_ = 1.0;
403 convergence_reports_.back().report.reserve(11);
422 template <
class NonlinearSolverType>
435 if (!report.converged) {
438 report.total_newton_iterations = 1;
441 unsigned nc = simulator_.model().numGridDof();
445 linear_solve_setup_time_ = 0.0;
450 wellModel().linearize(simulator().model().linearizer().jacobian(),
451 simulator().model().linearizer().residual());
456 report.linear_solve_setup_time += linear_solve_setup_time_;
457 report.linear_solve_time +=
perfTimer.stop();
461 report.linear_solve_setup_time += linear_solve_setup_time_;
462 report.linear_solve_time +=
perfTimer.stop();
465 failureReport_ += report;
484 current_relaxation_ = std::max(current_relaxation_,
nonlinear_solver.relaxMax());
486 std::string
msg =
" Oscillating behavior detected: Relaxation set to "
487 + std::to_string(current_relaxation_);
514 simulator_.problem().endTimeStep();
516 report.pre_post_time +=
perfTimer.stop();
525 simulator_.model().newtonMethod().setIterationIndex(
iterationIdx);
526 simulator_.problem().beginIteration();
527 simulator_.model().linearizer().linearizeDomain();
528 simulator_.problem().endIteration();
533 Scalar relativeChange()
const
538 const auto&
elemMapper = simulator_.model().elementMapper();
539 const auto& gridView = simulator_.gridView();
549 if (FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx) &&
550 FluidSystem::numActivePhases() > 1 &&
551 priVarsNew.primaryVarsMeaningWater() == PrimaryVariables::WaterMeaning::Sw) {
556 if (FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx) &&
557 FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) &&
558 priVarsNew.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Sg) {
559 assert(Indices::compositionSwitchIdx >= 0 );
564 if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx)) {
581 if (FluidSystem::numActivePhases() > 1) {
582 if (
priVarsOld.primaryVarsMeaningWater() == PrimaryVariables::WaterMeaning::Sw) {
587 if (
priVarsOld.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Sg)
589 assert(Indices::compositionSwitchIdx >= 0 );
594 if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx)) {
619 return simulator_.model().newtonMethod().linearSolver().iterations ();
624 double& linearSolveSetupTime()
626 return linear_solve_setup_time_;
634 auto& jacobian = simulator_.model().linearizer().jacobian().istlMatrix();
635 auto& residual = simulator_.model().linearizer().residual();
636 auto&
linSolver = simulator_.model().newtonMethod().linearSolver();
642 OpmLog::debug(
"\nRunning speed test for comparing available linear solvers.");
681 linear_solve_setup_time_ =
perfTimer.stop();
696 auto& newtonMethod = simulator_.model().newtonMethod();
697 SolutionVector& solution = simulator_.model().solution(0);
699 newtonMethod.update_(solution,
709 simulator_.model().invalidateAndUpdateIntensiveQuantities(0);
719 std::tuple<Scalar,Scalar> convergenceReduction(Parallel::Communication comm,
722 std::vector< Scalar >&
R_sum,
724 std::vector< Scalar >&
B_avg)
731 if( comm.size() > 1 )
784 std::vector<Scalar>&
B_avg,
790 const auto& model = simulator_.model();
791 const auto& problem = simulator_.problem();
793 const auto& residual = simulator_.model().linearizer().residual();
795 ElementContext
elemCtx(simulator_);
796 const auto& gridView = simulator().gridView();
798 OPM_BEGIN_PARALLEL_TRY_CATCH();
799 for (
const auto&
elem :
elements(gridView, Dune::Partitions::interior)) {
801 elemCtx.updatePrimaryIntensiveQuantities(0);
820 OPM_END_PARALLEL_TRY_CATCH(
"BlackoilModel::localConvergenceData() failed: ", grid_.comm());
824 for (
int i = 0; i<
bSize; ++i )
836 std::pair<std::vector<double>, std::vector<int>>
844 constexpr auto numPvGroups = std::vector<double>::size_type{3};
846 auto cnvPvSplit = std::pair<std::vector<double>, std::vector<int>> {
847 std::piecewise_construct,
855 std::inner_product(residual.begin(), residual.end(),
856 B_avg.begin(), Scalar{0},
857 [](
const Scalar
m,
const auto& x)
860 return std::max(m, abs(x));
861 }, std::multiplies<>{});
866 const auto& model = this->simulator().model();
867 const auto& problem = this->simulator().problem();
868 const auto& residual = model.linearizer().residual();
869 const auto& gridView = this->simulator().gridView();
873 ElementContext
elemCtx(this->simulator());
875 OPM_BEGIN_PARALLEL_TRY_CATCH();
876 for (
const auto&
elem :
elements(gridView, Dune::Partitions::interior)) {
897 OPM_END_PARALLEL_TRY_CATCH(
"BlackoilModel::characteriseCnvPvSplit() failed: ",
912 OpmLog::debug(fmt::format(
"Setting BlackoilModel mass "
913 "balance limit (XXXMBE) to {:.2e}",
919 ConvergenceReport getReservoirConvergence(
const double reportTime,
923 std::vector<Scalar>&
B_avg,
927 using Vector = std::vector<Scalar>;
929 ConvergenceReport report{reportTime};
942 this->convergenceReduction(this->grid_.comm(),
984 const auto& cnvPvSplit = report.cnvPvSplit().first;
988 return static_cast<Scalar
>(cnvPvSplit[1] + cnvPvSplit[2]) <
989 this->param_.relaxed_max_pv_fraction_ *
eligible;
999 std::string message =
1000 "Number of newton iterations reached its maximum "
1001 "try to continue with relaxed tolerances:";
1011 OpmLog::debug(message);
1029 using CR = ConvergenceReport;
1031 const Scalar
res[2] = {
1035 const CR::ReservoirFailure::Type
types[2] = {
1036 CR::ReservoirFailure::Type::MassBalance,
1037 CR::ReservoirFailure::Type::Cnv,
1041 if (has_energy_ &&
compIdx == contiEnergyEqIdx) {
1046 for (
int ii : {0, 1}) {
1047 if (std::isnan(
res[
ii])) {
1048 report.setReservoirFailed({
types[
ii], CR::Severity::NotANumber,
compIdx});
1050 OpmLog::debug(
"NaN residual for " + this->compNames_.name(
compIdx) +
" equation.");
1053 else if (
res[
ii] > maxResidualAllowed()) {
1054 report.setReservoirFailed({
types[
ii], CR::Severity::TooLarge,
compIdx});
1056 OpmLog::debug(
"Too large residual for " + this->compNames_.name(
compIdx) +
" equation.");
1059 else if (
res[
ii] < 0.0) {
1060 report.setReservoirFailed({
types[
ii], CR::Severity::Normal,
compIdx});
1062 OpmLog::debug(
"Negative residual for " + this->compNames_.name(
compIdx) +
" equation.");
1066 report.setReservoirFailed({
types[
ii], CR::Severity::Normal,
compIdx});
1076 if (iteration == 0) {
1077 std::string
msg =
"Iter";
1093 std::ostringstream
ss;
1094 const std::streamsize
oprec =
ss.precision(3);
1095 const std::ios::fmtflags
oflags =
ss.setf(std::ios::scientific);
1109 OpmLog::debug(
ss.str());
1115 void checkCardPenalty(ConvergenceReport& report,
int iteration)
1136 report.addNonConvergedPenalty();
1140 report.addDistanceDecayPenalty();
1147 if (report.wellFailures().size() > 0) {
1148 report.addLargeWellResidualsPenalty();
1151 total_penaltyCard_ += report.getPenaltyCard();
1154 report.setReservoirFailed({ConvergenceReport::ReservoirFailure::Type::ConvergenceMonitorFailure,
1155 ConvergenceReport::Severity::ConvergenceMonitorFailure,
1173 std::vector<Scalar>
B_avg(numEq, 0.0);
1179 report +=
wellModel().getWellConvergence(
B_avg, report.converged());
1191 return phaseUsage_.num_phases;
1196 std::vector<std::vector<Scalar> >
1203 std::vector<std::vector<Scalar> >
1209 std::vector<std::vector<Scalar> >
regionValues(0, std::vector<Scalar>(0,0.0));
1214 {
return simulator_; }
1216 Simulator& simulator()
1217 {
return simulator_; }
1221 {
return failureReport_; }
1230 const std::vector<StepReport>& stepReports()
const
1232 return convergence_reports_;
1235 void writePartitions(
const std::filesystem::path&
odir)
const
1242 const auto& elementMapper = this->simulator().model().elementMapper();
1243 const auto&
cartMapper = this->simulator().vanguard().cartesianIndexMapper();
1245 const auto& grid = this->simulator().vanguard().grid();
1246 const auto& comm = grid.comm();
1247 const auto nDigit = 1 +
static_cast<int>(std::floor(std::log10(comm.size())));
1249 std::ofstream
pfile {
odir / fmt::format(
"{1:0>{0}}",
nDigit, comm.rank()) };
1252 pfile << comm.rank() <<
' '
1253 <<
cartMapper.cartesianIndex(elementMapper.index(cell)) <<
' '
1254 << comm.rank() <<
'\n';
1258 const std::vector<std::vector<int>>& getConvCells()
const
1264 Simulator& simulator_;
1266 const PhaseUsage phaseUsage_;
1276 ModelParameters param_;
1277 SimulatorReportSingle failureReport_;
1289 std::vector<std::vector<Scalar>> residual_norms_history_;
1290 Scalar current_relaxation_;
1293 std::vector<StepReport> convergence_reports_;
1304 wellModel()
const {
return well_model_; }
1306 void beginReportStep()
1308 simulator_.problem().beginEpisode();
1311 void endReportStep()
1313 simulator_.problem().endEpisode();
1316 template<
class Flu
idState,
class Res
idual>
1317 void getMaxCoeff(
const unsigned cell_idx,
1319 const FluidState&
fs,
1322 std::vector<Scalar>&
B_avg,
1323 std::vector<Scalar>&
R_sum,
1329 if (!FluidSystem::phaseIsActive(
phaseIdx)) {
1333 const unsigned compIdx = Indices::canonicalToActiveComponentIndex(FluidSystem::solventComponentIndex(
phaseIdx));
1346 if constexpr (has_solvent_) {
1347 B_avg[contiSolventEqIdx] += 1.0 /
intQuants.solventInverseFormationVolumeFactor().value();
1349 R_sum[contiSolventEqIdx] +=
R2;
1353 if constexpr (has_extbo_) {
1354 B_avg[contiZfracEqIdx] += 1.0 /
fs.invB(FluidSystem::gasPhaseIdx).value();
1356 R_sum[ contiZfracEqIdx ] +=
R2;
1360 if constexpr (has_polymer_) {
1361 B_avg[contiPolymerEqIdx] += 1.0 /
fs.invB(FluidSystem::waterPhaseIdx).value();
1363 R_sum[contiPolymerEqIdx] +=
R2;
1367 if constexpr (has_foam_) {
1368 B_avg[ contiFoamEqIdx ] += 1.0 /
fs.invB(FluidSystem::gasPhaseIdx).value();
1374 if constexpr (has_brine_) {
1375 B_avg[ contiBrineEqIdx ] += 1.0 /
fs.invB(FluidSystem::waterPhaseIdx).value();
1382 if constexpr (has_polymermw_) {
1383 static_assert(has_polymer_);
1385 B_avg[contiPolymerMWEqIdx] += 1.0 /
fs.invB(FluidSystem::waterPhaseIdx).value();
1390 R_sum[contiPolymerMWEqIdx] +=
R2;
1395 if constexpr (has_energy_) {
1396 B_avg[contiEnergyEqIdx] += 1.0 / (4.182e1);
1398 R_sum[contiEnergyEqIdx] +=
R2;
1403 if constexpr (has_micp_) {
1404 B_avg[contiMicrobialEqIdx] += 1.0 /
fs.invB(FluidSystem::waterPhaseIdx).value();
1406 R_sum[contiMicrobialEqIdx] +=
R1;
1409 B_avg[contiOxygenEqIdx] += 1.0 /
fs.invB(FluidSystem::waterPhaseIdx).value();
1411 R_sum[contiOxygenEqIdx] +=
R2;
1414 B_avg[contiUreaEqIdx] += 1.0 /
fs.invB(FluidSystem::waterPhaseIdx).value();
1419 B_avg[contiBiofilmEqIdx] += 1.0 /
fs.invB(FluidSystem::waterPhaseIdx).value();
1421 R_sum[contiBiofilmEqIdx] +=
R4;
1424 B_avg[contiCalciteEqIdx] += 1.0 /
fs.invB(FluidSystem::waterPhaseIdx).value();
1426 R_sum[contiCalciteEqIdx] +=
R5;
1445 Scalar dpMaxRel()
const {
return param_.dp_max_rel_; }
1446 Scalar dsMax()
const {
return param_.ds_max_; }
1447 Scalar drMaxRel()
const {
return param_.dr_max_rel_; }
1448 Scalar maxResidualAllowed()
const {
return param_.max_residual_allowed_; }
1449 double linear_solve_setup_time_;
1450 ConvergenceReport::PenaltyCard total_penaltyCard_;
1451 double prev_distance_ = std::numeric_limits<double>::infinity();
1452 int prev_above_tolerance_ = 0;
1454 std::vector<bool> wasSwitched_;
This problem simulates an input file given in the data format used by the commercial ECLiPSE simulato...
Class for handling the blackoil aquifer model.
Definition BlackoilAquiferModel.hpp:50
A model implementation for three-phase black oil.
Definition BlackoilModel.hpp:163
BlackoilModel(Simulator &simulator, const ModelParameters ¶m, BlackoilWellModel< TypeTag > &well_model, const bool terminal_output)
Construct the model.
Definition BlackoilModel.hpp:225
std::vector< std::vector< Scalar > > computeFluidInPlace(const T &, const std::vector< int > &fipnum) const
Wrapper required due to not following generic API.
Definition BlackoilModel.hpp:1197
int linearIterationsLastSolve() const
Number of linear iterations used in last call to solveJacobianSystem().
Definition BlackoilModel.hpp:617
SimulatorReportSingle nonlinearIteration(const int iteration, const SimulatorTimerInterface &timer, NonlinearSolverType &nonlinear_solver)
Called once per nonlinear iteration.
Definition BlackoilModel.hpp:389
SimulatorReportSingle assembleReservoir(const SimulatorTimerInterface &, const int iterationIdx)
Assemble the residual and Jacobian of the nonlinear system.
Definition BlackoilModel.hpp:521
ConvergenceReport getConvergence(const SimulatorTimerInterface &timer, const int iteration, const int maxIter, std::vector< Scalar > &residual_norms)
Compute convergence based on total mass balance (tol_mb) and maximum residual mass balance (tol_cnv).
Definition BlackoilModel.hpp:1166
bool terminalOutputEnabled() const
Return true if output to cout is wanted.
Definition BlackoilModel.hpp:714
int numPhases() const
The number of active fluid phases in the model.
Definition BlackoilModel.hpp:1189
SimulatorReportSingle afterStep(const SimulatorTimerInterface &)
Called once after each time step.
Definition BlackoilModel.hpp:509
const ComponentName & compNames() const
Returns const reference to component names.
Definition BlackoilModel.hpp:1439
void updateSolution(const BVector &dx)
Apply an update to the primary variables.
Definition BlackoilModel.hpp:693
long int global_nc_
The number of cells of the global grid.
Definition BlackoilModel.hpp:1287
const ModelParameters & param() const
Returns const reference to model parameters.
Definition BlackoilModel.hpp:1433
std::unique_ptr< BlackoilModelNldd< TypeTag > > nlddSolver_
Non-linear DD solver.
Definition BlackoilModel.hpp:1296
std::pair< std::vector< double >, std::vector< int > > characteriseCnvPvSplit(const std::vector< Scalar > &B_avg, const double dt)
Compute pore-volume/cell count split among "converged", "relaxed converged", "unconverged" cells base...
Definition BlackoilModel.hpp:837
const SimulatorReportSingle & failureReport() const
return the statistics if the nonlinearIteration() method failed
Definition BlackoilModel.hpp:1220
BlackoilWellModel< TypeTag > & wellModel()
return the StandardWells object
Definition BlackoilModel.hpp:1301
std::vector< std::vector< Scalar > > computeFluidInPlace(const std::vector< int > &) const
Should not be called.
Definition BlackoilModel.hpp:1204
SimulatorReportSingle localAccumulatedReports() const
return the statistics if the nonlinearIteration() method failed
Definition BlackoilModel.hpp:1224
std::pair< Scalar, Scalar > localConvergenceData(std::vector< Scalar > &R_sum, std::vector< Scalar > &maxCoeff, std::vector< Scalar > &B_avg, std::vector< int > &maxCoeffCell)
Get reservoir quantities on this process needed for convergence calculations.
Definition BlackoilModel.hpp:782
void solveJacobianSystem(BVector &x)
Solve the Jacobian system Jx = r where J is the Jacobian and r is the residual.
Definition BlackoilModel.hpp:632
SimulatorReportSingle prepareStep(const SimulatorTimerInterface &timer)
Called once before each time step.
Definition BlackoilModel.hpp:269
RSTConv rst_conv_
Helper class for RPTRST CONV.
Definition BlackoilModel.hpp:1282
bool terminal_output_
Whether we print something to std::cout.
Definition BlackoilModel.hpp:1285
Class for handling the blackoil well model.
Definition BlackoilWellModel.hpp:100
Definition ComponentName.hpp:34
Represents the convergence status of the whole simulator, to make it possible to query and store the ...
Definition ConvergenceReport.hpp:38
This problem simulates an input file given in the data format used by the commercial ECLiPSE simulato...
Definition FlowProblem.hpp:92
Class computing RPTRST CONV output.
Definition RSTConv.hpp:34
const std::vector< std::vector< int > > & getData() const
Obtain a const-ref to the accumulated data.
Definition RSTConv.hpp:58
void update(const ResidualVector &resid)
Adds the CONV output for given residual vector.
Definition RSTConv.cpp:58
void init(const std::size_t numCells, const RSTConfig &rst_config, const std::array< int, 6 > &compIdx)
Init state at beginning of step.
Definition RSTConv.cpp:35
Interface class for SimulatorTimer objects, to be improved.
Definition SimulatorTimerInterface.hpp:34
virtual int reportStepNum() const
Current report step number. This might differ from currentStepNum in case of sub stepping.
Definition SimulatorTimerInterface.hpp:50
virtual bool lastStepFailed() const =0
Return true if last time step failed.
virtual double currentStepLength() const =0
Current step length.
virtual double simulationTimeElapsed() const =0
Time elapsed since the start of the simulation until the beginning of the current time step [s].
virtual int currentStepNum() const =0
Current step number.
Manages the initializing and running of time dependent problems.
Definition simulator.hh:92
This file contains a set of helper functions used by VFPProd / VFPInj.
Definition blackoilboundaryratevector.hh:37
constexpr auto getPropValue()
get the value data member of a property
Definition propertysystem.hh:242
typename Properties::Detail::GetPropImpl< TypeTag, Property >::type::type GetPropType
get the type alias defined in the property (equivalent to old macro GET_PROP_TYPE(....
Definition propertysystem.hh:235
PhaseUsage phaseUsageFromDeck(const EclipseState &eclipseState)
Looks at presence of WATER, OIL and GAS keywords in state object to determine active phases.
Definition phaseUsageFromDeck.cpp:137
Solver parameters for the BlackoilModel.
Definition BlackoilModelParameters.hpp:162
Scalar tolerance_mb_relaxed_
Relaxed mass balance tolerance (can be used when iter >= min_strict_mb_iter_).
Definition BlackoilModelParameters.hpp:182
Scalar tolerance_energy_balance_
Relative energy balance tolerance (total energy balance error).
Definition BlackoilModelParameters.hpp:184
bool update_equations_scaling_
Update scaling factors for mass balance equations.
Definition BlackoilModelParameters.hpp:249
Scalar tolerance_energy_balance_relaxed_
Relaxed energy balance tolerance (can be used when iter >= min_strict_mb_iter_).
Definition BlackoilModelParameters.hpp:186
Scalar convergence_monitoring_decay_factor_
Decay factor used in convergence monitoring.
Definition BlackoilModelParameters.hpp:316
int min_strict_mb_iter_
Minimum number of Newton iterations before we can use relaxed MB convergence criterion.
Definition BlackoilModelParameters.hpp:243
int min_strict_cnv_iter_
Minimum number of Newton iterations before we can use relaxed CNV convergence criterion.
Definition BlackoilModelParameters.hpp:240
bool use_update_stabilization_
Try to detect oscillation or stagnation.
Definition BlackoilModelParameters.hpp:252
Scalar tolerance_cnv_energy_
Local energy convergence tolerance (max of local energy errors).
Definition BlackoilModelParameters.hpp:192
Scalar tolerance_cnv_energy_relaxed_
Relaxed local energy convergence tolerance (can be used when iter >= min_strict_cnv_iter_ && cnvViola...
Definition BlackoilModelParameters.hpp:194
Scalar tolerance_mb_
Relative mass balance tolerance (total mass balance error).
Definition BlackoilModelParameters.hpp:180
bool convergence_monitoring_
Whether to enable convergence monitoring.
Definition BlackoilModelParameters.hpp:312
Scalar tolerance_cnv_
Local convergence tolerance (max of local saturation errors).
Definition BlackoilModelParameters.hpp:188
Scalar tolerance_cnv_relaxed_
Relaxed local convergence tolerance (can be used when iter >= min_strict_cnv_iter_ && cnvViolatedPV <...
Definition BlackoilModelParameters.hpp:190
int convergence_monitoring_cutoff_
Cut-off limit for convergence monitoring.
Definition BlackoilModelParameters.hpp:314
std::string nonlinear_solver_
Nonlinear solver type: newton or nldd.
Definition BlackoilModelParameters.hpp:294
Definition AquiferGridUtils.hpp:35
Definition FlowBaseProblemProperties.hpp:62
Enable surface volume scaling.
Definition blackoilproperties.hh:54
Enable the ECL-blackoil extension for salt.
Definition blackoilproperties.hh:60
Enable convective mixing?
Definition multiphasebaseproperties.hh:85
Definition FlowBaseProblemProperties.hpp:73
Enable dispersive fluxes?
Definition multiphasebaseproperties.hh:82
Specify whether energy should be considered as a conservation quantity or not.
Definition multiphasebaseproperties.hh:76
Enable the ECL-blackoil extension for foam.
Definition blackoilproperties.hh:57
Enable the ECL-blackoil extension for MICP.
Definition blackoilproperties.hh:72
Enable the ECL-blackoil extension for polymer.
Definition blackoilproperties.hh:48
Enable the ECL-blackoil extension for salt precipitation.
Definition blackoilproperties.hh:63
Enable the ECL-blackoil extension for solvents. ("Second gas")
Definition blackoilproperties.hh:42
Allow the spatial and temporal domains to exhibit non-constant temperature in the black-oil model.
Definition blackoilproperties.hh:78
Definition fvbaseproperties.hh:53
Definition ISTLSolver.hpp:63
Definition BlackoilModel.hpp:80
Specify whether to use volumetric residuals or not.
Definition fvbaseproperties.hh:237
Definition FlowBaseProblemProperties.hpp:82
A struct for returning timing data from a simulator to its caller.
Definition SimulatorReport.hpp:34