In that case processEclipseFormat will create NNCs over the pinched
out cells with correct transmissibilities. Those NNCs are marked as
being created in PINCH and used to overwrite calculated
transmissibilties for the horizontal intersections (transmissibilities
of normal NNCs are usually added).
Note that the trnasmissibilities (without the multipliers) do not
change later. Only the multipliers can change them in the schedule and
that will still happen.
There is no need to update the stencil if we are skipping the cell.
Also, the extensive quantities will not change while iterating over
the neighbours, so that update can be moved out of the loop.
The 'FIP' mnemonic continues to be an alias for 'SFIP' in the
current implementation, and the output layer will create the 'SFIP'
arrays as copies of 'FIP' if passed only the 'FIP' arrays.
To this end, make 'outputFipRestart_' into a structure that tracks
which of the *FIP mnemonics have been requested, and insert the
pertinent solution arrays into the data::Solution object when
needed.
The earlier condition
0 <= SGU < 1
was not appropriate and would, for instance, fail the NORNE_ATW2013
test case in which SGU = 1 in the unscaled table for saturation
region 1. Revise the condition to be more in line with that of SWU,
i.e., as
0 < SGU <= 1
Pointy Hat: [at]bska
This commit introduces consistency checks for the scaled displacing
saturation in the three point horizontal scaling method
(SCALECRS=YES). These plug into the framework introduced in commit
c3939c544 (PR #5438). We implement the following two checks
- SGCR < 1-SOGCR-SWL < SGU
- SWCR < 1-SOWCR-SGL < SWU
which collectively guarantee a mobile displacing oil saturation in
the two phase gas/oil and oil/water systems.
If the user chooses a specific number of NLDD domains, there is no
need to compute the default number of domains based on a specific
target number of cells per domain. Defer the, potentially costly,
calculation to when we know we need it.
While here, also split/rejoin a couple of long lines.
This commit introduces a set of consistency checks for the water
phase saturation functions. These plug into the framework
introduced in commit c3939c544 (PR #5438). We implement the
following three checks
- 0 <= SWL < 1
- 0 < SWU <= 1
- SWL <= SWCR < SWU
which collectively enable a non-negative oil saturation in the two
phase oil/water system.
This commit introduces a set of consistency checks for the gas phase
saturation functions. These plug into the framework introduced in
commit c3939c544 (PR #5438). We implement the following three checks
- 0 <= SGL < 1
- 0 <= SGU < 1
- SGL <= SGCR < SGU
which collectively enable a non-negative oil saturation in the two
phase gas/oil system.
This commit introduces a set of consistency checks for the oil phase
saturation functions. These plug into the framework introduced in
commit c3939c544 (PR #5438). We implement the following four checks
for the gas/oil two-phase system
- 0 <= SOGCR < 1
- SWL + SGU <= 1
- SOGCR < 1 - SWL - SGL
- SOGCR < 1 - SWL - SGCR
which all guarantee a non-negative (mobile) oil saturation in the
gas/oil system. Similarly, we implement the following four checks
for the oil/water two-phase system
- 0 <= SOWCR < 1
- SGL + SWU <= 1
- SOWCR < 1 - SWL - SGL
- SOWCR < 1 - SWCR - SGL
which provide the same guarantees as outlined above, but for the
oil/water system.
We add a base class, PhaseCheckBase<Scalar>, which provides a common
representation of the violated/critical predicates and implement the
specific checks as derived types of this base class.
This commit introduces helper functions for each individual part of
a convergence report record in the INFOITER file. In particular, we
create helpers for
- Time related columns (report step, time step, time &c)
- CNV pore-volume histogram columns
- Reservoir convergence metrics (CNV and MB values per phase)
- Well convergence metrics
This makes the body of the main loop in writeConvergenceRequest()
slightly easier to read and means that we can apply some additional
logic to the CNV pore-volume histograms if the number of values does
not match the expected 3 per type. In that case we output sentinel
values (e.g., NaN and -1) to signify that the corresponding pieces
of information are unavailable.
This commit switches the parallel implemenation of function
Opm::gatherConvergenceReport() into using the general serialisation
framework (classes Opm::Serializer<> and Opm::Mpi::Packer). In
particular, we add serializeOp() functions to each of the types
- ConvergenceReport
- ConvergenceReport::ReservoirFailure
- ConvergenceReport::ReservoirConvergenceMetric
- ConvergenceReport::WellFailure
and defer the job of converting the objects between in-memory and
byte stream representations to Opm::Serializer<>. The new special
purpose class CollectConvReports inherits from the latter and uses
its pack() and unpack() member functions, along with its internal
m_buffer data member, to distribute each rank's convergence report
object to all ranks. We add this feature here, in a very narrowly
scoped use case, to enable testing and experimentation before we
consider adding this distribution mechanism as a general feature in
Opm::MpiSerializer.
This commit tracks the number of cells and their associate fraction
of the model's "eligible" pore volume (total pore volume in
numerical aquifers subtracted from the model's total pore volume) in
three distinct categories as a function of the non-linear iteration
number:
- 0: MAX_p { CNV_p } <= strict CNV tolerance
- 1: MAX_p { CNV_p } \in (strict, relaxed]
- 2: MAX_p { CNV_p } > relaxed CNV tolerance
We then output these cell counts and pore volume fractions as new
items in the INFOITER file to enable more targeted analysis of the
non-linear convergence behaviour.
To this end, introduce a type alias CnvPvSplit in the
ConvergenceReport and aggregate these across the MPI ranks before we
collect them in the ConvergenceReport objects.
While here, also reduce the amount of repeated logic in
gatherConvergenceReport.cpp through a few local lambdas.
BILU0: optionally instantiate for float
BISAI: optionally instantiate for float
CPR: optionally instantiate for float
CPRCreation: optionally instantiate for float
Misc: optionally instantiate for float
This commit switches the approach introduced in commit eeb1b7e36 (PR
#3169) to using a mobility weighted average of cell level densities
for the connection level mixture densities in no-flow producing
wells. We also use the recent stoppedOrZeroRateTarget() predicate
to identify those no-flow producing wells instead of inspecting the
connection flow rates.
The mobility weighted average gives a more monotone pressure buildup
for the stopped wells and this is usually what the engineer wants.
This revised approach furthermore needs fewer cell-level dynamic
properties so simplify the computeProperties() signature by
introducing a structure for the property callback functions and
update the callers accordingly.
This commit switches computePropertiesForPressures() to return a
Properties object directly instead of populating an object
constructed in the caller. There is just a single call site for
this function so there's no benefit to using an out parameter here.
While here, also collect the property callbacks into a structure to
simplify the function signature. This also enables not filling in
the solvent properties unless solvent is active in the run. Update
caller accordingly.
In particular, split the sections of the main loop out to helper
functions
- calculatePerforationOutflow() uses the global container factory
to compute the outflow from each connection
- initialiseConnectionMixture() computes the 'mix' array depending
on the local flowing conditions of the connection. We have
renamed 'x' and 'mix' arrays to 'currentMixture' and
'previousMixture' respectively to give more descriptive names in
the process.
We've also split out the redistribution of the individual phases to
the new private helper functions reapportionGasOilMixture() and
reapportionGasWaterMixture() in order to reduce the cognitive load
of the main loop in computePropertiesForPressures(). While here,
employ pointer arithmetic to expose the underlying structure of the
assignment expressions.
In particular
* Split some long lines
* Reverse conditions to reduce nesting
* Mark potentially unused arguments as [[maybe_unused]]
* Try to remove redundant calculations
* Mark some objets 'const' where possible
cuWellContributions: optionally instantiate for float
openclWellContributions: optionally instantiate for float
rocsparseWellContributions: optionally instantiate for float
these need to go in the same commit due to circular dependencies
