OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2024-12-29 10:40:59 -06:00
Code Issues Packages Projects Releases Wiki Activity
586f2cc962
opm-simulators/opm/autodiff/BlackoilModelBase.hpp

565 lines
23 KiB
C++
Raw Normal View History

Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
/*
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
Copyright 2013, 2015 SINTEF ICT, Applied Mathematics.
Copyright 2014, 2015 Statoil ASA.
Update copyright notices
2015-05-20 02:26:25 -05:00
Copyright 2014, 2015 Dr. Markus Blatt - HPC-Simulation-Software & Services
Copyright 2015 NTNU
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
Renamed ImplicitBOStep -> FullyImplicitBlackoilSolver.
2013-05-24 03:49:59 -05:00
This file is part of the Open Porous Media project (OPM).
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
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/>.
*/
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
#ifndef OPM_BLACKOILMODELBASE_HEADER_INCLUDED
#define OPM_BLACKOILMODELBASE_HEADER_INCLUDED
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
FullyImplicitBlackoilSolver: fix dangerous usage of assert.
2015-01-20 05:55:46 -06:00
#include <cassert>
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
#include <opm/autodiff/AutoDiffBlock.hpp>
#include <opm/autodiff/AutoDiffHelpers.hpp>
#include <opm/autodiff/BlackoilPropsAdInterface.hpp>
Renamed class {FullyImplicit->Linearised}BlackoilResidual.
2014-04-08 08:56:08 -05:00
#include <opm/autodiff/LinearisedBlackoilResidual.hpp>
Renamed more classes. FullyImplicitSystemSolver{Interface, Simple} -> NewtonIterationBlackoil{Interface, Simple}. Change suggested by B. Skaflestad.
2014-04-08 09:11:08 -05:00
#include <opm/autodiff/NewtonIterationBlackoilInterface.hpp>
Moved enums to a separate file.
2015-05-25 16:06:03 -05:00
#include <opm/autodiff/BlackoilModelEnums.hpp>
Minor refactoring
2015-08-19 04:46:29 -05:00
#include <opm/autodiff/VFPProperties.hpp>
removing the StandardWells definition inside BlackoilModelBase and some other tiny cleaning up.
2016-04-06 08:31:58 -05:00
#include <opm/autodiff/StandardWells.hpp>
Add support for NNC in the simulator 1) NNC are added the grad, div and average operators 2) NNC are added the upwindSelector 3) NNC transmissibilities are added to the face transmissibilities
2015-06-10 02:25:45 -05:00
#include <opm/parser/eclipse/EclipseState/Grid/NNC.hpp>
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
Factors out the reduction part into a separate function. Theses reductions are global and will require a different behaviour in the parallel case.
2015-01-20 07:21:45 -06:00
#include <array>
Class FullyImplicitBlackoilSolver is no longer a template.
2013-05-24 04:00:55 -05:00
struct Wells;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
namespace Opm {
Finishing the modification for solver class.
2014-05-16 11:02:55 -05:00
namespace parameter { class ParameterGroup; }
Class FullyImplicitBlackoilSolver is no longer a template.
2013-05-24 04:00:55 -05:00
class DerivedGeology;
Added rock compressibility to fully implicit solver.
2013-06-03 07:14:48 -05:00
class RockCompressibility;
Renamed more classes. FullyImplicitSystemSolver{Interface, Simple} -> NewtonIterationBlackoil{Interface, Simple}. Change suggested by B. Skaflestad.
2014-04-08 09:11:08 -05:00
class NewtonIterationBlackoilInterface;
Partial integration of VFPProperties into BlackoilModel
2015-07-03 05:16:50 -05:00
class VFPProperties;
Replaced SimulatorState -> SimulationDataContainer
2016-02-28 04:27:00 -06:00
class SimulationDataContainer;
Moved SolutionState to ModelTraits. Also extracting existing private class and renamed it DefaultBlackoilSolutionState.
2015-05-24 17:46:28 -05:00
/// Struct for containing iteration variables.
struct DefaultBlackoilSolutionState
{
typedef AutoDiffBlock<double> ADB;
explicit DefaultBlackoilSolutionState(const int np)
: pressure ( ADB::null())
, temperature( ADB::null())
, saturation(np, ADB::null())
, rs ( ADB::null())
, rv ( ADB::null())
, qs ( ADB::null())
, bhp ( ADB::null())
, canonical_phase_pressures(3, ADB::null())
{
}
ADB pressure;
ADB temperature;
std::vector<ADB> saturation;
ADB rs;
ADB rv;
ADB qs;
ADB bhp;
// Below are quantities stored in the state for optimization purposes.
std::vector<ADB> canonical_phase_pressures; // Always has 3 elements, even if only 2 phases active.
};
Class FullyImplicitBlackoilSolver is no longer a template.
2013-05-24 04:00:55 -05:00
Moved implementation to .cpp file.
2013-05-24 04:14:05 -05:00
Make nonlinearIteration() the only interface to the model. This means that details such as calling assemble(), solveJacobianSystem(), updateState() etc. are now left to the model class. This will make it easier to create new model classes with different behaviour (such as sequential models).
2015-10-02 06:51:40 -05:00
/// Class used for reporting the outcome of a nonlinearIteration() call.
struct IterationReport
{
bool failed;
bool converged;
int linear_iterations;
};
Use the Curiously Recurring Template Pattern for BlackoilModel.
2015-05-24 10:36:29 -05:00
/// Traits to encapsulate the types used by classes using or
/// extending this model. Forward declared here, must be
/// specialised for each concrete model class.
template <class ConcreteModel>
struct ModelTraits;
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
/// A model implementation for three-phase black oil.
Documented class FullyImplicitBlackoilSolver.
2013-09-20 07:55:43 -05:00
///
/// The simulator is capable of handling three-phase problems
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
/// where gas can be dissolved in oil and vice versa. It
Documented class FullyImplicitBlackoilSolver.
2013-09-20 07:55:43 -05:00
/// uses an industry-standard TPFA discretization with per-phase
/// upwind weighting of mobilities.
///
/// It uses automatic differentiation via the class AutoDiffBlock
/// to simplify assembly of the jacobian matrix.
Use the Curiously Recurring Template Pattern for BlackoilModel.
2015-05-24 10:36:29 -05:00
/// \tparam Grid UnstructuredGrid or CpGrid.
/// \tparam Implementation Provides concrete state types.
template<class Grid, class Implementation>
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
class BlackoilModelBase
Class FullyImplicitBlackoilSolver is no longer a template.
2013-05-24 04:00:55 -05:00
{
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
public:
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
// --------- Types and enums ---------
typedef AutoDiffBlock<double> ADB;
typedef ADB::V V;
typedef ADB::M M;
Use the Curiously Recurring Template Pattern for BlackoilModel.
2015-05-24 10:36:29 -05:00
typedef typename ModelTraits<Implementation>::ReservoirState ReservoirState;
typedef typename ModelTraits<Implementation>::WellState WellState;
typedef typename ModelTraits<Implementation>::ModelParameters ModelParameters;
Moved SolutionState to ModelTraits. Also extracting existing private class and renamed it DefaultBlackoilSolutionState.
2015-05-24 17:46:28 -05:00
typedef typename ModelTraits<Implementation>::SolutionState SolutionState;
added solver parameters to void reading in every step.
2014-10-01 05:48:41 -05:00
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
// --------- Public methods ---------
/// Construct the model. It will retain references to the
Documented class FullyImplicitBlackoilSolver.
2013-09-20 07:55:43 -05:00
/// arguments of this functions, and they are expected to
/// remain in scope for the lifetime of the solver.
added solver parameters to void reading in every step.
2014-10-01 05:48:41 -05:00
/// \param[in] param parameters
Documented class FullyImplicitBlackoilSolver.
2013-09-20 07:55:43 -05:00
/// \param[in] grid grid data structure
/// \param[in] fluid fluid properties
/// \param[in] geo rock properties
/// \param[in] rock_comp_props if non-null, rock compressibility properties
/// \param[in] wells well structure
Partial integration of VFPProperties into BlackoilModel
2015-07-03 05:16:50 -05:00
/// \param[in] vfp_properties Vertical flow performance tables
Documented class FullyImplicitBlackoilSolver.
2013-09-20 07:55:43 -05:00
/// \param[in] linsolver linear solver
Add support for NNC in the simulator 1) NNC are added the grad, div and average operators 2) NNC are added the upwindSelector 3) NNC transmissibilities are added to the face transmissibilities
2015-06-10 02:25:45 -05:00
/// \param[in] eclState eclipse state
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
/// \param[in] has_disgas turn on dissolved gas
/// \param[in] has_vapoil turn on vaporized oil feature
/// \param[in] terminal_output request output to cout/cerr
BlackoilModelBase(const ModelParameters& param,
const Grid& grid ,
const BlackoilPropsAdInterface& fluid,
const DerivedGeology& geo ,
const RockCompressibility* rock_comp_props,
const Wells* wells,
const NewtonIterationBlackoilInterface& linsolver,
Add support for NNC in the simulator 1) NNC are added the grad, div and average operators 2) NNC are added the upwindSelector 3) NNC transmissibilities are added to the face transmissibilities
2015-06-10 02:25:45 -05:00
Opm::EclipseStateConstPtr eclState,
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
const bool has_disgas,
const bool has_vapoil,
const bool terminal_output);
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
Add setThresholdPressures() method.
2014-08-27 04:30:42 -05:00
/// \brief Set threshold pressures that prevent or reduce flow.
/// This prevents flow across faces if the potential
/// difference is less than the threshold. If the potential
/// difference is greater, the threshold value is subtracted
/// before calculating flow. This is treated symmetrically, so
/// flow is prevented or reduced in both directions equally.
Change setThresholdPressures() interface. Now it takes a std::vector instead of an Eigen::Array, more importantly it expects one element per face, not interior face. The mapping now takes place in setThresholdPressures().
2014-08-27 07:21:34 -05:00
/// \param[in] threshold_pressures_by_face array of size equal to the number of faces
Add setThresholdPressures() method.
2014-08-27 04:30:42 -05:00
/// of the grid passed in the constructor.
Change setThresholdPressures() interface. Now it takes a std::vector instead of an Eigen::Array, more importantly it expects one element per face, not interior face. The mapping now takes place in setThresholdPressures().
2014-08-27 07:21:34 -05:00
void setThresholdPressures(const std::vector<double>& threshold_pressures_by_face);
Add setThresholdPressures() method.
2014-08-27 04:30:42 -05:00
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
/// Called once before each time step.
/// \param[in] dt time step size
/// \param[in, out] reservoir_state reservoir state variables
/// \param[in, out] well_state well state variables
void prepareStep(const double dt,
ReservoirState& reservoir_state,
WellState& well_state);
Make nonlinearIteration() the only interface to the model. This means that details such as calling assemble(), solveJacobianSystem(), updateState() etc. are now left to the model class. This will make it easier to create new model classes with different behaviour (such as sequential models).
2015-10-02 06:51:40 -05:00
/// Called once per nonlinear iteration.
/// This model will perform a Newton-Raphson update, changing reservoir_state
/// and well_state. It will also use the nonlinear_solver to do relaxation of
/// updates if necessary.
/// \param[in] iteration should be 0 for the first call of a new timestep
/// \param[in] dt time step size
/// \param[in] nonlinear_solver nonlinear solver used (for oscillation/relaxation control)
/// \param[in, out] reservoir_state reservoir state variables
/// \param[in, out] well_state well state variables
template <class NonlinearSolverType>
IterationReport nonlinearIteration(const int iteration,
const double dt,
NonlinearSolverType& nonlinear_solver,
ReservoirState& reservoir_state,
WellState& well_state);
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
/// Called once after each time step.
/// In this class, this function does nothing.
/// \param[in] dt time step size
/// \param[in, out] reservoir_state reservoir state variables
/// \param[in, out] well_state well state variables
void afterStep(const double dt,
ReservoirState& reservoir_state,
WellState& well_state);
/// Assemble the residual and Jacobian of the nonlinear system.
/// \param[in] reservoir_state reservoir state variables
/// \param[in, out] well_state well state variables
/// \param[in] initial_assembly pass true if this is the first call to assemble() in this timestep
Using ReservoirState and WellState consistently. This means that for extended models the functions in BlackoilModelBase will be compiled with the types used by those models and not BlackoilState and WellStateFullyImplicitBlackoil (which are specified by BlackoilModel).
2015-05-25 16:49:09 -05:00
void assemble(const ReservoirState& reservoir_state,
WellState& well_state,
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
const bool initial_assembly);
/// \brief Compute the residual norms of the mass balance for each phase,
/// the well flux, and the well equation.
/// \return a vector that contains for each phase the norm of the mass balance
/// and afterwards the norm of the residual of the well flux and the well equation.
std::vector<double> computeResidualNorms() const;
BlackOilModelBase: revision of adaptive time stepping such that time error is computed by model.
2015-10-31 06:32:54 -05:00
/// \brief compute the relative change between to simulation states
// \return || u^n+1 - u^n || / || u^n+1 ||
Replaced SimulatorState -> SimulationDataContainer
2016-02-28 04:27:00 -06:00
double relativeChange( const SimulationDataContainer& previous, const SimulationDataContainer& current ) const;
BlackOilModelBase: revision of adaptive time stepping such that time error is computed by model.
2015-10-31 06:32:54 -05:00
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
/// The size (number of unknowns) of the nonlinear system of equations.
int sizeNonLinear() const;
/// Number of linear iterations used in last call to solveJacobianSystem().
int linearIterationsLastSolve() const;
/// Solve the Jacobian system Jx = r where J is the Jacobian and
/// r is the residual.
V solveJacobianSystem() const;
/// Apply an update to the primary variables, chopped if appropriate.
/// \param[in] dx updates to apply to primary variables
/// \param[in, out] reservoir_state reservoir state variables
/// \param[in, out] well_state well state variables
void updateState(const V& dx,
Using ReservoirState and WellState consistently. This means that for extended models the functions in BlackoilModelBase will be compiled with the types used by those models and not BlackoilState and WellStateFullyImplicitBlackoil (which are specified by BlackoilModel).
2015-05-25 16:49:09 -05:00
ReservoirState& reservoir_state,
WellState& well_state);
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
/// Return true if output to cout is wanted.
bool terminalOutputEnabled() const;
/// Compute convergence based on total mass balance (tol_mb) and maximum
/// residual mass balance (tol_cnv).
/// \param[in] dt timestep length
/// \param[in] iteration current iteration number
bool getConvergence(const double dt, const int iteration);
Separate phase and material concepts.
2015-09-30 07:44:50 -05:00
/// The number of active fluid phases in the model.
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
int numPhases() const;
added number of linear and newton iterations to output.
2015-03-04 08:02:00 -06:00
Separate phase and material concepts.
2015-09-30 07:44:50 -05:00
/// The number of active materials in the model.
/// This should be equal to the number of material balance
/// equations.
int numMaterials() const;
/// The name of an active material in the model.
/// It is required that material_index < numMaterials().
const std::string& materialName(int material_index) const;
Added phaseName() method.
2015-09-30 05:48:16 -05:00
update scaling factors for mass balance equations.
2015-08-27 09:58:44 -05:00
/// Update the scaling factors for mass balance equations
void updateEquationsScaling();
Use the Curiously Recurring Template Pattern for BlackoilModel.
2015-05-24 10:36:29 -05:00
protected:
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
// --------- Types and enums ---------
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
typedef Eigen::Array<double,
Eigen::Dynamic,
Eigen::Dynamic,
Eigen::RowMajor> DataBlock;
struct ReservoirResidualQuant {
Moved implementation to .cpp file.
2013-05-24 04:14:05 -05:00
ReservoirResidualQuant();
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
std::vector<ADB> accum; // Accumulations
ADB mflux; // Mass flux (surface conditions)
ADB b; // Reciprocal FVF
Renamed rq_.head to rq_.dh, since it is used for head differences. Also moved multiplication with transmissibilities so that dh does not include them (so it really is the head difference).
2015-05-26 09:33:00 -05:00
ADB dh; // Pressure drop across int. interfaces
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
ADB mob; // Phase mobility (per cell)
};
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
// --------- Data members ---------
Add an example program of FIBOS that uses CpGrid.
2014-02-20 06:17:18 -06:00
const Grid& grid_;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
const BlackoilPropsAdInterface& fluid_;
Class FullyImplicitBlackoilSolver is no longer a template.
2013-05-24 04:00:55 -05:00
const DerivedGeology& geo_;
Added rock compressibility to fully implicit solver.
2013-06-03 07:14:48 -05:00
const RockCompressibility* rock_comp_props_;
making StandardWells non-templated we will focus on template functions instead.
2016-04-08 03:20:11 -05:00
StandardWells std_wells_;
Minor refactoring
2015-08-19 04:46:29 -05:00
VFPProperties vfp_properties_;
Renamed more classes. FullyImplicitSystemSolver{Interface, Simple} -> NewtonIterationBlackoil{Interface, Simple}. Change suggested by B. Skaflestad.
2014-04-08 09:11:08 -05:00
const NewtonIterationBlackoilInterface& linsolver_;
Clarify some variables' purposes.
2013-05-24 03:39:10 -05:00
// For each canonical phase -> true if active
const std::vector<bool> active_;
Fix contextual misprint: face -> phase
2014-06-03 03:59:50 -05:00
// Size = # active phases. Maps active -> canonical phase indices.
Clarify some variables' purposes.
2013-05-24 03:39:10 -05:00
const std::vector<int> canph_;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
const std::vector<int> cells_; // All grid cells
HelperOps ops_;
Read DISGAS and VAPOIL from deck and pass them to the simulator
2014-05-27 06:36:22 -05:00
const bool has_disgas_;
const bool has_vapoil_;
added solver parameters to void reading in every step.
2014-10-01 05:48:41 -05:00
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
ModelParameters param_;
Add applyThresholdPressures() method and usage. Note that this commit does not introduce any way to set use_threshold_pressure to true, so the new code is not run.
2014-08-27 03:27:49 -05:00
bool use_threshold_pressure_;
Handle combination of threshold_pressure and nnc The nncs threshold pressures are calculated and appended to the face threshold pressures
2015-12-08 03:56:42 -06:00
V threshold_pressures_by_connection_;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
std::vector<ReservoirResidualQuant> rq_;
Implementation of live gas The simulator now handles live gas as well as live oil. The primary variables are Po,Sw and Rs,Rv or Sg depending on fluid condition State 1 Gas only (Undersaturated gas): Po, Sw and Rv State 2 Gas and oil: Po, Sw and Sg State 3 Oil only (Undersaturated oil): Po, Sw and Rs This commit includes: 1. New interfaces for the vapor oil/gas ratios (Rv) 2. Modifications in the equations to handle rvs 3. New definition of ADI variable to handle changing primary variables 4. Modifications in the solution updates to handle changing primary variable 5. Some changes in the appleyard process to sync with Mrsts livegas implementation. NOTE: The implementation is tested on the liveoil cases SPE1 and a simplified SPE9 and produces the same results as the old code. The simulator is not yet able to converge on SPE3 with livegas present. For SPE3 to converge a more robust well implementation is needed. The current simulator reproduce the results of Mrst when a similar well model is used in Mrst as is currently implemented OPM.
2014-01-10 07:19:37 -06:00
std::vector<PhasePresence> phaseCondition_;
Add members isSg_, isRs_ and isRv_. This replaces local variables that were used in more than one place, and initialised locally in the exact same way depending only on primalVariable_. Now they are updated once when primalVariable_ has changed, simplifying the code for variableState() and updateState().
2015-05-26 07:38:25 -05:00
V isRs_;
V isRv_;
V isSg_;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
Renamed class {FullyImplicit->Linearised}BlackoilResidual.
2014-04-08 08:56:08 -05:00
LinearisedBlackoilResidual residual_;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
Fxied typo wether -> whether.
2015-02-20 09:03:08 -06:00
/// \brief Whether we print something to std::cout
Rename variable verbosity_ to terminal_output_.
2015-02-20 09:02:06 -06:00
bool terminal_output_;
Correctly compute the scaling factor for the equations in parallel. When running parallel one cannot use Eigen::Array::mean() for this as the it is just a local part of the complete array. With this commit we correctly compute the number of global cells in the grid and use this together with a parallel reduction to compute a global mean value.
2015-10-26 18:29:22 -05:00
/// \brief The number of cells of the global grid.
int global_nc_;
Print status output only on rank 0 for parallel runs.
2015-02-20 04:35:47 -06:00
Introduce primaryVariable_ and use it to switch primary variables
2014-05-27 08:09:58 -05:00
std::vector<int> primalVariable_;
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
V pvdt_;
Separate phase and material concepts.
2015-09-30 07:44:50 -05:00
std::vector<std::string> material_name_;
Make nonlinearIteration() the only interface to the model. This means that details such as calling assemble(), solveJacobianSystem(), updateState() etc. are now left to the model class. This will make it easier to create new model classes with different behaviour (such as sequential models).
2015-10-02 06:51:40 -05:00
std::vector<std::vector<double>> residual_norms_history_;
double current_relaxation_;
V dx_old_;
Introduce primaryVariable_ and use it to switch primary variables
2014-05-27 08:09:58 -05:00
Use the Curiously Recurring Template Pattern for BlackoilModel.
2015-05-24 10:36:29 -05:00
// --------- Protected methods ---------
BlockOilSimulator: allow to run without wells (mainly for testing and debugging).
2015-01-19 07:14:18 -06:00
Use asImpl() pattern for static polymorphism. Not yet applied to all method calls, but only ones needed for polymer solver after initial refactoring.
2015-05-25 18:48:45 -05:00
/// Access the most-derived class used for
/// static polymorphism (CRTP).
Implementation& asImpl()
{
return static_cast<Implementation&>(*this);
}
/// Access the most-derived class used for
/// static polymorphism (CRTP).
const Implementation& asImpl() const
{
return static_cast<const Implementation&>(*this);
}
updating for the comments. implement wells(), localWellsActive() and wellsActive() for the BlackoilModelBase and its derived classed.
2016-04-06 05:52:54 -05:00
/// return the StandardWells object
making StandardWells non-templated we will focus on template functions instead.
2016-04-08 03:20:11 -05:00
StandardWells& stdWells() { return std_wells_; }
const StandardWells& stdWells() const { return std_wells_; }
BlockOilSimulator: allow to run without wells (mainly for testing and debugging).
2015-01-19 07:14:18 -06:00
updating for the comments. implement wells(), localWellsActive() and wellsActive() for the BlackoilModelBase and its derived classed.
2016-04-06 05:52:54 -05:00
/// return the Well struct in the StandardWells
const Wells& wells() const { return std_wells_.wells(); }
/// return true if wells are available in the reservoir
bool wellsActive() const { return std_wells_.wellsActive(); }
/// return true if wells are available on this process
bool localWellsActive() const { return std_wells_.localWellsActive(); }
Refactor updatState() to use numWellVars(). This allows us to use the base version of updateState().
2015-11-20 04:45:35 -06:00
int numWellVars() const;
Move initial term computation to assemble().
2015-03-06 06:05:37 -06:00
void
makeConstantState(SolutionState& state) const;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
SolutionState
Using ReservoirState and WellState consistently. This means that for extended models the functions in BlackoilModelBase will be compiled with the types used by those models and not BlackoilState and WellStateFullyImplicitBlackoil (which are specified by BlackoilModel).
2015-05-25 16:49:09 -05:00
variableState(const ReservoirState& x,
const WellState& xw) const;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
Refactor variableState(). Has been split into multiple methods to give more flexibility to extended models.
2015-05-26 04:16:21 -05:00
std::vector<V>
variableStateInitials(const ReservoirState& x,
const WellState& xw) const;
Seperate wells stuff from the reservoir stuff The seperation is done in order to better accommodate solving the well equation seperatly.
2015-06-11 01:03:28 -05:00
void
variableReservoirStateInitials(const ReservoirState& x,
std::vector<V>& vars0) const;
void
variableWellStateInitials(const WellState& xw,
std::vector<V>& vars0) const;
Refactor variableState(). Has been split into multiple methods to give more flexibility to extended models.
2015-05-26 04:16:21 -05:00
std::vector<int>
variableStateIndices() const;
Seperate wells stuff from the reservoir stuff The seperation is done in order to better accommodate solving the well equation seperatly.
2015-06-11 01:03:28 -05:00
std::vector<int>
removing s from the name of function variableWellStateIndices()
2015-06-16 03:40:25 -05:00
variableWellStateIndices() const;
Seperate wells stuff from the reservoir stuff The seperation is done in order to better accommodate solving the well equation seperatly.
2015-06-11 01:03:28 -05:00
Refactor variableState(). Has been split into multiple methods to give more flexibility to extended models.
2015-05-26 04:16:21 -05:00
SolutionState
variableStateExtractVars(const ReservoirState& x,
const std::vector<int>& indices,
std::vector<ADB>& vars) const;
Seperate wells stuff from the reservoir stuff The seperation is done in order to better accommodate solving the well equation seperatly.
2015-06-11 01:03:28 -05:00
void
variableStateExtractWellsVars(const std::vector<int>& indices,
std::vector<ADB>& vars,
SolutionState& state) const;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
void
computeAccum(const SolutionState& state,
Moved implementation to .cpp file.
2013-05-24 04:14:05 -05:00
const int aix );
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
Work in progress: use WellDensitySegmented class. This is work in progress since it is non-working: phaseRates() is not used correctly, and changes must be made to WellState or equivalent.
2014-03-18 02:48:34 -05:00
void computeWellConnectionPressures(const SolutionState& state,
Using ReservoirState and WellState consistently. This means that for extended models the functions in BlackoilModelBase will be compiled with the types used by those models and not BlackoilState and WellStateFullyImplicitBlackoil (which are specified by BlackoilModel).
2015-05-25 16:49:09 -05:00
const WellState& xw);
Work in progress: use WellDensitySegmented class. This is work in progress since it is non-working: phaseRates() is not used correctly, and changes must be made to WellState or equivalent.
2014-03-18 02:48:34 -05:00
Move mass balance equations to separate function. Note that well contributions are added on later in addWellEq() as before.
2015-05-25 17:31:50 -05:00
void
assembleMassBalanceEq(const SolutionState& state);
adding extractWellPerfProperties to StandardWellsSolvent to fix the flow_solvent running.
2016-04-11 10:10:15 -05:00
// TODO: only kept for now due to flow_multisegment
// will be removed soon
Improve assemble() with new method extractWellPerfProperties().
2015-10-13 01:50:13 -05:00
void
Pass solutionState as first parameter output parameters go last...
2016-04-01 08:52:38 -05:00
extractWellPerfProperties(const SolutionState& state,
std::vector<ADB>& mob_perfcells,
std::vector<ADB>& b_perfcells) const;
Improve assemble() with new method extractWellPerfProperties().
2015-10-13 01:50:13 -05:00
fixing the running of flow_multisegment
2016-04-12 07:00:22 -05:00
// TODO: only kept for now due to flow_multisegment
// will be removed soon
void updateWellState(const V& dwells,
WellState& well_state);
Made the solveWellEq() method return if it converged. Also use this to avoid updating if not converged in the multi-segment version.
2015-11-19 06:49:42 -06:00
bool
Add option for solving the wellEq seperatly The well equations is solved seperatly in order to provide more accurate initinal values to the reservoir model.
2015-06-11 23:49:25 -05:00
solveWellEq(const std::vector<ADB>& mob_perfcells,
const std::vector<ADB>& b_perfcells,
SolutionState& state,
WellState& well_state);
Add extraAddWellEq() hook in addWellEq(). This allows extended models to add functionality to the well treatment.
2015-05-26 07:07:08 -05:00
void
Move computation of well potentials from simulator class ot model class - the computation of well potentials in the model class calculates the well potentials using computeWellFlux() - in this way the well potential calculations also handle well where some perforations are closed by the simulator due to cross-flow. - the well potentials pr perforation and phase is stored in the well state.
2016-04-12 01:50:34 -05:00
computeWellPotentials(const SolutionState& state,
const std::vector<ADB>& mob_perfcells,
const std::vector<ADB>& b_perfcells,
WellState& well_state);
void
Refactor addWellEq(). The method has been split in three parts: computeWellFlux(const SolutionState& state, const std::vector<ADB>& mob_perfcells, const std::vector<ADB>& b_perfcells, V& aliveWells, std::vector<ADB>& cq_s); void updatePerfPhaseRatesAndPressures(const std::vector<ADB>& cq_s, const SolutionState& state, WellState& xw); void addWellFluxEq(const std::vector<ADB>& cq_s, const SolutionState& state); This reduces the function length, although most of the content of addWellEq() now is in computeWellFlux(), so that function is still quite long. It also allows us to use smaller sets of function arguments, which makes methods easier to understand. Finally, it makes it easier to create derived models with custom behaviour.
2015-06-22 04:34:10 -05:00
addWellFluxEq(const std::vector<ADB>& cq_s,
const SolutionState& state);
void
addWellContributionToMassBalanceEq(const std::vector<ADB>& cq_s,
const SolutionState& state,
const WellState& xw);
void
addWellControlEq(const SolutionState& state,
const WellState& xw,
const V& aliveWells);
Add extraAddWellEq() hook in addWellEq(). This allows extended models to add functionality to the well treatment.
2015-05-26 07:07:08 -05:00
Add option for solving the wellEq seperatly The well equations is solved seperatly in order to provide more accurate initinal values to the reservoir model.
2015-06-11 23:49:25 -05:00
bool getWellConvergence(const int iteration);
Fixed sign issue with vfpprod->bhp(flo)
2015-08-18 07:53:36 -05:00
bool isVFPActive() const;
Minor performance improvement for non-VFP runs
2015-08-18 03:24:57 -05:00
Add on overload of computePressure() that accepts explicit saturations The overload is used direcly in variableState() to clean the code as well as in the orignal computePressures(state) implementation.
2015-01-07 04:24:11 -06:00
std::vector<ADB>
computePressures(const ADB& po,
const ADB& sw,
const ADB& so,
const ADB& sg) const;
Add helper computeGasPress(), use to improve performance. This avoids excessive calling of constantState().
2015-03-06 09:02:22 -06:00
V
computeGasPressure(const V& po,
const V& sw,
const V& so,
const V& sg) const;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
std::vector<ADB>
Added assembly of well equations. This has not been tested. Well contributions to mass balance equations are not done yet.
2013-05-25 03:47:22 -05:00
computeRelPerm(const SolutionState& state) const;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
void
computeMassFlux(const int actph ,
const V& transi,
include capillary pressure in the PDEs I'm neither sure that this is fully correct nor that I found all occurences (so far, the output writing code is missing in this patch), but it seems to work for SPE1...
2013-11-26 06:51:10 -06:00
const ADB& kr ,
Density and viscosity as inputs instead of computed in computeMassFlux Density and viscosity are given as input instead of calculated inside computeMassFlux. This allow for modifying the properties prior to calling computeMassFlux which avoids code duplication in the solvent implementation.
2016-02-03 04:26:11 -06:00
const ADB& mu ,
const ADB& rho ,
include capillary pressure in the PDEs I'm neither sure that this is fully correct nor that I found all occurences (so far, the output writing code is missing in this patch), but it seems to work for SPE1...
2013-11-26 06:51:10 -06:00
const ADB& p ,
Moved implementation to .cpp file.
2013-05-24 04:14:05 -05:00
const SolutionState& state );
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
Add applyThresholdPressures() method and usage. Note that this commit does not introduce any way to set use_threshold_pressure to true, so the new code is not run.
2014-08-27 03:27:49 -05:00
void applyThresholdPressures(ADB& dp);
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
ADB
fluidViscosity(const int phase,
const ADB& p ,
PVT properties: allow them to be temperature dependent Note that this patch does not introduce any real temperature dependence but only changes the APIs for the viscosity and for the density related methods. Note that I also don't like the fact that this requires so many changes to so many files, but with the current design of the property classes I cannot see a way to avoid this...
2014-11-20 05:31:50 -06:00
const ADB& temp ,
New updateState() method, changes to fluid interfaces. - updateState() is a new method that modifies the state object after solution, this was formerly done in solveJacobianSystem(). - Implemented Appleyard chop (not verified yet) for handling variable switching. - Added rs as input to fluid interfaces to include rs-derivatives.
2013-05-30 07:43:32 -05:00
const ADB& rs ,
Implementation of live gas The simulator now handles live gas as well as live oil. The primary variables are Po,Sw and Rs,Rv or Sg depending on fluid condition State 1 Gas only (Undersaturated gas): Po, Sw and Rv State 2 Gas and oil: Po, Sw and Sg State 3 Oil only (Undersaturated oil): Po, Sw and Rs This commit includes: 1. New interfaces for the vapor oil/gas ratios (Rv) 2. Modifications in the equations to handle rvs 3. New definition of ADI variable to handle changing primary variables 4. Modifications in the solution updates to handle changing primary variable 5. Some changes in the appleyard process to sync with Mrsts livegas implementation. NOTE: The implementation is tested on the liveoil cases SPE1 and a simplified SPE9 and produces the same results as the old code. The simulator is not yet able to converge on SPE3 with livegas present. For SPE3 to converge a more robust well implementation is needed. The current simulator reproduce the results of Mrst when a similar well model is used in Mrst as is currently implemented OPM.
2014-01-10 07:19:37 -06:00
const ADB& rv ,
Simplify fluid interfaces, reuse formation volume factor. The simplifications are: - Do not pass cell indices to fluidViscosity(), fluidReciprocFVF(). - Pass b (reciprocal f.v.f.) to fluidDensity() instead of pressure etc. This saves one call to fluidReciprocFVF(), that is removed from fluidDensity(). Instead the previously stored quantity is passed to fluidDensity() as an argument.
2015-06-24 03:22:23 -05:00
const std::vector<PhasePresence>& cond) const;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
ADB
fluidReciprocFVF(const int phase,
const ADB& p ,
PVT properties: allow them to be temperature dependent Note that this patch does not introduce any real temperature dependence but only changes the APIs for the viscosity and for the density related methods. Note that I also don't like the fact that this requires so many changes to so many files, but with the current design of the property classes I cannot see a way to avoid this...
2014-11-20 05:31:50 -06:00
const ADB& temp ,
New updateState() method, changes to fluid interfaces. - updateState() is a new method that modifies the state object after solution, this was formerly done in solveJacobianSystem(). - Implemented Appleyard chop (not verified yet) for handling variable switching. - Added rs as input to fluid interfaces to include rs-derivatives.
2013-05-30 07:43:32 -05:00
const ADB& rs ,
Implementation of live gas The simulator now handles live gas as well as live oil. The primary variables are Po,Sw and Rs,Rv or Sg depending on fluid condition State 1 Gas only (Undersaturated gas): Po, Sw and Rv State 2 Gas and oil: Po, Sw and Sg State 3 Oil only (Undersaturated oil): Po, Sw and Rs This commit includes: 1. New interfaces for the vapor oil/gas ratios (Rv) 2. Modifications in the equations to handle rvs 3. New definition of ADI variable to handle changing primary variables 4. Modifications in the solution updates to handle changing primary variable 5. Some changes in the appleyard process to sync with Mrsts livegas implementation. NOTE: The implementation is tested on the liveoil cases SPE1 and a simplified SPE9 and produces the same results as the old code. The simulator is not yet able to converge on SPE3 with livegas present. For SPE3 to converge a more robust well implementation is needed. The current simulator reproduce the results of Mrst when a similar well model is used in Mrst as is currently implemented OPM.
2014-01-10 07:19:37 -06:00
const ADB& rv ,
Simplify fluid interfaces, reuse formation volume factor. The simplifications are: - Do not pass cell indices to fluidViscosity(), fluidReciprocFVF(). - Pass b (reciprocal f.v.f.) to fluidDensity() instead of pressure etc. This saves one call to fluidReciprocFVF(), that is removed from fluidDensity(). Instead the previously stored quantity is passed to fluidDensity() as an argument.
2015-06-24 03:22:23 -05:00
const std::vector<PhasePresence>& cond) const;
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
ADB
Simplify fluid interfaces, reuse formation volume factor. The simplifications are: - Do not pass cell indices to fluidViscosity(), fluidReciprocFVF(). - Pass b (reciprocal f.v.f.) to fluidDensity() instead of pressure etc. This saves one call to fluidReciprocFVF(), that is removed from fluidDensity(). Instead the previously stored quantity is passed to fluidDensity() as an argument.
2015-06-24 03:22:23 -05:00
fluidDensity(const int phase,
const ADB& b,
const ADB& rs,
const ADB& rv) const;
Added method fluidRsMax(), added rs as a primary variable. Also increased amount of whitespace between methods for readability.
2013-05-27 03:29:04 -05:00
New updateState() method, changes to fluid interfaces. - updateState() is a new method that modifies the state object after solution, this was formerly done in solveJacobianSystem(). - Implemented Appleyard chop (not verified yet) for handling variable switching. - Added rs as input to fluid interfaces to include rs-derivatives.
2013-05-30 07:43:32 -05:00
V
Implementation of live gas The simulator now handles live gas as well as live oil. The primary variables are Po,Sw and Rs,Rv or Sg depending on fluid condition State 1 Gas only (Undersaturated gas): Po, Sw and Rv State 2 Gas and oil: Po, Sw and Sg State 3 Oil only (Undersaturated oil): Po, Sw and Rs This commit includes: 1. New interfaces for the vapor oil/gas ratios (Rv) 2. Modifications in the equations to handle rvs 3. New definition of ADI variable to handle changing primary variables 4. Modifications in the solution updates to handle changing primary variable 5. Some changes in the appleyard process to sync with Mrsts livegas implementation. NOTE: The implementation is tested on the liveoil cases SPE1 and a simplified SPE9 and produces the same results as the old code. The simulator is not yet able to converge on SPE3 with livegas present. For SPE3 to converge a more robust well implementation is needed. The current simulator reproduce the results of Mrst when a similar well model is used in Mrst as is currently implemented OPM.
2014-01-10 07:19:37 -06:00
fluidRsSat(const V& p,
Support for kw VAPPARS. When this kw is active, BlackoilPropsAdFromDeck now modifies rvSat and rsSat curves cell-wise by a power of (sat_oil_cell / sat_oil_cell_historical_max). Currently, the associated jacobians do not reflect terms of type d/d_sat_oil, but code for doing this is given as comments to BlackoilPropsAdFromDeck::applyVap(ADB& r, ...).
2014-07-05 08:06:12 -05:00
const V& so,
New updateState() method, changes to fluid interfaces. - updateState() is a new method that modifies the state object after solution, this was formerly done in solveJacobianSystem(). - Implemented Appleyard chop (not verified yet) for handling variable switching. - Added rs as input to fluid interfaces to include rs-derivatives.
2013-05-30 07:43:32 -05:00
const std::vector<int>& cells) const;
Added method fluidRsMax(), added rs as a primary variable. Also increased amount of whitespace between methods for readability.
2013-05-27 03:29:04 -05:00
ADB
Implementation of live gas The simulator now handles live gas as well as live oil. The primary variables are Po,Sw and Rs,Rv or Sg depending on fluid condition State 1 Gas only (Undersaturated gas): Po, Sw and Rv State 2 Gas and oil: Po, Sw and Sg State 3 Oil only (Undersaturated oil): Po, Sw and Rs This commit includes: 1. New interfaces for the vapor oil/gas ratios (Rv) 2. Modifications in the equations to handle rvs 3. New definition of ADI variable to handle changing primary variables 4. Modifications in the solution updates to handle changing primary variable 5. Some changes in the appleyard process to sync with Mrsts livegas implementation. NOTE: The implementation is tested on the liveoil cases SPE1 and a simplified SPE9 and produces the same results as the old code. The simulator is not yet able to converge on SPE3 with livegas present. For SPE3 to converge a more robust well implementation is needed. The current simulator reproduce the results of Mrst when a similar well model is used in Mrst as is currently implemented OPM.
2014-01-10 07:19:37 -06:00
fluidRsSat(const ADB& p,
Support for kw VAPPARS. When this kw is active, BlackoilPropsAdFromDeck now modifies rvSat and rsSat curves cell-wise by a power of (sat_oil_cell / sat_oil_cell_historical_max). Currently, the associated jacobians do not reflect terms of type d/d_sat_oil, but code for doing this is given as comments to BlackoilPropsAdFromDeck::applyVap(ADB& r, ...).
2014-07-05 08:06:12 -05:00
const ADB& so,
Implementation of live gas The simulator now handles live gas as well as live oil. The primary variables are Po,Sw and Rs,Rv or Sg depending on fluid condition State 1 Gas only (Undersaturated gas): Po, Sw and Rv State 2 Gas and oil: Po, Sw and Sg State 3 Oil only (Undersaturated oil): Po, Sw and Rs This commit includes: 1. New interfaces for the vapor oil/gas ratios (Rv) 2. Modifications in the equations to handle rvs 3. New definition of ADI variable to handle changing primary variables 4. Modifications in the solution updates to handle changing primary variable 5. Some changes in the appleyard process to sync with Mrsts livegas implementation. NOTE: The implementation is tested on the liveoil cases SPE1 and a simplified SPE9 and produces the same results as the old code. The simulator is not yet able to converge on SPE3 with livegas present. For SPE3 to converge a more robust well implementation is needed. The current simulator reproduce the results of Mrst when a similar well model is used in Mrst as is currently implemented OPM.
2014-01-10 07:19:37 -06:00
const std::vector<int>& cells) const;
V
fluidRvSat(const V& p,
Support for kw VAPPARS. When this kw is active, BlackoilPropsAdFromDeck now modifies rvSat and rsSat curves cell-wise by a power of (sat_oil_cell / sat_oil_cell_historical_max). Currently, the associated jacobians do not reflect terms of type d/d_sat_oil, but code for doing this is given as comments to BlackoilPropsAdFromDeck::applyVap(ADB& r, ...).
2014-07-05 08:06:12 -05:00
const V& so,
Implementation of live gas The simulator now handles live gas as well as live oil. The primary variables are Po,Sw and Rs,Rv or Sg depending on fluid condition State 1 Gas only (Undersaturated gas): Po, Sw and Rv State 2 Gas and oil: Po, Sw and Sg State 3 Oil only (Undersaturated oil): Po, Sw and Rs This commit includes: 1. New interfaces for the vapor oil/gas ratios (Rv) 2. Modifications in the equations to handle rvs 3. New definition of ADI variable to handle changing primary variables 4. Modifications in the solution updates to handle changing primary variable 5. Some changes in the appleyard process to sync with Mrsts livegas implementation. NOTE: The implementation is tested on the liveoil cases SPE1 and a simplified SPE9 and produces the same results as the old code. The simulator is not yet able to converge on SPE3 with livegas present. For SPE3 to converge a more robust well implementation is needed. The current simulator reproduce the results of Mrst when a similar well model is used in Mrst as is currently implemented OPM.
2014-01-10 07:19:37 -06:00
const std::vector<int>& cells) const;
ADB
fluidRvSat(const ADB& p,
Support for kw VAPPARS. When this kw is active, BlackoilPropsAdFromDeck now modifies rvSat and rsSat curves cell-wise by a power of (sat_oil_cell / sat_oil_cell_historical_max). Currently, the associated jacobians do not reflect terms of type d/d_sat_oil, but code for doing this is given as comments to BlackoilPropsAdFromDeck::applyVap(ADB& r, ...).
2014-07-05 08:06:12 -05:00
const ADB& so,
Added method fluidRsMax(), added rs as a primary variable. Also increased amount of whitespace between methods for readability.
2013-05-27 03:29:04 -05:00
const std::vector<int>& cells) const;
Added rock compressibility to fully implicit solver.
2013-06-03 07:14:48 -05:00
ADB
poroMult(const ADB& p) const;
ADB
transMult(const ADB& p) const;
Whether the fluid is saturated or not is explicitly passed to the pvts The criteria for whether the fluid is saturated or not is moved from the within the pvt calculations to the solver, and passed to the pvt calculations as a array of boolean values.
2013-11-28 04:27:25 -06:00
Implementation of live gas The simulator now handles live gas as well as live oil. The primary variables are Po,Sw and Rs,Rv or Sg depending on fluid condition State 1 Gas only (Undersaturated gas): Po, Sw and Rv State 2 Gas and oil: Po, Sw and Sg State 3 Oil only (Undersaturated oil): Po, Sw and Rs This commit includes: 1. New interfaces for the vapor oil/gas ratios (Rv) 2. Modifications in the equations to handle rvs 3. New definition of ADI variable to handle changing primary variables 4. Modifications in the solution updates to handle changing primary variable 5. Some changes in the appleyard process to sync with Mrsts livegas implementation. NOTE: The implementation is tested on the liveoil cases SPE1 and a simplified SPE9 and produces the same results as the old code. The simulator is not yet able to converge on SPE3 with livegas present. For SPE3 to converge a more robust well implementation is needed. The current simulator reproduce the results of Mrst when a similar well model is used in Mrst as is currently implemented OPM.
2014-01-10 07:19:37 -06:00
const std::vector<PhasePresence>
phaseCondition() const {return phaseCondition_;}
void
Using ReservoirState and WellState consistently. This means that for extended models the functions in BlackoilModelBase will be compiled with the types used by those models and not BlackoilState and WellStateFullyImplicitBlackoil (which are specified by BlackoilModel).
2015-05-25 16:49:09 -05:00
classifyCondition(const ReservoirState& state);
Implementation of live gas The simulator now handles live gas as well as live oil. The primary variables are Po,Sw and Rs,Rv or Sg depending on fluid condition State 1 Gas only (Undersaturated gas): Po, Sw and Rv State 2 Gas and oil: Po, Sw and Sg State 3 Oil only (Undersaturated oil): Po, Sw and Rs This commit includes: 1. New interfaces for the vapor oil/gas ratios (Rv) 2. Modifications in the equations to handle rvs 3. New definition of ADI variable to handle changing primary variables 4. Modifications in the solution updates to handle changing primary variable 5. Some changes in the appleyard process to sync with Mrsts livegas implementation. NOTE: The implementation is tested on the liveoil cases SPE1 and a simplified SPE9 and produces the same results as the old code. The simulator is not yet able to converge on SPE3 with livegas present. For SPE3 to converge a more robust well implementation is needed. The current simulator reproduce the results of Mrst when a similar well model is used in Mrst as is currently implemented OPM.
2014-01-10 07:19:37 -06:00
Support Oil/Water case The updatePrimalVariableFromState is now only called when the gas phase is active.
2014-06-03 06:30:35 -05:00
/// update the primal variable for Sg, Rv or Rs. The Gas phase must
/// be active to call this method.
Introduce primaryVariable_ and use it to switch primary variables
2014-05-27 08:09:58 -05:00
void
Using ReservoirState and WellState consistently. This means that for extended models the functions in BlackoilModelBase will be compiled with the types used by those models and not BlackoilState and WellStateFullyImplicitBlackoil (which are specified by BlackoilModel).
2015-05-25 16:49:09 -05:00
updatePrimalVariableFromState(const ReservoirState& state);
Introduce primaryVariable_ and use it to switch primary variables
2014-05-27 08:09:58 -05:00
Update phase condition vector from primary variables. This is necessary as an interim measure, since the phase condition vectors are still used in property calculations.
2014-07-17 07:34:07 -05:00
/// Update the phaseCondition_ member based on the primalVariable_ member.
Add members isSg_, isRs_ and isRv_. This replaces local variables that were used in more than one place, and initialised locally in the exact same way depending only on primalVariable_. Now they are updated once when primalVariable_ has changed, simplifying the code for variableState() and updateState().
2015-05-26 07:38:25 -05:00
/// Also updates isRs_, isRv_ and isSg_;
Update phase condition vector from primary variables. This is necessary as an interim measure, since the phase condition vectors are still used in property calculations.
2014-07-17 07:34:07 -05:00
void
updatePhaseCondFromPrimalVariable();
Moves calculation of the total pore volume into convergenceReduction. It is a global reduction in the parallel case and should therefore be computed together with the other ones.
2015-01-27 05:49:55 -06:00
/// \brief Compute the reduction within the convergence check.
Improve documentation of convergenceReductions.
2015-01-28 09:53:16 -06:00
/// \param[in] B A matrix with MaxNumPhases columns and the same number rows
/// as the number of cells of the grid. B.col(i) contains the values
/// for phase i.
/// \param[in] tempV A matrix with MaxNumPhases columns and the same number rows
/// as the number of cells of the grid. tempV.col(i) contains the
/// values
/// for phase i.
/// \param[in] R A matrix with MaxNumPhases columns and the same number rows
/// as the number of cells of the grid. B.col(i) contains the values
/// for phase i.
/// \param[out] R_sum An array of size MaxNumPhases where entry i contains the sum
/// of R for the phase i.
Fixes rotated function parameters during function call. There was a mixup in the order of the function parameters, both in the declaration and in the actual function call. This commit resolves this.
2015-01-28 12:08:48 -06:00
/// \param[out] maxCoeff An array of size MaxNumPhases where entry i contains the
docu fix (???) -> tempV.
2015-01-28 12:17:25 -06:00
/// maximum of tempV for the phase i.
Fixes rotated function parameters during function call. There was a mixup in the order of the function parameters, both in the declaration and in the actual function call. This commit resolves this.
2015-01-28 12:08:48 -06:00
/// \param[out] B_avg An array of size MaxNumPhases where entry i contains the average
/// of B for the phase i.
Make convergence methods work for multi-segment wells. The convergenceReduction() method no longer takes a number-of-wells argument, instead it infers the number of well fluxes to check from the size of the well_flux_eq member of the residual. After this, a custom getConvergence() method is no longer required for the multi-segment well model.
2015-10-12 08:49:10 -05:00
/// \param[out] maxNormWell The maximum of the well flux equations for each phase.
Improve documentation of convergenceReductions.
2015-01-28 09:53:16 -06:00
/// \param[in] nc The number of cells of the local grid.
/// \return The total pore volume over all cells.
Moves calculation of the total pore volume into convergenceReduction. It is a global reduction in the parallel case and should therefore be computed together with the other ones.
2015-01-27 05:49:55 -06:00
double
Use active and not canonical phases in getConvergence() etc.
2015-09-30 03:03:48 -05:00
convergenceReduction(const Eigen::Array<double, Eigen::Dynamic, Eigen::Dynamic>& B,
const Eigen::Array<double, Eigen::Dynamic, Eigen::Dynamic>& tempV,
const Eigen::Array<double, Eigen::Dynamic, Eigen::Dynamic>& R,
std::vector<double>& R_sum,
std::vector<double>& maxCoeff,
std::vector<double>& B_avg,
Compute scaled well residuals correctly for parallel runs. This commit adapts the PR #375 for parallel runs. That is, the norms are calculated over all wells, not just the ones that perforate the local grid cells. As this is a reduction, too, we move the computation to convergenceReduction method.
2015-05-13 05:00:38 -05:00
std::vector<double>& maxNormWell,
Make convergence methods work for multi-segment wells. The convergenceReduction() method no longer takes a number-of-wells argument, instead it infers the number of well fluxes to check from the size of the well_flux_eq member of the residual. After this, a custom getConvergence() method is no longer required for the multi-segment well model.
2015-10-12 08:49:10 -05:00
int nc) const;
Factors out the reduction part into a separate function. Theses reductions are global and will require a different behaviour in the parallel case.
2015-01-20 07:21:45 -06:00
added solver parameters to void reading in every step.
2014-10-01 05:48:41 -05:00
double dpMaxRel() const { return param_.dp_max_rel_; }
double dsMax() const { return param_.ds_max_; }
Use the same relative threshold for drs and drv update The drs_max_rel param is renamed to dr_max_rel and used to restrict both drs and drv.
2014-11-05 06:03:00 -06:00
double drMaxRel() const { return param_.dr_max_rel_; }
FullyImplicitBlackoilSolver: add max_residual_allowed parameter to restart solver when residual is to large.
2015-01-21 08:43:18 -06:00
double maxResidualAllowed() const { return param_.max_residual_allowed_; }
Implementation of live gas The simulator now handles live gas as well as live oil. The primary variables are Po,Sw and Rs,Rv or Sg depending on fluid condition State 1 Gas only (Undersaturated gas): Po, Sw and Rv State 2 Gas and oil: Po, Sw and Sg State 3 Oil only (Undersaturated oil): Po, Sw and Rs This commit includes: 1. New interfaces for the vapor oil/gas ratios (Rv) 2. Modifications in the equations to handle rvs 3. New definition of ADI variable to handle changing primary variables 4. Modifications in the solution updates to handle changing primary variable 5. Some changes in the appleyard process to sync with Mrsts livegas implementation. NOTE: The implementation is tested on the liveoil cases SPE1 and a simplified SPE9 and produces the same results as the old code. The simulator is not yet able to converge on SPE3 with livegas present. For SPE3 to converge a more robust well implementation is needed. The current simulator reproduce the results of Mrst when a similar well model is used in Mrst as is currently implemented OPM.
2014-01-10 07:19:37 -06:00
Add first cut at fully implicit system assembly. Compile-tested only. At this point, we only include reservoir effects--i.e., we don't consider wells.
2013-05-23 11:28:50 -05:00
};
} // namespace Opm
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
#include "BlackoilModelBase_impl.hpp"
Renamed ImplicitBOStep -> FullyImplicitBlackoilSolver.
2013-05-24 03:49:59 -05:00
Create BlackoilModelBase class. The class is identical to BlackoilModel class at this stage, but since it was renamed from FullyImplicitBlackoilSolver it keeps the commit history better.
2015-05-24 02:59:40 -05:00
#endif // OPM_BLACKOILMODELBASE_HEADER_INCLUDED
Reference in New Issue Copy Permalink