mirror of
https://github.com/OPM/opm-simulators.git
synced 2025-02-25 18:55:30 -06:00
e5b5e250fe
while the parts related to polymer are not incoporated fully yet, since it has been considered in the new well model refactoring.
223 lines
7.2 KiB
C++
223 lines
7.2 KiB
C++
/*
|
|
Copyright 2017 SINTEF ICT, Applied Mathematics.
|
|
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/>.
|
|
*/
|
|
|
|
|
|
#ifndef OPM_WELLINTERFACE_HEADER_INCLUDED
|
|
#define OPM_WELLINTERFACE_HEADER_INCLUDED
|
|
|
|
#include <opm/common/OpmLog/OpmLog.hpp>
|
|
|
|
|
|
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
|
|
#include <opm/core/wells.h>
|
|
#include <opm/core/well_controls.h>
|
|
#include <opm/core/props/BlackoilPhases.hpp>
|
|
|
|
#include <opm/autodiff/VFPProperties.hpp>
|
|
#include <opm/autodiff/VFPInjProperties.hpp>
|
|
#include <opm/autodiff/VFPProdProperties.hpp>
|
|
#include <opm/autodiff/WellHelpers.hpp>
|
|
#include <opm/autodiff/WellStateFullyImplicitBlackoilDense.hpp>
|
|
#include <opm/autodiff/BlackoilModelParameters.hpp>
|
|
|
|
#include <opm/simulators/WellSwitchingLogger.hpp>
|
|
|
|
#include <string>
|
|
#include <memory>
|
|
#include <vector>
|
|
#include <cassert>
|
|
|
|
namespace Opm
|
|
{
|
|
|
|
|
|
template<typename TypeTag>
|
|
class WellInterface
|
|
{
|
|
public:
|
|
|
|
using WellState = WellStateFullyImplicitBlackoilDense;
|
|
|
|
typedef BlackoilModelParameters ModelParameters;
|
|
typedef typename GET_PROP_TYPE(TypeTag, Simulator) Simulator;
|
|
typedef typename GET_PROP_TYPE(TypeTag, FluidSystem) FluidSystem;
|
|
typedef typename GET_PROP_TYPE(TypeTag, Indices) BlackoilIndices;
|
|
typedef typename GET_PROP_TYPE(TypeTag, IntensiveQuantities) IntensiveQuantities;
|
|
typedef typename GET_PROP_TYPE(TypeTag, MaterialLaw) MaterialLaw;
|
|
|
|
static const int solventCompIdx = 3; //TODO get this from ebos
|
|
static const bool has_solvent = GET_PROP_VALUE(TypeTag, EnableSolvent);
|
|
|
|
/// Constructor
|
|
// TODO: Wel can be reference.
|
|
WellInterface(const Well* well, const int time_step, const Wells* wells);
|
|
|
|
/// Well name.
|
|
const std::string& name() const;
|
|
|
|
/// The index of the well in Wells struct
|
|
// It is used to locate the inforation in Wells and also WellState for now.
|
|
int indexOfWell() const;
|
|
|
|
/// Well type, INJECTOR or PRODUCER.
|
|
WellType wellType() const;
|
|
|
|
/// number of phases
|
|
int numberOfPhases() const;
|
|
|
|
/// Component fractions for each phase for the well
|
|
const std::vector<double>& compFrac() const;
|
|
|
|
/// Well controls
|
|
// TODO: later to see whether we need to return const.
|
|
WellControls* wellControls() const;
|
|
|
|
/// Number of the perforations
|
|
int numberOfPerforations() const;
|
|
|
|
/// Well productivity index for each perforation.
|
|
const std::vector<double>& wellIndex() const;
|
|
|
|
/// Depth of perforations
|
|
const std::vector<double>& perfDepth() const;
|
|
|
|
/// Indices of the grid cells/blocks that perforations are completed within.
|
|
const std::vector<int>& wellCells() const;
|
|
|
|
// TODO: the following function should be able to be removed by refactoring the well class
|
|
// It is probably only needed for StandardWell
|
|
/// the densities of the fluid in each perforation
|
|
virtual const std::vector<double>& perfDensities() const = 0;
|
|
virtual std::vector<double>& perfDensities() = 0;
|
|
|
|
/// the pressure difference between different perforations
|
|
virtual const std::vector<double>& perfPressureDiffs() const = 0;
|
|
virtual std::vector<double>& perfPressureDiffs() = 0;
|
|
|
|
// TODO: the parameters need to be optimized/adjusted
|
|
void init(const PhaseUsage* phase_usage_arg,
|
|
const std::vector<bool>* active_arg,
|
|
const VFPProperties* vfp_properties_arg,
|
|
const double gravity_arg,
|
|
const int num_cells);
|
|
|
|
// TODO: temporary
|
|
virtual void setWellVariables(const WellState& well_state) = 0;
|
|
|
|
const std::vector<bool>& active() const;
|
|
|
|
const PhaseUsage& phaseUsage() const;
|
|
|
|
int flowPhaseToEbosCompIdx( const int phaseIdx ) const;
|
|
|
|
int flowToEbosPvIdx( const int flowPv ) const;
|
|
|
|
int flowPhaseToEbosPhaseIdx( const int phaseIdx ) const;
|
|
|
|
int numPhases() const;
|
|
|
|
int numComponents() const;
|
|
|
|
bool allowCrossFlow() const;
|
|
|
|
// TODO: for this kind of function, maybe can make a function with parameter perf
|
|
const std::vector<int>& saturationTableNumber() const;
|
|
|
|
const double wsolvent() const;
|
|
|
|
virtual bool getWellConvergence(Simulator& ebosSimulator,
|
|
const std::vector<double>& B_avg,
|
|
const ModelParameters& param) const = 0;
|
|
|
|
virtual void wellEqIteration(Simulator& ebosSimulator,
|
|
const ModelParameters& param,
|
|
WellState& well_state) = 0;
|
|
|
|
virtual void assembleWellEq(Simulator& ebosSimulator,
|
|
const double dt,
|
|
WellState& well_state,
|
|
bool only_wells) = 0;
|
|
|
|
protected:
|
|
// TODO: some variables shared by all the wells should be made static
|
|
// well name
|
|
std::string name_;
|
|
|
|
// the index of well in Wells struct
|
|
int index_of_well_;
|
|
|
|
// well type
|
|
// INJECTOR or PRODUCER
|
|
enum WellType well_type_;
|
|
|
|
// whether the well allows crossflow
|
|
bool allow_cf_;
|
|
|
|
// number of phases
|
|
int number_of_phases_;
|
|
|
|
// component fractions for each well
|
|
// typically, it should apply to injection wells
|
|
std::vector<double> comp_frac_;
|
|
|
|
// controls for this well
|
|
// TODO: later will check whehter to let it stay with pointer
|
|
struct WellControls* well_controls_;
|
|
|
|
// number of the perforations for this well
|
|
int number_of_perforations_;
|
|
|
|
// record the index of the first perforation
|
|
// TODO: it might not be needed if we refactor WellState to be a vector
|
|
// of states of individual well.
|
|
int first_perf_;
|
|
|
|
// well index for each perforation
|
|
std::vector<double> well_index_;
|
|
|
|
// depth for each perforation
|
|
std::vector<double> perf_depth_;
|
|
|
|
// reference depth for the BHP
|
|
int ref_depth_;
|
|
|
|
double well_efficiency_factor_;
|
|
|
|
// cell index for each well perforation
|
|
std::vector<int> well_cell_;
|
|
|
|
// saturation table nubmer for each well perforation
|
|
std::vector<int> saturation_table_number_;
|
|
|
|
const PhaseUsage* phase_usage_;
|
|
|
|
const std::vector<bool>* active_;
|
|
|
|
const VFPProperties* vfp_properties_;
|
|
|
|
double gravity_;
|
|
};
|
|
|
|
}
|
|
|
|
#include "WellInterface_impl.hpp"
|
|
|
|
#endif // OPM_WELLINTERFACE_HEADER_INCLUDED
|