it seems like most build systems pass a -DHAVE_CONFIG_H flag to the
compiler which still causes `#if HAVE_CONFIG_H` to be false while it
clearly is supposed to be triggered.
That said, I do not really see a good reason why the inclusion of the
`config.h` file should be guarded in the first place: the file is
guaranteed to always available by proper build systems, and if it was
not included the build either breaks at the linking stage or -- at the
very least -- the runtime behavior of the resulting libraries will be
very awkward.
if PETSc is not available, the .cpp file will compile fine because it
will be reduced to be empty, but trying to include
LinearSolverPetsc.hpp in this case will result in an error.
This is quite a hack: Even though energy is not a "phase" and it is
also not considered in MaxNumPhases and pu.num_phases because this
would break a lot of assumptions in old code, it is nevertheless
assigned an "canonical index" that can be translated "active index"
via PhaseUsage::phase_pos[]. This awkwardness is needed because much
of the legacy OPM code conflates the concepts of "fluid phase" and
"conserved quantity" and fixing that issue would basically mean an
almost complete rewrite of much of the legacy code. That said, the
same statement applies to polymer and solvent, but these are currently
handled as even more second-class citizens because they are not even
given a canonical index and also cannot be translated into an active
one.
I originally wanted to make share_obj a class so that I could hide the
helper function, but it turned out that I needed a function after all
since a function template can be inferred from the parameters but the
type cannot from the constructor.
By returning a shared_ptr directly, the compiler can do return object
optimization.
Note 1: The initialization code now always consider 3 phases.
For 2-phase cases a trivial (0) state is returned.
Note 2: The initialization code does not compute a BlackoilStats,
but instead pass the initialization object with the initial state.
inconsistent and unnecessary.
this is purely a cosmetic change, the only exception was a function with
the generic name 'split', which was renamed to splitParam to avoid confusion.
in WellsGroup::updateWellProductionTargets. The current implementation
of group control is allowed tiny over-producing of the group target
while it cause negative rate_for_group_control . When all the wells are
not under group controls, it can cause oscillation of the control mode
later.
Probably a better way is to do something when we see overproducing
happens.
for each iteration. Even all the wells are under individual controls,
their group targets/constraints should also be updated for correct group
behavoirs.
When all production wells are under individual controls, the group can
have zero production guide rates, which can result NaN value targets for
injectors.
GCONINJE only support single phase injection. When we inject one phase,
the values of distr for other phases should be set to be zero.
It will provide one strategy to figure out which phase we are
injecting. It is important when we inject one phase while the well is
claimed to be another phase in WELSPECS.
it only handles the calculation based on wellPotentials though.
Or it should also give each well a value for wells does not specify a
guide rates? which will be some value same for all the wells?
this information is already part of the EclipseState. The reason why
this should IMO be avoided is that this enforces an implementation
(ordering of the permeability matrices) the simulator on the well
model. If this needs to be done for performance reasons, IMO it would
be smarter to pass an array of matrices, instead of passing a raw
array of doubles. I doubt that this is necessary, though: completing
the full Norne deck takes about 0.25 seconds longer on my machine,
that's substantially less than 0.1% of the total runtime.
in order to avoid code duplication, the permeability extraction
function of the RockFromDeck class is now made a public static
function and used as an implementation detail of the WellsManager.
finally, the permfield_valid_ attribute is removed from the
RockFromDeck class because this data was unused and not accessible via
the class' public API.
for the first time
Not sure it is always the better things to do here, while it can help
the consistence of the two current controls in the well_controls and
well_state.
When the group is producing its target, we consider it is converged.
When the group is not producing its target, while the group can not
produce more based on its own limits, we also consider it is converged.
When the group is not producing its target, while the group can
potentially produce more, we consider it is not converged.
to provide a better standard for the wells under individual control to
return to group control. For example, some wells get really big group
control limit and switch to individual control, it is very difficult for
them to return to group control with that kind of unreasonable fixed
group limit.
The reasoning behind this to make it possible to initialize the case
without SWATINIT in order to compute the same defaulted THPRES values as
Ecl. The initialization needs to be re-computed to account for SWATINIT
in the simulations.
this fixes some valgrind errors while doing the twophase capability
for flow_ebos: In all previously tested cases, these errors were
probably non-fatal because the memory illegally accessed here is
likely to be allocated (but after this function was finished it
contained garbage).
note that I'm not completely sure if this patch is semantically
correct, so I'd appreciate some input who understands it. (what is
"z"?)
When the group has wells both under individual control and group
control, since the well rates under individual control changes each
iteration, the well targets for this kind of group need to be updated
each iteration.
When we change to use implicit well potentials later, which is supposed
to be more accurate, we probably should always (unless we decided not to)
update the well targets each iteration.
it is for WellCollection, which is logically wrong. It should be done in
the group level, while things will be different for multi-level groups.
The current implementation basically works for current needs, that we
only have one group.
forced and only_group basically mean two opposite things. Having both of
them in the same context will be really confusing and error-prone.
And also, we do not do anything forcedly. We do things base on what
setup tells us to do.
Only_group may not be the final name, while deinitely a better one than
forced.
For the WellModel from the simulator to use. Not decided totally,
well_collection might need to be updated during the simualtion due
to the update the target of wells.
Current understanding. Two ways might prevent to return the guide_rate here
1. preventing the well from group control with keyword WGRUPCON
2. the well violating some limits and working under limits. We do not have strategy
to handle this situation yet.
Very hacky way here. The logic of the code is that only
a well is specified under GRUP control, it is under group
control. Which is not the case observed from the result.
From the result, if we specify group control with GCONPROD
and WCONPROD for a well, it looks like the well will be
under group control. TODO: make the logic correct here
instead of using `false` here.
