353 lines
10 KiB
C
353 lines
10 KiB
C
/*
|
|
Copyright 2012 SINTEF ICT, Applied Mathematics.
|
|
|
|
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_WELLS_H_INCLUDED
|
|
#define OPM_WELLS_H_INCLUDED
|
|
|
|
#include <stdbool.h>
|
|
#include <opm/core/well_controls.h>
|
|
|
|
/**
|
|
* \file
|
|
*
|
|
* Main OPM-Core well data structure along with functions
|
|
* to create, populate and destroy it.
|
|
*/
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* Well type indicates desired/expected well behaviour.
|
|
*/
|
|
enum WellType {
|
|
INJECTOR, /**< Well is an injector */
|
|
PRODUCER /**< Well is a producer */
|
|
};
|
|
|
|
|
|
/**
|
|
* Data structure aggregating static information about all wells in a scenario.
|
|
*/
|
|
struct Wells
|
|
{
|
|
int number_of_wells; /**< Number of wells. */
|
|
int number_of_phases; /**< Number of phases. */
|
|
|
|
/**
|
|
* Array of well types.
|
|
*/
|
|
enum WellType *type;
|
|
|
|
/**
|
|
* Array of well reference depths.
|
|
*/
|
|
double *depth_ref;
|
|
|
|
/**
|
|
* Component fractions for each well. Array of size
|
|
* <CODE>number_of_wells * number_of_phases</CODE>.
|
|
* For injection wells, this gives the injected component mix.
|
|
* For production wells the component fractions of the wellbore
|
|
* will vary and cannot be specified a priori, the component mix
|
|
* given here should be considered a default or preferred mix.
|
|
*/
|
|
double *comp_frac;
|
|
|
|
/**
|
|
* Array of indices into well_cells (and WI). For a well @c w,
|
|
* <CODE>well_connpos[w]</CODE> and <CODE>well_connpos[w+1]</CODE> are start
|
|
* and one-beyond-end indices into the @c well_cells array for accessing
|
|
* @c w's perforation cell indices.
|
|
*/
|
|
int *well_connpos;
|
|
|
|
/**
|
|
* Array of perforation cell indices.
|
|
* Size is number of perforations (== well_connpos[number_of_wells]).
|
|
*/
|
|
int *well_cells;
|
|
|
|
/**
|
|
* Well productivity index, same size and structure as well_cells.
|
|
*/
|
|
double *WI;
|
|
|
|
/**
|
|
* Saturation table number , same size and structure as well_cells.
|
|
*/
|
|
int *sat_table_id;
|
|
|
|
/**
|
|
* Well controls, one set of controls for each well.
|
|
*/
|
|
struct WellControls **ctrls;
|
|
|
|
/**
|
|
* Well names. One string for each well.
|
|
*/
|
|
char **name;
|
|
|
|
/**
|
|
* Array of flags indicating whether crossflow is allowed or not
|
|
* if allow_cf[w] == 0 (false) then crossflow is not allowed in well w.
|
|
*/
|
|
int *allow_cf;
|
|
|
|
/**
|
|
* Internal management structure.
|
|
*/
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
|
/**
|
|
* Data structure aggregating dynamic information about all wells in a scenario.
|
|
* All arrays in this structure contain data for each perforation, ordered the
|
|
* same as Wells::well_cells and Wells:WI. The array sizes are, respectively,
|
|
*
|
|
* wdp NP
|
|
* A n²*NP (matrix in column-major (i.e., Fortran) order).
|
|
* phasemob n*NP
|
|
*
|
|
* in which "n" denotes the number of active fluid phases (and constituent
|
|
* components) and "NP" is the total number of perforations,
|
|
* <CODE>well_connpos[ number_of_wells ]</CODE>.
|
|
*/
|
|
struct CompletionData
|
|
{
|
|
/**
|
|
* Gravity potentials.
|
|
*/
|
|
double *wdp;
|
|
|
|
/**
|
|
* Volumes to surface-components matrix, A = RB^{-1}.
|
|
*/
|
|
double *A;
|
|
|
|
/**
|
|
* Phase mobilities for all perforations, stored consecutively with the
|
|
* phase index cycling the most rapidly.
|
|
*/
|
|
double *phasemob;
|
|
};
|
|
|
|
/**
|
|
* Construct a Wells object initially capable of managing a given
|
|
* number of wells and total number of well connections
|
|
* (perforations).
|
|
*
|
|
* Function add_well() is used to populate the Wells object. No
|
|
* reallocation occurs in function add_well() as long as the
|
|
* initially indicated capacities are sufficient. Call function
|
|
* destroy_wells() to dispose of the Wells object and its allocated
|
|
* memory resources.
|
|
*
|
|
* \param[in] nphases Number of active phases in simulation scenario.
|
|
*
|
|
* \param[in] nwells Expected number of wells in simulation scenario.
|
|
* Pass zero if the total number of wells is unknown.
|
|
*
|
|
* \param[in] nperf Expected total number of well connections
|
|
* (perforations) for all wells in simulation
|
|
* scenario. Pass zero if the total number of well
|
|
* connections is unknown.
|
|
*
|
|
* \return A valid Wells object with no wells if successful, and NULL
|
|
* otherwise.
|
|
*/
|
|
struct Wells *
|
|
create_wells(int nphases, int nwells, int nperf);
|
|
|
|
|
|
/**
|
|
* Append a new well to an existing Wells object.
|
|
*
|
|
* Increments W->number_of_wells by one if successful. The new well
|
|
* does not include operational constraints. Such information is
|
|
* specified using function append_well_controls(). The current
|
|
* control index is set to -1 (invalid).
|
|
*
|
|
* \param[in] type Type of well.
|
|
* \param[in] depth_ref Reference depth for well's BHP.
|
|
* \param[in] nperf Number of perforations.
|
|
* \param[in] comp_frac Injection fraction array (size equal to W->number_of_phases) or NULL.
|
|
* \param[in] cells Grid cells in which well is perforated. Should
|
|
* ideally be track ordered.
|
|
* \param[in] WI Well production index per perforation, or NULL.
|
|
* \param[in] name Name of new well. NULL if no name.
|
|
* \param[in] allow_cf Flag to determine whether crossflow is allowed or not.
|
|
* \param[in,out] W Existing set of wells to which new well will
|
|
* be added.
|
|
*
|
|
* \return Non-zero (true) if successful and zero otherwise.
|
|
*/
|
|
int
|
|
add_well(enum WellType type ,
|
|
double depth_ref,
|
|
int nperf ,
|
|
const double *comp_frac,
|
|
const int *cells ,
|
|
const double *WI ,
|
|
const int *sat_table_id,
|
|
const char *name ,
|
|
int allow_cf ,
|
|
struct Wells *W );
|
|
|
|
|
|
/**
|
|
* Append operational constraint to an existing well.
|
|
*
|
|
* Increments ctrl->num by one if successful. Introducing a new
|
|
* operational constraint does not affect the well's notion of the
|
|
* currently active constraint represented by ctrl->current.
|
|
* Note that *_RATE controls now require a phase distribution array
|
|
* to be associated with the control, see WellControls.
|
|
*
|
|
* \param[in] type Control type.
|
|
* \param[in] target Target value for the control.
|
|
* \param[in] alq Artificial lift quantity for control (for THP type only)
|
|
* \param[in] vfp VFP table number for control (for THP type only)
|
|
* \param[in] distr Array of size W->number_of_phases or NULL.
|
|
* \param[in] well_index Index of well to receive additional control.
|
|
* \param[in,out] W Existing set of well controls.
|
|
* \return Non-zero (true) if successful and zero (false) otherwise.
|
|
*/
|
|
|
|
|
|
int
|
|
append_well_controls(enum WellControlType type ,
|
|
double target,
|
|
double alq,
|
|
int vfp,
|
|
const double *distr,
|
|
int well_index,
|
|
struct Wells *W);
|
|
|
|
|
|
/**
|
|
* Set the current/active control for a single well.
|
|
*
|
|
* The new control ID must refer to a previously defined control mode.
|
|
* Total number of defined control modes available through function
|
|
* well_controls_get_num().
|
|
*
|
|
* \param[in] well_index
|
|
* Identity of particular well. Must be in
|
|
* \code [0 .. number_of_wells - 1] \endcode.
|
|
*
|
|
* \param[in] current_control
|
|
* Index of new control mode.
|
|
*
|
|
* \param[in,out] W Existing set of wells.
|
|
*/
|
|
void
|
|
set_current_control(int well_index, int current_control, struct Wells *W);
|
|
|
|
|
|
/**
|
|
* Clear all controls from a single well.
|
|
*
|
|
* Does not affect the control set capacity.
|
|
*
|
|
* \param[in] well_index
|
|
* Identity of particular well. Must be in
|
|
* \code [0 .. number_of_wells - 1] \endcode.
|
|
*
|
|
* \param[in,out] W Existing set of wells.
|
|
*/
|
|
void
|
|
clear_well_controls(int well_index, struct Wells *W);
|
|
|
|
|
|
/**
|
|
* Wells object destructor.
|
|
*
|
|
* Disposes of all resources managed by the Wells object.
|
|
*
|
|
* The Wells object must be built using function create_wells() and
|
|
* subsequently populated using function add_well().
|
|
*/
|
|
void
|
|
destroy_wells(struct Wells *W);
|
|
|
|
|
|
/**
|
|
* Create a deep-copy (i.e., clone) of an existing Wells object, including its
|
|
* controls.
|
|
*
|
|
* @param[in] W Existing Wells object.
|
|
* @return Complete clone of the input object. Dispose of resources using
|
|
* function destroy_wells() when no longer needed. Returns @c NULL in case of
|
|
* allocation failure.
|
|
*/
|
|
struct Wells *
|
|
clone_wells(const struct Wells *W);
|
|
|
|
|
|
/**
|
|
* Compare well structures for equality.
|
|
*
|
|
* Two sets of wells are equal if all of the following conditions hold
|
|
* - They have the same number of wells
|
|
*
|
|
* - They have the same number of completions/connections
|
|
*
|
|
* - They specify the same number of phases
|
|
*
|
|
* - Individual wells with corresponding well IDs have the same names
|
|
* (including both being \c NULL).
|
|
*
|
|
* - Individual wells with corresponding well IDs have the same
|
|
* completions
|
|
*
|
|
* - Individual wells with corresponding well IDs have the same well
|
|
* types
|
|
*
|
|
* - Individual wells with corresponding well IDs specify the same
|
|
* reference depths
|
|
*
|
|
* - Individual wells with corresponding well IDs have the same set
|
|
* of defined and active operational constraints as determined by
|
|
* function well_controls_equal()
|
|
*
|
|
* \param[in] W1 Existing set of wells.
|
|
* \param[in] W2 Existing set of wells.
|
|
*
|
|
* \param[in] verbose Flag for whether or not to report which
|
|
* conditions do not hold. Use \code verbose =
|
|
* true \endcode to print transcript to \c stdout.
|
|
*
|
|
* \return Whether or not well structures \c W1 and \c W2 represent
|
|
* the same set of wells.
|
|
*/
|
|
bool
|
|
wells_equal(const struct Wells *W1, const struct Wells *W2 , bool verbose);
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* OPM_WELLS_H_INCLUDED */
|