Total time will be written to walltime.txt, and single step times to
step_timing.txt (changed suffix from param to txt). This did not work
properly before this fix (step_timing file was overwritten each step).
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, ...).
This commit replaces an if-else-based query of the primaryVariable_
with the equivalent switch() statement for uniformity with the rest
of the implementation.
This commit introduces support for the RESV control mode of
prediction (WCONPROD) and history-matching (WCONHIST) alike. The
implementation uses class SurfaceToReservoirVoidage<> to compute
coefficients that convert component rates at surface conditions
(i.e., the primary degrees of freedom in the well residual) to phase
rates at reservoir condition. The resulting coefficients can be
entered directly into system matrix of the linearised residual.
Note: We abuse the "distr" mechanism of struct WellControls to store
the conversion coefficients. This may require refactorisation and
clarification at a later stage. In the meantime, it allows for
transparent assembly of well equations--irrespective of surface- or
reservoir (voidage) rates.
Note: We do not yet support injectors controlled by total reservoir
voidage rate--either in history-matching (WCONINJH) or
prediction-scenario capacity.
This commit changes the API of class SimulatorFullyImplicitBlackoil<>
in order to support wells controlled by (total) reservoir voidage
volume rates. Specifically, we switch to holding a mutable Wells
object (backed by a std::shared_ptr<>) in class Impl rather than a
reference to a WellsManager. This allows dynamically updating rate
distributions and targets of individual well controls. That, in
turn, is a prerequisite to supporting ECL-style "RESV" control
modes--be it in prediction or history matching capacity.
While in the process of API changes, also prepare for the second
stage of "WCONHIST/RESV" support: Accept a ScheduleConstPtr that
holds the input deck's notion of the history matching vs. prediction
controls. We need to distinguish the two in order to support the
exact semantics of "WCONHIST/RESV".
Update SimFIBO<> clients accordingly.
This was copy-pasted into the class at its inception (a94f1921) and
never used thereafter. If we need it we can bring it back in
modified form at a later stage.
This commit adds a simple facility for converting component rates at
surface conditions to voidage rates at reservoir conditions. It is
intentionally limited in scope and meant to be employed only in the
context of class FullyImplicitBlackoilSolver<> or something very
similar. In particular, class SurfaceToReservoirVoidage<> assumes
that it will be used to compute conversion coefficients for
component rates to voidage rates, and that those coefficients will
typically be entered into the coefficient matrix of a linearised
residual.
Add a trivial test just to demonstrate the setup and calling
process. This is not a feature or correctness test.
The solver (class FullyImplicitBlackoilSolver<>) gained the ability
to do control mode switching/updating in commit 4a22c56 at which
point using WellsManager::conditionsMet() ceased to be useful. This
is a preparatory step towards adding support for RESV-type control
modes.
If we need this type of behaviour in the Simulator*, we can bring it
back (in modified form) at a later time.
This is a relic of the way we originally handled gravity. The member
remained after the change, and is now a major time-consumption sink
due to the unfortunate fact that it is computed every time step
(unnecessary), and because the gravityOperator() function (now removed)
was very unperformant after changing to use the faceCells() function.
this means that the NTG, MULTPV and MULT[XYZ]-? keywords are now
supported.
Actually FAULTS and MULTFAULT are supported too, but that's abstracted
away by opm-parser's TransMult class. (Kudos to [at]joakim-hove for
implementing this.)
this is required to implement pore volume and permeability multipliers
as discussed with [at]bska and [at]joakim-hove.
Note that this implies that the DerivedGeology class can't be
instantiated anymore if there is no EclipseState object. Thus all code
paths and tests that don't load a deck are removed by this patch. If
this is undesireable, there are two options: First, don't require
EclipseState for DerivedGeology which would imply to make the about 10
required multiplier functions part of the
BlackoilPropertiesAdInterface, or second, one can copy-and-paste the
DerivedGeology class as it was before this patch, derive from a newly
introduced DerivedGeologyInterface and pass DerivedGeologyInterface
objects to the simulator. IMHO, the second solution would be a bit
better but it would involve substantial overhead to implement and to
maintain it.
Anyway, in the mean time simulators cannot be instantiated without
decks.
Commit 5112b8a misinterpreted the role of index 'i' and, as a result,
installed code that would only define one-sided gravity potentials of
the first cell (roughly)--albeit eventually using the geometry of the
last active cell.
This commit restores the original, intended behaviour.
Class FullyImplicitBlackoilSolver<Grid> already features a list of
"all" cells, built at object construction time. There's no need to
re-compute that list on every call to variableState() (when Gas is
active).
The "xvar" exists only if Gas is active. Therefore, we cannot
extract that variable from "vars" unless we know that Gas is an
active phase. Failing to do so would wrongfully increment 'nextvar'
whence the final BHP variable would be an out-of-bounds access.
Methods 'computeRelperm()' and 'computePressures()' *always* return
a three-element vector of phase properties. We must therefore
translate to canonical phase indices before indexing into the
results.
i.e. reading the grid properties from EclipseState instead of from the
raw deck. This requires that all deck files exhibit a GRID and a
SCHEDULE section or else EclipseState will throw in the constructor.
Removing the bool input parameters osicllate and stagnate from the
stablizeNewton(). Basically, the value omega will decide if the
relaxation will be applied.
With some caveats:
- scaling factors for material balance equations and pressure are hardcoded.
- pressure system is formed from sum of material balance equations, with
no check for diagonal dominance.
The bugs were:
- Not accounting for the different storage orders used for the
state.qs variable and the WellState*::wellRates() field.
- When switching to rate control, well rates for phases other
than that to be controlled by were set to zero.
In its current state, we still don't do CPR, but eliminate the well equations,
solve the resulting system and finally recover the eliminated well unknowns.
The following is changed in this commit:
- The constructor for NewtonIterationBlackoilSimple now takes
a parameter object instead of a linear solver.
- The fully implicit black-oil simulators can now use the CPR
preconditioning strategy (by passing use_cpr=true) or the
simple strategy (the default).
Note that as of this commit, the CPR preconditioning still has
not been implemented properly, and behaves just like the simple
strategy.
When invoking a member template in a template function one must in most
cases use the template keyword as a qualifier to indicate that the member
is a template.
I do not understand why this did not trigger a compiler error for the
original author though.
Formerly only the control was changed. Now both well state and primary variables
will be modified to match control targets that were switched to (bhp or rates).
This commit adds a few annotations to closing braces on namespaces
and one "#ifdef" conditional. This is an aid to (hopefully) avoid
the problem fixed in commit 688d65e.
Namely the template parameter was missing for the added methods.
In addition there were still various instances where the grid was
used directly rather than via the functions in GridHelpers.hh.
Conflicts:
examples/sim_fibo_ad.cpp
opm/autodiff/FullyImplicitBlackoilSolver_impl.hpp
This brings the "CpGrid support" branch up to date with respect to
recent changes in opm-autodiff master.
The wellmore mix is set to preferred phase for dead wells, where the
total volumetric rates are zero. This sets the phase of the flow out of
perforations in dead wells and thus avoids zero volumerats for injecting
preforations in dead wells.
i.e., the simulator does not deal with any output operations
anymore. This makes sense because report steps are handled by
Opm::TimeMap and the constructor for the simulator already needs more
arguments than appropriate even without this...
With this, constantState() just calls variableState() and throws away
the derivatives. This might be a bit slower than necessary, but it
makes these two methods automatically consistent and constantState()
is only called once per timestep anyway...
thanks to @atgeirr for the suggestion!
Now the well state is consulted for the controls to use when assembling
the well control equations, instead of the (immutable) wells_ struct.
Also, added dummy implementation of updateWellControls().
This is done since the solver will need to be able to switch well controls
during Newton iterations. The current control specified in the Wells struct
will be used as default and initial value for currentControls().
Manually resolved conficts in the following files
examples/sim_fibo_ad.cpp
opm/autodiff/FullyImplicitBlackoilSolver_impl.hpp
opm/autodiff/SimulatorFullyImplicitBlackoil_impl.hpp
In additions examples/sim_fibo_ad_cp.cpp was adapted to compile again.
Conflicts:
opm/autodiff/FullyImplicitBlackoilSolver.cpp
To resolve conflicts, WellState was changed to WellStateFullyImplicitBlackoil
in multiple places, and perfRate() changed to perfPhaseRate() in
WellDensitySegmented.
This is intended to be used instead of the WellState class in the fully
implicit blackoil simulator. It contains a WellState to reuse the init()
method and to enable users to call functions requiring a WellState.
This is done with containment and an access member function,
basicWellState(), instead of with inheritance to minimize surprises.
