Exercises the initializers for SW{L,CR,U}, SO{W,G}CR, SG{L,CR,U}, as
well as the function values KRW, KRWR, KRG, KRGR, KRO, KRORW, KRORG
and capillary pressure function values PCW and PCG.
Example data from region one (1) of
opm-tests/model1/include/sattab_basemod1.sattab
Example phrased both as family I (S*OF) and as family II (S*FN, SOF3).
The RawString class is introduced as a string which can hold the literals '*',
'/' and '''. The RawString class is used to hold the content of UDQ and ACTIONX
keywords.
1. If the well is MSW the connections in the WellConnection class is sorted in
output order in the ::order() method, and retained that way.
2. Add method WellConnection::output() which return a vector of connection
pointers sorted in output order.
With this commit the PYACTION keyword is changed, instead of embedding the
Python code directly in the .DATA file the keyword now points to an external
file which is loaded verbatim into the PyAction keyword.
In addition the PYACTION keyword has now got a name and a string indicating how
many times it should run.
In order to support the extended network model going forwards, the method Opm::Group::parent() is split in the API into two new methods, Opm::Group::control_group() and Opm::Group::flow_group(). These methods give the names of the parent node in the group control hierarchy and network structure, respectively.
While for the standard network model these two values will be the same (and the same as ::parent()), code that presently calls ::parent() should be revisited with an eye to the question of which parent group is desired.
since we still support g++-7, where filesystem is marked experimental,
we introduce a wrapper header and expose the namespace to use
as Opm::filesystem.
for gcc we unconditionally link with libstdc++fs in the python bindings.
the setup.py stuff links as c code, not c++ code, so it is not
automatically added on any gcc version. this might prove unportable
later.
- Make constructor and operator== for struct
- Make constructor and accessor for serialization
- Initial pressure stored in std::pair<bool, double>
- Add size() and begin() and end()
- Remove unused memmbers cell_id and inftableID
- Use ParserKeywords::AQUIFETP class instead of string lookup
make Tuning a simple struct, and store as a DynamicState<Tuning>.
in the process the unused setTuningInitialValue is removed. it was
only used in unit tests and seem like a leftover
This commit passes the run's notion of its active phases, an object
of type Opm::Phases, through to the initialisation layer for the
saturation functions' scaling properties. In particular, this
allows us to discriminate between the phases and to not index into
tables or properties that would not be appropriate (e.g., maximum
gas saturation (SGU) in a simulation run without active gas).
Moreover, we now have enough information to know to look for SOF2 in
two-phase run using family II saturation function keywords. These
changes are necessary in order to extend Flow's support for the
FILLEPS output request to two-phase runs.
motivation: an upcoming parallel frontend to the field props manager.
templated functions cannot be virtualized, and thus having these exposed
would give a great chance of confusing the users in the downstream
code, where properties would be caught from the (potentially) empty
backend instead of from the frontend.
This commit internalises the TOLCRIT keyword into the EclipseState
for subsequent use in determining critical saturations when
processing saturation function keywords such as SGOF and SOF3.
Specifically, we add a new type
Opm::SatFuncControls
that, at present, stores only the TOLCRIT data item (defaulted to
the keyword's default value). Client code can then retrieve the
value by calling the
SatFuncControls::minimumRelpermMobilityThreshold()
member function.
Add a new data member of this type to the Opm::Runspec class so that
we complete the chain from EclipseState, and a few simple unit tests
to exercise the expected functionality.
Generally, this commit captures more of the surrounding context of
calls to the updateRFT() and updatePLT() member functions. We need
this additional context in order to handle the conflicting semantics
of output requests WRFT and WRFTPLT:FOPN. The former generates RFT
output when the well opens if this event does not happen earlier in
the simulation schedule than the output request. Otherwise no RFT
data is emitted. The latter outputs RFT data at request time if
well opens no later than the request; otherwise at well-open time.
To this end, switch the well_open_rft_name data member from an
unordered_set of well names into an unordered_map from well names to
RFT output request times. With this additional information we can
use well_open_rft_time to infer the appropriate response to whether
or not to activate RFT output at well open time. Moreover, we now
guarantee that no RFT output is ever activated before the first RFT
output request.
Switching the type of the well_open_rft_name data member also begets
an API update to the serialization related RFTConfig constructor and
to the return type of RFTConfig::wellOpenRftName().
We furthermore switch to caching the first RFT output event in a new
scalar data member, first_rft_event. This caching, coupled with the
additional calling context mentioned earlier, means we are now able
to report a high-fidelity, constant time answer to the
RFTConfig::firstRFTOutput()
request. This, in turn, is very useful for the RFT output code.
Finally, we also add a couple of new, private member functions to
simplify updating first_rft_event depending on context.
As part of this update, member function
RFTConfig::setWellOpenRFT(report_step)
will now use the minimum of all 'report_step' values to support the
WRFT keyword being specified more than once.
Finally, add a set of unit tests to exercise the various RFT output
request combinations.
While here, also switch to using unordered_map::find() and emplace()
where possible to limit repeated look-up of the same keys.
- The lowest level get method is called init_get() - this will unconditionally
create new keyword. The init_get() method is private.
- Introduced FieldDataManager which keeps track of data pointer and status.
- Refactored get( ) implementation
- In the case of several tokens separated with +/- the final tree is assembled
from left, was previously from the right. This fixes evaluation bug with
expressions like A - B - C which were eventually evaluated as A - (B - C).
- Improved handling of different types; both transiton from scalar to sets of
wells and groups, and also groups in general. In particular you can now
assign to a group variable:
DEFINE GUXXX WOPR * 0.25
- Actually hook up the evaluation of group variables from the Summary code.
That way, we won't have to pollute the Segment API when adding new
segment types. While here, also reduce header file coupling by
forward-declaring SpiralICD and Valve in Segment.hpp.
This commit adds a new type (Connection::CTFKind), and new data
member of this type (Connection::m_ctfkin, initialised in the
constructor) that tracks the source of the connection's
transmissibility factor (Connection::m_CF). The primary user of
this information is the restart file writing code which needs to
know if the connection transmissbility factor is assigned from the
input file (e.g., directly from the COMPDAT keyword) or if the value
is calculated from other information.
Add a convenience predicate function,
Connection::ctfAssignedFromInput
that returns true if the connection transmissibility factor source
indeed is a direct assignment in the COMPDAT keyword.
Update Connection constructor callers accordingly.
...
ParserKeyword: bool double_records set.
added keywords CECONT.
ParserKeywords: double_records set by keyword generator.
Parsertests: added test for parsing double_records.
ParserKeywords.parse: if double_records returns empty.
double_records keywords set to SLASH_TERMINATED.
...
ParserKeyword: for double records size_type = DOUBLE_SLASH_TERMINATED.
double_records: RawKeyword is Raw::DOUBLE_SLASH_TERMINATED.
RawKeyword uses m_isTempFinished.
Parser: can parse files with double-record keywords.
Parser.cpp/RawRecord.cpp: removed comments.
DeckKeyword has param m_isDoubleRecordKeyword.
test ParseDoubleRecords: double records to have linear structure.
DeckKeyword: Can create records of type double_record.
double-records parser test transferred to ParserTests.cpp.
...
...
