Field efficiency: (OIP(initial) - OIP(now)) / OIP(initial). The initial
OIP is cached, and FOIP is reused for OIP(now). Adds the
operator-(double,quantity) to make the formula obvious from the FOE
function.
Several functions were aliased to hide the fact that they shared the
same templated function, but with different specialisations. By
introducing aliases for producer and injector some readability is gained
and some (clumsy) aliases are removed, in favour of passing the
interesting aspect along with the general base name.
The data exchanged in data::Well::Completions is now a vector, more
closely matching the disk format and the order exposed by the simulator.
Zero'd wells and complations are still written for shut wells, or wells
the simulator does not provide any information for; however, all
non-closed wells (according to the schedule) will be restored. The
completions are written and restored in the same order as CompletionSet
from parser.
Change the structure used to populate OPM_XWEL to use a plain map of
data::Wells objects rather than dumping a series of vectors to
data::Wells. Tests are added for serialising and restoring wells.
Will use one common container for both the solution data required for the
restart, e.g. PRESSURE and SWAT and also the auxillary data like KRG and
FIP which is intended as extra information in the restart file, or
alternatively the summary file.
- The outputwriter will now take a a separate EclipseGrid instance as
input argument, it is assumed that calling scope has already made sure
ACTNUM and ZCORN are correct.
- All active/inactive cell mappings are based on the grid argument, the
naked int* with global / active cell mappings has been completely
removed.
By moving the unit conversion to the low-level arithmetic rather than
the high level functions, the DSL is simplified by inferring result
types rather than requiring explicit conversions. This means the
formulae are more lisp-like and more natural, since there is no more
need for liq_vol and fiends.
An added benefit is that multiplication now is commutative also with
respect to units, so the wonky left-hand-side-converts semantics are
gone.
Write the corresponding unit type (as a string) to the values written in
the Summary file.
Accomplished by running every registered function as the ert entry is
created and obtaining the string representation of the result. The
computation is called with empty, dummy structures.
In line with Eclipse water cuts, gas-oil ratio etc. only applies to
production values, rather than all rates. This sparked some other
refactoring that moves the negative-else-zero logic into the rate
calculation.
A small set of the completion family of keywords, water/oil/gas
production and injection. The tests and example data file are updated
accordingly, with edge cases.
A rewritten Summary.cpp with some minor header modifications. Synposis
of the new implementation:
* Uses unordered_map< string, std::function > for dispatch, instead of
multiple functions and a switch
* Some poor man's function composition support has been added
(privately) to avoid a lot of reptition in the post processing.
* Functions assume they work over lists of wells instead of single wells
being special cased - this means groups of well etc. can share
implementation with single wells and field keywords.
* Unsupported keywords are not written in the Summary file.
Furthermore, some comments on special cases and overall approach and
a generally more declarative implementation. This change is invisible to
downstream developers. Users will obviously see no more garbage
keywords.
Since production is seen as negative injection, and production rates
often are zero, negative zeros would be returned. Likewise, occasionally
numerical noise gives slightly-below-zero values which are now rounded
to be plain zeros.
