mirror of
https://github.com/OPM/opm-simulators.git
synced 2024-12-19 05:53:28 -06:00
033625c5a8
New function well_controls_clone(), implemented in terms of the public API only, mirrors the objective of function clone_wells(), only for well control sets. Add a basic test to demonstrate the function too.
406 lines
11 KiB
C
406 lines
11 KiB
C
/*===========================================================================
|
|
//
|
|
// File: newwells.c
|
|
//
|
|
// Created: 2012-02-03 11:28:40+0100
|
|
//
|
|
// Authors: Knut-Andreas Lie <Knut-Andreas.Lie@sintef.no>
|
|
// Jostein R. Natvig <Jostein.R.Natvig@sintef.no>
|
|
// Halvor M. Nilsen <HalvorMoll.Nilsen@sintef.no>
|
|
// Atgeirr F. Rasmussen <atgeirr@sintef.no>
|
|
// Xavier Raynaud <Xavier.Raynaud@sintef.no>
|
|
// Bård Skaflestad <Bard.Skaflestad@sintef.no>
|
|
//
|
|
//==========================================================================*/
|
|
|
|
|
|
/*
|
|
Copyright 2012 SINTEF ICT, Applied Mathematics.
|
|
Copyright 2012 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/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <opm/core/well_controls.h>
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
/**
|
|
* Controls for a single well.
|
|
* Each control specifies a well rate or bottom-hole pressure. Only
|
|
* one control can be active at a time, indicated by current. The
|
|
* meaning of each control's target value depends on the control type:
|
|
*
|
|
* - BHP -> target pressure in Pascal.
|
|
* - RESERVOIR_RATE -> target reservoir volume rate in cubic(meter)/second
|
|
* - SURFACE_RATE -> target surface volume rate in cubic(meter)/second
|
|
*
|
|
* The sign convention for RATE targets is as follows:
|
|
*
|
|
* - (+) Fluid flowing into reservoir, i.e. injecting.
|
|
* - (-) Fluid flowing out of reservoir, i.e. producing.
|
|
*
|
|
* For *_RATE controls, the distribution of phases used for the control
|
|
* is also needed. For example, a total rate control should have 1.0
|
|
* for each phase, whereas a control on oil rate should have 1.0 for
|
|
* the oil phase and 0.0 for the rest. For BHP controls, this is unused.
|
|
* The active control acts as an equality constraint, whereas the
|
|
* non-active controls should be interpreted as inequality
|
|
* constraints (upper or lower bounds). For instance, a PRODUCER's
|
|
* BHP constraint defines a minimum acceptable bottom-hole pressure
|
|
* value for the well.
|
|
*/
|
|
|
|
struct WellControls
|
|
{
|
|
/**
|
|
* Number of controls.
|
|
*/
|
|
int num;
|
|
|
|
int number_of_phases;
|
|
|
|
/**
|
|
* Array of control types.
|
|
*/
|
|
enum WellControlType *type;
|
|
|
|
/**
|
|
* Array of control targets.
|
|
*/
|
|
double *target;
|
|
|
|
/**
|
|
* Array of rate control distributions,
|
|
* <CODE>number_of_phases</CODE> numbers for each control
|
|
*/
|
|
double *distr;
|
|
|
|
/**
|
|
* Index of current active control.
|
|
*/
|
|
int current;
|
|
|
|
bool well_is_open;
|
|
|
|
/*
|
|
The capacity allocated.
|
|
*/
|
|
int cpty;
|
|
};
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
void
|
|
well_controls_destroy(struct WellControls *ctrl)
|
|
/* ---------------------------------------------------------------------- */
|
|
{
|
|
if (ctrl != NULL) {
|
|
free (ctrl->distr);
|
|
free (ctrl->target);
|
|
free (ctrl->type);
|
|
}
|
|
|
|
free(ctrl);
|
|
}
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
struct WellControls *
|
|
well_controls_create(void)
|
|
/* ---------------------------------------------------------------------- */
|
|
{
|
|
struct WellControls *ctrl;
|
|
|
|
ctrl = malloc(1 * sizeof *ctrl);
|
|
|
|
if (ctrl != NULL) {
|
|
/* Initialise empty control set; the well is created open. */
|
|
ctrl->num = 0;
|
|
ctrl->number_of_phases = 0;
|
|
ctrl->type = NULL;
|
|
ctrl->target = NULL;
|
|
ctrl->distr = NULL;
|
|
ctrl->current = -1;
|
|
ctrl->cpty = 0;
|
|
ctrl->well_is_open = true;
|
|
}
|
|
|
|
return ctrl;
|
|
}
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
static int
|
|
well_controls_reserve(int nctrl, struct WellControls *ctrl)
|
|
/* ---------------------------------------------------------------------- */
|
|
{
|
|
int c, p, ok;
|
|
void *type, *target, *distr;
|
|
|
|
type = realloc(ctrl->type , nctrl * 1 * sizeof *ctrl->type );
|
|
target = realloc(ctrl->target, nctrl * 1 * sizeof *ctrl->target);
|
|
distr = realloc(ctrl->distr , nctrl * ctrl->number_of_phases * sizeof *ctrl->distr );
|
|
|
|
ok = 0;
|
|
if (type != NULL) { ctrl->type = type ; ok++; }
|
|
if (target != NULL) { ctrl->target = target; ok++; }
|
|
if (distr != NULL) { ctrl->distr = distr ; ok++; }
|
|
|
|
if (ok == 3) {
|
|
for (c = ctrl->cpty; c < nctrl; c++) {
|
|
ctrl->type [c] = BHP;
|
|
ctrl->target[c] = -1.0;
|
|
}
|
|
|
|
for (p = ctrl->cpty * ctrl->number_of_phases; p < nctrl * ctrl->number_of_phases; ++p) {
|
|
ctrl->distr[ p ] = 0.0;
|
|
}
|
|
|
|
ctrl->cpty = nctrl;
|
|
}
|
|
|
|
return ok == 3;
|
|
}
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
struct WellControls *
|
|
well_controls_clone(const struct WellControls *ctrl)
|
|
/* ---------------------------------------------------------------------- */
|
|
{
|
|
int ok, i, n;
|
|
double target;
|
|
const double *distr;
|
|
struct WellControls *new;
|
|
enum WellControlType type;
|
|
|
|
new = well_controls_create();
|
|
|
|
if (new != NULL) {
|
|
/* Assign appropriate number of phases */
|
|
well_controls_assert_number_of_phases(new, ctrl->number_of_phases);
|
|
|
|
n = well_controls_get_num(ctrl);
|
|
ok = well_controls_reserve(n, new);
|
|
|
|
if (! ok) {
|
|
well_controls_destroy(new);
|
|
new = NULL;
|
|
}
|
|
else {
|
|
for (i = 0; ok && (i < n); i++) {
|
|
type = well_controls_iget_type (ctrl, i);
|
|
distr = well_controls_iget_distr (ctrl, i);
|
|
target = well_controls_iget_target(ctrl, i);
|
|
|
|
ok = well_controls_add_new(type, target, distr, new);
|
|
}
|
|
|
|
if (i < n) {
|
|
assert (!ok);
|
|
well_controls_destroy(new);
|
|
|
|
new = NULL;
|
|
}
|
|
else {
|
|
i = well_controls_get_current(ctrl);
|
|
well_controls_set_current(new, i);
|
|
|
|
if (well_controls_well_is_open(ctrl)) {
|
|
well_controls_open_well(new);
|
|
}
|
|
else {
|
|
well_controls_shut_well(new);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
assert (well_controls_equal(ctrl, new, true));
|
|
|
|
return new;
|
|
}
|
|
|
|
|
|
int well_controls_get_num(const struct WellControls *ctrl) {
|
|
return ctrl->num;
|
|
}
|
|
|
|
|
|
int well_controls_get_current( const struct WellControls * ctrl) {
|
|
return ctrl->current;
|
|
}
|
|
|
|
void
|
|
well_controls_set_current( struct WellControls * ctrl, int current) {
|
|
ctrl->current = current;
|
|
}
|
|
|
|
bool well_controls_well_is_shut(const struct WellControls * ctrl) {
|
|
return !ctrl->well_is_open;
|
|
}
|
|
|
|
bool well_controls_well_is_open(const struct WellControls * ctrl) {
|
|
return ctrl->well_is_open;
|
|
}
|
|
|
|
void well_controls_open_well( struct WellControls * ctrl) {
|
|
ctrl->well_is_open = true;
|
|
}
|
|
|
|
void well_controls_shut_well( struct WellControls * ctrl) {
|
|
ctrl->well_is_open = false;
|
|
}
|
|
|
|
|
|
|
|
enum WellControlType
|
|
well_controls_iget_type(const struct WellControls * ctrl, int control_index) {
|
|
return ctrl->type[control_index];
|
|
}
|
|
|
|
|
|
enum WellControlType
|
|
well_controls_get_current_type(const struct WellControls * ctrl) {
|
|
return well_controls_iget_type( ctrl , ctrl->current);
|
|
}
|
|
|
|
|
|
void
|
|
well_controls_iset_type( struct WellControls * ctrls , int control_index , enum WellControlType type) {
|
|
ctrls->type[control_index] = type;
|
|
}
|
|
|
|
|
|
double
|
|
well_controls_iget_target(const struct WellControls * ctrl, int control_index) {
|
|
return ctrl->target[control_index];
|
|
}
|
|
|
|
double
|
|
well_controls_get_current_target(const struct WellControls * ctrl) {
|
|
return ctrl->target[ctrl->current];
|
|
}
|
|
|
|
void
|
|
well_controls_iset_target(struct WellControls * ctrl, int control_index , double target) {
|
|
ctrl->target[control_index] = target;
|
|
}
|
|
|
|
|
|
const double *
|
|
well_controls_iget_distr(const struct WellControls * ctrl, int control_index) {
|
|
int offset = control_index * ctrl->number_of_phases;
|
|
return &ctrl->distr[offset];
|
|
}
|
|
|
|
|
|
const double *
|
|
well_controls_get_current_distr(const struct WellControls * ctrl) {
|
|
return well_controls_iget_distr( ctrl , ctrl->current );
|
|
}
|
|
|
|
|
|
|
|
void
|
|
well_controls_iset_distr(const struct WellControls * ctrl, int control_index, const double * distr) {
|
|
int offset = control_index * ctrl->number_of_phases;
|
|
for (int p=0; p < ctrl->number_of_phases; p++)
|
|
ctrl->distr[offset + p] = distr[p];
|
|
}
|
|
|
|
|
|
void
|
|
well_controls_assert_number_of_phases(struct WellControls * ctrl , int number_of_phases) {
|
|
if (ctrl->num == 0)
|
|
ctrl->number_of_phases = number_of_phases;
|
|
|
|
assert( ctrl->number_of_phases == number_of_phases );
|
|
}
|
|
|
|
void
|
|
well_controls_clear(struct WellControls * ctrl) {
|
|
ctrl->num = 0;
|
|
ctrl->number_of_phases = 0;
|
|
}
|
|
|
|
|
|
|
|
int
|
|
well_controls_add_new(enum WellControlType type , double target , const double * distr , struct WellControls * ctrl) {
|
|
if (ctrl->num == ctrl->cpty) {
|
|
int new_cpty = 2*ctrl->cpty;
|
|
if (new_cpty == ctrl->num)
|
|
new_cpty += 1;
|
|
|
|
if (!well_controls_reserve( new_cpty , ctrl))
|
|
return 0;
|
|
}
|
|
|
|
well_controls_iset_type( ctrl , ctrl->num , type);
|
|
well_controls_iset_target( ctrl , ctrl->num , target);
|
|
|
|
if (distr != NULL)
|
|
well_controls_iset_distr( ctrl , ctrl->num , distr);
|
|
|
|
ctrl->num += 1;
|
|
return 1;
|
|
}
|
|
|
|
|
|
bool
|
|
well_controls_equal(const struct WellControls *ctrls1, const struct WellControls *ctrls2 , bool verbose)
|
|
/* ---------------------------------------------------------------------- */
|
|
{
|
|
bool are_equal = true;
|
|
|
|
if (ctrls1->num != ctrls2->num) {
|
|
are_equal = false;
|
|
if (verbose)
|
|
printf("ctrls1->num:%d ctrls2->num:%d \n",ctrls1->num , ctrls2->num);
|
|
}
|
|
|
|
if (ctrls1->number_of_phases != ctrls2->number_of_phases) {
|
|
are_equal = false;
|
|
if (verbose)
|
|
printf("ctrls1->number_of_phases:%d ctrls2->number_of_phases:%d \n",ctrls1->number_of_phases , ctrls2->number_of_phases);
|
|
}
|
|
|
|
if (!are_equal) {
|
|
return are_equal;
|
|
}
|
|
|
|
if (memcmp(ctrls1->type, ctrls2->type, ctrls1->num * sizeof *ctrls1->type ) != 0) {
|
|
are_equal = false;
|
|
if (verbose)
|
|
printf("The ->type vectors are different \n");
|
|
}
|
|
|
|
if (memcmp(ctrls1->target, ctrls2->target, ctrls1->num * sizeof *ctrls1->target ) != 0) {
|
|
are_equal = false;
|
|
if (verbose)
|
|
printf("The ->target vectors are different \n");
|
|
}
|
|
|
|
return are_equal;
|
|
}
|
|
|