This at least slightly improves the old design. In that design the
subclass had no own constructor but inherited the one of the base class.
That base class constructor called certain subclass
functions (createGrids_, filterConnections_, updateOutputDir_, and
finalizeInit_)that would initialize raw pointers of the
subclass. Hence subclasses where not allowed to have non-pod members
and those used later (e.g. deleted in the destructor) had to be
initialized in these functions.
The new (still ugly) design introduces constructors into the
subclasses and skips inheriting constructors. Now one must call a base
class function classImplementationInit which will still call the
functions createGrids_, filterConnections_, updateOutputDir_, and
finalizeInit_, but at least at this point the baseclass is fully
constructed and the subclass is constructed as much as
possible/needed (non-pod types will be initialized now.)
In particular, the .type() function is renamed to .category(), and
it no longer returns a LibECL type. Similarly, the .num() function
has been renamed to .number().
i.e., the EclProblem does no longer need to implement the
`timeIntegration()` method itself. since `flow` does not use this code
path, it is unaffected.
this value is was chosen to exactly replicate `flow`'s behavior. IMO,
it would be less surprising to set the default to `1`, i.e., the user
needs to specify `--threads-per-process=$N` explicitly if
multithreaded linearization ought to be used.
`mebos` works similarly as `flow`, but in contrast to `flow`, `mebos`
only creates the deck in the common code path whilst the
'EclipseState' and the other higher-level parser objects are always
created internally by the vanguard. this approach avoids code
duplication and the worst effects of parser API creep.
to avoid having to compile non-trivial compile units multiple times,
the actual code of the variants is moved into `ebos_$VARIANT.{hh,cc}`
files and the respective compile units are each put into a small
static library whilst the main function of said libraries are invoked
by either the multiplexed or the respective specialized simulator's
`main()`. This is also somewhat similar of how `flow` works, with the
difference that `mebos` uses the blackoil variant to determine the
parameters it needs to know for parsing the deck instead of
introducing a "fake" type tag for this. The rationale is to reduce
compile time compared to the "fake type tag" approach and -- to a
lesser extend -- avoid unnecessary copy-and-pasting of code. In
particular, this means that for the vast majority of cases, only one
place needs changed in the code for all `ebos` variants if, for
example, the parser API requires further objects in the future.
this makes slightly incorrect decks usable with `ebos`. since the
common `flow` variants use a different code path to parse the deck,
they are unaffected. (as far as I can see, the only variant which
might be affected is `flow_ebos_oilwater_polymer_injectivity` and even
for it `flow`'s multiplexing code will abort the run before the
vanguard is even called.)
The intend is to make the purpose of `ebos` clearer: while it can be
used in production, the stability guarantees are somewhat lower than
for `flow` and testing is a bit less rigorous (most of the time).
