OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2024-12-30 11:06:55 -06:00
Code Issues Packages Projects Releases Wiki Activity
6ef0c5010c
opm-simulators/opm/autodiff/StandardWellsDense.hpp

288 lines
12 KiB
C++
Raw Normal View History

Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
/*
Copyright 2016 SINTEF ICT, Applied Mathematics.
Updated Copyright stuff
2017-03-24 06:19:11 -05:00
Copyright 2016 - 2017 Statoil ASA.
Copyright 2017 Dr. Blatt - HPC-Simulation-Software & Services
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
Copyright 2016 - 2017 IRIS AS
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
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/>.
*/
#ifndef OPM_STANDARDWELLSDENSE_HEADER_INCLUDED
#define OPM_STANDARDWELLSDENSE_HEADER_INCLUDED
#include <opm/common/OpmLog/OpmLog.hpp>
#include <opm/common/utility/platform_dependent/disable_warnings.h>
#include <opm/common/utility/platform_dependent/reenable_warnings.h>
#include <cassert>
#include <tuple>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/core/wells.h>
#include <opm/core/wells/DynamicListEconLimited.hpp>
adding well collection to StandardWellsDense to make StandardWellsDense have access to the group information.
2017-01-09 03:36:17 -06:00
#include <opm/core/wells/WellCollection.hpp>
Fix the PR that said it activated AMG. Actually, it did not as it did set the define eith wrong or the wrong locations. This commit fixes this and finally makes AMG available.
2017-05-22 12:35:38 -05:00
#include <opm/core/simulator/SimulatorReport.hpp>
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
#include <opm/autodiff/VFPProperties.hpp>
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
#include <opm/autodiff/WellHelpers.hpp>
#include <opm/autodiff/BlackoilModelEnums.hpp>
#include <opm/autodiff/WellDensitySegmented.hpp>
remove the BlackoilPropsAdInterface abstraction layer instead, directly use BlackoilPropsAdFromDeck.
2016-12-29 09:35:24 -06:00
#include <opm/autodiff/BlackoilPropsAdFromDeck.hpp>
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
#include <opm/autodiff/BlackoilDetails.hpp>
#include <opm/autodiff/BlackoilModelParameters.hpp>
Remove WellStateFullyImplicitBlackoilDense After the restructuring of of the well model, keeping an extra class for the "Dense" model is not needed. The only thing still left in WellStateFullyImplicitBlackoilDense was some solvent related stuff, this PR moves this to WellStateFullyImplicitBlackoil and removes WellStateFullyImplicitBlackoilDense. In addition to a cleaning code this PR fixes missing solvent well output.
2017-10-06 03:59:42 -05:00
#include <opm/autodiff/WellStateFullyImplicitBlackoil.hpp>
adding a pointer to rate_converter in BlackoilModelEbos in StandardWellsDense.
2017-01-17 06:14:32 -06:00
#include <opm/autodiff/RateConverter.hpp>
more or less getting the old implementation in and compile now.
2017-06-15 10:19:49 -05:00
#include <opm/autodiff/WellInterface.hpp>
incoporating more content from PR 1220 while the parts related to polymer are not incoporated fully yet, since it has been considered in the new well model refactoring.
2017-06-27 09:04:04 -05:00
#include <opm/autodiff/StandardWell.hpp>
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
#include <opm/autodiff/MultisegmentWell.hpp>
Temperary commit -- works on SPE1 but not SPE9 -- if number of perforations are increased to 3 in SPE1 the same error as in SPE9 occur.
2016-08-25 08:25:01 -05:00
#include<dune/common/fmatrix.hh>
#include<dune/istl/bcrsmatrix.hh>
#include<dune/istl/matrixmatrix.hh>
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
#include <opm/material/densead/Math.hpp>
moving the update the well_state at the end of the updatewellCotnrols in StandardWellsDense. The reason is that the update the well controls can change the well controls. It is better to update the well states after all the control checking is done.
2017-01-24 08:59:41 -06:00
#include <opm/simulators/WellSwitchingLogger.hpp>
more or less getting the old implementation in and compile now.
2017-06-15 10:19:49 -05:00
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
namespace Opm {
/// Class for handling the standard well model.
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
template<typename TypeTag>
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
class StandardWellsDense {
public:
// --------- Types ---------
Remove WellStateFullyImplicitBlackoilDense After the restructuring of of the well model, keeping an extra class for the "Dense" model is not needed. The only thing still left in WellStateFullyImplicitBlackoilDense was some solvent related stuff, this PR moves this to WellStateFullyImplicitBlackoil and removes WellStateFullyImplicitBlackoilDense. In addition to a cleaning code this PR fixes missing solvent well output.
2017-10-06 03:59:42 -05:00
typedef WellStateFullyImplicitBlackoil WellState;
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
typedef BlackoilModelParameters ModelParameters;
[bugfix][StandardWellsDense] remove auto from method parameter list.
2017-06-27 09:51:11 -05:00
typedef typename GET_PROP_TYPE(TypeTag, Grid) Grid;
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
typedef typename GET_PROP_TYPE(TypeTag, FluidSystem) FluidSystem;
typedef typename GET_PROP_TYPE(TypeTag, ElementContext) ElementContext;
typedef typename GET_PROP_TYPE(TypeTag, Indices) BlackoilIndices;
typedef typename GET_PROP_TYPE(TypeTag, Simulator) Simulator;
[feature] Added two-phase executable for numEq = 2.
2017-06-27 07:04:59 -05:00
typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
static const int numEq = BlackoilIndices::numEq;
Add polymer option to flow_ebos No extra equation is added for polymer in the well equation. Seperate executables are added for polymer: flow_ebos_polymer and solvent: flow_ebos_solvent Tested and verified on the test cases in polymer_test_suite This PR should not effect the performance and results of the blackoil simulator
2017-06-07 02:29:31 -05:00
static const int solventSaturationIdx = BlackoilIndices::solventSaturationIdx;
[feature] Added two-phase executable for numEq = 2.
2017-06-27 07:04:59 -05:00
adding applySolutionWellState to apply solution from reservoir to update well state. With this way, the BlackoilModelEbos does not need to know the data type assocated with different well type. It is not well tested yet.
2017-07-21 08:30:34 -05:00
// TODO: where we should put these types, WellInterface or Well Model?
// or there is some other strategy, like TypeTag
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
typedef Dune::FieldVector<Scalar, numEq > VectorBlockType;
Remove Eigen from StandardWellsDense
2016-11-01 07:41:00 -05:00
typedef Dune::BlockVector<VectorBlockType> BVector;
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
Add polymer option to flow_ebos No extra equation is added for polymer in the well equation. Seperate executables are added for polymer: flow_ebos_polymer and solvent: flow_ebos_solvent Tested and verified on the test cases in polymer_test_suite This PR should not effect the performance and results of the blackoil simulator
2017-06-07 02:29:31 -05:00
typedef Ewoms::BlackOilPolymerModule<TypeTag> PolymerModule;
Fix the 2p simulator Only tested for oil+water case The blockmatrix and vectors are hardcoded to be 3 and a trivial equation is used for the Gas phase.
2016-11-18 05:43:53 -06:00
adding a pointer to rate_converter in BlackoilModelEbos in StandardWellsDense.
2017-01-17 06:14:32 -06:00
// For the conversion between the surface volume rate and resrevoir voidage rate
using RateConverterType = RateConverter::
SurfaceToReservoirVoidage<BlackoilPropsAdFromDeck::FluidSystem, std::vector<int> >;
Remove Eigen from StandardWellsDense
2016-11-01 07:41:00 -05:00
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
// --------- Public methods ---------
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
StandardWellsDense(const Wells* wells_arg,
adding well collection to StandardWellsDense to make StandardWellsDense have access to the group information.
2017-01-09 03:36:17 -06:00
WellCollection* well_collection,
Implement solvent model in flow_ebos 1) Extends the well model to account for solvent surface volumes 2) Add solvent to updateState 3) Add solvent to well and field output The solvent parts is encapsled in if (has_solvent_) and should not effect the standard runs.
2017-05-09 01:21:51 -05:00
const std::vector< const Well* >& wells_ecl,
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
const ModelParameters& param,
making rate_converter to be reference to the one in Simulator keeping the const property in the Well Model.
2017-08-10 04:20:09 -05:00
const RateConverterType& rate_converter,
Implement solvent model in flow_ebos 1) Extends the well model to account for solvent surface volumes 2) Add solvent to updateState 3) Add solvent to well and field output The solvent parts is encapsled in if (has_solvent_) and should not effect the standard runs.
2017-05-09 01:21:51 -05:00
const bool terminal_output,
Use pore volume weighted averaged hydrocarbon state in rateConverted. - pressure, rs and rv is averaged using hydrocarbon pore volume weights. - pvtRegions is used as input in the conversion factor calculations. - the pvt cell of the first well cell is used as the pvt index. (Completing a well in two different PVT regions sounds like a very bad idea anyway) - FIP region support is added to the rate converter also for the ebos interface.
2017-10-02 07:18:33 -05:00
const int current_index,
std::vector<int>& pvt_region_idx);
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
small improvements to StandardWellsDense the most significant change is that only a "PhaseUsage" object must be passed to its constructor instead of a full "fluid object". also, the pointers to the vector of "active" phases has been converted into a full object. (this helps to avoid potential use-after-free errors.)
2017-01-11 10:02:20 -06:00
void init(const PhaseUsage phase_usage_arg,
const std::vector<bool>& active_arg,
Some micro performance improvments and cleaning -- The jacobian and residual in the reservoir is updated directly -- The sparsity pattern are provided to the well matrices. -- Some cleaning in updateWellState()
2016-09-09 07:58:54 -05:00
const double gravity_arg,
const std::vector<double>& depth_arg,
Add polymer option to flow_ebos No extra equation is added for polymer in the well equation. Seperate executables are added for polymer: flow_ebos_polymer and solvent: flow_ebos_solvent Tested and verified on the test cases in polymer_test_suite This PR should not effect the performance and results of the blackoil simulator
2017-06-07 02:29:31 -05:00
long int global_nc,
[bugfix][StandardWellsDense] remove auto from method parameter list.
2017-06-27 09:51:11 -05:00
const Grid& grid);
Some micro performance improvments and cleaning -- The jacobian and residual in the reservoir is updated directly -- The sparsity pattern are provided to the well matrices. -- Some cleaning in updateWellState()
2016-09-09 07:58:54 -05:00
fixing the running of the vfp related for flow_ebos the output of the THP is still not yet correct.
2017-08-07 04:35:59 -05:00
void setVFPProperties(const VFPProperties* vfp_properties_arg);
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
extend and clean up the SimulatorReport
2016-11-23 14:44:33 -06:00
SimulatorReport assemble(Simulator& ebosSimulator,
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
const int iterationIdx,
const double dt,
the first part in separating the StandardWellsDense.hpp implementations. split into commits for easy debugging purpose.
2017-02-13 09:45:06 -06:00
WellState& well_state);
Temperary commit -- works on SPE1 but not SPE9 -- if number of perforations are increased to 3 in SPE1 the same error as in SPE9 occur.
2016-08-25 08:25:01 -05:00
add and use class wellModelMatrixAdapter The well contribution is substracted in the MatrixAdapter i.e. Ax - BinvDCx
2016-09-07 06:23:52 -05:00
// substract Binv(D)rw from r;
the second part in separating the StandardWellsDense.hpp implementations.
2017-02-13 10:07:34 -06:00
void apply( BVector& r) const;
Temperary commit -- works on SPE1 but not SPE9 -- if number of perforations are increased to 3 in SPE1 the same error as in SPE9 occur.
2016-08-25 08:25:01 -05:00
add and use class wellModelMatrixAdapter The well contribution is substracted in the MatrixAdapter i.e. Ax - BinvDCx
2016-09-07 06:23:52 -05:00
// subtract B*inv(D)*C * x from A*x
making wellMod_ in WellModelMatrixAdapter is actually a well model instead of the BlackoilModelEbos, which reduces some confusion and also removes a few unnecessary wrapping functions.
2017-06-07 07:23:43 -05:00
void apply(const BVector& x, BVector& Ax) const;
Temperary commit -- works on SPE1 but not SPE9 -- if number of perforations are increased to 3 in SPE1 the same error as in SPE9 occur.
2016-08-25 08:25:01 -05:00
[bugfix][WellModelMatrixAdapter] fix applyscaleadd method.
2016-11-17 06:43:39 -06:00
// apply well model with scaling of alpha
making wellMod_ in WellModelMatrixAdapter is actually a well model instead of the BlackoilModelEbos, which reduces some confusion and also removes a few unnecessary wrapping functions.
2017-06-07 07:23:43 -05:00
void applyScaleAdd(const Scalar alpha, const BVector& x, BVector& Ax) const;
[bugfix][WellModelMatrixAdapter] fix applyscaleadd method.
2016-11-17 06:43:39 -06:00
adding applySolutionWellState to apply solution from reservoir to update well state. With this way, the BlackoilModelEbos does not need to know the data type assocated with different well type. It is not well tested yet.
2017-07-21 08:30:34 -05:00
// using the solution x to recover the solution xw for wells and applying
// xw to update Well State
renaming a few functions to reflect the functions better. No functional change.
2017-08-21 07:16:24 -05:00
void recoverWellSolutionAndUpdateWellState(const BVector& x, WellState& well_state) const;
Temperary commit -- works on SPE1 but not SPE9 -- if number of perforations are increased to 3 in SPE1 the same error as in SPE9 occur.
2016-08-25 08:25:01 -05:00
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
int numWells() const;
Reset wellcontrols from well_state
2016-08-19 06:50:27 -05:00
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
/// return true if wells are available in the reservoir
the second part in separating the StandardWellsDense.hpp implementations.
2017-02-13 10:07:34 -06:00
bool wellsActive() const;
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
the second part in separating the StandardWellsDense.hpp implementations.
2017-02-13 10:07:34 -06:00
void setWellsActive(const bool wells_active);
/// return true if wells are available on this process
bool localWellsActive() const;
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
bool getWellConvergence(Simulator& ebosSimulator,
using getWellConvergence in BlackoilModelEbos Tested with SPE1. TODO: with the current way, we are not outputting any well residual information. We need to address what kind of residual information we want to output with the new well model.
2017-07-21 09:01:32 -05:00
const std::vector<Scalar>& B_avg) const;
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
/// upate the dynamic lists related to economic limits
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
void updateListEconLimited(const Schedule& schedule,
const int current_step,
const Wells* wells_struct,
const WellState& well_state,
DynamicListEconLimited& list_econ_limited) const;
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
finishing separating the StandardWellsDense.hpp implementations.
2017-02-14 08:06:57 -06:00
WellCollection* wellCollection() const;
adding well perforation efficiency factor to StandardWellsDense And also calculateEfficiencyFactor to initialize the values.
2017-01-09 04:29:00 -06:00
adding setWellSolutions to StandardWellsDense. the function will calculate the well_solutions_ based on well_state. It will be used when we recover the well_state from a failed iteration, then we should also update well_solutions_ for consistence.
2017-08-08 03:44:10 -05:00
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
protected:
bool wells_active_;
const Wells* wells_;
Implement solvent model in flow_ebos 1) Extends the well model to account for solvent surface volumes 2) Add solvent to updateState 3) Add solvent to well and field output The solvent parts is encapsled in if (has_solvent_) and should not effect the standard runs.
2017-05-09 01:21:51 -05:00
const std::vector< const Well* > wells_ecl_;
adding well collection to StandardWellsDense to make StandardWellsDense have access to the group information.
2017-01-09 03:36:17 -06:00
solveWellEq in StandardWellsDense calls solveWellEq from each individual well.
2017-06-27 05:17:36 -05:00
// the number of wells in this process
cleaning up a few fucntions in StandardWellsDense to remove the implementation implemented in StandardWell already.
2017-06-28 04:15:04 -05:00
// trying not to use things from Wells struct
// TODO: maybe a better name to emphasize it is local?
solveWellEq in StandardWellsDense calls solveWellEq from each individual well.
2017-06-27 05:17:36 -05:00
const int number_of_wells_;
cleaning up some functions from StandardWellsDense.
2017-07-25 03:15:27 -05:00
const int number_of_phases_;
makding createWellContainer a static function.
2017-08-21 03:23:42 -05:00
using WellInterfacePtr = std::unique_ptr<WellInterface<TypeTag> >;
more or less getting the old implementation in and compile now.
2017-06-15 10:19:49 -05:00
// a vector of all the wells.
// eventually, the wells_ above should be gone.
// the name is just temporary
// later, might make share_ptr const later.
makding createWellContainer a static function.
2017-08-21 03:23:42 -05:00
std::vector<WellInterfacePtr > well_container_;
more or less getting the old implementation in and compile now.
2017-06-15 10:19:49 -05:00
collecting the NaN and too large well residuals make sure all the processes will throw if there is any of the processes found abnormal residual values.
2017-08-22 07:49:30 -05:00
using ConvergenceReport = typename WellInterface<TypeTag>::ConvergenceReport;
makding createWellContainer a static function.
2017-08-21 03:23:42 -05:00
// create the well container
static std::vector<WellInterfacePtr > createWellContainer(const Wells* wells,
const std::vector<const Well*>& wells_ecl,
adding a use_multisegment_well_ to determine whether we will treat mutlisegment wells with MultisegmentWell well model. Currently, it will be faulse by default. It might be changed to be true by default when considering the multisegment well model is well tested.
2017-09-25 08:09:34 -05:00
const bool use_multisegment_well,
makding createWellContainer a static function.
2017-08-21 03:23:42 -05:00
const int time_step);
more or less getting the old implementation in and compile now.
2017-06-15 10:19:49 -05:00
adding well collection to StandardWellsDense to make StandardWellsDense have access to the group information.
2017-01-09 03:36:17 -06:00
// Well collection is used to enforce the group control
WellCollection* well_collection_;
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
ModelParameters param_;
bool terminal_output_;
Implement solvent model in flow_ebos 1) Extends the well model to account for solvent surface volumes 2) Add solvent to updateState 3) Add solvent to well and field output The solvent parts is encapsled in if (has_solvent_) and should not effect the standard runs.
2017-05-09 01:21:51 -05:00
bool has_solvent_;
Add polymer option to flow_ebos No extra equation is added for polymer in the well equation. Seperate executables are added for polymer: flow_ebos_polymer and solvent: flow_ebos_solvent Tested and verified on the test cases in polymer_test_suite This PR should not effect the performance and results of the blackoil simulator
2017-06-07 02:29:31 -05:00
bool has_polymer_;
Implement solvent model in flow_ebos 1) Extends the well model to account for solvent surface volumes 2) Add solvent to updateState 3) Add solvent to well and field output The solvent parts is encapsled in if (has_solvent_) and should not effect the standard runs.
2017-05-09 01:21:51 -05:00
int current_timeIdx_;
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
small improvements to StandardWellsDense the most significant change is that only a "PhaseUsage" object must be passed to its constructor instead of a full "fluid object". also, the pointers to the vector of "active" phases has been converted into a full object. (this helps to avoid potential use-after-free errors.)
2017-01-11 10:02:20 -06:00
PhaseUsage phase_usage_;
std::vector<bool> active_;
making rate_converter to be reference to the one in Simulator keeping the const property in the Well Model.
2017-08-10 04:20:09 -05:00
const RateConverterType& rate_converter_;
Use pore volume weighted averaged hydrocarbon state in rateConverted. - pressure, rs and rv is averaged using hydrocarbon pore volume weights. - pvtRegions is used as input in the conversion factor calculations. - the pvt cell of the first well cell is used as the pvt index. (Completing a well in two different PVT regions sounds like a very bad idea anyway) - FIP region support is added to the rate converter also for the ebos interface.
2017-10-02 07:18:33 -05:00
std::vector<int> pvt_region_idx_;
adding well perforation efficiency factor to StandardWellsDense And also calculateEfficiencyFactor to initialize the values.
2017-01-09 04:29:00 -06:00
more cleaning up of StandardWellsDense. not functional change.
2017-08-11 07:51:29 -05:00
// the number of the cells in the local grid
int number_of_cells_;
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
Use the global number of cells for the average. This number is still wrong in master but well become correct once PR #1107 is merged.
2017-03-24 09:12:42 -05:00
long int global_nc_;
makding createWellContainer a static function.
2017-08-21 03:23:42 -05:00
// used to better efficiency of calcuation
[bugfix][WellModelMatrixAdapter] fix applyscaleadd method.
2016-11-17 06:43:39 -06:00
mutable BVector scaleAddRes_;
[cleanup] Use class variables instead of creating new vectors inside the apply method of StandardWellsDense.
2016-11-02 04:43:55 -05:00
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
void updateWellControls(WellState& xw) const;
void updateGroupControls(WellState& well_state) const;
// setting the well_solutions_ based on well_state.
renaming well_solutions_ and well_variables to give slightly easier understanding.
2017-08-21 08:41:25 -05:00
void updatePrimaryVariables(const WellState& well_state) const;
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
Add polymer option to flow_ebos No extra equation is added for polymer in the well equation. Seperate executables are added for polymer: flow_ebos_polymer and solvent: flow_ebos_solvent Tested and verified on the test cases in polymer_test_suite This PR should not effect the performance and results of the blackoil simulator
2017-06-07 02:29:31 -05:00
void setupCompressedToCartesian(const int* global_cell, int number_of_cells, std::map<int,int>& cartesian_to_compressed ) const;
Remove 'auto' from one more parameter list.
2017-06-27 13:06:44 -05:00
void computeRepRadiusPerfLength(const Grid& grid);
Add polymer option to flow_ebos No extra equation is added for polymer in the well equation. Seperate executables are added for polymer: flow_ebos_polymer and solvent: flow_ebos_solvent Tested and verified on the test cases in polymer_test_suite This PR should not effect the performance and results of the blackoil simulator
2017-06-07 02:29:31 -05:00
adding function computeAverageFormationFactor to StandardWellsDense which is seperated from getWellConvergence for better flexiblity later.
2017-06-23 05:24:50 -05:00
void computeAverageFormationFactor(Simulator& ebosSimulator,
std::vector<double>& B_avg) const;
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
void applyVREPGroupControl(WellState& well_state) const;
void computeWellVoidageRates(const WellState& well_state,
std::vector<double>& well_voidage_rates,
std::vector<double>& voidage_conversion_coeffs) const;
// Calculating well potentials for each well
// TODO: getBhp() will be refactored to reduce the duplication of the code calculating the bhp from THP.
void computeWellPotentials(const Simulator& ebosSimulator,
const WellState& well_state,
std::vector<double>& well_potentials) const;
const std::vector<double>& wellPerfEfficiencyFactors() const;
void calculateEfficiencyFactors();
adding a function calculateExplictQuantities to WellInterface to hide some implementation details.
2017-09-05 04:09:58 -05:00
// it should be able to go to prepareTimeStep(), however, the updateWellControls() and initPrimaryVariablesEvaluation()
// makes it a little more difficult. unless we introduce if (iterationIdx != 0) to avoid doing the above functions
// twice at the beginning of the time step
/// Calculating the explict quantities used in the well calculation. By explicit, we mean they are cacluated
/// at the beginning of the time step and no derivatives are included in these quantities
removing two functions from WellInterface computeWellConnectionPressures() and computeAccumWell(). They belongs to the implementation details of well models now.
2017-09-05 04:20:43 -05:00
void calculateExplicitQuantities(const Simulator& ebosSimulator,
adding a function calculateExplictQuantities to WellInterface to hide some implementation details.
2017-09-05 04:09:58 -05:00
const WellState& xw) const;
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
SimulatorReport solveWellEq(Simulator& ebosSimulator,
const double dt,
WellState& well_state) const;
renaming well_solutions_ and well_variables to give slightly easier understanding.
2017-08-21 08:41:25 -05:00
void initPrimaryVariablesEvaluation() const;
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
more cleaning up of StandardWellsDense. not functional change.
2017-08-11 07:51:29 -05:00
// The number of components in the model.
int numComponents() const
{
if (numPhases() == 2) {
return 2;
}
int numComp = FluidSystem::numComponents;
if (has_solvent_) {
numComp ++;
}
return numComp;
}
int numPhases() const;
int flowPhaseToEbosPhaseIdx( const int phaseIdx ) const;
void resetWellControlFromState(const WellState& xw) const;
void assembleWellEq(Simulator& ebosSimulator,
const double dt,
WellState& well_state,
bool only_wells) const;
adding comments about function calculateBhpFromThp.
2017-08-14 07:11:58 -05:00
// some preparation work, mostly related to group control and RESV,
// at the beginning of each time step (Not report step)
void prepareTimeStep(const Simulator& ebos_simulator,
re-organizting the function prepareTimeStep() for StandardWellsDense for better readibility and organization.
2017-09-04 06:54:41 -05:00
WellState& well_state) const;
void prepareGroupControl(const Simulator& ebos_simulator,
WellState& well_state) const;
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
};
} // namespace Opm
the first part in separating the StandardWellsDense.hpp implementations. split into commits for easy debugging purpose.
2017-02-13 09:45:06 -06:00
#include "StandardWellsDense_impl.hpp"
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
#endif
Reference in New Issue Copy Permalink