This is intentionally black-oil specific because we presently do no
know how to handle other cases (e.g., more phases or number of phases
different from number of components).
The second input of initBlackoilStateFromDeck that computes surface
volumes based on gas/oil ratio is changed from
BlackoilPropertiesInterface to Props. To avoid duplication with the old
initBlackoilStateFromDeck its name is changed to
initBlackoilSurfvolUsingRS.
Add new function is added that computes saturation from surface volumes
solving z = As for each cell. This function is used to compute an
intial guess to the saturations in initState_impl.hpp.
The 'comp_term' is supposed to be a total divergence term, which is supposed
to be zero for incompressible flow. It was added for improved robustness in
stagnant areas, but as implemented it would not be computed properly for
oil injection scenarios, due to the convention for two-phase transport
source terms (positive terms are inflow of first phase [water], negative
terms are total outflow).
The WellsManager class handles INJECTORS by assigning a phase
distribution (W->ctrls[i]->distr) that coincides with the injected
fluid for the corresponding well (e.g., {1,0,0} for WATER injectors in
a three-phase WATER/OIL/GAS simulation). This, however, meshes poorly
with the restriction that all phase components must be ONE in the case
of wells constrained by total reservoir volume flow targets (RESV)
that was introduced in commit b7d1634.
This change-set limits the restriction on phase distributions to
PRODUCERs only and is a tentative solution to GitHub PR #360.
Otherwise the compiler will probably give us a warning that these
pragmas are unknown. By default that warning is disabled with our
own build system, but we also want to be able to link to our library
without incorporating the entire build system too.
To avoid deprecation warnings the number of smoothing steps was passed
through the Criterion instead of directly to the constructor in commit
a7f32b934b.
However, due to an insufficient test matrix this was not tested using
the fast AMG variant of DUNE so it breaks the builds if
`-DHAS_DUNE_FAST_AMG` is defined.
This change should apply the same type of change to this branch as for
the others. The number of smoothing steps is put into a constant to
avoid the magic number 1 to appear in too many places (although I am
not sure the number for pre- and post-smoothing always should be the
same).
If a function is used by a template but this template is not
instantiated, the function will still be defined in the header
of a module but it won't be callable because it is in an anonymous
namespace and thus we get a warning.
This only happens in Clang; GCC consider functions referenced from
templates as used.
fixup! Don't warn about functions not emitted
make all non-implementation headers includable without
preconditions. Also, this removes the GravityColumnSolver.hpp file,
because it tried to include a non-existing file and it was thus unused.
for some of these files this is needed to make to keep it compiling
after the next patch because the new ErrorMacros.hpp file will no
longer implicitly includes <iostream>. for the remaining files it is
just good style.
While at it, the includes for most of these files have been ordered in
order of decreasing abstraction level.
SuiteSparse may or may not be installed in a suitesparse/ directory.
FindSuiteSparse will look in a suitesparse/ subdirectory when trying
to locate umfpack.h, but it will add the full directory to the compiler
command-line (e.g. `-I/usr/include/suitesparse`) and not that of the
parent. Since the parent is usually included too, it is not noticed
that it is advertedly using another include paths than its own.
However, if we have SuiteSparse installed in a non-system location,
using the subdirectory in the `#include` statement may now cause an
error, even though configuration actually found SuiteSparse!
AGMG is now under a closed-source license, meaning that results
obtained with this solver is not freely reproducible by others.
Its use is therefore discouraged.
As of version 2.3, the DUNE AMG parts are competitive, so there
is a free and open alternative.
our policy is that we only use boost if necessary, i.e., if the oldest
supported compiler does not support a given feature but boost
does. since we recently switched to GCC 4.4 or newer, std::shared_ptr
is available unconditionally.
most of them quite insignificant, but still annoying. The only
exception is the warning about the changed alignment for the 'work'
argument of spu_implicit_assemble(). AFAICT, the only reason why it
worked was that the pointer produced by malloc() was passed
directly. (malloc() seems to fulfill all alignment criteria.) To fix
this, I've changed that argument's type from char* to double*.
The current implementations of IncompPropertiesInterface are very
all-or-nothing. In some situations, you want to read rock and fluid
properties from an Eclipse file, but use analytical functions for
the unsaturated properties. Or you want to update properties based
on a marching filter.
This patch provides a way to mix various property objects, or to
"shadow" the properties with a raw array of data, so you don't have
to reimplement the entire interface just to make a small change.
The <have_boost_redef.hpp> header was introduced (commit 82369f9) as
a work-around for a particular interaction in the Autotools-based
setup of OPM-Core and the Dune core modules. Notably, Dune's
"Enable" trick for Boost failed on some older Autoconf systems. Now
that we're using CMake, however, that kluge is no longer needed
because we (OPM-Core) always
#define HAVE_BOOST 1
i.e., as an explict true/false value.
Therefore, we need no longer include <have_boost_redef.hpp> . The
header will be removed at a later time.
After this patch one can set the prolongation factor for all
AMG calls and the number of smoothing steps for all except
of FastAMG that currently only supports on step.
Do not use the well's comp_frac member, only rely on the control's distr
member for initialization. This forced a change to WellsManager's
initialization of the distr member.
- Changed interface.
- Read tracerheads (tracer start locations) from file in compute_tof_from_files.
- Initialize tracerheads from wells in compute_tof.
Now it will no longer trigger assertation failure when grids are not
edge-conformal (faulted cornerpoint grids processed by our code will
usually not be). Minor algorithm change to handle this.
Interface change: solver now requires a linear solver (for the multi-cell blocks only).
Implementation uses new private method assembleSingleCell(), that is a modified copy
of solveSingleCell(). Should refactor.
Deleted some unused code (or moved to opm-porsol), moved all code dealing with
time-of-flight to opm/core/tof, moved code for implicit transport solver to
opm/core/transport/implicit, spu_[im|ex]plicit.[ch] to opm/core/transport/minimal.
The "maxit_" counter is an upper limit on the number of non-linear
iterations in a single cell. Declaring this as a "double" is counter
intuitive unless one expects the number to be *really* high.
Present since
- Commit 93d4bd8 (TransportModelTwophase.hpp)
- Commit e0d38cf (TransportModelTwophaseCompressible.hpp)
This commit corrects an error that has been present since the
introduction of function wellsToSrc() in commit a50bb8f but was never
detected. Although the conversion int->double->std::size_t is likely to
be loss-less, it is better to not introduce any more steps than are
actually needed.
This is a minor bugfix to account for the presence of shut wells
(characterised by "ctrls[w]->current < 0"). The existing code would
lead to indexing outside the "ctrls" array in the context of a shut
well.
Also:
- Add use_tensorial_basis parameter allowing run-time choice of basis.
- Remove degree argument from solveTof() method, degree is instead obtained
from parameters in constructors. Modified compute_tof* programs to match.
Skeleton in place for increased flexibility in methods and usage.
(So far behaviour choices are hardcoded, though.)
Added relative flux thresholding to existing limiter to avoid flux noise
strongly affecting solution. For example no-flow boundaries could be treated
as inflow boundaries and make the minimum upwind face limiter meaningless.
There is a different problem that needs fixing, however:
Flux inaccuracies (for example on boundaries) may tag some
face as inflow face for a cell, even if it should have been
no-flow. This may let the cell avoid limiting, even though it
should have been limited according to the proper inflow faces.
The limiter is experimental and unfinished, untested work in progress.
Limiter is therefore inactive by default.
Also fixed a minor bug: use_cvi_ was not initialized.
opm/core/eclipse/EclipseGridParser.cpp
opm/core/eclipse/EclipseGridParser.hpp
- New keywords: ENDSCALE SCALECRS SWCR SWL SWU SOWCR KRW KRWR KRO KRORW
opm/core/eclipse/SpecialEclipseFields.hpp
- Parsers for ENDSCALE and SCALECRS.
opm/core/fluid/BlackoilPropertiesFromDeck.cpp
- Consistency check: ENDSCALE implemented for SatFuncSimple only.
opm/core/fluid/SatFuncGwseg.hpp
opm/core/fluid/SatFuncSimple.hpp
opm/core/fluid/SatFuncStone2.hpp
- Accomodate "default" values for scalable parameters.
- For SatFuncGwseg and SatFuncStone2 the associated functionality not
yet supported and the variables are dummies to satisfy the compiler.
opm/core/fluid/SatFuncSimple.cpp
- Initialisation for scalable parameters.
- Evaluation of relperms: Use (1-so) for evaluation of oil-relperms.
(For scaled arguments sw and so do not necessarily add to one.)
- TODO: SatFuncGwseg.cpp and SatFuncStone2.cpp for oil-water systems.
opm/core/fluid/SaturationPropsFromDeck.hpp
- Struct to accomodate cell-wise scaling factors.
- Two flags indicating scaling and method.
- Methods for parameter initialisation and scaled relperm computation.
opm/core/fluid/SaturationPropsFromDeck_impl.hpp
- Initialize scaling options and relevant cell-wise scaling factors.
- Relperm evaluation modified for possible end point scaling.
This means that the class does expect source terms that are just that, and not
'transport source' terms that include boundary inflows (like the transport
solvers expect). This is also consistent with the behaviour of the DG version.
Should now be in sync with cfs_tpfa_residual C interface. Simple well
gravity model implemented.
More flexibility in well gravity models would be a natural future extension.
We previously ignored effects of gravity in the calculation of the well
connection fluxes (i.e., perforation fluxes). This commit includes
those effects where appropriate.
Specifically, the tests
if (!wells->type[self_index] == INJECTOR)
if (!wells->type[self_index] == PRODUCER)
produced the expected results *only* because INJECTOR==0 and PRODUCER==1
in the WellType enumeration, thus (!INJECTOR == PRODUCER) and
(!PRODUCER == INJECTOR).
Installing the (much) more appropriate
if (wells->type[self_index] != INJECTOR)
if (wells->type[self_index] != PRODUCER)
is not only more readable, it is also future-proof and scales better if
we ever introduce new WellTypes (e.g., a MONITOR).
It complains about not finding a match for the pair<> template class,
because the first parameter (this) is allegedly const. However, this
isn't a const method, so I suspect it is a compiler bug.
In order to move on, I slap on a harmless cast which will make this
particular compiler happy, and which should have no effects elsewhere,
but put it in a #if..#else..#endif macro to avoid warnings on others;
hopefully this also makes it easier to spot and remove in the future.
The class TransportModelTracerTofDiscGal now uses
VelocityInterpolationInterface, and acts as a factory
internally, choosing an interpolation method depending on
the parameter 'use_cvi'.
Order of arguments for computePhaseFlowRatesPerWell() was wrong.
This fix was done previously for SimulatorCompressibleTwophase,
but the incompressible sim was ignored.
Also added an ASSERT that may help catch some misuse.
In the Wells struct, production rate control targets must be negative
(and injection rate control targets are always positive).
In the WellsGroup classes, there are separate variables for injection
and production, and all rates are positive. Therefore, upon adding or
modification of a production rate control, the negated value must
be used.
This installs a measure of safety on the part of the interface in that
the caller is free to dispose of the wells object upon returning from
the WellsManager constructor.
