OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity
8860c598fe
opm-simulators/opm/simulators/wells/MultisegmentWell_impl.hpp

2305 lines
105 KiB
C++
Raw Normal View History

adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
/*
Copyright 2017 SINTEF Digital, Mathematics and Cybernetics.
Copyright 2017 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
MultisegmentWell: improve IDE experience
2024-02-23 01:45:25 -06:00
// Improve IDE experience
#ifndef OPM_MULTISEGMENTWELL_HEADER_INCLUDED
#define OPM_MULTISEGMENTWELL_IMPL_HEADER_INCLUDED
#include <config.h>
#include <opm/simulators/wells/MultisegmentWell.hpp>
#endif
use exception classes from opm-common
2022-12-13 05:54:27 -06:00
#include <opm/common/Exceptions.hpp>
#include <opm/common/OpmLog/OpmLog.hpp>
Hook New WBPn Calculation Up to Well Model This commit activates the support for calculating WBPn summary result values per well in parallel. To affect the calculation we add two new data members in BlackoilWellModelGeneric: - conn_idx_map_: Maps well's connection index (0..getConnections().size() - 1) to connections on current rank. Its local() connections are negative 1 (-1) if the connection is not on current rank, and a non-negative value otherwise. The global() function maps well connections on current rank to global connection ID for each well. Effectively the reverse of local(). Finally, the open() function maps well connections on current rank to open/flowing connections on current rank. Negative 1 if connection is not flowing. - wbpCalculationService: Parallel collection of WBPn calculation objects that knows how to exchange source and result information between all ranks in a communicator. Also handles distributed wells. We furthermore need a way to compute connection-level fluid mixture density values. For the standard well class we add a way to access the StandardWellConnection's 'perf_densities_' values. However, since these are defined for open/flowing connections only, this means we're not able to fully meet the requirements of the WELL/ALL WPAVE depth correction procedure for standard wells. The multi-segmented well type, on the other hand, uses the fluid mixture density in the associated well segment and is therefore well defined for ALL connections. OPEN well connections are supported for both well types.
2023-06-06 14:31:17 -05:00
#include <opm/input/eclipse/Schedule/MSW/Segment.hpp>
use exception classes from opm-common
2022-12-13 05:54:27 -06:00
#include <opm/input/eclipse/Schedule/MSW/Valve.hpp>
Hook New WBPn Calculation Up to Well Model This commit activates the support for calculating WBPn summary result values per well in parallel. To affect the calculation we add two new data members in BlackoilWellModelGeneric: - conn_idx_map_: Maps well's connection index (0..getConnections().size() - 1) to connections on current rank. Its local() connections are negative 1 (-1) if the connection is not on current rank, and a non-negative value otherwise. The global() function maps well connections on current rank to global connection ID for each well. Effectively the reverse of local(). Finally, the open() function maps well connections on current rank to open/flowing connections on current rank. Negative 1 if connection is not flowing. - wbpCalculationService: Parallel collection of WBPn calculation objects that knows how to exchange source and result information between all ranks in a communicator. Also handles distributed wells. We furthermore need a way to compute connection-level fluid mixture density values. For the standard well class we add a way to access the StandardWellConnection's 'perf_densities_' values. However, since these are defined for open/flowing connections only, this means we're not able to fully meet the requirements of the WELL/ALL WPAVE depth correction procedure for standard wells. The multi-segmented well type, on the other hand, uses the fluid mixture density in the associated well segment and is therefore well defined for ALL connections. OPEN well connections are supported for both well types.
2023-06-06 14:31:17 -05:00
#include <opm/input/eclipse/Schedule/MSW/WellSegments.hpp>
#include <opm/input/eclipse/Schedule/Well/Connection.hpp>
support WINJMULT
2023-06-21 04:48:57 -05:00
#include <opm/input/eclipse/Schedule/Well/WellConnections.hpp>
Hook New WBPn Calculation Up to Well Model This commit activates the support for calculating WBPn summary result values per well in parallel. To affect the calculation we add two new data members in BlackoilWellModelGeneric: - conn_idx_map_: Maps well's connection index (0..getConnections().size() - 1) to connections on current rank. Its local() connections are negative 1 (-1) if the connection is not on current rank, and a non-negative value otherwise. The global() function maps well connections on current rank to global connection ID for each well. Effectively the reverse of local(). Finally, the open() function maps well connections on current rank to open/flowing connections on current rank. Negative 1 if connection is not flowing. - wbpCalculationService: Parallel collection of WBPn calculation objects that knows how to exchange source and result information between all ranks in a communicator. Also handles distributed wells. We furthermore need a way to compute connection-level fluid mixture density values. For the standard well class we add a way to access the StandardWellConnection's 'perf_densities_' values. However, since these are defined for open/flowing connections only, this means we're not able to fully meet the requirements of the WELL/ALL WPAVE depth correction procedure for standard wells. The multi-segmented well type, on the other hand, uses the fluid mixture density in the associated well segment and is therefore well defined for ALL connections. OPEN well connections are supported for both well types.
2023-06-06 14:31:17 -05:00
clean up Units.hpp includes include it where required instead of relying on other headers to pull it in
2023-01-16 05:21:29 -06:00
#include <opm/input/eclipse/Units/Units.hpp>
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
MultisegmentWell: use {fmt} to format error messages
2022-12-20 05:42:09 -06:00
#include <opm/material/densead/EvaluationFormat.hpp>
added: MultisegmentWellAssemble this handles assembly of the equation system for multisegment well. start by moving assembleControlEq into the new class
2022-11-18 04:57:37 -06:00
#include <opm/simulators/wells/MultisegmentWellAssemble.hpp>
changed: move mostStrictBhpFromBhpLimits to WellBhpThpCalculator
2022-10-19 02:55:14 -05:00
#include <opm/simulators/wells/WellBhpThpCalculator.hpp>
Moved files to opm/simulators/ subdirs.
2019-05-07 06:06:02 -05:00
#include <opm/simulators/utils/DeferredLoggingErrorHelpers.hpp>
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
PI/II: Switch to Using Values Only We don't need to do the calculations in terms of EvalWell when we're going to reduce this to the .value() before calling the PI/II calculation routine. We can also get by with a simpler approach to computing the II by assuming we always inject pure phases and no cross flow in injectors. Suggested by: [at]atgeirr
2020-11-06 14:13:10 -06:00
#include <algorithm>
consistently use std::size_t
2023-08-15 02:32:10 -05:00
#include <cstddef>
#include <string>
PI/II: Switch to Using Values Only We don't need to do the calculations in terms of EvalWell when we're going to reduce this to the .value() before calling the PI/II calculation routine. We can also get by with a simpler approach to computing the II by assuming we always inject pure phases and no cross flow in injectors. Suggested by: [at]atgeirr
2020-11-06 14:13:10 -06:00
Rename bda to gpu for classes
2024-11-04 05:31:34 -06:00
#if COMPILE_GPU_BRIDGE && (HAVE_CUDA || HAVE_OPENCL)
#include <opm/simulators/linalg/gpubridge/WellContributions.hpp>
add StandardWellEval
2021-06-01 08:49:24 -05:00
#endif
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
namespace Opm
{
adding getHydorPressureLoss() to MultisegmentWell to handle the hydrostatic pressure loss.
2017-09-12 07:26:32 -05:00
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
MultisegmentWell<TypeTag>::
Make the parallel reduction when applying the Wells. The B matrix is basically a component-wise multiplication with a vector followed by a parallel reduction. We do that reduction to all ranks computing for the well to save the broadcast when applying C^T.
2020-10-09 08:09:28 -05:00
MultisegmentWell(const Well& well,
ParallelWellInfo: template Scalar type
2024-02-20 08:35:13 -06:00
const ParallelWellInfo<Scalar>& pw_info,
Make the parallel reduction when applying the Wells. The B matrix is basically a component-wise multiplication with a vector followed by a parallel reduction. We do that reduction to all ranks computing for the well to save the broadcast when applying C^T.
2020-10-09 08:09:28 -05:00
const int time_step,
Move Rateconverter and pvtIdx to the wellInterface
2017-11-23 01:37:30 -06:00
const ModelParameters& param,
const RateConverterType& rate_converter,
removing numComponents() from WellInterface which is dumplicated from BlackoilWellModel.
2017-11-30 09:31:48 -06:00
const int pvtRegionIdx,
Avoid using the Wells struct.
2019-10-23 02:09:45 -05:00
const int num_components,
const int num_phases,
const int index_of_well,
PerforationData: template Scalar type
2024-02-20 07:37:48 -06:00
const std::vector<PerforationData<Scalar>>& perf_data)
Remove first perf member from Well classes
2021-06-06 01:58:41 -05:00
: Base(well, pw_info, time_step, param, rate_converter, pvtRegionIdx, num_components, num_phases, index_of_well, perf_data)
Give the parallel well info object to the MultisegmentWellEval class as well
2024-09-30 01:55:00 -05:00
, MSWEval(static_cast<WellInterfaceIndices<FluidSystem,Indices>&>(*this), pw_info)
regularize MSW equation when iter > strict_inner_iter
2022-04-06 03:09:21 -05:00
, regularize_(false)
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
, segment_fluid_initial_(this->numberOfSegments(), std::vector<Scalar>(this->num_components_, 0.0))
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
{
throw for unsupported situations and fix warnings for MultisegmentWell.
2017-10-13 03:16:44 -05:00
// not handling solvent or polymer for now with multisegment well
use if constexpr to eliminate some solvent code
2021-05-14 14:38:47 -05:00
if constexpr (has_solvent) {
throw for unsupported situations and fix warnings for MultisegmentWell.
2017-10-13 03:16:44 -05:00
OPM_THROW(std::runtime_error, "solvent is not supported by multisegment well yet");
}
use if constexpr to eliminate some polymer code
2021-05-14 14:38:47 -05:00
if constexpr (has_polymer) {
throw for unsupported situations and fix warnings for MultisegmentWell.
2017-10-13 03:16:44 -05:00
OPM_THROW(std::runtime_error, "polymer is not supported by multisegment well yet");
}
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
make has_energy constexpr and use if constexpr to eliminate code
2021-05-14 14:49:47 -05:00
if constexpr (Base::has_energy) {
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
OPM_THROW(std::runtime_error, "energy is not supported by multisegment well yet");
some minor cleaning up
2019-04-12 03:43:30 -05:00
}
Add brine to output
2020-06-30 06:16:03 -05:00
use if constexpr to eliminate some foam code
2021-05-14 14:38:47 -05:00
if constexpr (Base::has_foam) {
Add brine to output
2020-06-30 06:16:03 -05:00
OPM_THROW(std::runtime_error, "foam is not supported by multisegment well yet");
}
use if constexpr to eliminate some brine code
2021-05-14 14:38:47 -05:00
if constexpr (Base::has_brine) {
Add brine to output
2020-06-30 06:16:03 -05:00
OPM_THROW(std::runtime_error, "brine is not supported by multisegment well yet");
}
add throw for case msw is true and vapwat is true
2022-05-11 04:50:54 -05:00
if constexpr (Base::has_watVapor) {
OPM_THROW(std::runtime_error, "water evaporation is not supported by multisegment well yet");
}
implement rsrv item 10 WCONINJE MSW not supported yet
2022-04-21 04:03:11 -05:00
if(this->rsRvInj() > 0) {
MultisegmentWell: avoid use of sstream
2023-01-02 08:24:35 -06:00
OPM_THROW(std::runtime_error,
"dissolved gas/ vapporized oil in injected oil/gas not supported by multisegment well yet."
" \n See (WCONINJE item 10 / WCONHIST item 8)");
implement rsrv item 10 WCONINJE MSW not supported yet
2022-04-21 04:03:11 -05:00
}
Support gas dissolution in water (Rsw) - adapt to interface change in waterPvt() - add gas + water + disgasw simulator Note - MSW is not supported - EQUIL initialization is not supported
2022-11-24 07:32:41 -06:00
if constexpr (!Indices::oilEnabled && Indices::numPhases > 1) {
OPM_THROW(std::runtime_error, "water + gas case not supported by multisegment well yet");
}
move updateWellStateWithTHPTargetProd to WellInterface to share implementation between STW and MSW
2023-05-12 04:57:48 -05:00
this->thp_update_iterations = true;
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
}
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
void
MultisegmentWell<TypeTag>::
init(const PhaseUsage* phase_usage_arg,
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const std::vector<Scalar>& depth_arg,
const Scalar gravity_arg,
dont use explicit vfp lookup for newly opened wells
2022-04-12 01:44:52 -05:00
const std::vector< Scalar >& B_avg,
const bool changed_to_open_this_step)
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
{
Remove unused num_cells argument from well equations
2024-10-10 11:53:47 -05:00
Base::init(phase_usage_arg, depth_arg, gravity_arg, B_avg, changed_to_open_this_step);
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
// TODO: for StandardWell, we need to update the perf depth here using depth_arg.
// for MultisegmentWell, it is much more complicated.
// It can be specified directly, it can be calculated from the segment depth,
// it can also use the cell center, which is the same for StandardWell.
// For the last case, should we update the depth with the depth_arg? For the
// future, it can be a source of wrong result with Multisegment well.
adding initMSWell() to handle MS well related WellState.
2017-08-31 11:22:48 -05:00
// An indicator from the opm-parser should indicate what kind of depth we should use here.
when encountering a multisegment well we create a multisegment well instead of treating all the wells as StandardWell. Making it compile.
2017-09-01 10:37:51 -05:00
// \Note: we do not update the depth here. And it looks like for now, we only have the option to use
// specified perforation depth
Remove unused num_cells argument from well equations
2024-10-10 11:53:47 -05:00
this->initMatrixAndVectors();
adding getHydorPressureLoss() to MultisegmentWell to handle the hydrostatic pressure loss.
2017-09-12 07:26:32 -05:00
fixing some typos in MultisegmentWell_impl.hpp
2022-11-05 16:51:59 -05:00
// calculate the depth difference between the perforations and the perforated grid block
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
for (int local_perf_index = 0; local_perf_index < this->number_of_perforations_; ++local_perf_index) {
// This variable loops over the number_of_perforations_ of *this* process, hence it is *local*.
const int cell_idx = this->well_cells_[local_perf_index];
this->cell_perforation_depth_diffs_[local_perf_index] = depth_arg[cell_idx] - this->perf_depth_[local_perf_index];
adding getHydorPressureLoss() to MultisegmentWell to handle the hydrostatic pressure loss.
2017-09-12 07:26:32 -05:00
}
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
}
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
void
MultisegmentWell<TypeTag>::
WellInterface: make initPrimaryVariablesEvaluation non-const this will obviously modify well state
2022-11-09 06:01:30 -06:00
initPrimaryVariablesEvaluation()
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
{
added: MultisegmentWellPrimaryVariables this is a container class for the primary variables in multisegment well
2022-11-07 23:38:12 -06:00
this->primary_variables_.init();
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
}
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
void
MultisegmentWell<TypeTag>::
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
updatePrimaryVariables(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
const WellState<Scalar>& well_state,
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
DeferredLogger& deferred_logger)
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
{
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
const bool stop_or_zero_rate_target = this->stoppedOrZeroRateTarget(simulator, well_state, deferred_logger);
combining wellIsStopped and wellUnderZeroRateTaget for better readability.
2023-03-29 07:33:05 -05:00
this->primary_variables_.update(well_state, stop_or_zero_rate_target);
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
}
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
updateWellStateWithTarget(const Simulator& simulator,
GroupState: template Scalar type
2024-02-17 11:13:46 -06:00
const GroupState<Scalar>& group_state,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
WellState<Scalar>& well_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-05 04:22:44 -05:00
DeferredLogger& deferred_logger) const
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
{
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
Base::updateWellStateWithTarget(simulator, group_state, well_state, deferred_logger);
Initial well rates with the well potentials and scale the segment rates Initialize the well rates with well potentials when computing rates from bhp or bhp(thp) The bhp was already initialized. Scale the segment rates and pressure to adapt to changes in well rate and bhp Improves convergence of the well potential calculations
2020-12-14 08:55:14 -06:00
// scale segment rates based on the wellRates
// and segment pressure based on bhp
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
this->scaleSegmentRatesWithWellRates(this->segments_.inlets(),
this->segments_.perforations(),
move segment_inlets_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
well_state);
add MultisegmentWellGeneric avoid rebuilding this for all simulators when code is only dependent on Scalar. instanced for double
2021-06-03 08:34:14 -05:00
this->scaleSegmentPressuresWithBhp(well_state);
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
}
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
Rename ConvergenceStatus -> ConvergenceReport.
2018-10-25 04:57:47 -05:00
ConvergenceReport
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
MultisegmentWell<TypeTag>::
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
getWellConvergence(const Simulator& /* simulator */,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
const WellState<Scalar>& well_state,
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const std::vector<Scalar>& B_avg,
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
DeferredLogger& deferred_logger,
const bool relax_tolerance) const
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
{
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
return this->MSWEval::getWellConvergence(well_state,
B_avg,
deferred_logger,
drop using statement for param_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
this->param_.max_residual_allowed_,
this->param_.tolerance_wells_,
add option for relaxed convergence for stw
2021-09-06 03:08:28 -05:00
this->param_.relaxed_tolerance_flow_well_,
drop using statement for param_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
this->param_.tolerance_pressure_ms_wells_,
add option for relaxed convergence for stw
2021-09-06 03:08:28 -05:00
this->param_.relaxed_tolerance_pressure_ms_well_,
fix well-convergence for well-copies
2023-11-08 14:07:47 -06:00
relax_tolerance,
this->wellIsStopped());
stricter tolerance for wells with zero rate target for StandardWell only at this moment.
2023-03-30 08:49:27 -05:00
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
}
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
void
MultisegmentWell<TypeTag>::
when encountering a multisegment well we create a multisegment well instead of treating all the wells as StandardWell. Making it compile.
2017-09-01 10:37:51 -05:00
apply(const BVector& x, BVector& Ax) const
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
{
added: MultisegmentWellEquations::apply(x,Ax) this applies the equation system to a vector. use the new method in the well implementation.
2022-11-11 14:41:24 -06:00
if (!this->isOperableAndSolvable() && !this->wellIsStopped()) {
return;
}
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
added: MultisegmentWellEquations::apply(x,Ax) this applies the equation system to a vector. use the new method in the well implementation.
2022-11-11 14:41:24 -06:00
if (this->param_.matrix_add_well_contributions_) {
Implement addWellContributions() for MultisegmentWell.
2020-10-29 06:57:29 -05:00
// Contributions are already in the matrix itself
return;
}
using function invDX to implement functions in MultisegmentWell it compiles, while not sure how it gonna work.
2017-09-13 10:48:08 -05:00
added: MultisegmentWellEquations::apply(x,Ax) this applies the equation system to a vector. use the new method in the well implementation.
2022-11-11 14:41:24 -06:00
this->linSys_.apply(x, Ax);
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
}
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
void
MultisegmentWell<TypeTag>::
apply(BVector& r) const
{
added: MultisegmentWellEquations::apply(r) this applies the equation system to a vector. use the new method in the well implementation.
2022-11-11 14:41:24 -06:00
if (!this->isOperableAndSolvable() && !this->wellIsStopped()) {
return;
}
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
added: MultisegmentWellEquations::apply(r) this applies the equation system to a vector. use the new method in the well implementation.
2022-11-11 14:41:24 -06:00
this->linSys_.apply(r);
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
}
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
void
MultisegmentWell<TypeTag>::
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
recoverWellSolutionAndUpdateWellState(const Simulator& simulator,
make sure zero production rates are obtained for the following wells 1. stopped production wells 2. production wells under zero rate control We guarantee the objective through enforce zero values for the WQTotal primary variable during the initialization and update process during the Newton solution.
2023-03-22 09:10:00 -05:00
const BVector& x,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
WellState<Scalar>& well_state,
WellInterface: make recoverWellSolutionAndUpdateWellState non-const this will obviously modify well state
2022-11-09 06:01:30 -06:00
DeferredLogger& deferred_logger)
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
{
added: MultisegmentWellEquations::recoverSolutionWell() this recovers the well solution from a solution vector. use the new method in the well implementation.
2022-11-11 14:41:24 -06:00
if (!this->isOperableAndSolvable() && !this->wellIsStopped()) {
return;
}
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
implement recoverWellSolutionAndUpdateWellState for MultisegmentWell_impl.
2017-09-18 09:31:11 -05:00
BVectorWell xw(1);
added: MultisegmentWellEquations::recoverSolutionWell() this recovers the well solution from a solution vector. use the new method in the well implementation.
2022-11-11 14:41:24 -06:00
this->linSys_.recoverSolutionWell(x, xw);
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
updateWellState(simulator, xw, well_state, deferred_logger);
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
}
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellPotentials(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
const WellState<Scalar>& well_state,
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar>& well_potentials,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-05 04:22:44 -05:00
DeferredLogger& deferred_logger)
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
{
reorganize (Std|MS)Well::computeWellPotentials put shared parts in WellInterfaceGeneric::computeWellPotentials and WellInterfaceGeneric::checkNegativeWellPotentials
2023-05-12 05:53:59 -05:00
const auto [compute_potential, bhp_controlled_well] =
WellInterfaceGeneric: template Scalar type
2024-02-19 07:34:38 -06:00
this->WellInterfaceGeneric<Scalar>::computeWellPotentials(well_potentials, well_state);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
reorganize (Std|MS)Well::computeWellPotentials put shared parts in WellInterfaceGeneric::computeWellPotentials and WellInterfaceGeneric::checkNegativeWellPotentials
2023-05-12 05:53:59 -05:00
if (!compute_potential) {
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
return;
}
use rates for potentials for pressure controlled (bhp or thp) controled wells
2021-05-25 08:24:00 -05:00
dont copy the well model in computeWellPotentials
2020-12-22 02:25:56 -06:00
debug_cost_counter_ = 0;
revert changes
2023-10-26 10:28:05 -05:00
bool converged_implicit = false;
if (this->param_.local_well_solver_control_switching_) {
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
converged_implicit = computeWellPotentialsImplicit(simulator, well_potentials, deferred_logger);
revert changes
2023-10-26 10:28:05 -05:00
if (!converged_implicit) {
deferred_logger.debug("Implicit potential calculations failed for well "
+ this->name() + ", reverting to original aproach.");
}
}
if (!converged_implicit) {
// does the well have a THP related constraint?
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& summaryState = simulator.vanguard().summaryState();
revert changes
2023-10-26 10:28:05 -05:00
if (!Base::wellHasTHPConstraints(summaryState) || bhp_controlled_well) {
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesAtBhpLimit(simulator, well_potentials, deferred_logger);
revert changes
2023-10-26 10:28:05 -05:00
} else {
well_potentials = computeWellPotentialWithTHP(
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
well_state, simulator, deferred_logger);
revert changes
2023-10-26 10:28:05 -05:00
}
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
}
deferred_logger.debug("Cost in iterations of finding well potential for well "
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
+ this->name() + ": " + std::to_string(debug_cost_counter_));
Mark wells with negative and trivial potentials as not operable The simulator will try to compute potentials at every iterations to try to reopen the well.
2021-11-18 05:57:16 -06:00
reorganize (Std|MS)Well::computeWellPotentials put shared parts in WellInterfaceGeneric::computeWellPotentials and WellInterfaceGeneric::checkNegativeWellPotentials
2023-05-12 05:53:59 -05:00
this->checkNegativeWellPotentials(well_potentials,
this->param_.check_well_operability_,
deferred_logger);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
}
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
template<typename TypeTag>
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesAtBhpLimit(const Simulator& simulator,
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar>& well_flux,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-05 04:22:44 -05:00
DeferredLogger& deferred_logger) const
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
{
drop using statement for well_ecl_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
if (this->well_ecl_.isInjector()) {
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto controls = this->well_ecl_.injectionControls(simulator.vanguard().summaryState());
computeWellRatesWithBhpIterations(simulator, controls.bhp_limit, well_flux, deferred_logger);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
} else {
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto controls = this->well_ecl_.productionControls(simulator.vanguard().summaryState());
computeWellRatesWithBhpIterations(simulator, controls.bhp_limit, well_flux, deferred_logger);
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
}
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
}
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
template<typename TypeTag>
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesWithBhp(const Simulator& simulator,
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar& bhp,
std::vector<Scalar>& well_flux,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-05 04:22:44 -05:00
DeferredLogger& deferred_logger) const
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
{
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
const int np = this->number_of_phases_;
well_flux.resize(np, 0.0);
const bool allow_cf = this->getAllowCrossFlow();
const int nseg = this->numberOfSegments();
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
const WellState<Scalar>& well_state = simulator.problem().wellModel().wellState();
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
const auto& ws = well_state.well(this->indexOfWell());
auto segments_copy = ws.segments;
segments_copy.scale_pressure(bhp);
const auto& segment_pressure = segments_copy.pressure;
for (int seg = 0; seg < nseg; ++seg) {
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
for (const int perf : this->segments_.perforations()[seg]) {
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const int local_perf_index = this->pw_info_.globalToLocal(perf);
if (local_perf_index < 0) // then the perforation is not on this process
continue;
const int cell_idx = this->well_cells_[local_perf_index];
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& intQuants = simulator.model().intensiveQuantities(cell_idx, /*timeIdx=*/ 0);
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
// flux for each perforation
std::vector<Scalar> mob(this->num_components_, 0.);
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
getMobility(simulator, local_perf_index, mob, deferred_logger);
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar trans_mult = simulator.problem().template wellTransMultiplier<Scalar>(intQuants, cell_idx);
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& wellstate_nupcol = simulator.problem().wellModel().nupcolWellState().well(this->index_of_well_);
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const std::vector<Scalar> Tw = this->wellIndex(local_perf_index, intQuants, trans_mult, wellstate_nupcol);
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
const Scalar seg_pressure = segment_pressure[seg];
std::vector<Scalar> cq_s(this->num_components_, 0.);
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
Scalar perf_press = 0.0;
PerforationRates: template Scalar type
2024-02-20 07:18:30 -06:00
PerforationRates<Scalar> perf_rates;
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
computePerfRate(intQuants, mob, Tw, seg, perf, seg_pressure,
allow_cf, cq_s, perf_press, perf_rates, deferred_logger);
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
for(int p = 0; p < np; ++p) {
WellInterfaceIndices: rename ebosCompIdxToFlowCompIdx to modelCompIdxToFlowCompIdx
2024-02-06 05:12:13 -06:00
well_flux[this->modelCompIdxToFlowCompIdx(p)] += cq_s[p];
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
}
}
}
this->parallel_well_info_.communication().sum(well_flux.data(), well_flux.size());
}
template<typename TypeTag>
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesWithBhpIterations(const Simulator& simulator,
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
const Scalar& bhp,
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar>& well_flux,
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
DeferredLogger& deferred_logger) const
{
fixing some typos in MultisegmentWell_impl.hpp
2022-11-05 16:51:59 -05:00
// creating a copy of the well itself, to avoid messing up the explicit information
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
// during this copy, the only information not copied properly is the well controls
MultisegmentWell<TypeTag> well_copy(*this);
Resetting WINJMULT dampening factors before fixed BHP calculations
2024-10-10 02:25:28 -05:00
well_copy.resetDampening();
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
well_copy.debug_cost_counter_ = 0;
Address PR comments
2019-05-24 09:45:27 -05:00
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
// store a copy of the well state, we don't want to update the real well state
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
WellState<Scalar> well_state_copy = simulator.problem().wellModel().wellState();
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& group_state = simulator.problem().wellModel().groupState();
Add trivial class SingleWellState with bhp and thp
2021-08-03 13:05:14 -05:00
auto& ws = well_state_copy.well(this->index_of_well_);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
Refactor solving functions to take control objects directly. This allows us to avoid some very hacky manipulation of the Well object.
2019-12-05 05:40:35 -06:00
// Get the current controls.
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& summary_state = simulator.vanguard().summaryState();
Refactor solving functions to take control objects directly. This allows us to avoid some very hacky manipulation of the Well object.
2019-12-05 05:40:35 -06:00
auto inj_controls = well_copy.well_ecl_.isInjector()
? well_copy.well_ecl_.injectionControls(summary_state)
: Well::InjectionControls(0);
auto prod_controls = well_copy.well_ecl_.isProducer()
? well_copy.well_ecl_.productionControls(summary_state) :
Well::ProductionControls(0);
// Set current control to bhp, and bhp value in state, modify bhp limit in control object.
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
if (well_copy.well_ecl_.isInjector()) {
Refactor solving functions to take control objects directly. This allows us to avoid some very hacky manipulation of the Well object.
2019-12-05 05:40:35 -06:00
inj_controls.bhp_limit = bhp;
Use SingleWellState for production and injection control
2021-08-04 05:03:36 -05:00
ws.injection_cmode = Well::InjectorCMode::BHP;
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
} else {
Refactor solving functions to take control objects directly. This allows us to avoid some very hacky manipulation of the Well object.
2019-12-05 05:40:35 -06:00
prod_controls.bhp_limit = bhp;
Use SingleWellState for production and injection control
2021-08-04 05:03:36 -05:00
ws.production_cmode = Well::ProducerCMode::BHP;
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
}
Add trivial class SingleWellState with bhp and thp
2021-08-03 13:05:14 -05:00
ws.bhp = bhp;
some cleanup
2020-12-16 05:58:17 -06:00
well_copy.scaleSegmentPressuresWithBhp(well_state_copy);
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
Initial well rates with the well potentials and scale the segment rates Initialize the well rates with well potentials when computing rates from bhp or bhp(thp) The bhp was already initialized. Scale the segment rates and pressure to adapt to changes in well rate and bhp Improves convergence of the well potential calculations
2020-12-14 08:55:14 -06:00
// initialized the well rates with the potentials i.e. the well rates based on bhp
drop using statement for number_of_phases_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
const int np = this->number_of_phases_;
improve initialization msw new wells
2022-03-23 06:29:40 -05:00
bool trivial = true;
Initial well rates with the well potentials and scale the segment rates Initialize the well rates with well potentials when computing rates from bhp or bhp(thp) The bhp was already initialized. Scale the segment rates and pressure to adapt to changes in well rate and bhp Improves convergence of the well potential calculations
2020-12-14 08:55:14 -06:00
for (int phase = 0; phase < np; ++phase){
improve initialization msw new wells
2022-03-23 06:29:40 -05:00
trivial = trivial && (ws.well_potentials[phase] == 0.0) ;
}
if (!trivial) {
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar sign = well_copy.well_ecl_.isInjector() ? 1.0 : -1.0;
improve initialization msw new wells
2022-03-23 06:29:40 -05:00
for (int phase = 0; phase < np; ++phase) {
ws.surface_rates[phase] = sign * ws.well_potentials[phase];
}
Initial well rates with the well potentials and scale the segment rates Initialize the well rates with well potentials when computing rates from bhp or bhp(thp) The bhp was already initialized. Scale the segment rates and pressure to adapt to changes in well rate and bhp Improves convergence of the well potential calculations
2020-12-14 08:55:14 -06:00
}
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
well_copy.scaleSegmentRatesWithWellRates(this->segments_.inlets(),
this->segments_.perforations(),
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
well_state_copy);
Initial well rates with the well potentials and scale the segment rates Initialize the well rates with well potentials when computing rates from bhp or bhp(thp) The bhp was already initialized. Scale the segment rates and pressure to adapt to changes in well rate and bhp Improves convergence of the well potential calculations
2020-12-14 08:55:14 -06:00
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
well_copy.calculateExplicitQuantities(simulator, well_state_copy, deferred_logger);
const double dt = simulator.timeStepSize();
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
// iterate to get a solution at the given bhp.
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
well_copy.iterateWellEqWithControl(simulator, dt, inj_controls, prod_controls, well_state_copy, group_state,
renaming solveWellEqUntilConverged to be iterateWellEquations
2020-06-02 07:54:45 -05:00
deferred_logger);
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
// compute the potential and store in the flux vector.
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
well_flux.clear();
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
well_flux.resize(np, 0.0);
drop using statement for num_components_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
for (int compIdx = 0; compIdx < this->num_components_; ++compIdx) {
MultisegmentWell: move getQs to MultisegmentWellPrimaryVariables
2022-12-19 02:52:48 -06:00
const EvalWell rate = well_copy.primary_variables_.getQs(compIdx);
WellInterfaceIndices: rename ebosCompIdxToFlowCompIdx to modelCompIdxToFlowCompIdx
2024-02-06 05:12:13 -06:00
well_flux[this->modelCompIdxToFlowCompIdx(compIdx)] = rate.value();
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
}
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
debug_cost_counter_ += well_copy.debug_cost_counter_;
}
template<typename TypeTag>
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<typename MultisegmentWell<TypeTag>::Scalar>
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
MultisegmentWell<TypeTag>::
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
computeWellPotentialWithTHP(const WellState<Scalar>& well_state,
const Simulator& simulator,
DeferredLogger& deferred_logger) const
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
{
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> potentials(this->number_of_phases_, 0.0);
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& summary_state = simulator.vanguard().summaryState();
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
drop using statement for well_ecl_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
const auto& well = this->well_ecl_;
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
if (well.isInjector()) {
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
auto bhp_at_thp_limit = computeBhpAtThpLimitInj(simulator, summary_state, deferred_logger);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
if (bhp_at_thp_limit) {
drop using statement for well_ecl_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
const auto& controls = well.injectionControls(summary_state);
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar bhp = std::min(*bhp_at_thp_limit,
static_cast<Scalar>(controls.bhp_limit));
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesWithBhpIterations(simulator, bhp, potentials, deferred_logger);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
deferred_logger.debug("Converged thp based potential calculation for well "
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
+ this->name() + ", at bhp = " + std::to_string(bhp));
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
} else {
deferred_logger.warning("FAILURE_GETTING_CONVERGED_POTENTIAL",
"Failed in getting converged thp based potential calculation for well "
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
+ this->name() + ". Instead the bhp based value is used");
drop using statement for well_ecl_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
const auto& controls = well.injectionControls(summary_state);
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar bhp = controls.bhp_limit;
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesWithBhpIterations(simulator, bhp, potentials, deferred_logger);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
}
} else {
Add gaslift optimization support for MSW. Implements gas lift optimization support for multisegmented wells (MSW).
2022-02-07 04:28:35 -06:00
auto bhp_at_thp_limit = computeBhpAtThpLimitProd(
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
well_state, simulator, summary_state, deferred_logger);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
if (bhp_at_thp_limit) {
drop using statement for well_ecl_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
const auto& controls = well.productionControls(summary_state);
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar bhp = std::max(*bhp_at_thp_limit,
static_cast<Scalar>(controls.bhp_limit));
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesWithBhpIterations(simulator, bhp, potentials, deferred_logger);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
deferred_logger.debug("Converged thp based potential calculation for well "
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
+ this->name() + ", at bhp = " + std::to_string(bhp));
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
} else {
deferred_logger.warning("FAILURE_GETTING_CONVERGED_POTENTIAL",
"Failed in getting converged thp based potential calculation for well "
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
+ this->name() + ". Instead the bhp based value is used");
drop using statement for well_ecl_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
const auto& controls = well.productionControls(summary_state);
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar bhp = controls.bhp_limit;
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesWithBhpIterations(simulator, bhp, potentials, deferred_logger);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
}
}
return potentials;
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
}
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
revert changes
2023-10-26 10:28:05 -05:00
template<typename TypeTag>
bool
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellPotentialsImplicit(const Simulator& simulator,
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar>& well_potentials,
revert changes
2023-10-26 10:28:05 -05:00
DeferredLogger& deferred_logger) const
{
// Create a copy of the well.
// TODO: check if we can avoid taking multiple copies. Call from updateWellPotentials
// is allready a copy, but not from other calls.
MultisegmentWell<TypeTag> well_copy(*this);
well_copy.debug_cost_counter_ = 0;
// store a copy of the well state, we don't want to update the real well state
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
WellState<Scalar> well_state_copy = simulator.problem().wellModel().wellState();
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& group_state = simulator.problem().wellModel().groupState();
revert changes
2023-10-26 10:28:05 -05:00
auto& ws = well_state_copy.well(this->index_of_well_);
// get current controls
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& summary_state = simulator.vanguard().summaryState();
revert changes
2023-10-26 10:28:05 -05:00
auto inj_controls = well_copy.well_ecl_.isInjector()
? well_copy.well_ecl_.injectionControls(summary_state)
: Well::InjectionControls(0);
auto prod_controls = well_copy.well_ecl_.isProducer()
? well_copy.well_ecl_.productionControls(summary_state)
: Well::ProductionControls(0);
// prepare/modify well state and control
well_copy.prepareForPotentialCalculations(summary_state, well_state_copy, inj_controls, prod_controls);
well_copy.scaleSegmentPressuresWithBhp(well_state_copy);
// initialize rates from previous potentials
const int np = this->number_of_phases_;
bool trivial = true;
for (int phase = 0; phase < np; ++phase){
trivial = trivial && (ws.well_potentials[phase] == 0.0) ;
}
if (!trivial) {
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar sign = well_copy.well_ecl_.isInjector() ? 1.0 : -1.0;
revert changes
2023-10-26 10:28:05 -05:00
for (int phase = 0; phase < np; ++phase) {
ws.surface_rates[phase] = sign * ws.well_potentials[phase];
}
}
well_copy.scaleSegmentRatesWithWellRates(this->segments_.inlets(),
this->segments_.perforations(),
well_state_copy);
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
well_copy.calculateExplicitQuantities(simulator, well_state_copy, deferred_logger);
const double dt = simulator.timeStepSize();
revert changes
2023-10-26 10:28:05 -05:00
// solve equations
include thp-solve for potentials
2023-11-07 10:29:50 -06:00
bool converged = false;
if (this->well_ecl_.isProducer() && this->wellHasTHPConstraints(summary_state)) {
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
converged = well_copy.solveWellWithTHPConstraint(simulator, dt, inj_controls, prod_controls, well_state_copy, group_state, deferred_logger);
include thp-solve for potentials
2023-11-07 10:29:50 -06:00
} else {
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
converged = well_copy.iterateWellEqWithSwitching(simulator, dt, inj_controls, prod_controls, well_state_copy, group_state, deferred_logger);
include thp-solve for potentials
2023-11-07 10:29:50 -06:00
}
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
revert changes
2023-10-26 10:28:05 -05:00
// fetch potentials (sign is updated on the outside).
well_potentials.clear();
well_potentials.resize(np, 0.0);
for (int compIdx = 0; compIdx < this->num_components_; ++compIdx) {
const EvalWell rate = well_copy.primary_variables_.getQs(compIdx);
WellInterfaceIndices: rename ebosCompIdxToFlowCompIdx to modelCompIdxToFlowCompIdx
2024-02-06 05:12:13 -06:00
well_potentials[this->modelCompIdxToFlowCompIdx(compIdx)] = rate.value();
revert changes
2023-10-26 10:28:05 -05:00
}
debug_cost_counter_ += well_copy.debug_cost_counter_;
return converged;
}
adding comments for MultisegmentWell
2017-08-29 10:26:36 -05:00
Revert "removing unused function solveEqAndUpdateWellState" This reverts commit 7931e6e00a21e68f85a1cf306784747e4e06ac28.
2023-04-21 02:10:10 -05:00
template <typename TypeTag>
void
MultisegmentWell<TypeTag>::
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
solveEqAndUpdateWellState(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
WellState<Scalar>& well_state,
Revert "removing unused function solveEqAndUpdateWellState" This reverts commit 7931e6e00a21e68f85a1cf306784747e4e06ac28.
2023-04-21 02:10:10 -05:00
DeferredLogger& deferred_logger)
{
if (!this->isOperableAndSolvable() && !this->wellIsStopped()) return;
// We assemble the well equations, then we check the convergence,
// which is why we do not put the assembleWellEq here.
Make sure that problems with singular matrices are logged. Previously, if the problem occured on an MPI process with rank other than zero the the logging would not seen (at least in the output files). Now together with the previous commit the problem should be logged together with the well name and calling method.
2023-12-04 16:15:08 -06:00
try{
const BVectorWell dx_well = this->linSys_.solve();
Revert "removing unused function solveEqAndUpdateWellState" This reverts commit 7931e6e00a21e68f85a1cf306784747e4e06ac28.
2023-04-21 02:10:10 -05:00
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
updateWellState(simulator, dx_well, well_state, deferred_logger);
Make sure that problems with singular matrices are logged. Previously, if the problem occured on an MPI process with rank other than zero the the logging would not seen (at least in the output files). Now together with the previous commit the problem should be logged together with the well name and calling method.
2023-12-04 16:15:08 -06:00
}
catch(const NumericalProblem& exp) {
// Add information about the well and log to deferred logger
// (Logging done inside of solve() method will only be seen if
// this is the process with rank zero)
deferred_logger.problem("In MultisegmentWell::solveEqAndUpdateWellState for well "
+ this->name() +": "+exp.what());
throw;
}
Revert "removing unused function solveEqAndUpdateWellState" This reverts commit 7931e6e00a21e68f85a1cf306784747e4e06ac28.
2023-04-21 02:10:10 -05:00
}
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding a few functions to calculate the fractions in MultisegmentWell
2017-09-05 08:16:04 -05:00
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computePerfCellPressDiffs(const Simulator& simulator)
adding a few functions to calculate the fractions in MultisegmentWell
2017-09-05 08:16:04 -05:00
{
drop using statement for number_of_perforations_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
for (int perf = 0; perf < this->number_of_perforations_; ++perf) {
implementing computePerfCellPressDiffs to calculate the pressure difference between perforation and perforated grid cell.
2017-09-29 02:39:32 -05:00
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> kr(this->number_of_phases_, 0.0);
std::vector<Scalar> density(this->number_of_phases_, 0.0);
implementing computePerfCellPressDiffs to calculate the pressure difference between perforation and perforated grid cell.
2017-09-29 02:39:32 -05:00
drop using statement for well_cells_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
const int cell_idx = this->well_cells_[perf];
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& intQuants = simulator.model().intensiveQuantities(cell_idx, /*timeIdx=*/ 0);
implementing computePerfCellPressDiffs to calculate the pressure difference between perforation and perforated grid cell.
2017-09-29 02:39:32 -05:00
const auto& fs = intQuants.fluidState();
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
Scalar sum_kr = 0.;
implementing computePerfCellPressDiffs to calculate the pressure difference between perforation and perforated grid cell.
2017-09-29 02:39:32 -05:00
drop using statement for phaseUsage rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
const PhaseUsage& pu = this->phaseUsage();
replacing BlackoilPhases:: with Oil Water Gas in well model and also WellStateFullyImplicitBlackoil. There are more places to do so, while it might be easier to create a header file for this.
2017-11-16 04:42:34 -06:00
if (pu.phase_used[Water]) {
const int water_pos = pu.phase_pos[Water];
implementing computePerfCellPressDiffs to calculate the pressure difference between perforation and perforated grid cell.
2017-09-29 02:39:32 -05:00
kr[water_pos] = intQuants.relativePermeability(FluidSystem::waterPhaseIdx).value();
sum_kr += kr[water_pos];
density[water_pos] = fs.density(FluidSystem::waterPhaseIdx).value();
}
replacing BlackoilPhases:: with Oil Water Gas in well model and also WellStateFullyImplicitBlackoil. There are more places to do so, while it might be easier to create a header file for this.
2017-11-16 04:42:34 -06:00
if (pu.phase_used[Oil]) {
const int oil_pos = pu.phase_pos[Oil];
implementing computePerfCellPressDiffs to calculate the pressure difference between perforation and perforated grid cell.
2017-09-29 02:39:32 -05:00
kr[oil_pos] = intQuants.relativePermeability(FluidSystem::oilPhaseIdx).value();
sum_kr += kr[oil_pos];
density[oil_pos] = fs.density(FluidSystem::oilPhaseIdx).value();
}
replacing BlackoilPhases:: with Oil Water Gas in well model and also WellStateFullyImplicitBlackoil. There are more places to do so, while it might be easier to create a header file for this.
2017-11-16 04:42:34 -06:00
if (pu.phase_used[Gas]) {
const int gas_pos = pu.phase_pos[Gas];
implementing computePerfCellPressDiffs to calculate the pressure difference between perforation and perforated grid cell.
2017-09-29 02:39:32 -05:00
kr[gas_pos] = intQuants.relativePermeability(FluidSystem::gasPhaseIdx).value();
sum_kr += kr[gas_pos];
density[gas_pos] = fs.density(FluidSystem::gasPhaseIdx).value();
}
assert(sum_kr != 0.);
// calculate the average density
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
Scalar average_density = 0.;
drop using statement for number_of_phases_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
for (int p = 0; p < this->number_of_phases_; ++p) {
implementing computePerfCellPressDiffs to calculate the pressure difference between perforation and perforated grid cell.
2017-09-29 02:39:32 -05:00
average_density += kr[p] * density[p];
}
average_density /= sum_kr;
drop using statement for gravity_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
this->cell_perforation_pressure_diffs_[perf] = this->gravity_ * average_density * this->cell_perforation_depth_diffs_[perf];
implementing computePerfCellPressDiffs to calculate the pressure difference between perforation and perforated grid cell.
2017-09-29 02:39:32 -05:00
}
adding a few functions to calculate the fractions in MultisegmentWell
2017-09-05 08:16:04 -05:00
}
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding a few functions to calculate the fractions in MultisegmentWell
2017-09-05 08:16:04 -05:00
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeInitialSegmentFluids(const Simulator& simulator)
adding a few functions to calculate the fractions in MultisegmentWell
2017-09-05 08:16:04 -05:00
{
add MultisegmentWellGeneric avoid rebuilding this for all simulators when code is only dependent on Scalar. instanced for double
2021-06-03 08:34:14 -05:00
for (int seg = 0; seg < this->numberOfSegments(); ++seg) {
considering the pressure dependence of the segment volume segment volume is fixed, while duo to composition and pressure change, within the fixed segment volume, different amounts of fluids can be contained.
2019-02-12 05:48:51 -06:00
// TODO: trying to reduce the times for the surfaceVolumeFraction calculation
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar surface_volume = getSegmentSurfaceVolume(simulator, seg).value();
drop using statement for num_components_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
for (int comp_idx = 0; comp_idx < this->num_components_; ++comp_idx) {
MultisegmentWell: move surfaceVolumeFraction to MultisegmentWellPrimaryVariables
2022-12-19 02:52:48 -06:00
segment_fluid_initial_[seg][comp_idx] = surface_volume * this->primary_variables_.surfaceVolumeFraction(seg, comp_idx).value();
adding function computeInitialComposition to MultisegmentWell
2017-09-05 08:34:31 -05:00
}
}
adding a few functions to calculate the fractions in MultisegmentWell
2017-09-05 08:16:04 -05:00
}
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding updateWellState for MultisegmentWell
2017-09-12 10:32:27 -05:00
void
MultisegmentWell<TypeTag>::
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
updateWellState(const Simulator& simulator,
make sure zero production rates are obtained for the following wells 1. stopped production wells 2. production wells under zero rate control We guarantee the objective through enforce zero values for the WQTotal primary variable during the initialization and update process during the Newton solution.
2023-03-22 09:10:00 -05:00
const BVectorWell& dwells,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
WellState<Scalar>& well_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-05 04:22:44 -05:00
DeferredLogger& deferred_logger,
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar relaxation_factor)
adding updateWellState for MultisegmentWell
2017-09-12 10:32:27 -05:00
{
rename and cleanup
2021-09-29 09:01:16 -05:00
if (!this->isOperableAndSolvable() && !this->wellIsStopped()) return;
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar dFLimit = this->param_.dwell_fraction_max_;
const Scalar max_pressure_change = this->param_.max_pressure_change_ms_wells_;
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
const bool stop_or_zero_rate_target =
this->stoppedOrZeroRateTarget(simulator, well_state, deferred_logger);
MultisegmentWell: move updatePrimaryVariablesNewton to MultisegmentWellPrimaryVariables
2022-12-19 02:52:48 -06:00
this->primary_variables_.updateNewton(dwells,
relaxation_factor,
dFLimit,
combining wellIsStopped and wellUnderZeroRateTaget for better readability.
2023-03-29 07:33:05 -05:00
stop_or_zero_rate_target,
outputting segments with pressure close to lower limit if the well does not get converged.
2024-03-02 09:21:53 -06:00
max_pressure_change);
a few bug fixing for MultisegmentWell
2017-09-15 09:28:10 -05:00
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
const auto& summary_state = simulator.vanguard().summaryState();
this->primary_variables_.copyToWellState(*this, getRefDensity(),
well_state,
summary_state,
deferred_logger);
Calculate Segment Phase and Mixture Densities for Summary Output This commit adds logic and backing storage in the SegmentState to provide the segment level summary vectors - SDENx -- Phase density of phase 'x' (O, G, W) - SDENM -- Mixture density without flowing fraction exponents - SMDEN -- Mixture density with flowing fraction exponents We defer the calculation of SDENM and, especially, SMDEN, to the MultisegmentWellSegments class since this class maintains the current flowing fractions.
2023-07-04 11:40:13 -05:00
{
auto& ws = well_state.well(this->index_of_well_);
this->segments_.copyPhaseDensities(ws.pu, ws.segments);
}
Use cell temperature in perforated cell to compute reservoir rates
2024-07-29 04:27:39 -05:00
Base::calculateReservoirRates(simulator.vanguard().eclState().runspec().co2Storage(), well_state.well(this->index_of_well_));
adding updateWellState for MultisegmentWell
2017-09-12 10:32:27 -05:00
}
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding a function calculateExplictQuantities to WellInterface to hide some implementation details.
2017-09-05 04:09:58 -05:00
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
calculateExplicitQuantities(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
const WellState<Scalar>& well_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-05 04:22:44 -05:00
DeferredLogger& deferred_logger)
adding a function calculateExplictQuantities to WellInterface to hide some implementation details.
2017-09-05 04:09:58 -05:00
{
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
updatePrimaryVariables(simulator, well_state, deferred_logger);
updating the primary variables before calculating accumulation term
2019-02-27 03:46:10 -06:00
initPrimaryVariablesEvaluation();
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computePerfCellPressDiffs(simulator);
computeInitialSegmentFluids(simulator);
adding a function calculateExplictQuantities to WellInterface to hide some implementation details.
2017-09-05 04:09:58 -05:00
}
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
template<typename TypeTag>
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
updateProductivityIndex(const Simulator& simulator,
WellProdIndexCalculator: template Scalar type
2024-02-20 16:39:23 -06:00
const WellProdIndexCalculator<Scalar>& wellPICalc,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
WellState<Scalar>& well_state,
PI: Treat Production Differently From Injection This commit makes the PI/II calculation more closely mirror the approach taken when computing connection flow rates. In particular, we switch to using total mobility, mixing and volume ratios for injecting connections while producing connections continue to use the phase mobilities and formation volume factors derived from conditions in the connecting cells. We also include dissolved gas/oil ratios and vaporised oil/gas ratios in order to fully capture the surface flow conditions. We split the handling of producing/injecting connections out to separate helper functions in order to make the overall logic in updateProductivityIndex() more manageable.ex() more manageable.
2020-10-26 11:33:07 -05:00
DeferredLogger& deferred_logger) const
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
{
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
auto fluidState = [&simulator, this](const int perf)
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
{
const auto cell_idx = this->well_cells_[perf];
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
return simulator.model()
-- prepared for possibliy of not using cached intentensive quantities
2023-03-24 13:57:31 -05:00
.intensiveQuantities(cell_idx, /*timeIdx=*/ 0).fluidState();
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
};
PI: Treat Production Differently From Injection This commit makes the PI/II calculation more closely mirror the approach taken when computing connection flow rates. In particular, we switch to using total mobility, mixing and volume ratios for injecting connections while producing connections continue to use the phase mobilities and formation volume factors derived from conditions in the connecting cells. We also include dissolved gas/oil ratios and vaporised oil/gas ratios in order to fully capture the surface flow conditions. We split the handling of producing/injecting connections out to separate helper functions in order to make the overall logic in updateProductivityIndex() more manageable.ex() more manageable.
2020-10-26 11:33:07 -05:00
const int np = this->number_of_phases_;
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
auto setToZero = [np](Scalar* x) -> void
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
{
PI: Treat Production Differently From Injection This commit makes the PI/II calculation more closely mirror the approach taken when computing connection flow rates. In particular, we switch to using total mobility, mixing and volume ratios for injecting connections while producing connections continue to use the phase mobilities and formation volume factors derived from conditions in the connecting cells. We also include dissolved gas/oil ratios and vaporised oil/gas ratios in order to fully capture the surface flow conditions. We split the handling of producing/injecting connections out to separate helper functions in order to make the overall logic in updateProductivityIndex() more manageable.ex() more manageable.
2020-10-26 11:33:07 -05:00
std::fill_n(x, np, 0.0);
};
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
auto addVector = [np](const Scalar* src, Scalar* dest) -> void
PI: Treat Production Differently From Injection This commit makes the PI/II calculation more closely mirror the approach taken when computing connection flow rates. In particular, we switch to using total mobility, mixing and volume ratios for injecting connections while producing connections continue to use the phase mobilities and formation volume factors derived from conditions in the connecting cells. We also include dissolved gas/oil ratios and vaporised oil/gas ratios in order to fully capture the surface flow conditions. We split the handling of producing/injecting connections out to separate helper functions in order to make the overall logic in updateProductivityIndex() more manageable.ex() more manageable.
2020-10-26 11:33:07 -05:00
{
std::transform(src, src + np, dest, dest, std::plus<>{});
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
};
Add productivity_index to SingleWellState
2021-08-05 05:17:57 -05:00
auto& ws = well_state.well(this->index_of_well_);
Include perforation data in SingleWellState
2021-08-06 06:14:00 -05:00
auto& perf_data = ws.perf_data;
Use PerfData for connection productivity index
2021-06-07 02:10:53 -05:00
auto* connPI = perf_data.prod_index.data();
Add productivity_index to SingleWellState
2021-08-05 05:17:57 -05:00
auto* wellPI = ws.productivity_index.data();
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
PI: Treat Production Differently From Injection This commit makes the PI/II calculation more closely mirror the approach taken when computing connection flow rates. In particular, we switch to using total mobility, mixing and volume ratios for injecting connections while producing connections continue to use the phase mobilities and formation volume factors derived from conditions in the connecting cells. We also include dissolved gas/oil ratios and vaporised oil/gas ratios in order to fully capture the surface flow conditions. We split the handling of producing/injecting connections out to separate helper functions in order to make the overall logic in updateProductivityIndex() more manageable.ex() more manageable.
2020-10-26 11:33:07 -05:00
setToZero(wellPI);
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
PI/II: Switch to Using Values Only We don't need to do the calculations in terms of EvalWell when we're going to reduce this to the .value() before calling the PI/II calculation routine. We can also get by with a simpler approach to computing the II by assuming we always inject pure phases and no cross flow in injectors. Suggested by: [at]atgeirr
2020-11-06 14:13:10 -06:00
const auto preferred_phase = this->well_ecl_.getPreferredPhase();
Use WellInterface::perf_data_ to calculate PI. that simplifies the code a bit and will work with distributed wells. Previously, we assumed that all non-shut perforations are stored locally. That does not hold any more.
2020-12-01 06:54:50 -06:00
auto subsetPerfID = 0;
PI/II: Switch to Using Values Only We don't need to do the calculations in terms of EvalWell when we're going to reduce this to the .value() before calling the PI/II calculation routine. We can also get by with a simpler approach to computing the II by assuming we always inject pure phases and no cross flow in injectors. Suggested by: [at]atgeirr
2020-11-06 14:13:10 -06:00
Use WellInterface::perf_data_ to calculate PI. that simplifies the code a bit and will work with distributed wells. Previously, we assumed that all non-shut perforations are stored locally. That does not hold any more.
2020-12-01 06:54:50 -06:00
for ( const auto& perf : *this->perf_data_){
auto allPerfID = perf.ecl_index;
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
auto connPICalc = [&wellPICalc, allPerfID](const Scalar mobility) -> Scalar
PI/II: Switch to Using Values Only We don't need to do the calculations in terms of EvalWell when we're going to reduce this to the .value() before calling the PI/II calculation routine. We can also get by with a simpler approach to computing the II by assuming we always inject pure phases and no cross flow in injectors. Suggested by: [at]atgeirr
2020-11-06 14:13:10 -06:00
{
return wellPICalc.connectionProdIndStandard(allPerfID, mobility);
};
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
std::vector<Scalar> mob(this->num_components_, 0.0);
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
// The subsetPerfID loops over 0 .. this->perf_data_->size().
// *(this->perf_data_) contains info about the local processes only,
// hence subsetPerfID is a local perf id and we can call getMobility
// directly with that.
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
getMobility(simulator, static_cast<int>(subsetPerfID), mob, deferred_logger);
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
PI: Treat Production Differently From Injection This commit makes the PI/II calculation more closely mirror the approach taken when computing connection flow rates. In particular, we switch to using total mobility, mixing and volume ratios for injecting connections while producing connections continue to use the phase mobilities and formation volume factors derived from conditions in the connecting cells. We also include dissolved gas/oil ratios and vaporised oil/gas ratios in order to fully capture the surface flow conditions. We split the handling of producing/injecting connections out to separate helper functions in order to make the overall logic in updateProductivityIndex() more manageable.ex() more manageable.
2020-10-26 11:33:07 -05:00
const auto& fs = fluidState(subsetPerfID);
setToZero(connPI);
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
PI/II: Switch to Using Values Only We don't need to do the calculations in terms of EvalWell when we're going to reduce this to the .value() before calling the PI/II calculation routine. We can also get by with a simpler approach to computing the II by assuming we always inject pure phases and no cross flow in injectors. Suggested by: [at]atgeirr
2020-11-06 14:13:10 -06:00
if (this->isInjector()) {
this->computeConnLevelInjInd(fs, preferred_phase, connPICalc,
mob, connPI, deferred_logger);
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
}
PI/II Loop: Switch Order of Injection/Production Branches For readability reasons. Suggested by: [at]atgeirr
2020-11-06 14:17:53 -06:00
else { // Production or zero flow rate
PI/II: Switch to Using Values Only We don't need to do the calculations in terms of EvalWell when we're going to reduce this to the .value() before calling the PI/II calculation routine. We can also get by with a simpler approach to computing the II by assuming we always inject pure phases and no cross flow in injectors. Suggested by: [at]atgeirr
2020-11-06 14:13:10 -06:00
this->computeConnLevelProdInd(fs, connPICalc, mob, connPI);
PI/II Loop: Switch Order of Injection/Production Branches For readability reasons. Suggested by: [at]atgeirr
2020-11-06 14:17:53 -06:00
}
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
PI: Treat Production Differently From Injection This commit makes the PI/II calculation more closely mirror the approach taken when computing connection flow rates. In particular, we switch to using total mobility, mixing and volume ratios for injecting connections while producing connections continue to use the phase mobilities and formation volume factors derived from conditions in the connecting cells. We also include dissolved gas/oil ratios and vaporised oil/gas ratios in order to fully capture the surface flow conditions. We split the handling of producing/injecting connections out to separate helper functions in order to make the overall logic in updateProductivityIndex() more manageable.ex() more manageable.
2020-10-26 11:33:07 -05:00
addVector(connPI, wellPI);
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
++subsetPerfID;
connPI += np;
}
PI/II Loop: Check That We Process All Active Connections Assert that the 'subsetPerfID' is equal to number_of_perforations_ at the end of the loop. Suggested by: [at]atgeirr
2020-11-06 14:15:25 -06:00
Other communication measures taken from StandardWells
2024-09-30 02:05:25 -05:00
// Sum with communication in case of distributed well.
const auto& comm = this->parallel_well_info_.communication();
if (comm.size() > 1) {
comm.sum(wellPI, np);
}
PI/II Loop: Check That We Process All Active Connections Assert that the 'subsetPerfID' is equal to number_of_perforations_ at the end of the loop. Suggested by: [at]atgeirr
2020-11-06 14:15:25 -06:00
assert (static_cast<int>(subsetPerfID) == this->number_of_perforations_ &&
"Internal logic error in processing connections for PI/II");
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
}
Hook New WBPn Calculation Up to Well Model This commit activates the support for calculating WBPn summary result values per well in parallel. To affect the calculation we add two new data members in BlackoilWellModelGeneric: - conn_idx_map_: Maps well's connection index (0..getConnections().size() - 1) to connections on current rank. Its local() connections are negative 1 (-1) if the connection is not on current rank, and a non-negative value otherwise. The global() function maps well connections on current rank to global connection ID for each well. Effectively the reverse of local(). Finally, the open() function maps well connections on current rank to open/flowing connections on current rank. Negative 1 if connection is not flowing. - wbpCalculationService: Parallel collection of WBPn calculation objects that knows how to exchange source and result information between all ranks in a communicator. Also handles distributed wells. We furthermore need a way to compute connection-level fluid mixture density values. For the standard well class we add a way to access the StandardWellConnection's 'perf_densities_' values. However, since these are defined for open/flowing connections only, this means we're not able to fully meet the requirements of the WELL/ALL WPAVE depth correction procedure for standard wells. The multi-segmented well type, on the other hand, uses the fluid mixture density in the associated well segment and is therefore well defined for ALL connections. OPEN well connections are supported for both well types.
2023-06-06 14:31:17 -05:00
template<typename TypeTag>
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
typename MultisegmentWell<TypeTag>::Scalar
Hook New WBPn Calculation Up to Well Model This commit activates the support for calculating WBPn summary result values per well in parallel. To affect the calculation we add two new data members in BlackoilWellModelGeneric: - conn_idx_map_: Maps well's connection index (0..getConnections().size() - 1) to connections on current rank. Its local() connections are negative 1 (-1) if the connection is not on current rank, and a non-negative value otherwise. The global() function maps well connections on current rank to global connection ID for each well. Effectively the reverse of local(). Finally, the open() function maps well connections on current rank to open/flowing connections on current rank. Negative 1 if connection is not flowing. - wbpCalculationService: Parallel collection of WBPn calculation objects that knows how to exchange source and result information between all ranks in a communicator. Also handles distributed wells. We furthermore need a way to compute connection-level fluid mixture density values. For the standard well class we add a way to access the StandardWellConnection's 'perf_densities_' values. However, since these are defined for open/flowing connections only, this means we're not able to fully meet the requirements of the WELL/ALL WPAVE depth correction procedure for standard wells. The multi-segmented well type, on the other hand, uses the fluid mixture density in the associated well segment and is therefore well defined for ALL connections. OPEN well connections are supported for both well types.
2023-06-06 14:31:17 -05:00
MultisegmentWell<TypeTag>::
connectionDensity(const int globalConnIdx,
[[maybe_unused]] const int openConnIdx) const
{
// Simple approximation: Mixture density at reservoir connection is
// mixture density at connection's segment.
const auto segNum = this->wellEcl()
.getConnections()[globalConnIdx].segment();
const auto segIdx = this->wellEcl()
.getSegments().segmentNumberToIndex(segNum);
return this->segments_.density(segIdx).value();
}
throw when calling addWellContributions() for MSW
2019-08-15 04:29:30 -05:00
template<typename TypeTag>
void
MultisegmentWell<TypeTag>::
Implement addWellContributions() for MultisegmentWell.
2020-10-29 06:57:29 -05:00
addWellContributions(SparseMatrixAdapter& jacobian) const
throw when calling addWellContributions() for MSW
2019-08-15 04:29:30 -05:00
{
added: MultisegmentWellEquations::extract(SparseMatrixAdapter) this adds the well matrices to a sparse matrix adapter. this is the core of MultisegmentWell::addWellContributions. use the new method in the implementation.
2022-11-11 14:41:24 -06:00
this->linSys_.extract(jacobian);
throw when calling addWellContributions() for MSW
2019-08-15 04:29:30 -05:00
}
Changes to make ms wells work with cprw
2022-04-28 02:32:07 -05:00
template<typename TypeTag>
void
MultisegmentWell<TypeTag>::
addWellPressureEquations(PressureMatrix& jacobian,
const BVector& weights,
const int pressureVarIndex,
added: MultisegmentWellEquations::extractCPRPressureMatrix() this adds the cpr pressure matrix to a matrix. this is the core of MultisegmentWell::addWellPressureEquations use the new method in the implementation.
2022-11-11 14:41:24 -06:00
const bool use_well_weights,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
const WellState<Scalar>& well_state) const
Changes to make ms wells work with cprw
2022-04-28 02:32:07 -05:00
{
cleaning code
2022-05-05 07:21:28 -05:00
// Add the pressure contribution to the cpr system for the well
added: MultisegmentWellEquations::extractCPRPressureMatrix() this adds the cpr pressure matrix to a matrix. this is the core of MultisegmentWell::addWellPressureEquations use the new method in the implementation.
2022-11-11 14:41:24 -06:00
this->linSys_.extractCPRPressureMatrix(jacobian,
weights,
pressureVarIndex,
use_well_weights,
*this,
this->SPres,
well_state);
Changes to make ms wells work with cprw
2022-04-28 02:32:07 -05:00
}
added: MultisegmentWellPrimaryVariables this is a container class for the primary variables in multisegment well
2022-11-07 23:38:12 -06:00
throw when calling addWellContributions() for MSW
2019-08-15 04:29:30 -05:00
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
template<typename TypeTag>
template<class Value>
void
MultisegmentWell<TypeTag>::
computePerfRate(const Value& pressure_cell,
const Value& rs,
const Value& rv,
const std::vector<Value>& b_perfcells,
const std::vector<Value>& mob_perfcells,
only use d factor for gas wells
2023-11-14 05:45:25 -06:00
const std::vector<Scalar>& Tw,
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
const int perf,
const Value& segment_pressure,
const Value& segment_density,
const bool& allow_cf,
const std::vector<Value>& cmix_s,
std::vector<Value>& cq_s,
Value& perf_press,
PerforationRates: template Scalar type
2024-02-20 07:18:30 -06:00
PerforationRates<Scalar>& perf_rates,
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
DeferredLogger& deferred_logger) const
{
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const int local_perf_index = this->pw_info_.globalToLocal(perf);
if (local_perf_index < 0) // then the perforation is not on this process
return;
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
// pressure difference between the segment and the perforation
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
const Value perf_seg_press_diff = this->gravity() * segment_density *
this->segments_.perforation_depth_diff(perf);
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
// pressure difference between the perforation and the grid cell
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const Scalar cell_perf_press_diff = this->cell_perforation_pressure_diffs_[local_perf_index];
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
Fixing MSW connection pressure output
2023-02-17 05:17:41 -06:00
// perforation pressure is the wellbore pressure corrected to perforation depth
// (positive sign due to convention in segments_.perforation_depth_diff() )
perf_press = segment_pressure + perf_seg_press_diff;
stricter tolerance for wells with zero rate target for StandardWell only at this moment.
2023-03-30 08:49:27 -05:00
// cell pressure corrected to perforation depth
Fixing MSW connection pressure output
2023-02-17 05:17:41 -06:00
const Value cell_press_at_perf = pressure_cell - cell_perf_press_diff;
stricter tolerance for wells with zero rate target for StandardWell only at this moment.
2023-03-30 08:49:27 -05:00
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
// Pressure drawdown (also used to determine direction of flow)
Fixing MSW connection pressure output
2023-02-17 05:17:41 -06:00
const Value drawdown = cell_press_at_perf - perf_press;
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
// producing perforations
cosmetics
2023-05-05 06:58:23 -05:00
if (drawdown > 0.0) {
// Do nothing if crossflow is not allowed
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
if (!allow_cf && this->isInjector()) {
return;
}
// compute component volumetric rates at standard conditions
for (int comp_idx = 0; comp_idx < this->numComponents(); ++comp_idx) {
only use d factor for gas wells
2023-11-14 05:45:25 -06:00
const Value cq_p = - Tw[comp_idx] * (mob_perfcells[comp_idx] * drawdown);
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
cq_s[comp_idx] = b_perfcells[comp_idx] * cq_p;
}
throw when calling addWellContributions() for MSW
2019-08-15 04:29:30 -05:00
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) && FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
const unsigned oilCompIdx = Indices::canonicalToActiveComponentIndex(FluidSystem::oilCompIdx);
const unsigned gasCompIdx = Indices::canonicalToActiveComponentIndex(FluidSystem::gasCompIdx);
const Value cq_s_oil = cq_s[oilCompIdx];
const Value cq_s_gas = cq_s[gasCompIdx];
cq_s[gasCompIdx] += rs * cq_s_oil;
cq_s[oilCompIdx] += rv * cq_s_gas;
}
} else { // injecting perforations
// Do nothing if crossflow is not allowed
if (!allow_cf && this->isProducer()) {
return;
}
// for injecting perforations, we use total mobility
Value total_mob = mob_perfcells[0];
for (int comp_idx = 1; comp_idx < this->numComponents(); ++comp_idx) {
total_mob += mob_perfcells[comp_idx];
}
// compute volume ratio between connection and at standard conditions
Value volume_ratio = 0.0;
if (FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx)) {
const unsigned waterCompIdx = Indices::canonicalToActiveComponentIndex(FluidSystem::waterCompIdx);
volume_ratio += cmix_s[waterCompIdx] / b_perfcells[waterCompIdx];
}
if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) && FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
const unsigned oilCompIdx = Indices::canonicalToActiveComponentIndex(FluidSystem::oilCompIdx);
const unsigned gasCompIdx = Indices::canonicalToActiveComponentIndex(FluidSystem::gasCompIdx);
// Incorporate RS/RV factors if both oil and gas active
// TODO: not sure we use rs rv from the perforation cells when handling injecting perforations
// basically, for injecting perforations, the wellbore is the upstreaming side.
const Value d = 1.0 - rv * rs;
if (getValue(d) == 0.0) {
Add and use OPM_DEFLOG_PROBLEM macro. This should replace OPM_DEFLOG_THROW in places where the problem category is more appropriate than the error category. In this commit, uses of OPM_DEFLOG_THROW have been replaced whenever the exception class used was NumericalProblem.
2023-11-08 08:16:17 -06:00
OPM_DEFLOG_PROBLEM(NumericalProblem,
fmt::format("Zero d value obtained for well {} "
"during flux calculation with rs {} and rv {}",
this->name(), rs, rv),
deferred_logger);
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
}
const Value tmp_oil = (cmix_s[oilCompIdx] - rv * cmix_s[gasCompIdx]) / d;
volume_ratio += tmp_oil / b_perfcells[oilCompIdx];
const Value tmp_gas = (cmix_s[gasCompIdx] - rs * cmix_s[oilCompIdx]) / d;
volume_ratio += tmp_gas / b_perfcells[gasCompIdx];
} else { // not having gas and oil at the same time
if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx)) {
const unsigned oilCompIdx = Indices::canonicalToActiveComponentIndex(FluidSystem::oilCompIdx);
volume_ratio += cmix_s[oilCompIdx] / b_perfcells[oilCompIdx];
}
if (FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
const unsigned gasCompIdx = Indices::canonicalToActiveComponentIndex(FluidSystem::gasCompIdx);
volume_ratio += cmix_s[gasCompIdx] / b_perfcells[gasCompIdx];
}
}
// injecting connections total volumerates at standard conditions
only use d factor for gas wells
2023-11-14 05:45:25 -06:00
for (int componentIdx = 0; componentIdx < this->numComponents(); ++componentIdx) {
Fix connection and well dfactor The well dfactor is scaled by the well index If postive the connection dfactor is threated as a well factor and also scaled. If negative the connection dfactor is not scaled
2023-11-14 07:06:23 -06:00
const Value cqt_i = - Tw[componentIdx] * (total_mob * drawdown);
Value cqt_is = cqt_i / volume_ratio;
cq_s[componentIdx] = cmix_s[componentIdx] * cqt_is;
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
}
} // end for injection perforations
// calculating the perforation solution gas rate and solution oil rates
if (this->isProducer()) {
if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) && FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
const unsigned oilCompIdx = Indices::canonicalToActiveComponentIndex(FluidSystem::oilCompIdx);
const unsigned gasCompIdx = Indices::canonicalToActiveComponentIndex(FluidSystem::gasCompIdx);
// TODO: the formulations here remain to be tested with cases with strong crossflow through production wells
// s means standard condition, r means reservoir condition
// q_os = q_or * b_o + rv * q_gr * b_g
// q_gs = q_gr * g_g + rs * q_or * b_o
// d = 1.0 - rs * rv
// q_or = 1 / (b_o * d) * (q_os - rv * q_gs)
// q_gr = 1 / (b_g * d) * (q_gs - rs * q_os)
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar d = 1.0 - getValue(rv) * getValue(rs);
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
// vaporized oil into gas
// rv * q_gr * b_g = rv * (q_gs - rs * q_os) / d
changed: simplify computePerfRate signatures pass a PerforationRates ref instead of multiple references to doubles
2023-05-04 06:02:17 -05:00
perf_rates.vap_oil = getValue(rv) * (getValue(cq_s[gasCompIdx]) - getValue(rs) * getValue(cq_s[oilCompIdx])) / d;
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
// dissolved of gas in oil
// rs * q_or * b_o = rs * (q_os - rv * q_gs) / d
changed: simplify computePerfRate signatures pass a PerforationRates ref instead of multiple references to doubles
2023-05-04 06:02:17 -05:00
perf_rates.dis_gas = getValue(rs) * (getValue(cq_s[oilCompIdx]) - getValue(rv) * getValue(cq_s[gasCompIdx])) / d;
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
}
}
}
throw when calling addWellContributions() for MSW
2019-08-15 04:29:30 -05:00
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
template<class Value>
adding computePerfRate() in MultisegmentWell not tested yet.
2017-09-08 04:31:43 -05:00
void
MultisegmentWell<TypeTag>::
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
computePerfRate(const IntensiveQuantities& int_quants,
const std::vector<Value>& mob_perfcells,
only use d factor for gas wells
2023-11-14 05:45:25 -06:00
const std::vector<Scalar>& Tw,
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
const int seg,
const int perf,
const Value& segment_pressure,
const bool& allow_cf,
std::vector<Value>& cq_s,
Value& perf_press,
PerforationRates: template Scalar type
2024-02-20 07:18:30 -06:00
PerforationRates<Scalar>& perf_rates,
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
DeferredLogger& deferred_logger) const
correct exception handling in wells for parallel runs
2019-02-07 07:43:17 -06:00
adding computePerfRate() in MultisegmentWell not tested yet.
2017-09-08 04:31:43 -05:00
{
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
auto obtain = [this](const Eval& value)
{
if constexpr (std::is_same_v<Value, Scalar>) {
suppress unused lambda capture warnings with clang
2023-06-27 06:41:12 -05:00
static_cast<void>(this); // suppress clang warning
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
return getValue(value);
} else {
return this->extendEval(value);
}
};
auto obtainN = [](const auto& value)
{
if constexpr (std::is_same_v<Value, Scalar>) {
return getValue(value);
} else {
return value;
Use phase and comp info from FluidSystem TODO: The output, fip and restart still uses a mixture of old and new phase indices. This needs to be adressed in future PRs
2017-12-04 02:14:08 -06:00
}
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
};
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
const auto& fs = int_quants.fluidState();
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
const Value pressure_cell = obtain(this->getPerfCellPressure(fs));
const Value rs = obtain(fs.Rs());
const Value rv = obtain(fs.Rv());
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
// not using number_of_phases_ because of solvent
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
std::vector<Value> b_perfcells(this->num_components_, 0.0);
adding computeSegmentFluidProperties for MultisegmentWell only considering the fluid densities for now. more fluid densities needs to be considered.
2017-09-08 04:09:54 -05:00
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
for (unsigned phaseIdx = 0; phaseIdx < FluidSystem::numPhases; ++phaseIdx) {
if (!FluidSystem::phaseIsActive(phaseIdx)) {
continue;
}
const unsigned compIdx = Indices::canonicalToActiveComponentIndex(FluidSystem::solventComponentIndex(phaseIdx));
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
b_perfcells[compIdx] = obtain(fs.invB(phaseIdx));
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
}
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
std::vector<Value> cmix_s(this->numComponents(), 0.0);
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
for (int comp_idx = 0; comp_idx < this->numComponents(); ++comp_idx) {
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
cmix_s[comp_idx] = obtainN(this->primary_variables_.surfaceVolumeFraction(seg, comp_idx));
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
}
this->computePerfRate(pressure_cell,
rs,
rv,
b_perfcells,
mob_perfcells,
Tw,
perf,
segment_pressure,
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
obtainN(this->segments_.density(seg)),
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
allow_cf,
cmix_s,
cq_s,
perf_press,
changed: simplify computePerfRate signatures pass a PerforationRates ref instead of multiple references to doubles
2023-05-04 06:02:17 -05:00
perf_rates,
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
deferred_logger);
}
adding computeSegmentFluidProperties for MultisegmentWell only considering the fluid densities for now. more fluid densities needs to be considered.
2017-09-08 04:09:54 -05:00
handling the acceleration pressure drop not tested yet.
2017-09-28 08:12:09 -05:00
template <typename TypeTag>
adding computeSegmentFluidProperties for MultisegmentWell only considering the fluid densities for now. more fluid densities needs to be considered.
2017-09-08 04:09:54 -05:00
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeSegmentFluidProperties(const Simulator& simulator, DeferredLogger& deferred_logger)
adding computeSegmentFluidProperties for MultisegmentWell only considering the fluid densities for now. more fluid densities needs to be considered.
2017-09-08 04:09:54 -05:00
{
adding the code to calculate the segment viscosities. not tested yet.
2017-09-28 03:04:04 -05:00
// TODO: the concept of phases and components are rather confusing in this function.
// needs to be addressed sooner or later.
adding computeSegmentFluidProperties for MultisegmentWell only considering the fluid densities for now. more fluid densities needs to be considered.
2017-09-08 04:09:54 -05:00
// get the temperature for later use. It is only useful when we are not handling
// thermal related simulation
// basically, it is a single value for all the segments
cleaning up. no functional change.
2017-10-12 08:36:54 -05:00
adding computeSegmentFluidProperties for MultisegmentWell only considering the fluid densities for now. more fluid densities needs to be considered.
2017-09-08 04:09:54 -05:00
EvalWell temperature;
pass the saltConcentration to the waterPVT
2020-07-02 06:44:01 -05:00
EvalWell saltConcentration;
adding computeSegmentFluidProperties for MultisegmentWell only considering the fluid densities for now. more fluid densities needs to be considered.
2017-09-08 04:09:54 -05:00
// not sure how to handle the pvt region related to segment
// for the current approach, we use the pvt region of the first perforated cell
// although there are some text indicating using the pvt region of the lowest
// perforated cell
// TODO: later to investigate how to handle the pvt region
int pvt_region_index;
{
// using the first perforated cell
drop using statement for well_cells_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
const int cell_idx = this->well_cells_[0];
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& intQuants = simulator.model().intensiveQuantities(cell_idx, /*timeIdx=*/0);
adding computeSegmentFluidProperties for MultisegmentWell only considering the fluid densities for now. more fluid densities needs to be considered.
2017-09-08 04:09:54 -05:00
const auto& fs = intQuants.fluidState();
temperature.setValue(fs.temperature(FluidSystem::oilPhaseIdx).value());
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
saltConcentration = this->extendEval(fs.saltConcentration());
adding computeSegmentFluidProperties for MultisegmentWell only considering the fluid densities for now. more fluid densities needs to be considered.
2017-09-08 04:09:54 -05:00
pvt_region_index = fs.pvtRegionIndex();
}
move computeSegmentFluidProperties to MultisegmentWellSegments
2022-12-19 07:20:55 -06:00
this->segments_.computeFluidProperties(temperature,
saltConcentration,
this->primary_variables_,
pvt_region_index,
deferred_logger);
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
}
Use phase and comp info from FluidSystem TODO: The output, fip and restart still uses a mixture of old and new phase indices. This needs to be adressed in future PRs
2017-12-04 02:14:08 -06:00
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
template <typename TypeTag>
changed: unify MultisegmentWell::getMobility(Eval|Scalar)
2023-05-07 14:56:09 -05:00
template<class Value>
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
getMobility(const Simulator& simulator,
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const int local_perf_index,
introduce getMobility in WellInterface we now share implementation between StandardWell and MultisegmentWell
2023-05-12 03:02:05 -05:00
std::vector<Value>& mob,
DeferredLogger& deferred_logger) const
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
{
changed: unify MultisegmentWell::getMobility(Eval|Scalar)
2023-05-07 14:56:09 -05:00
auto obtain = [this](const Eval& value)
{
if constexpr (std::is_same_v<Value, Scalar>) {
suppress unused lambda capture warnings with clang
2023-06-27 06:41:12 -05:00
static_cast<void>(this); // suppress clang warning
changed: unify MultisegmentWell::getMobility(Eval|Scalar)
2023-05-07 14:56:09 -05:00
return getValue(value);
} else {
introduce getMobility in WellInterface we now share implementation between StandardWell and MultisegmentWell
2023-05-12 03:02:05 -05:00
return this->extendEval(value);
changed: unify MultisegmentWell::getMobility(Eval|Scalar)
2023-05-07 14:56:09 -05:00
}
};
addressing the review comments
2023-06-27 06:59:10 -05:00
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
WellInterface<TypeTag>::getMobility(simulator, local_perf_index, mob, obtain, deferred_logger);
removing white spaces in the wells folder
2023-10-09 04:14:48 -05:00
support WINJMULT
2023-06-21 04:48:57 -05:00
if (this->isInjector() && this->well_ecl_.getInjMultMode() != Well::InjMultMode::NONE) {
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const auto perf_ecl_index = this->perforationData()[local_perf_index].ecl_index;
addressing the review comments
2023-06-27 06:59:10 -05:00
const Connection& con = this->well_ecl_.getConnections()[perf_ecl_index];
const int seg = this->segmentNumberToIndex(con.segment());
support WINJMULT
2023-06-21 04:48:57 -05:00
// from the reference results, it looks like MSW uses segment pressure instead of BHP here
// Note: this is against the documented definition.
// we can change this depending on what we want
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar segment_pres = this->primary_variables_.getSegmentPressure(seg).value();
const Scalar perf_seg_press_diff = this->gravity() * this->segments_.density(seg).value()
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
* this->segments_.perforation_depth_diff(local_perf_index);
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar perf_press = segment_pres + perf_seg_press_diff;
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const Scalar multiplier = this->getInjMult(local_perf_index, segment_pres, perf_press, deferred_logger);
consistently use std::size_t
2023-08-15 02:32:10 -05:00
for (std::size_t i = 0; i < mob.size(); ++i) {
support WINJMULT
2023-06-21 04:48:57 -05:00
mob[i] *= multiplier;
}
}
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
}
adding getControlEq() to MultisegmentWell to handle the well control equation. THP control is not handled there yet.
2017-09-11 10:31:42 -05:00
add support for thp control in MSW
2019-11-01 04:04:44 -05:00
template<typename TypeTag>
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
typename MultisegmentWell<TypeTag>::Scalar
add support for thp control in MSW
2019-11-01 04:04:44 -05:00
MultisegmentWell<TypeTag>::
Remove code duplication between STW and MSW
2021-04-26 02:31:29 -05:00
getRefDensity() const
add support for thp control in MSW
2019-11-01 04:04:44 -05:00
{
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
return this->segments_.getRefDensity();
adding function processFractions() to MultisegmentWell to handle the undershooting and overshooting of the fractions during updateWellState.
2017-09-12 10:13:30 -05:00
}
adding updateWellState for MultisegmentWell
2017-09-12 10:32:27 -05:00
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
template<typename TypeTag>
void
MultisegmentWell<TypeTag>::
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
checkOperabilityUnderBHPLimit(const WellState<Scalar>& /*well_state*/,
const Simulator& simulator,
DeferredLogger& deferred_logger)
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
{
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& summaryState = simulator.vanguard().summaryState();
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar bhp_limit = WellBhpThpCalculator(*this).mostStrictBhpFromBhpLimits(summaryState);
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
// Crude but works: default is one atmosphere.
// TODO: a better way to detect whether the BHP is defaulted or not
const bool bhp_limit_not_defaulted = bhp_limit > 1.5 * unit::barsa;
if ( bhp_limit_not_defaulted || !this->wellHasTHPConstraints(summaryState) ) {
// if the BHP limit is not defaulted or the well does not have a THP limit
// we need to check the BHP limit
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
Scalar total_ipr_mass_rate = 0.0;
fix component/phase mixup
2022-06-07 04:30:35 -05:00
for (unsigned phaseIdx = 0; phaseIdx < FluidSystem::numPhases; ++phaseIdx)
{
if (!FluidSystem::phaseIsActive(phaseIdx)) {
continue;
}
const unsigned compIdx = Indices::canonicalToActiveComponentIndex(FluidSystem::solventComponentIndex(phaseIdx));
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar ipr_rate = this->ipr_a_[compIdx] - this->ipr_b_[compIdx] * bhp_limit;
fix component/phase mixup
2022-06-07 04:30:35 -05:00
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar rho = FluidSystem::referenceDensity( phaseIdx, Base::pvtRegionIdx() );
Only flag a bhp producer/injector operable if the sum of IPR are negative/positive
2022-05-31 07:31:26 -05:00
total_ipr_mass_rate += ipr_rate * rho;
check the sum not individual phases for operability
2020-11-30 02:23:16 -06:00
}
Only flag a bhp producer/injector operable if the sum of IPR are negative/positive
2022-05-31 07:31:26 -05:00
if ( (this->isProducer() && total_ipr_mass_rate < 0.) || (this->isInjector() && total_ipr_mass_rate > 0.) ) {
check the sum not individual phases for operability
2020-11-30 02:23:16 -06:00
this->operability_status_.operable_under_only_bhp_limit = false;
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
}
// checking whether running under BHP limit will violate THP limit
if (this->operability_status_.operable_under_only_bhp_limit && this->wellHasTHPConstraints(summaryState)) {
// option 1: calculate well rates based on the BHP limit.
// option 2: stick with the above IPR curve
// we use IPR here
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> well_rates_bhp_limit;
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesWithBhp(simulator, bhp_limit, well_rates_bhp_limit, deferred_logger);
adding updateWellState for MultisegmentWell
2017-09-12 10:32:27 -05:00
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar thp_limit = this->getTHPConstraint(summaryState);
const Scalar thp = WellBhpThpCalculator(*this).calculateThpFromBhp(well_rates_bhp_limit,
changed: move calculateThpFromBhp to WellBhpThpCalculator
2022-10-19 02:55:14 -05:00
bhp_limit,
this->getRefDensity(),
Allow using UDQ for WCONPROD item 12 (ALQ)
2023-12-01 06:21:34 -06:00
this->wellEcl().alq_value(summaryState),
Account for pressure loss also in thp
2023-05-09 16:44:05 -05:00
thp_limit,
changed: move calculateThpFromBhp to WellBhpThpCalculator
2022-10-19 02:55:14 -05:00
deferred_logger);
check operability injectors
2021-10-01 06:47:53 -05:00
if ( (this->isProducer() && thp < thp_limit) || (this->isInjector() && thp > thp_limit) ) {
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
this->operability_status_.obey_thp_limit_under_bhp_limit = false;
}
}
} else {
// defaulted BHP and there is a THP constraint
// default BHP limit is about 1 atm.
// when applied the hydrostatic pressure correction dp,
// most likely we get a negative value (bhp + dp)to search in the VFP table,
// which is not desirable.
// we assume we can operate under defaulted BHP limit and will violate the THP limit
// when operating under defaulted BHP limit.
this->operability_status_.operable_under_only_bhp_limit = true;
this->operability_status_.obey_thp_limit_under_bhp_limit = false;
}
}
template<typename TypeTag>
adding function checkWellOperatability() to StandardWell it includes BHPLimit check, THPlimit check, and also to see whether if the well can produce/inject in the correct direction.
2018-11-15 07:31:41 -06:00
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
updateIPR(const Simulator& simulator, DeferredLogger& deferred_logger) const
adding function checkWellOperatability() to StandardWell it includes BHPLimit check, THPlimit check, and also to see whether if the well can produce/inject in the correct direction.
2018-11-15 07:31:41 -06:00
{
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
// TODO: not handling solvent related here for now
Complain less about missing operability checking. Do not give a warning for production wells or history wells, respect the EnableWellOperabilityCheck flag. This is identical to the behaviour of StandardWell. There will now only be a warning for producers in prediction mode.
2019-12-13 04:00:01 -06:00
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
// initialize all the values to be zero to begin with
drop using statement for ipr_a_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
std::fill(this->ipr_a_.begin(), this->ipr_a_.end(), 0.);
drop using statement for ipr_b_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
std::fill(this->ipr_b_.begin(), this->ipr_b_.end(), 0.);
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
add MultisegmentWellGeneric avoid rebuilding this for all simulators when code is only dependent on Scalar. instanced for double
2021-06-03 08:34:14 -05:00
const int nseg = this->numberOfSegments();
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> seg_dp(nseg, 0.0);
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
for (int seg = 0; seg < nseg; ++seg) {
// calculating the perforation rate for each perforation that belongs to this segment
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar dp = this->getSegmentDp(seg,
MultisegmentWell: move code using WellSegments to compile unit
2023-01-12 07:23:22 -06:00
this->segments_.density(seg).value(),
seg_dp);
fix hydrostatic correction for branched wells in IPR
2022-06-07 07:14:59 -05:00
seg_dp[seg] = dp;
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
for (const int perf : this->segments_.perforations()[seg]) {
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const int local_perf_index = this->pw_info_.globalToLocal(perf);
if (local_perf_index < 0) // then the perforation is not on this process
continue;
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
std::vector<Scalar> mob(this->num_components_, 0.0);
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
// TODO: maybe we should store the mobility somewhere, so that we only need to calculate it one per iteration
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
getMobility(simulator, local_perf_index, mob, deferred_logger);
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const int cell_idx = this->well_cells_[local_perf_index];
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& int_quantities = simulator.model().intensiveQuantities(cell_idx, /*timeIdx=*/ 0);
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
const auto& fs = int_quantities.fluidState();
// pressure difference between the segment and the perforation
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar perf_seg_press_diff = this->segments_.getPressureDiffSegPerf(seg, perf);
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
// pressure difference between the perforation and the grid cell
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const Scalar cell_perf_press_diff = this->cell_perforation_pressure_diffs_[local_perf_index];
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar pressure_cell = this->getPerfCellPressure(fs).value();
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
// calculating the b for the connection
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> b_perf(this->num_components_);
consistently use std::size_t
2023-08-15 02:32:10 -05:00
for (std::size_t phase = 0; phase < FluidSystem::numPhases; ++phase) {
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
if (!FluidSystem::phaseIsActive(phase)) {
continue;
}
const unsigned comp_idx = Indices::canonicalToActiveComponentIndex(FluidSystem::solventComponentIndex(phase));
b_perf[comp_idx] = fs.invB(phase).value();
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
}
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
// the pressure difference between the connection and BHP
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar h_perf = cell_perf_press_diff + perf_seg_press_diff + dp;
const Scalar pressure_diff = pressure_cell - h_perf;
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
// do not take into consideration the crossflow here.
if ( (this->isProducer() && pressure_diff < 0.) || (this->isInjector() && pressure_diff > 0.) ) {
deferred_logger.debug("CROSSFLOW_IPR",
"cross flow found when updateIPR for well " + this->name());
}
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
// the well index associated with the connection
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar trans_mult = simulator.problem().template wellTransMultiplier<Scalar>(int_quantities, cell_idx);
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& wellstate_nupcol = simulator.problem().wellModel().nupcolWellState().well(this->index_of_well_);
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const std::vector<Scalar> tw_perf = this->wellIndex(local_perf_index, int_quantities, trans_mult, wellstate_nupcol);
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> ipr_a_perf(this->ipr_a_.size());
std::vector<Scalar> ipr_b_perf(this->ipr_b_.size());
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
for (int comp_idx = 0; comp_idx < this->num_components_; ++comp_idx) {
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar tw_mob = tw_perf[comp_idx] * mob[comp_idx] * b_perf[comp_idx];
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
ipr_a_perf[comp_idx] += tw_mob * pressure_diff;
ipr_b_perf[comp_idx] += tw_mob;
}
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
// we need to handle the rs and rv when both oil and gas are present
if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) && FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
const unsigned oil_comp_idx = Indices::canonicalToActiveComponentIndex(FluidSystem::oilCompIdx);
const unsigned gas_comp_idx = Indices::canonicalToActiveComponentIndex(FluidSystem::gasCompIdx);
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar rs = (fs.Rs()).value();
const Scalar rv = (fs.Rv()).value();
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar dis_gas_a = rs * ipr_a_perf[oil_comp_idx];
const Scalar vap_oil_a = rv * ipr_a_perf[gas_comp_idx];
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
ipr_a_perf[gas_comp_idx] += dis_gas_a;
ipr_a_perf[oil_comp_idx] += vap_oil_a;
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar dis_gas_b = rs * ipr_b_perf[oil_comp_idx];
const Scalar vap_oil_b = rv * ipr_b_perf[gas_comp_idx];
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
ipr_b_perf[gas_comp_idx] += dis_gas_b;
ipr_b_perf[oil_comp_idx] += vap_oil_b;
}
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
consistently use std::size_t
2023-08-15 02:32:10 -05:00
for (std::size_t comp_idx = 0; comp_idx < ipr_a_perf.size(); ++comp_idx) {
move segment_perforations_ and perforation_segment_depth_diffs_ to MultisegmentWellSegments
2022-12-19 06:52:21 -06:00
this->ipr_a_[comp_idx] += ipr_a_perf[comp_idx];
this->ipr_b_[comp_idx] += ipr_b_perf[comp_idx];
}
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
}
Complain less about missing operability checking. Do not give a warning for production wells or history wells, respect the EnableWellOperabilityCheck flag. This is identical to the behaviour of StandardWell. There will now only be a warning for producers in prediction mode.
2019-12-13 04:00:01 -06:00
}
Other communication measures taken from StandardWells
2024-09-30 02:05:25 -05:00
this->parallel_well_info_.communication().sum(this->ipr_a_.data(), this->ipr_a_.size());
this->parallel_well_info_.communication().sum(this->ipr_b_.data(), this->ipr_b_.size());
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
}
Complain less about missing operability checking. Do not give a warning for production wells or history wells, respect the EnableWellOperabilityCheck flag. This is identical to the behaviour of StandardWell. There will now only be a warning for producers in prediction mode.
2019-12-13 04:00:01 -06:00
revert changes
2023-10-26 10:28:05 -05:00
template<typename TypeTag>
void
MultisegmentWell<TypeTag>::
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
updateIPRImplicit(const Simulator& simulator,
WellState<Scalar>& well_state,
DeferredLogger& deferred_logger)
revert changes
2023-10-26 10:28:05 -05:00
{
Include implicit ipr for ms-wells
2023-11-07 05:31:26 -06:00
// Compute IPR based on *converged* well-equation:
// For a component rate r the derivative dr/dbhp is obtained by
updates according to Atgeirrs comments
2023-12-07 05:15:40 -06:00
// dr/dbhp = - (partial r/partial x) * inv(partial Eq/partial x) * (partial Eq/partial bhp_target)
// where Eq(x)=0 is the well equation setup with bhp control and primary variables x
Include implicit ipr for ms-wells
2023-11-07 05:31:26 -06:00
// We shouldn't have zero rates at this stage, but check
bool zero_rates;
auto rates = well_state.well(this->index_of_well_).surface_rates;
zero_rates = true;
for (std::size_t p = 0; p < rates.size(); ++p) {
zero_rates &= rates[p] == 0.0;
}
auto& ws = well_state.well(this->index_of_well_);
if (zero_rates) {
const auto msg = fmt::format("updateIPRImplicit: Well {} has zero rate, IPRs might be problematic", this->name());
deferred_logger.debug(msg);
/*
clean-up
2023-11-08 14:58:26 -06:00
// could revert to standard approach here:
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
updateIPR(simulator, deferred_logger);
Include implicit ipr for ms-wells
2023-11-07 05:31:26 -06:00
for (int comp_idx = 0; comp_idx < this->num_components_; ++comp_idx){
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const int idx = this->modelCompIdxToFlowCompIdx(comp_idx);
rename to implicit_ipr
2023-11-07 06:31:12 -06:00
ws.implicit_ipr_a[idx] = this->ipr_a_[comp_idx];
ws.implicit_ipr_b[idx] = this->ipr_b_[comp_idx];
Include implicit ipr for ms-wells
2023-11-07 05:31:26 -06:00
}
return;
*/
}
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& group_state = simulator.problem().wellModel().groupState();
Include implicit ipr for ms-wells
2023-11-07 05:31:26 -06:00
rename to implicit_ipr
2023-11-07 06:31:12 -06:00
std::fill(ws.implicit_ipr_a.begin(), ws.implicit_ipr_a.end(), 0.);
std::fill(ws.implicit_ipr_b.begin(), ws.implicit_ipr_b.end(), 0.);
Include implicit ipr for ms-wells
2023-11-07 05:31:26 -06:00
//WellState well_state_copy = well_state;
auto inj_controls = Well::InjectionControls(0);
auto prod_controls = Well::ProductionControls(0);
prod_controls.addControl(Well::ProducerCMode::BHP);
prod_controls.bhp_limit = well_state.well(this->index_of_well_).bhp;
// Set current control to bhp, and bhp value in state, modify bhp limit in control object.
const auto cmode = ws.production_cmode;
ws.production_cmode = Well::ProducerCMode::BHP;
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const double dt = simulator.timeStepSize();
assembleWellEqWithoutIteration(simulator, dt, inj_controls, prod_controls, well_state, group_state, deferred_logger);
Include implicit ipr for ms-wells
2023-11-07 05:31:26 -06:00
BVectorWell rhs(this->numberOfSegments());
rhs = 0.0;
rhs[0][SPres] = -1.0;
const BVectorWell x_well = this->linSys_.solve(rhs);
constexpr int num_eq = MSWEval::numWellEq;
for (int comp_idx = 0; comp_idx < this->num_components_; ++comp_idx){
const EvalWell comp_rate = this->primary_variables_.getQs(comp_idx);
WellInterfaceIndices: rename ebosCompIdxToFlowCompIdx to modelCompIdxToFlowCompIdx
2024-02-06 05:12:13 -06:00
const int idx = this->modelCompIdxToFlowCompIdx(comp_idx);
Include implicit ipr for ms-wells
2023-11-07 05:31:26 -06:00
for (size_t pvIdx = 0; pvIdx < num_eq; ++pvIdx) {
updates according to Atgeirrs comments
2023-12-07 05:15:40 -06:00
// well primary variable derivatives in EvalWell start at position Indices::numEq
rename to implicit_ipr
2023-11-07 06:31:12 -06:00
ws.implicit_ipr_b[idx] -= x_well[0][pvIdx]*comp_rate.derivative(pvIdx+Indices::numEq);
Include implicit ipr for ms-wells
2023-11-07 05:31:26 -06:00
}
rename to implicit_ipr
2023-11-07 06:31:12 -06:00
ws.implicit_ipr_a[idx] = ws.implicit_ipr_b[idx]*ws.bhp - comp_rate.value();
Include implicit ipr for ms-wells
2023-11-07 05:31:26 -06:00
}
// reset cmode
ws.production_cmode = cmode;
revert changes
2023-10-26 10:28:05 -05:00
}
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
template<typename TypeTag>
void
MultisegmentWell<TypeTag>::
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
checkOperabilityUnderTHPLimit(const Simulator& simulator,
const WellState<Scalar>& well_state,
DeferredLogger& deferred_logger)
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
{
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& summaryState = simulator.vanguard().summaryState();
Add gaslift optimization support for MSW. Implements gas lift optimization support for multisegmented wells (MSW).
2022-02-07 04:28:35 -06:00
const auto obtain_bhp = this->isProducer()
? computeBhpAtThpLimitProd(
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
well_state, simulator, summaryState, deferred_logger)
: computeBhpAtThpLimitInj(simulator, summaryState, deferred_logger);
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
if (obtain_bhp) {
this->operability_status_.can_obtain_bhp_with_thp_limit = true;
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar bhp_limit = WellBhpThpCalculator(*this).mostStrictBhpFromBhpLimits(summaryState);
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
this->operability_status_.obey_bhp_limit_with_thp_limit = (*obtain_bhp >= bhp_limit);
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar thp_limit = this->getTHPConstraint(summaryState);
check operability injectors
2021-10-01 06:47:53 -05:00
if (this->isProducer() && *obtain_bhp < thp_limit) {
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
const std::string msg = " obtained bhp " + std::to_string(unit::convert::to(*obtain_bhp, unit::barsa))
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
+ " bars is SMALLER than thp limit "
+ std::to_string(unit::convert::to(thp_limit, unit::barsa))
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
+ " bars as a producer for well " + this->name();
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
deferred_logger.debug(msg);
adding updateWellState for MultisegmentWell
2017-09-12 10:32:27 -05:00
}
check operability injectors
2021-10-01 06:47:53 -05:00
else if (this->isInjector() && *obtain_bhp > thp_limit) {
const std::string msg = " obtained bhp " + std::to_string(unit::convert::to(*obtain_bhp, unit::barsa))
+ " bars is LARGER than thp limit "
+ std::to_string(unit::convert::to(thp_limit, unit::barsa))
+ " bars as a injector for well " + this->name();
deferred_logger.debug(msg);
}
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
} else {
// Shutting wells that can not find bhp value from thp
// when under THP control
this->operability_status_.can_obtain_bhp_with_thp_limit = false;
this->operability_status_.obey_bhp_limit_with_thp_limit = false;
if (!this->wellIsStopped()) {
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar thp_limit = this->getTHPConstraint(summaryState);
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
deferred_logger.debug(" could not find bhp value at thp limit "
+ std::to_string(unit::convert::to(thp_limit, unit::barsa))
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
+ " bar for well " + this->name() + ", the well might need to be closed ");
adding updateWellState for MultisegmentWell
2017-09-12 10:32:27 -05:00
}
implementing the support for WSEGVALV
2019-11-29 10:23:26 -06:00
}
adding updateWellState for MultisegmentWell
2017-09-12 10:32:27 -05:00
}
adapting the change of PR 1263
2017-09-26 03:07:06 -05:00
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
template<typename TypeTag>
renaming solveWellEqUntilConverged to be iterateWellEquations
2020-06-02 07:54:45 -05:00
bool
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
iterateWellEqWithControl(const Simulator& simulator,
renaming solveWellEqUntilConverged to be iterateWellEquations
2020-06-02 07:54:45 -05:00
const double dt,
const Well::InjectionControls& inj_controls,
const Well::ProductionControls& prod_controls,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
WellState<Scalar>& well_state,
GroupState: template Scalar type
2024-02-17 11:13:46 -06:00
const GroupState<Scalar>& group_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-05 04:22:44 -05:00
DeferredLogger& deferred_logger)
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
{
rename and cleanup
2021-09-29 09:01:16 -05:00
if (!this->isOperableAndSolvable() && !this->wellIsStopped()) return true;
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
drop using statement for param_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
const int max_iter_number = this->param_.max_inner_iter_ms_wells_;
avoid throw for nan residuals instead return well as unconverged
2022-04-08 04:07:34 -05:00
{
// getWellFiniteResiduals returns false for nan/inf residuals
const auto& [isFinite, residuals] = this->getFiniteWellResiduals(Base::B_avg_, deferred_logger);
if(!isFinite)
return false;
}
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
std::vector<std::vector<Scalar> > residual_history;
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> measure_history;
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
int it = 0;
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
// relaxation factor
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
Scalar relaxation_factor = 1.;
const Scalar min_relaxation_factor = 0.6;
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
bool converged = false;
int stagnate_count = 0;
use relaxed tolerance for MSW when solution stagnates
2020-05-12 05:05:30 -05:00
bool relax_convergence = false;
reset regularize_ before starting the inner iterations
2022-05-03 01:25:26 -05:00
this->regularize_ = false;
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
for (; it < max_iter_number; ++it, ++debug_cost_counter_) {
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
assembleWellEqWithoutIteration(simulator, dt, inj_controls, prod_controls, well_state, group_state, deferred_logger);
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
Make sure that problems with singular matrices are logged. Previously, if the problem occured on an MPI process with rank other than zero the the logging would not seen (at least in the output files). Now together with the previous commit the problem should be logged together with the well name and calling method.
2023-12-04 16:15:08 -06:00
BVectorWell dx_well;
try{
dx_well = this->linSys_.solve();
}
catch(const NumericalProblem& exp) {
// Add information about the well and log to deferred logger
// (Logging done inside of solve() method will only be seen if
// this is the process with rank zero)
deferred_logger.problem("In MultisegmentWell::iterateWellEqWithControl for well "
+ this->name() +": "+exp.what());
throw;
}
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
regularize MSW equation when iter > strict_inner_iter
2022-04-06 03:09:21 -05:00
if (it > this->param_.strict_inner_iter_wells_) {
use relaxed tolerance for MSW when solution stagnates
2020-05-12 05:05:30 -05:00
relax_convergence = true;
regularize MSW equation when iter > strict_inner_iter
2022-04-06 03:09:21 -05:00
this->regularize_ = true;
}
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
const auto report = getWellConvergence(simulator, well_state, Base::B_avg_, deferred_logger, relax_convergence);
Use ConvergenceStatus in well subsystem.
2018-10-23 07:05:19 -05:00
if (report.converged()) {
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
converged = true;
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
break;
}
avoid throw for nan residuals instead return well as unconverged
2022-04-08 04:07:34 -05:00
{
// getFinteWellResiduals returns false for nan/inf residuals
const auto& [isFinite, residuals] = this->getFiniteWellResiduals(Base::B_avg_, deferred_logger);
if (!isFinite)
return false;
residual_history.push_back(residuals);
measure_history.push_back(this->getResidualMeasureValue(well_state,
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
residual_history[it],
drop using statement for param_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
this->param_.tolerance_wells_,
this->param_.tolerance_pressure_ms_wells_,
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
deferred_logger) );
avoid throw for nan residuals instead return well as unconverged
2022-04-08 04:07:34 -05:00
}
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
bool is_oscillate = false;
bool is_stagnate = false;
cleaning up to preapre for pull request
2023-09-25 06:07:39 -05:00
this->detectOscillations(measure_history, is_oscillate, is_stagnate);
fixing some typos in MultisegmentWell_impl.hpp
2022-11-05 16:51:59 -05:00
// TODO: maybe we should have more sophisticated strategy to recover the relaxation factor,
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
// for example, to recover it to be bigger
if (is_oscillate || is_stagnate) {
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
// HACK!
use relaxed tolerance for MSW when solution stagnates
2020-05-12 05:05:30 -05:00
std::ostringstream sstr;
if (relaxation_factor == min_relaxation_factor) {
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
// Still stagnating, terminate iterations if 5 iterations pass.
++stagnate_count;
use relaxed tolerance for MSW when solution stagnates
2020-05-12 05:05:30 -05:00
if (stagnate_count == 6) {
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
sstr << " well " << this->name() << " observes severe stagnation and/or oscillation. We relax the tolerance and check for convergence. \n";
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
const auto reportStag = getWellConvergence(simulator, well_state, Base::B_avg_, deferred_logger, true);
use relaxed tolerance for MSW when solution stagnates
2020-05-12 05:05:30 -05:00
if (reportStag.converged()) {
converged = true;
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
sstr << " well " << this->name() << " manages to get converged with relaxed tolerances in " << it << " inner iterations";
use relaxed tolerance for MSW when solution stagnates
2020-05-12 05:05:30 -05:00
deferred_logger.debug(sstr.str());
renaming solveWellEqUntilConverged to be iterateWellEquations
2020-06-02 07:54:45 -05:00
return converged;
use relaxed tolerance for MSW when solution stagnates
2020-05-12 05:05:30 -05:00
}
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
}
}
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
// a factor value to reduce the relaxation_factor
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar reduction_mutliplier = 0.9;
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
relaxation_factor = std::max(relaxation_factor * reduction_mutliplier, min_relaxation_factor);
// debug output
if (is_stagnate) {
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
sstr << " well " << this->name() << " observes stagnation in inner iteration " << it << "\n";
implementing the support for WSEGVALV
2019-11-29 10:23:26 -06:00
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
}
if (is_oscillate) {
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
sstr << " well " << this->name() << " observes oscillation in inner iteration " << it << "\n";
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
}
sstr << " relaxation_factor is " << relaxation_factor << " now\n";
regularize MSW equation when iter > strict_inner_iter
2022-04-06 03:09:21 -05:00
this->regularize_ = true;
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
deferred_logger.debug(sstr.str());
}
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
updateWellState(simulator, dx_well, well_state, deferred_logger, relaxation_factor);
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
initPrimaryVariablesEvaluation();
}
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
// TODO: we should decide whether to keep the updated well_state, or recover to use the old well_state
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
if (converged) {
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
std::ostringstream sstr;
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
sstr << " Well " << this->name() << " converged in " << it << " inner iterations.";
use relaxed tolerance for MSW when solution stagnates
2020-05-12 05:05:30 -05:00
if (relax_convergence)
add option for relaxed convergence for stw
2021-09-06 03:08:28 -05:00
sstr << " (A relaxed tolerance was used after "<< this->param_.strict_inner_iter_wells_ << " iterations)";
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
deferred_logger.debug(sstr.str());
} else {
std::ostringstream sstr;
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
sstr << " Well " << this->name() << " did not converge in " << it << " inner iterations.";
Prettifying and reducing log output from MSW.
2020-06-10 09:36:17 -05:00
#define EXTRA_DEBUG_MSW 0
#if EXTRA_DEBUG_MSW
drop using statement for name rather qualify member function calls with this->
2021-09-06 05:58:16 -05:00
sstr << "***** Outputting the residual history for well " << this->name() << " during inner iterations:";
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
for (int i = 0; i < it; ++i) {
const auto& residual = residual_history[i];
sstr << " residual at " << i << "th iteration ";
for (const auto& res : residual) {
sstr << " " << res;
}
sstr << " " << measure_history[i] << " \n";
}
Prettifying and reducing log output from MSW.
2020-06-10 09:36:17 -05:00
#endif
moved debug code into #if section
2022-11-14 04:36:48 -06:00
#undef EXTRA_DEBUG_MSW
various improvements to the inner iteration of ms wells
2019-03-08 06:50:34 -06:00
deferred_logger.debug(sstr.str());
}
renaming solveWellEqUntilConverged to be iterateWellEquations
2020-06-02 07:54:45 -05:00
return converged;
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
}
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
template<typename TypeTag>
bool
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
iterateWellEqWithSwitching(const Simulator& simulator,
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
const double dt,
const Well::InjectionControls& inj_controls,
const Well::ProductionControls& prod_controls,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
WellState<Scalar>& well_state,
GroupState: template Scalar type
2024-02-17 11:13:46 -06:00
const GroupState<Scalar>& group_state,
revert changes
2023-10-26 10:28:05 -05:00
DeferredLogger& deferred_logger,
updates
2023-10-30 14:58:09 -05:00
const bool fixed_control /*false*/,
const bool fixed_status /*false*/)
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
{
const int max_iter_number = this->param_.max_inner_iter_ms_wells_;
{
// getWellFiniteResiduals returns false for nan/inf residuals
const auto& [isFinite, residuals] = this->getFiniteWellResiduals(Base::B_avg_, deferred_logger);
if(!isFinite)
return false;
}
std::vector<std::vector<Scalar> > residual_history;
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> measure_history;
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
int it = 0;
// relaxation factor
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
Scalar relaxation_factor = 1.;
const Scalar min_relaxation_factor = 0.6;
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
bool converged = false;
mark variable maybe_unused quells a clang warning
2023-10-05 02:31:36 -05:00
[[maybe_unused]] int stagnate_count = 0;
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
bool relax_convergence = false;
this->regularize_ = false;
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& summary_state = simulator.vanguard().summaryState();
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
updates according to Atgeirrs comments
2023-12-07 05:15:40 -06:00
// Always take a few (more than one) iterations after a switch before allowing a new switch
// The optimal number here is subject to further investigation, but it has been observerved
// that unless this number is >1, we may get stuck in a cycle
fix well-convergence for well-copies
2023-11-08 14:07:47 -06:00
const int min_its_after_switch = 3;
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
int its_since_last_switch = min_its_after_switch;
int switch_count= 0;
always set wells operable to avoid skipping linear solve/updating
2023-11-10 09:03:48 -06:00
// if we fail to solve eqs, we reset status/operability before leaving
fix well-convergence for well-copies
2023-11-08 14:07:47 -06:00
const auto well_status_orig = this->wellStatus_;
always set wells operable to avoid skipping linear solve/updating
2023-11-10 09:03:48 -06:00
const auto operability_orig = this->operability_status_;
fix well-convergence for well-copies
2023-11-08 14:07:47 -06:00
auto well_status_cur = well_status_orig;
avoid re-opening previously stopped wells
2024-01-26 09:24:09 -06:00
// don't allow opening wells that are stopped from schedule or has a stopped well state
const bool allow_open = this->well_ecl_.getStatus() == WellStatus::OPEN &&
well_state.well(this->index_of_well_).status == WellStatus::OPEN;
// don't allow switcing for wells under zero rate target or requested fixed status and control
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
const bool allow_switching = !this->wellUnderZeroRateTarget(simulator, well_state, deferred_logger) &&
avoid re-opening previously stopped wells
2024-01-26 09:24:09 -06:00
(!fixed_control || !fixed_status) && allow_open;
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
bool changed = false;
removing white spaces in the wells folder
2023-10-09 04:14:48 -05:00
bool final_check = false;
always set wells operable to avoid skipping linear solve/updating
2023-11-10 09:03:48 -06:00
// well needs to be set operable or else solving/updating of re-opened wells is skipped
this->operability_status_.resetOperability();
this->operability_status_.solvable = true;
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
for (; it < max_iter_number; ++it, ++debug_cost_counter_) {
its_since_last_switch++;
fix well-convergence for well-copies
2023-11-08 14:07:47 -06:00
if (allow_switching && its_since_last_switch >= min_its_after_switch){
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar wqTotal = this->primary_variables_.getWQTotal().value();
changed = this->updateWellControlAndStatusLocalIteration(simulator, well_state, group_state,
inj_controls, prod_controls, wqTotal,
deferred_logger, fixed_control, fixed_status);
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
if (changed){
its_since_last_switch = 0;
switch_count++;
fix well-convergence for well-copies
2023-11-08 14:07:47 -06:00
if (well_status_cur != this->wellStatus_) {
well_status_cur = this->wellStatus_;
}
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
}
if (!changed && final_check) {
break;
} else {
final_check = false;
}
}
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
assembleWellEqWithoutIteration(simulator, dt, inj_controls, prod_controls, well_state, group_state, deferred_logger);
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
const BVectorWell dx_well = this->linSys_.solve();
if (it > this->param_.strict_inner_iter_wells_) {
relax_convergence = true;
this->regularize_ = true;
}
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
const auto report = getWellConvergence(simulator, well_state, Base::B_avg_, deferred_logger, relax_convergence);
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
converged = report.converged();
Throw an error if the status "well convergence" in iterateWellEqWithSwitching of MultisegmentWell is not the same across all processes
2024-09-30 02:06:50 -05:00
if (this->parallel_well_info_.communication().size() > 1 && converged != this->parallel_well_info_.communication().min(converged)) {
OPM_THROW(std::runtime_error, fmt::format("Misalignment of the parallel simulation run in iterateWellEqWithSwitching - the well calculation succeeded on rank {} but failed on other ranks.", this->parallel_well_info_.communication().rank()));
}
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
if (converged) {
// if equations are sufficiently linear they might converge in less than min_its_after_switch
// in this case, make sure all constraints are satisfied before returning
if (switch_count > 0 && its_since_last_switch < min_its_after_switch) {
final_check = true;
its_since_last_switch = min_its_after_switch;
} else {
break;
cleaning up to preapre for pull request
2023-09-25 06:07:39 -05:00
}
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
}
cleaning up to preapre for pull request
2023-09-25 06:07:39 -05:00
// getFinteWellResiduals returns false for nan/inf residuals
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
{
const auto& [isFinite, residuals] = this->getFiniteWellResiduals(Base::B_avg_, deferred_logger);
if (!isFinite)
return false;
residual_history.push_back(residuals);
}
cleaning up to preapre for pull request
2023-09-25 06:07:39 -05:00
if (!converged) {
measure_history.push_back(this->getResidualMeasureValue(well_state,
residual_history[it],
this->param_.tolerance_wells_,
this->param_.tolerance_pressure_ms_wells_,
deferred_logger));
bool is_oscillate = false;
bool is_stagnate = false;
this->detectOscillations(measure_history, is_oscillate, is_stagnate);
// TODO: maybe we should have more sophisticated strategy to recover the relaxation factor,
// for example, to recover it to be bigger
if (is_oscillate || is_stagnate) {
// HACK!
std::string message;
if (relaxation_factor == min_relaxation_factor) {
++stagnate_count;
if (false) { // this disables the usage of the relaxed tolerance
fmt::format_to(std::back_inserter(message), " Well {} observes severe stagnation and/or oscillation."
" We relax the tolerance and check for convergence. \n", this->name());
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
const auto reportStag = getWellConvergence(simulator, well_state, Base::B_avg_,
cleaning up to preapre for pull request
2023-09-25 06:07:39 -05:00
deferred_logger, true);
if (reportStag.converged()) {
converged = true;
fmt::format_to(std::back_inserter(message), " Well {} manages to get converged with relaxed tolerances in {} inner iterations", this->name(), it);
deferred_logger.debug(message);
return converged;
}
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
}
}
cleaning up to preapre for pull request
2023-09-25 06:07:39 -05:00
// a factor value to reduce the relaxation_factor
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
constexpr Scalar reduction_mutliplier = 0.9;
cleaning up to preapre for pull request
2023-09-25 06:07:39 -05:00
relaxation_factor = std::max(relaxation_factor * reduction_mutliplier, min_relaxation_factor);
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
cleaning up to preapre for pull request
2023-09-25 06:07:39 -05:00
// debug output
if (is_stagnate) {
fmt::format_to(std::back_inserter(message), " well {} observes stagnation in inner iteration {}\n", this->name(), it);
}
if (is_oscillate) {
fmt::format_to(std::back_inserter(message), " well {} observes oscillation in inner iteration {}\n", this->name(), it);
}
fmt::format_to(std::back_inserter(message), " relaxation_factor is {} now\n", relaxation_factor);
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
cleaning up to preapre for pull request
2023-09-25 06:07:39 -05:00
this->regularize_ = true;
deferred_logger.debug(message);
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
}
}
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
updateWellState(simulator, dx_well, well_state, deferred_logger, relaxation_factor);
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
initPrimaryVariablesEvaluation();
}
if (converged) {
if (allow_switching){
// update operability if status change
const bool is_stopped = this->wellIsStopped();
if (this->wellHasTHPConstraints(summary_state)){
this->operability_status_.can_obtain_bhp_with_thp_limit = !is_stopped;
this->operability_status_.obey_thp_limit_under_bhp_limit = !is_stopped;
} else {
this->operability_status_.operable_under_only_bhp_limit = !is_stopped;
}
cleaning up to preapre for pull request
2023-09-25 06:07:39 -05:00
}
std::string message = fmt::format(" Well {} converged in {} inner iterations ("
"{} control/status switches).", this->name(), it, switch_count);
if (relax_convergence) {
message.append(fmt::format(" (A relaxed tolerance was used after {} iterations)",
this->param_.strict_inner_iter_wells_));
}
deferred_logger.debug(message);
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
} else {
fix well-convergence for well-copies
2023-11-08 14:07:47 -06:00
this->wellStatus_ = well_status_orig;
always set wells operable to avoid skipping linear solve/updating
2023-11-10 09:03:48 -06:00
this->operability_status_ = operability_orig;
updates according to Atgeirrs comments
2023-12-07 05:15:40 -06:00
const std::string message = fmt::format(" Well {} did not converge in {} inner iterations ("
cleaning up to preapre for pull request
2023-09-25 06:07:39 -05:00
"{} control/status switches).", this->name(), it, switch_count);
deferred_logger.debug(message);
outputting segments with pressure close to lower limit if the well does not get converged.
2024-03-02 09:21:53 -06:00
this->primary_variables_.outputLowLimitPressureSegments(deferred_logger);
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 05:50:06 -05:00
}
return converged;
}
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
template<typename TypeTag>
void
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
assembleWellEqWithoutIteration(const Simulator& simulator,
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
const double dt,
Refactor solving functions to take control objects directly. This allows us to avoid some very hacky manipulation of the Well object.
2019-12-05 05:40:35 -06:00
const Well::InjectionControls& inj_controls,
const Well::ProductionControls& prod_controls,
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
WellState<Scalar>& well_state,
GroupState: template Scalar type
2024-02-17 11:13:46 -06:00
const GroupState<Scalar>& group_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-05 04:22:44 -05:00
DeferredLogger& deferred_logger)
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
{
rename and cleanup
2021-09-29 09:01:16 -05:00
if (!this->isOperableAndSolvable() && !this->wellIsStopped()) return;
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
adding function updateUpwindingSegments() for MSW to update the upwinding segment for each segment based on flow direction
2019-04-12 08:43:39 -05:00
// update the upwinding segments
move updateUpwindingSegments to MultisegmentWellSegments
2022-12-19 08:43:42 -06:00
this->segments_.updateUpwindingSegments(this->primary_variables_);
adding function updateUpwindingSegments() for MSW to update the upwinding segment for each segment based on flow direction
2019-04-12 08:43:39 -05:00
Fix upwining for friction, acceleration, valve and SIGD for MSW Note 1: The rate vectors used for the pressure equation now contains derivatives wrt to the upwind segment for fractions. To make sure derivatives wrt. to different segmens gets mixed we disregard the derivatives for the properties (density, viscosity) evaluated at the upwind segment. Note 2: A factor 2 is added to the velocity head term similar as in the friction term Note 3: A sign change is added to the acceleration term for massrates > 0. Is this correct. It seems like the reference simulator does this.
2020-06-08 06:53:13 -05:00
// calculate the fluid properties needed.
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeSegmentFluidProperties(simulator, deferred_logger);
Fix upwining for friction, acceleration, valve and SIGD for MSW Note 1: The rate vectors used for the pressure equation now contains derivatives wrt to the upwind segment for fractions. To make sure derivatives wrt. to different segmens gets mixed we disregard the derivatives for the properties (density, viscosity) evaluated at the upwind segment. Note 2: A factor 2 is added to the velocity head term similar as in the friction term Note 3: A sign change is added to the acceleration term for massrates > 0. Is this correct. It seems like the reference simulator does this.
2020-06-08 06:53:13 -05:00
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
// clear all entries
added: MultisegmentWellEquations::clear this zeros the equation system. use the new method in the well implementation.
2022-11-11 14:41:24 -06:00
this->linSys_.clear();
Reset duneDSolver only once.
2020-08-18 10:54:15 -05:00
Add dissolved_gas_rate and vaporized_oil_rate to SingleWellState
2021-08-05 03:14:02 -05:00
auto& ws = well_state.well(this->index_of_well_);
changed: store rates in an array in SingleWellState introduce an enum for indexing into the array. this again allows us to coalesce 4 parallel reductions into one.
2023-05-04 06:24:23 -05:00
ws.phase_mixing_rates.fill(0.0);
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
// for the black oil cases, there will be four equations,
// the first three of them are the mass balance equations, the last one is the pressure equations.
//
// but for the top segment, the pressure equation will be the well control equation, and the other three will be the same.
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const bool allow_cf = this->getAllowCrossFlow() || openCrossFlowAvoidSingularity(simulator);
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
add MultisegmentWellGeneric avoid rebuilding this for all simulators when code is only dependent on Scalar. instanced for double
2021-06-03 08:34:14 -05:00
const int nseg = this->numberOfSegments();
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
for (int seg = 0; seg < nseg; ++seg) {
using B_avg for the inner iteration for multisegment wells
2019-02-27 07:47:31 -06:00
// calculating the accumulation term
fixing some typos in MultisegmentWell_impl.hpp
2022-11-05 16:51:59 -05:00
// TODO: without considering the efficiency factor for now
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
{
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const EvalWell segment_surface_volume = getSegmentSurfaceVolume(simulator, seg);
add run time parameters for msw convergence tuning. Default values are set to minimize convergence failures for model2 based tests. These parameters are also tested on bigger models with good results
2020-05-20 09:36:05 -05:00
// Add a regularization_factor to increase the accumulation term
Implements support for gas lift optimization. Implements gas lift optimization for a single StandardWell. Support for gas lift optimization for multi-segment wells, groups of wells and networks is not implemented yet. The keywords LIFTOPT, WLIFTOPT, and VFPPROD are used to supply parameters for the optimization. Also adds support for summary output of liftgas injection rate via keyword WGLIR.
2020-09-30 03:04:39 -05:00
// This will make the system less stiff and help convergence for
add run time parameters for msw convergence tuning. Default values are set to minimize convergence failures for model2 based tests. These parameters are also tested on bigger models with good results
2020-05-20 09:36:05 -05:00
// difficult cases
remove msw(ms) from regulariztion parameter
2022-06-29 05:54:42 -05:00
const Scalar regularization_factor = this->regularize_? this->param_.regularization_factor_wells_ : 1.0;
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
// for each component
drop using statement for num_components_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
for (int comp_idx = 0; comp_idx < this->num_components_; ++comp_idx) {
MultisegmentWell: move surfaceVolumeFraction to MultisegmentWellPrimaryVariables
2022-12-19 02:52:48 -06:00
const EvalWell accumulation_term = regularization_factor * (segment_surface_volume * this->primary_variables_.surfaceVolumeFraction(seg, comp_idx)
first version of using upwinding to handle mass balance for MSW some details to come to make it complete. We are not handling it for injectors and also we are not considering the upwinding when handle the frictional pressure loss and acceleration pressure loss.
2019-04-08 04:40:37 -05:00
- segment_fluid_initial_[seg][comp_idx]) / dt;
MultisegmentWell: use CTAD
2024-02-22 07:50:58 -06:00
MultisegmentWellAssemble(*this).
added: MultisegmentWellAssemble::assembleAccumulationTerm extracted from MultisegmentWell::assembleWellEqWithoutIteration
2022-11-18 05:09:43 -06:00
assembleAccumulationTerm(seg, comp_idx, accumulation_term, this->linSys_);
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
}
}
first version of using upwinding to handle mass balance for MSW some details to come to make it complete. We are not handling it for injectors and also we are not considering the upwinding when handle the frictional pressure loss and acceleration pressure loss.
2019-04-08 04:40:37 -05:00
// considering the contributions due to flowing out from the segment
{
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
const int seg_upwind = this->segments_.upwinding_segment(seg);
drop using statement for num_components_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
for (int comp_idx = 0; comp_idx < this->num_components_; ++comp_idx) {
MultisegmentWell: move getSegmentRateUpwinding to MultisegmentWellPrimaryVariables
2022-12-19 02:52:48 -06:00
const EvalWell segment_rate =
this->primary_variables_.getSegmentRateUpwinding(seg,
seg_upwind,
comp_idx) *
this->well_efficiency_factor_;
MultisegmentWell: use CTAD
2024-02-22 07:50:58 -06:00
MultisegmentWellAssemble(*this).
added: MultisegmentWellAssemble::assembleOutflowTerm extracted from MultisegmentWell::assembleWellEqWithoutIteration
2022-11-18 05:09:43 -06:00
assembleOutflowTerm(seg, seg_upwind, comp_idx, segment_rate, this->linSys_);
first version of using upwinding to handle mass balance for MSW some details to come to make it complete. We are not handling it for injectors and also we are not considering the upwinding when handle the frictional pressure loss and acceleration pressure loss.
2019-04-08 04:40:37 -05:00
}
}
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
// considering the contributions from the inlet segments
{
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
for (const int inlet : this->segments_.inlets()[seg]) {
const int inlet_upwind = this->segments_.upwinding_segment(inlet);
drop using statement for num_components_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
for (int comp_idx = 0; comp_idx < this->num_components_; ++comp_idx) {
MultisegmentWell: move getSegmentRateUpwinding to MultisegmentWellPrimaryVariables
2022-12-19 02:52:48 -06:00
const EvalWell inlet_rate =
this->primary_variables_.getSegmentRateUpwinding(inlet,
inlet_upwind,
comp_idx) *
this->well_efficiency_factor_;
MultisegmentWell: use CTAD
2024-02-22 07:50:58 -06:00
MultisegmentWellAssemble(*this).
added: MultisegmentWellAssemble::assembleInflowTerm extracted from MultisegmentWell::assembleWellEqWithoutIteration
2022-11-18 05:09:43 -06:00
assembleInflowTerm(seg, inlet, inlet_upwind, comp_idx, inlet_rate, this->linSys_);
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
}
}
}
// calculating the perforation rate for each perforation that belongs to this segment
MultisegmentWell: move getSegmentPressure to MultisegmentWellPrimaryVariables
2022-12-19 02:52:48 -06:00
const EvalWell seg_pressure = this->primary_variables_.getSegmentPressure(seg);
Include perforation data in SingleWellState
2021-08-06 06:14:00 -05:00
auto& perf_data = ws.perf_data;
Use PerfData for perforation rates
2021-06-06 10:09:44 -05:00
auto& perf_rates = perf_data.phase_rates;
Use PerfData for perforation pressure
2021-06-05 01:52:18 -05:00
auto& perf_press_state = perf_data.pressure;
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
for (const int perf : this->segments_.perforations()[seg]) {
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const int local_perf_index = this->pw_info_.globalToLocal(perf);
if (local_perf_index < 0) // then the perforation is not on this process
continue;
const int cell_idx = this->well_cells_[local_perf_index];
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& int_quants = simulator.model().intensiveQuantities(cell_idx, /*timeIdx=*/ 0);
drop using statement for num_components_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
std::vector<EvalWell> mob(this->num_components_, 0.0);
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
getMobility(simulator, local_perf_index, mob, deferred_logger);
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar trans_mult = simulator.problem().template wellTransMultiplier<Scalar>(int_quants, cell_idx);
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& wellstate_nupcol = simulator.problem().wellModel().nupcolWellState().well(this->index_of_well_);
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const std::vector<Scalar> Tw = this->wellIndex(local_perf_index, int_quants, trans_mult, wellstate_nupcol);
drop using statement for num_components_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
std::vector<EvalWell> cq_s(this->num_components_, 0.0);
updating perforation pressure and rates for MSW well
2019-04-05 03:01:16 -05:00
EvalWell perf_press;
PerforationRates: template Scalar type
2024-02-20 07:18:30 -06:00
PerforationRates<Scalar> perfRates;
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
computePerfRate(int_quants, mob, Tw, seg, perf, seg_pressure,
allow_cf, cq_s, perf_press, perfRates, deferred_logger);
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
// updating the solution gas rate and solution oil rate
Avoid using the Wells struct.
2019-10-23 02:09:45 -05:00
if (this->isProducer()) {
changed: store rates in an array in SingleWellState introduce an enum for indexing into the array. this again allows us to coalesce 4 parallel reductions into one.
2023-05-04 06:24:23 -05:00
ws.phase_mixing_rates[ws.dissolved_gas] += perfRates.dis_gas;
ws.phase_mixing_rates[ws.vaporized_oil] += perfRates.vap_oil;
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
perf_data.phase_mixing_rates[local_perf_index][ws.dissolved_gas] = perfRates.dis_gas;
perf_data.phase_mixing_rates[local_perf_index][ws.vaporized_oil] = perfRates.vap_oil;
Add well potential output to MSW The common part is moved to the well interface class This commit also adds iterations to the standardWells well potential calculations to improve the results
2019-04-23 06:30:12 -05:00
}
updating perforation pressure and rates for MSW well
2019-04-05 03:01:16 -05:00
// store the perf pressure and rates
drop using statement for num_components_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
for (int comp_idx = 0; comp_idx < this->num_components_; ++comp_idx) {
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
perf_rates[local_perf_index*this->number_of_phases_ + this->modelCompIdxToFlowCompIdx(comp_idx)] = cq_s[comp_idx].value();
updating perforation pressure and rates for MSW well
2019-04-05 03:01:16 -05:00
}
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
perf_press_state[local_perf_index] = perf_press.value();
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
drop using statement for num_components_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
for (int comp_idx = 0; comp_idx < this->num_components_; ++comp_idx) {
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
// the cq_s entering mass balance equations need to consider the efficiency factors.
drop using statement for well_efficiency_factor_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
const EvalWell cq_s_effective = cq_s[comp_idx] * this->well_efficiency_factor_;
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
this->connectionRates_[local_perf_index][comp_idx] = Base::restrictEval(cq_s_effective);
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
MultisegmentWell: use CTAD
2024-02-22 07:50:58 -06:00
MultisegmentWellAssemble(*this).
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
assemblePerforationEq(seg, local_perf_index, comp_idx, cq_s_effective, this->linSys_);
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
}
}
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
// the fourth equation, the pressure drop equation
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
if (seg == 0) { // top segment, pressure equation is the control equation
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& summaryState = simulator.vanguard().summaryState();
const Schedule& schedule = simulator.vanguard().schedule();
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
const bool stopped_or_zero_target = this->stoppedOrZeroRateTarget(simulator, well_state, deferred_logger);
MultisegmentWell: use CTAD
2024-02-22 07:50:58 -06:00
MultisegmentWellAssemble(*this).
added: MultisegmentWellAssemble this handles assembly of the equation system for multisegment well. start by moving assembleControlEq into the new class
2022-11-18 04:57:37 -06:00
assembleControlEq(well_state,
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
group_state,
schedule,
summaryState,
inj_controls,
prod_controls,
getRefDensity(),
MultisegmentWellAssemble: simplify assembleControlEq by passing primary variables
2022-12-19 04:49:00 -06:00
this->primary_variables_,
added: MultisegmentWellAssemble this handles assembly of the equation system for multisegment well. start by moving assembleControlEq into the new class
2022-11-18 04:57:37 -06:00
this->linSys_,
Include checking for zero targets from groups where required
2024-03-19 06:50:34 -05:00
stopped_or_zero_target,
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
deferred_logger);
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
} else {
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const UnitSystem& unit_system = simulator.vanguard().eclState().getDeckUnitSystem();
const auto& summary_state = simulator.vanguard().summaryState();
Allow UDA for WSEGVALV item 4
2023-09-15 08:21:19 -05:00
this->assemblePressureEq(seg, unit_system, well_state, summary_state, this->param_.use_average_density_ms_wells_, deferred_logger);
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
}
}
added: MultisegmentWellEquations::createSolver this applies compute the LU decomposition of the D matrix
2022-11-11 14:41:24 -06:00
Other communication measures taken from StandardWells
2024-09-30 02:05:25 -05:00
this->parallel_well_info_.communication().sum(this->ipr_a_.data(), this->ipr_a_.size());
added: MultisegmentWellEquations::createSolver this applies compute the LU decomposition of the D matrix
2022-11-11 14:41:24 -06:00
this->linSys_.createSolver();
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
}
importing the old WSEGSICD implementation with small adjustments to make it compile
2019-11-24 04:11:50 -06:00
putting all the pressure assmeble function to one function assemblePressureEq for MSW
2021-01-08 08:27:43 -06:00
add openCrossFlowAvoidSingularity functionality for MSW
2019-11-07 07:01:21 -06:00
template<typename TypeTag>
bool
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
openCrossFlowAvoidSingularity(const Simulator& simulator) const
add openCrossFlowAvoidSingularity functionality for MSW
2019-11-07 07:01:21 -06:00
{
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
return !this->getAllowCrossFlow() && allDrawDownWrongDirection(simulator);
add openCrossFlowAvoidSingularity functionality for MSW
2019-11-07 07:01:21 -06:00
}
template<typename TypeTag>
bool
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
allDrawDownWrongDirection(const Simulator& simulator) const
add openCrossFlowAvoidSingularity functionality for MSW
2019-11-07 07:01:21 -06:00
{
bool all_drawdown_wrong_direction = true;
add MultisegmentWellGeneric avoid rebuilding this for all simulators when code is only dependent on Scalar. instanced for double
2021-06-03 08:34:14 -05:00
const int nseg = this->numberOfSegments();
trying to add an inner well iteration to speed up convergence.
2017-10-10 07:30:23 -05:00
add openCrossFlowAvoidSingularity functionality for MSW
2019-11-07 07:01:21 -06:00
for (int seg = 0; seg < nseg; ++seg) {
MultisegmentWell: move getSegmentPressure to MultisegmentWellPrimaryVariables
2022-12-19 02:52:48 -06:00
const EvalWell segment_pressure = this->primary_variables_.getSegmentPressure(seg);
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
for (const int perf : this->segments_.perforations()[seg]) {
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const int local_perf_index = this->pw_info_.globalToLocal(perf);
if (local_perf_index < 0) // then the perforation is not on this process
continue;
first version of the well testing for physical reason the key difficulty is that we do not have reliable explicit information to do the testing. In this version, we try to obtain the explicit information by finishing one converged solving.
2018-11-22 08:44:09 -06:00
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const int cell_idx = this->well_cells_[local_perf_index];
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& intQuants = simulator.model().intensiveQuantities(cell_idx, /*timeIdx=*/ 0);
add openCrossFlowAvoidSingularity functionality for MSW
2019-11-07 07:01:21 -06:00
const auto& fs = intQuants.fluidState();
// pressure difference between the segment and the perforation
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
const EvalWell perf_seg_press_diff = this->segments_.getPressureDiffSegPerf(seg, perf);
add openCrossFlowAvoidSingularity functionality for MSW
2019-11-07 07:01:21 -06:00
// pressure difference between the perforation and the grid cell
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const Scalar cell_perf_press_diff = this->cell_perforation_pressure_diffs_[local_perf_index];
add openCrossFlowAvoidSingularity functionality for MSW
2019-11-07 07:01:21 -06:00
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar pressure_cell = this->getPerfCellPressure(fs).value();
const Scalar perf_press = pressure_cell - cell_perf_press_diff;
add openCrossFlowAvoidSingularity functionality for MSW
2019-11-07 07:01:21 -06:00
// Pressure drawdown (also used to determine direction of flow)
// TODO: not 100% sure about the sign of the seg_perf_press_diff
const EvalWell drawdown = perf_press - (segment_pressure + perf_seg_press_diff);
// for now, if there is one perforation can produce/inject in the correct
// direction, we consider this well can still produce/inject.
// TODO: it can be more complicated than this to cause wrong-signed rates
Avoid using the Wells struct.
2019-10-23 02:09:45 -05:00
if ( (drawdown < 0. && this->isInjector()) ||
(drawdown > 0. && this->isProducer()) ) {
add openCrossFlowAvoidSingularity functionality for MSW
2019-11-07 07:01:21 -06:00
all_drawdown_wrong_direction = false;
break;
}
}
}
Other communication measures taken from StandardWells
2024-09-30 02:05:25 -05:00
const auto& comm = this->parallel_well_info_.communication();
if (comm.size() > 1)
{
all_drawdown_wrong_direction =
(comm.min(all_drawdown_wrong_direction ? 1 : 0) == 1);
}
first version of the well testing for physical reason the key difficulty is that we do not have reliable explicit information to do the testing. In this version, we try to obtain the explicit information by finishing one converged solving.
2018-11-22 08:44:09 -06:00
add openCrossFlowAvoidSingularity functionality for MSW
2019-11-07 07:01:21 -06:00
return all_drawdown_wrong_direction;
}
first version of the well testing for physical reason the key difficulty is that we do not have reliable explicit information to do the testing. In this version, we try to obtain the explicit information by finishing one converged solving.
2018-11-22 08:44:09 -06:00
finish the injecivity functionality the result looks okay
2018-11-30 05:15:51 -06:00
template<typename TypeTag>
void
MultisegmentWell<TypeTag>::
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
updateWaterThroughput(const double /*dt*/, WellState<Scalar>& /*well_state*/) const
finish the injecivity functionality the result looks okay
2018-11-30 05:15:51 -06:00
{
}
considering the pressure dependence of the segment volume segment volume is fixed, while duo to composition and pressure change, within the fixed segment volume, different amounts of fluids can be contained.
2019-02-12 05:48:51 -06:00
template<typename TypeTag>
typename MultisegmentWell<TypeTag>::EvalWell
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
getSegmentSurfaceVolume(const Simulator& simulator, const int seg_idx) const
considering the pressure dependence of the segment volume segment volume is fixed, while duo to composition and pressure change, within the fixed segment volume, different amounts of fluids can be contained.
2019-02-12 05:48:51 -06:00
{
EvalWell temperature;
pass the saltConcentration to the waterPVT
2020-07-02 06:44:01 -05:00
EvalWell saltConcentration;
considering the pressure dependence of the segment volume segment volume is fixed, while duo to composition and pressure change, within the fixed segment volume, different amounts of fluids can be contained.
2019-02-12 05:48:51 -06:00
int pvt_region_index;
{
// using the pvt region of first perforated cell
// TODO: it should be a member of the WellInterface, initialized properly
drop using statement for well_cells_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
const int cell_idx = this->well_cells_[0];
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& intQuants = simulator.model().intensiveQuantities(cell_idx, /*timeIdx=*/0);
considering the pressure dependence of the segment volume segment volume is fixed, while duo to composition and pressure change, within the fixed segment volume, different amounts of fluids can be contained.
2019-02-12 05:48:51 -06:00
const auto& fs = intQuants.fluidState();
temperature.setValue(fs.temperature(FluidSystem::oilPhaseIdx).value());
add MultisegmentWellEval
2021-06-03 08:34:14 -05:00
saltConcentration = this->extendEval(fs.saltConcentration());
considering the pressure dependence of the segment volume segment volume is fixed, while duo to composition and pressure change, within the fixed segment volume, different amounts of fluids can be contained.
2019-02-12 05:48:51 -06:00
pvt_region_index = fs.pvtRegionIndex();
}
move getSegmentSurfaceVolume to MultisegmentWellSegments
2022-12-19 07:20:55 -06:00
return this->segments_.getSurfaceVolume(temperature,
saltConcentration,
this->primary_variables_,
pvt_region_index,
seg_idx);
adding function updateUpwindingSegments() for MSW to update the upwinding segment for each segment based on flow direction
2019-04-12 08:43:39 -05:00
}
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
Add gaslift optimization support for MSW. Implements gas lift optimization support for multisegmented wells (MSW).
2022-02-07 04:28:35 -06:00
template<typename TypeTag>
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::optional<typename MultisegmentWell<TypeTag>::Scalar>
Add gaslift optimization support for MSW. Implements gas lift optimization support for multisegmented wells (MSW).
2022-02-07 04:28:35 -06:00
MultisegmentWell<TypeTag>::
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
computeBhpAtThpLimitProd(const WellState<Scalar>& well_state,
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const Simulator& simulator,
Add gaslift optimization support for MSW. Implements gas lift optimization support for multisegmented wells (MSW).
2022-02-07 04:28:35 -06:00
const SummaryState& summary_state,
DeferredLogger& deferred_logger) const
{
return this->MultisegmentWell<TypeTag>::computeBhpAtThpLimitProdWithAlq(
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
simulator,
Add gaslift optimization support for MSW. Implements gas lift optimization support for multisegmented wells (MSW).
2022-02-07 04:28:35 -06:00
summary_state,
changed: tidy up computeBhpAtThpLimitProdWithAlq interface put deferred_logger at the end of the parameter list. similar to the rest of this family of methods
2022-10-19 05:23:02 -05:00
this->getALQ(well_state),
Dont iterate when computing bhp from thp for computing of the well potentials for gaslift optimization
2024-10-23 02:09:09 -05:00
deferred_logger,
/*iterate_if_no_solution */ true);
Add gaslift optimization support for MSW. Implements gas lift optimization support for multisegmented wells (MSW).
2022-02-07 04:28:35 -06:00
}
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
implementing the support for WSEGVALV
2019-11-29 10:23:26 -06:00
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
template<typename TypeTag>
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::optional<typename MultisegmentWell<TypeTag>::Scalar>
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeBhpAtThpLimitProdWithAlq(const Simulator& simulator,
Add gaslift optimization support for MSW. Implements gas lift optimization support for multisegmented wells (MSW).
2022-02-07 04:28:35 -06:00
const SummaryState& summary_state,
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar alq_value,
Dont iterate when computing bhp from thp for computing of the well potentials for gaslift optimization
2024-10-23 02:09:09 -05:00
DeferredLogger& deferred_logger,
bool iterate_if_no_solution) const
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
{
// Make the frates() function.
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
auto frates = [this, &simulator, &deferred_logger](const Scalar bhp) {
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
// Not solving the well equations here, which means we are
// calculating at the current Fg/Fw values of the
// well. This does not matter unless the well is
// crossflowing, and then it is likely still a good
// approximation.
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> rates(3);
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesWithBhp(simulator, bhp, rates, deferred_logger);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
return rates;
};
changed: drop wrapper MultisegmentWellGeneric::computeBhpAtThpLimitProdWithAlq
2022-10-19 05:04:02 -05:00
auto bhpAtLimit = WellBhpThpCalculator(*this).
computeBhpAtThpLimitProd(frates,
add MultisegmentWellGeneric avoid rebuilding this for all simulators when code is only dependent on Scalar. instanced for double
2021-06-03 08:34:14 -05:00
summary_state,
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
this->maxPerfPress(simulator),
changed: drop wrapper MultisegmentWellGeneric::computeBhpAtThpLimitProdWithAlq
2022-10-19 05:04:02 -05:00
this->getRefDensity(),
alq_value,
fix regression in wells we need to call WellInterface::getTHPConstraint, not WellBhpThpCalculator::getTHPConstraint
2022-11-23 08:37:04 -06:00
this->getTHPConstraint(summary_state),
changed: drop wrapper MultisegmentWellGeneric::computeBhpAtThpLimitProdWithAlq
2022-10-19 05:04:02 -05:00
deferred_logger);
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
changed: drop wrapper MultisegmentWellGeneric::computeBhpAtThpLimitProdWithAlq
2022-10-19 05:04:02 -05:00
if (bhpAtLimit)
cleanup
2021-09-13 08:11:38 -05:00
return bhpAtLimit;
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
Dont iterate when computing bhp from thp for computing of the well potentials for gaslift optimization
2024-10-23 02:09:09 -05:00
if (!iterate_if_no_solution)
return std::nullopt;
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
auto fratesIter = [this, &simulator, &deferred_logger](const Scalar bhp) {
cleanup
2021-09-13 08:11:38 -05:00
// Solver the well iterations to see if we are
// able to get a solution with an update
// solution
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> rates(3);
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesWithBhpIterations(simulator, bhp, rates, deferred_logger);
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
return rates;
};
changed: drop wrapper MultisegmentWellGeneric::computeBhpAtThpLimitProdWithAlq
2022-10-19 05:04:02 -05:00
return WellBhpThpCalculator(*this).
computeBhpAtThpLimitProd(fratesIter,
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
summary_state,
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
this->maxPerfPress(simulator),
changed: drop wrapper MultisegmentWellGeneric::computeBhpAtThpLimitProdWithAlq
2022-10-19 05:04:02 -05:00
this->getRefDensity(),
alq_value,
fix regression in wells we need to call WellInterface::getTHPConstraint, not WellBhpThpCalculator::getTHPConstraint
2022-11-23 08:37:04 -06:00
this->getTHPConstraint(summary_state),
changed: drop wrapper MultisegmentWellGeneric::computeBhpAtThpLimitProdWithAlq
2022-10-19 05:04:02 -05:00
deferred_logger);
importing the old WSEGSICD implementation with small adjustments to make it compile
2019-11-24 04:11:50 -06:00
}
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
template<typename TypeTag>
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::optional<typename MultisegmentWell<TypeTag>::Scalar>
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeBhpAtThpLimitInj(const Simulator& simulator,
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
const SummaryState& summary_state,
DeferredLogger& deferred_logger) const
{
// Make the frates() function.
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
auto frates = [this, &simulator, &deferred_logger](const Scalar bhp) {
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
// Not solving the well equations here, which means we are
// calculating at the current Fg/Fw values of the
// well. This does not matter unless the well is
// crossflowing, and then it is likely still a good
// approximation.
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> rates(3);
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesWithBhp(simulator, bhp, rates, deferred_logger);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
return rates;
};
changed: move computeBhpFromThpLimitInj to WellBhpThpCalculator
2022-10-19 02:55:14 -05:00
auto bhpAtLimit = WellBhpThpCalculator(*this).
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
computeBhpAtThpLimitInj(frates,
summary_state,
changed: move computeBhpFromThpLimitInj to WellBhpThpCalculator
2022-10-19 02:55:14 -05:00
this->getRefDensity(),
0.05,
100,
false,
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
deferred_logger);
changed: move computeBhpFromThpLimitInj to WellBhpThpCalculator
2022-10-19 02:55:14 -05:00
if (bhpAtLimit)
cleanup
2021-09-13 08:11:38 -05:00
return bhpAtLimit;
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
auto fratesIter = [this, &simulator, &deferred_logger](const Scalar bhp) {
cleanup
2021-09-13 08:11:38 -05:00
// Solver the well iterations to see if we are
// able to get a solution with an update
// solution
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> rates(3);
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeWellRatesWithBhpIterations(simulator, bhp, rates, deferred_logger);
avoid iter in computeBhpFromThp
2021-09-13 03:58:50 -05:00
return rates;
};
changed: move computeBhpFromThpLimitInj to WellBhpThpCalculator
2022-10-19 02:55:14 -05:00
return WellBhpThpCalculator(*this).
computeBhpAtThpLimitInj(fratesIter,
summary_state,
this->getRefDensity(),
0.05,
100,
false,
deferred_logger);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
}
importing the old WSEGSICD implementation with small adjustments to make it compile
2019-11-24 04:11:50 -06:00
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
template<typename TypeTag>
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
typename MultisegmentWell<TypeTag>::Scalar
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
maxPerfPress(const Simulator& simulator) const
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
{
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
Scalar max_pressure = 0.0;
add MultisegmentWellGeneric avoid rebuilding this for all simulators when code is only dependent on Scalar. instanced for double
2021-06-03 08:34:14 -05:00
const int nseg = this->numberOfSegments();
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
for (int seg = 0; seg < nseg; ++seg) {
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
for (const int perf : this->segments_.perforations()[seg]) {
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const int local_perf_index = this->pw_info_.globalToLocal(perf);
if (local_perf_index < 0) // then the perforation is not on this process
continue;
const int cell_idx = this->well_cells_[local_perf_index];
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& int_quants = simulator.model().intensiveQuantities(cell_idx, /*timeIdx=*/ 0);
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
const auto& fs = int_quants.fluidState();
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
Scalar pressure_cell = this->getPerfCellPressure(fs).value();
Improve/fix well potential calculations for MultiSegmentWell. Includes fixes for bhp-based potentials, and an implementation for thp-based potentials similar to that for StandardWell.
2019-11-18 09:33:10 -06:00
max_pressure = std::max(max_pressure, pressure_cell);
}
}
return max_pressure;
}
importing the old WSEGSICD implementation with small adjustments to make it compile
2019-11-24 04:11:50 -06:00
Refactor to put updateWellStateRates() in base class.
2020-10-15 07:15:05 -05:00
template<typename TypeTag>
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<typename MultisegmentWell<TypeTag>::Scalar>
Refactor to put updateWellStateRates() in base class.
2020-10-15 07:15:05 -05:00
MultisegmentWell<TypeTag>::
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
computeCurrentWellRates(const Simulator& simulator,
Refactor to put updateWellStateRates() in base class.
2020-10-15 07:15:05 -05:00
DeferredLogger& deferred_logger) const
{
// Calculate the rates that follow from the current primary variables.
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
std::vector<Scalar> well_q_s(this->num_components_, 0.0);
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const bool allow_cf = this->getAllowCrossFlow() || openCrossFlowAvoidSingularity(simulator);
add MultisegmentWellGeneric avoid rebuilding this for all simulators when code is only dependent on Scalar. instanced for double
2021-06-03 08:34:14 -05:00
const int nseg = this->numberOfSegments();
Implemented computeCurrentWellRates() for multisegment wells. Also add effect of rock compressibility on well connection transmissibility factors, which was added to StandardWell earlier but not MultisegmentWell.
2020-10-15 09:24:55 -05:00
for (int seg = 0; seg < nseg; ++seg) {
// calculating the perforation rate for each perforation that belongs to this segment
MultisegmentWell: move getSegmentPressure to MultisegmentWellPrimaryVariables
2022-12-19 02:52:48 -06:00
const Scalar seg_pressure = getValue(this->primary_variables_.getSegmentPressure(seg));
MultisegmentWellSegments: make members private and add various read-only accessors
2022-12-19 08:52:36 -06:00
for (const int perf : this->segments_.perforations()[seg]) {
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const int local_perf_index = this->pw_info_.globalToLocal(perf);
if (local_perf_index < 0) // then the perforation is not on this process
continue;
const int cell_idx = this->well_cells_[local_perf_index];
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& int_quants = simulator.model().intensiveQuantities(cell_idx, /*timeIdx=*/ 0);
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
std::vector<Scalar> mob(this->num_components_, 0.0);
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
getMobility(simulator, local_perf_index, mob, deferred_logger);
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
const Scalar trans_mult = simulator.problem().template wellTransMultiplier<Scalar>(int_quants, cell_idx);
Rename ebos_simulator members/parameters to simulator
2024-02-06 04:55:07 -06:00
const auto& wellstate_nupcol = simulator.problem().wellModel().nupcolWellState().well(this->index_of_well_);
Use local_perf_index instead of perf index where applicable The vectors that contain info about the perforations of a multisegment well are *local* vectors, yet the way we access them by looping over the perforations is global, so when accessing a value we need to get the local perforation index (and with this also check if the perforation actually resides on the own process)
2024-10-15 07:11:34 -05:00
const std::vector<Scalar> Tw = this->wellIndex(local_perf_index, int_quants, trans_mult, wellstate_nupcol);
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
std::vector<Scalar> cq_s(this->num_components_, 0.0);
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
Scalar perf_press = 0.0;
PerforationRates: template Scalar type
2024-02-20 07:18:30 -06:00
PerforationRates<Scalar> perf_rates;
changed: unify MultisegmentdWell::computePerfRate(Eval|Scalar)
2023-05-07 14:56:09 -05:00
computePerfRate(int_quants, mob, Tw, seg, perf, seg_pressure,
allow_cf, cq_s, perf_press, perf_rates, deferred_logger);
drop using statement for num_components_ rather qualify member variable with this->
2021-09-06 05:58:16 -05:00
for (int comp = 0; comp < this->num_components_; ++comp) {
Implemented computeCurrentWellRates() for multisegment wells. Also add effect of rock compressibility on well connection transmissibility factors, which was added to StandardWell earlier but not MultisegmentWell.
2020-10-15 09:24:55 -05:00
well_q_s[comp] += cq_s[comp];
}
Refactor to put updateWellStateRates() in base class.
2020-10-15 07:15:05 -05:00
}
}
Other communication measures taken from StandardWells
2024-09-30 02:05:25 -05:00
const auto& comm = this->parallel_well_info_.communication();
if (comm.size() > 1)
{
comm.sum(well_q_s.data(), well_q_s.size());
}
make scalar version of computePerfRate
2021-09-13 02:36:16 -05:00
return well_q_s;
Unify group control equation codes.
2020-03-24 05:07:14 -05:00
}
Refactor to put updateWellStateRates() in base class.
2020-10-15 07:15:05 -05:00
Add methods for getting and setting primary variables. These can be used to manage state in the well models, and will be used in the NLDD solver option. Also added the setupDomains() method, as the getters and setters are working on a domain basis.
2023-06-13 05:58:07 -05:00
template <typename TypeTag>
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<typename MultisegmentWell<TypeTag>::Scalar>
Add methods for getting and setting primary variables. These can be used to manage state in the well models, and will be used in the NLDD solver option. Also added the setupDomains() method, as the getters and setters are working on a domain basis.
2023-06-13 05:58:07 -05:00
MultisegmentWell<TypeTag>::
getPrimaryVars() const
{
const int num_seg = this->numberOfSegments();
Silence shadowing warning.
2023-06-13 05:58:07 -05:00
constexpr int num_eq = MSWEval::numWellEq;
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::vector<Scalar> retval(num_seg * num_eq);
Add methods for getting and setting primary variables. These can be used to manage state in the well models, and will be used in the NLDD solver option. Also added the setupDomains() method, as the getters and setters are working on a domain basis.
2023-06-13 05:58:07 -05:00
for (int ii = 0; ii < num_seg; ++ii) {
const auto& pv = this->primary_variables_.value(ii);
Silence shadowing warning.
2023-06-13 05:58:07 -05:00
std::copy(pv.begin(), pv.end(), retval.begin() + ii * num_eq);
Add methods for getting and setting primary variables. These can be used to manage state in the well models, and will be used in the NLDD solver option. Also added the setupDomains() method, as the getters and setters are working on a domain basis.
2023-06-13 05:58:07 -05:00
}
return retval;
}
template <typename TypeTag>
int
MultisegmentWell<TypeTag>::
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
setPrimaryVars(typename std::vector<Scalar>::const_iterator it)
Add methods for getting and setting primary variables. These can be used to manage state in the well models, and will be used in the NLDD solver option. Also added the setupDomains() method, as the getters and setters are working on a domain basis.
2023-06-13 05:58:07 -05:00
{
const int num_seg = this->numberOfSegments();
Silence shadowing warning.
2023-06-13 05:58:07 -05:00
constexpr int num_eq = MSWEval::numWellEq;
MultisegmentWell: use Scalar type
2024-02-20 15:32:18 -06:00
std::array<Scalar, num_eq> tmp;
Add methods for getting and setting primary variables. These can be used to manage state in the well models, and will be used in the NLDD solver option. Also added the setupDomains() method, as the getters and setters are working on a domain basis.
2023-06-13 05:58:07 -05:00
for (int ii = 0; ii < num_seg; ++ii) {
Fix memory bug in setPrimaryVars for MSW
2024-10-15 09:31:38 -05:00
const auto start = it + ii * num_eq;
Silence shadowing warning.
2023-06-13 05:58:07 -05:00
std::copy(start, start + num_eq, tmp.begin());
Add methods for getting and setting primary variables. These can be used to manage state in the well models, and will be used in the NLDD solver option. Also added the setupDomains() method, as the getters and setters are working on a domain basis.
2023-06-13 05:58:07 -05:00
this->primary_variables_.setValue(ii, tmp);
}
Silence shadowing warning.
2023-06-13 05:58:07 -05:00
return num_seg * num_eq;
Add methods for getting and setting primary variables. These can be used to manage state in the well models, and will be used in the NLDD solver option. Also added the setupDomains() method, as the getters and setters are working on a domain basis.
2023-06-13 05:58:07 -05:00
}
Refactor to put updateWellStateRates() in base class.
2020-10-15 07:15:05 -05:00
} // namespace Opm
Reference in New Issue Copy Permalink