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

Made WellStateMultiSegment use inheritance properly.

Browse Source 
Use base class' data members (via public methods),
also change method names to match existing ones.
This commit is contained in:
Atgeirr Flø Rasmussen
2015-10-09 10:45:54 +02:00
committed by Kai Bao
parent cc2d40a1a8
commit f2c812fb3a
2 changed files with 60 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
opm/autodiff/BlackoilMultiSegmentModel_impl.hpp
View File

@@ -133,8 +133,8 @@ namespace Opm {
if ( wellsMultiSegment().size() > 0 ) if ( wellsMultiSegment().size() > 0 )
{ {
// Need to reshuffle well segment rates, from phase running fastest // Need to reshuffle well segment rates, from phase running fastest
const int nseg = xw.numberOfSegments(); const int nseg = xw.numSegments();
const int np = xw.numberOfPhases(); const int np = xw.numPhases();
// The transpose() below switches the ordering of the segment rates // The transpose() below switches the ordering of the segment rates
const DataBlock segrates = Eigen::Map<const DataBlock>(& xw.segPhaseRates()[0], nseg, np).transpose(); const DataBlock segrates = Eigen::Map<const DataBlock>(& xw.segPhaseRates()[0], nseg, np).transpose();
@@ -190,8 +190,8 @@ namespace Opm {
// 1. Compute properties required by computeConnectionPressureDelta(). // 1. Compute properties required by computeConnectionPressureDelta().
// Note that some of the complexity of this part is due to the function // Note that some of the complexity of this part is due to the function
// taking std::vector<double> arguments, and not Eigen objects. // taking std::vector<double> arguments, and not Eigen objects.
const int nperf = xw.numberOfPerforations(); const int nperf = xw.numPerforations();
const int nw = xw.numberOfWells(); const int nw = xw.numWells();
// the well cells for multisegment wells and non-segmented wells should be counted seperatedly // the well cells for multisegment wells and non-segmented wells should be counted seperatedly
// indexing should be put in WellState // indexing should be put in WellState
@@ -305,9 +305,9 @@ namespace Opm {
} }
std::string well_name(wellsMultiSegment()[w]->name()); std::string well_name(wellsMultiSegment()[w]->name());
typedef typename WellStateMultiSegment::WellMapType::const_iterator const_iterator; typedef typename WellStateMultiSegment::SegmentedWellMapType::const_iterator const_iterator;
const_iterator it_well = xw.wellMap().find(well_name); const_iterator it_well = xw.segmentedWellMap().find(well_name);
assert(it_well != xw.wellMap().end()); assert(it_well != xw.segmentedWellMap().end());
// for (int perf = wells().well_connpos[w]; perf < wells().well_connpos[w+1]; ++perf) { // for (int perf = wells().well_connpos[w]; perf < wells().well_connpos[w+1]; ++perf) {
const int start_perforation = (*it_well).second.start_perforation; const int start_perforation = (*it_well).second.start_perforation;
@@ -407,9 +407,9 @@ namespace Opm {
// If we need to consider the rs and rv for all the segments, the process will be similar with the above. // If we need to consider the rs and rv for all the segments, the process will be similar with the above.
// Are they actually zero for the current cases? // Are they actually zero for the current cases?
// TODO // TODO
well_perforations_segment_pressure_diffs_ = ADB::constant(V::Zero(xw.numberOfPerforations())); well_perforations_segment_pressure_diffs_ = ADB::constant(V::Zero(xw.numPerforations()));
well_perforation_pressure_cell_diffs_ = V::Zero(xw.numberOfPerforations()); well_perforation_pressure_cell_diffs_ = V::Zero(xw.numPerforations());
well_perforatoin_cell_pressure_diffs_ = V::Zero(xw.numberOfPerforations()); well_perforatoin_cell_pressure_diffs_ = V::Zero(xw.numPerforations());
#if 0 #if 0
std::cout << "well_perforation_densities_ " << std::endl; std::cout << "well_perforation_densities_ " << std::endl;
std::cout << well_perforation_densities_ << std::endl; std::cout << well_perforation_densities_ << std::endl;
@@ -482,12 +482,12 @@ namespace Opm {
V aliveWells; V aliveWells;
// const int np = wells().number_of_phases; // const int np = wells().number_of_phases;
const int np = well_state.numberOfPhases(); const int np = well_state.numPhases();
std::vector<ADB> cq_s(np, ADB::null()); std::vector<ADB> cq_s(np, ADB::null());
// const int nw = wellsMultiSegment().size(); // const int nw = wellsMultiSegment().size();
const int nw = well_state.numberOfWells(); const int nw = well_state.numWells();
const int nperf = well_state.numberOfPerforations(); const int nperf = well_state.numPerforations();
std::vector<int> well_cells; std::vector<int> well_cells;
well_cells.reserve(nperf); well_cells.reserve(nperf);
for (int i = 0; i < nw; ++i) { for (int i = 0; i < nw; ++i) {
@@ -535,7 +535,7 @@ namespace Opm {
const int nw = wellsMultiSegment().size(); const int nw = wellsMultiSegment().size();
const int nc = Opm::AutoDiffGrid::numCells(grid_); const int nc = Opm::AutoDiffGrid::numCells(grid_);
const int np = numPhases(); const int np = numPhases();
const int nperf = xw.numberOfPerforations(); const int nperf = xw.numPerforations();
std::vector<int> well_cells; std::vector<int> well_cells;
@@ -1077,7 +1077,7 @@ namespace Opm {
const int np = numPhases(); const int np = numPhases();
const int nw = wellsMultiSegment().size(); const int nw = wellsMultiSegment().size();
const int nseg_total = xw.numberOfSegments(); const int nseg_total = xw.numSegments();
ADB aqua = ADB::constant(ADB::V::Zero(nseg_total)); ADB aqua = ADB::constant(ADB::V::Zero(nseg_total));
ADB liquid = ADB::constant(ADB::V::Zero(nseg_total)); ADB liquid = ADB::constant(ADB::V::Zero(nseg_total));
@@ -1330,7 +1330,7 @@ namespace Opm {
varstart += dxvar.size(); varstart += dxvar.size();
// Extract well parts np phase rates + bhp // Extract well parts np phase rates + bhp
const int nseg_total = well_state.numberOfSegments(); const int nseg_total = well_state.numSegments();
const V dwells = subset(dx, Span((np+1)*nseg_total, 1, varstart)); const V dwells = subset(dx, Span((np+1)*nseg_total, 1, varstart));
varstart += dwells.size(); varstart += dwells.size();
@@ -1541,7 +1541,7 @@ namespace Opm {
{ {
const int np = numPhases(); const int np = numPhases();
const int nw = wellsMultiSegment().size(); const int nw = wellsMultiSegment().size();
const int nseg_total = well_state.numberOfSegments(); const int nseg_total = well_state.numSegments();
// Extract parts of dwells corresponding to each part. // Extract parts of dwells corresponding to each part.
int varstart = 0; int varstart = 0;
@@ -1610,10 +1610,10 @@ namespace Opm {
#if 0 #if 0
// Debug output. // Debug output.
std::cout << " output all the well state informations after updateWellState()" << std::endl; std::cout << " output all the well state informations after updateWellState()" << std::endl;
const int np = well_state.numberOfPhases(); const int np = well_state.numPhases();
const int nw = well_state.numberOfWells(); const int nw = well_state.numWells();
const int nperf_total = well_state.numberOfPerforations(); const int nperf_total = well_state.numPerforations();
const int nseg_total = well_state.numberOfSegments(); const int nseg_total = well_state.numSegments();
std::cout << " number of wells : " << nw << " nubmer of segments : " << nseg_total << std::endl; std::cout << " number of wells : " << nw << " nubmer of segments : " << nseg_total << std::endl;
std::cout << " number of phase : " << np << " nubmer of perforations " << nperf_total << std::endl; std::cout << " number of phase : " << np << " nubmer of perforations " << nperf_total << std::endl;
@@ -1807,8 +1807,8 @@ namespace Opm {
// should we relate the segments with different cells // should we relate the segments with different cells
// TODO: as the first solution, we calculate the rs and rv as the average rs and rv from the related perforations. // TODO: as the first solution, we calculate the rs and rv as the average rs and rv from the related perforations.
// Based on the current framework, it has to be done one well by one well // Based on the current framework, it has to be done one well by one well
const int nw = xw.numberOfWells(); const int nw = xw.numWells();
const int nseg_total = xw.numberOfSegments(); const int nseg_total = xw.numSegments();
const int np = numPhases(); const int np = numPhases();
assert(np == int(b_perf.size())); assert(np == int(b_perf.size()));

138
opm/autodiff/WellStateMultiSegment.hpp
View File

@@ -49,9 +49,6 @@ namespace Opm
typedef WellStateFullyImplicitBlackoil Base; typedef WellStateFullyImplicitBlackoil Base;
typedef WellMultiSegment::V V; typedef WellMultiSegment::V V;
// typedef std::array< int, 3 > mapentry_t;
// typedef std::map< std::string, mapentry_t > WellMapType;
// this map needs to change a little bit?
typedef struct { typedef struct {
int well_number; int well_number;
int start_segment; int start_segment;
@@ -60,17 +57,17 @@ namespace Opm
int number_of_perforations; int number_of_perforations;
std::vector<int> start_perforation_segment; // the starting position of perforation inside the segment std::vector<int> start_perforation_segment; // the starting position of perforation inside the segment
std::vector<int> number_of_perforations_segment; // the numbers for perforations for the segments std::vector<int> number_of_perforations_segment; // the numbers for perforations for the segments
} MapentryType; } SegmentedMapentryType;
typedef std::map<std::string, MapentryType> WellMapType; typedef std::map<std::string, SegmentedMapentryType> SegmentedWellMapType;
// MAYNOT NEED THIS // MAYNOT NEED THIS
/// Allocate and initialize if wells is non-null. Also tries /// Allocate and initialize if wells is non-null. Also tries
/// to give useful initial values to the bhp(), wellRates() /// to give useful initial values to the bhp(), wellRates()
/// and perfPhaseRates() fields, depending on controls /// and perfPhaseRates() fields, depending on controls
/// the PrevState here must be the same with State /// the PrevState here must be the same with State
template <class State, class PrevState> template <class ReservoirState, class PrevWellState>
void init(const std::vector<WellMultiSegmentConstPtr>& wells, const State& state, const PrevState& prevState) void init(const std::vector<WellMultiSegmentConstPtr>& wells, const ReservoirState& state, const PrevWellState& prevState)
{ {
const int nw = wells.size(); const int nw = wells.size();
if (nw == 0) { if (nw == 0) {
@@ -87,38 +84,16 @@ namespace Opm
nseg += wells[iw]->numberOfSegments(); nseg += wells[iw]->numberOfSegments();
} }
bhp_.resize(nw);
thp_.resize(nw);
top_segment_loc_.resize(nw); top_segment_loc_.resize(nw);
temperature_.resize(nw, 273.15 + 20); // standard temperature for now
// deciding to add the following variables temporarily // deciding to add the following variables temporarily
// TODO: making it better later // TODO: making it better later
np_ = np;
nseg_ = nseg; nseg_ = nseg;
nperf_ = nperf; nperf_ = nperf;
nwells_ = nw;
wellrates_.resize(nw * np, 0.0);
currentControls().resize(nw);
for(int iw = 0; iw < nw; ++iw) {
currentControls()[iw] = well_controls_get_current(wells[iw]->wellControls());
}
for (int iw = 0; iw < nw; ++iw) {
assert((wells[iw]->wellType() == INJECTOR) || (wells[iw]->wellType() == PRODUCER));
}
int start_segment = 0; int start_segment = 0;
int start_perforation = 0; int start_perforation = 0;
perfPhaseRates().clear();
perfPhaseRates().resize(nperf * np, 0.0);
perfpress_.clear();
perfpress_.resize(nperf, -1.0e100);
segphaserates_.clear(); segphaserates_.clear();
segphaserates_.resize(nseg * np, 0.0); segphaserates_.resize(nseg * np, 0.0);
@@ -132,7 +107,7 @@ namespace Opm
std::string well_name(wells[w]->name()); std::string well_name(wells[w]->name());
// Initialize the wellMap_ here // Initialize the wellMap_ here
MapentryType& wellMapEntry = wellMap_[well_name]; SegmentedMapentryType& wellMapEntry = segmentedWellMap_[well_name];
wellMapEntry.well_number = w; wellMapEntry.well_number = w;
wellMapEntry.start_segment = start_segment; wellMapEntry.start_segment = start_segment;
wellMapEntry.number_of_segments = wells[w]->numberOfSegments(); wellMapEntry.number_of_segments = wells[w]->numberOfSegments();
@@ -158,17 +133,17 @@ namespace Opm
// 2. Bhp: assign bhp equal to bhp control, if applicable, otherwise // 2. Bhp: assign bhp equal to bhp control, if applicable, otherwise
// assign equal to first perforation cell pressure. // assign equal to first perforation cell pressure.
if (well_controls_get_current_type(ctrl) == BHP) { if (well_controls_get_current_type(ctrl) == BHP) {
bhp_[w] = well_controls_get_current_target(ctrl); bhp()[w] = well_controls_get_current_target(ctrl);
} else { } else {
const int first_cell = wells[0]->wellCells()[0]; const int first_cell = wells[0]->wellCells()[0];
bhp_[w] = state.pressure()[first_cell]; bhp()[w] = state.pressure()[first_cell];
} }
// 3. Thp: assign thp equal to thp control, if applicable, // 3. Thp: assign thp equal to thp control, if applicable,
// otherwise assign equal to bhp value. // otherwise assign equal to bhp value.
if (well_controls_get_current_type(ctrl) == THP) { if (well_controls_get_current_type(ctrl) == THP) {
thp_[w] = well_controls_get_current_target( ctrl ); thp()[w] = well_controls_get_current_target( ctrl );
} else { } else {
thp_[w] = bhp_[w]; thp()[w] = bhp()[w];
} }
// 4. Perforation pressures and phase rates // 4. Perforation pressures and phase rates
// 5. Segment pressures and phase rates // 5. Segment pressures and phase rates
@@ -182,38 +157,38 @@ namespace Opm
const double rate_target = well_controls_get_current_target(ctrl); const double rate_target = well_controls_get_current_target(ctrl);
const double * distr = well_controls_get_current_distr( ctrl ); const double * distr = well_controls_get_current_distr( ctrl );
for (int p = 0; p < np; ++p) { for (int p = 0; p < np; ++p) {
wellrates_[np * w + p] = rate_target * distr[p]; wellRates()[np * w + p] = rate_target * distr[p];
} }
} else { } else {
const double small_rate = 1e-14; const double small_rate = 1e-14;
const double sign = (wells[w]->wellType() == INJECTOR) ? 1.0 : -1.0; const double sign = (wells[w]->wellType() == INJECTOR) ? 1.0 : -1.0;
for (int p = 0; p < np; ++p) { for (int p = 0; p < np; ++p) {
wellrates_[np * w + p] = small_rate * sign; wellRates()[np * w + p] = small_rate * sign;
} }
} }
// 2. Bhp: // 2. Bhp:
if (well_controls_get_current_type(ctrl) == BHP) { if (well_controls_get_current_type(ctrl) == BHP) {
bhp_[w] = well_controls_get_current_target(ctrl); bhp()[w] = well_controls_get_current_target(ctrl);
} else { } else {
const int first_cell = wells[w]->wellCells()[0]; const int first_cell = wells[w]->wellCells()[0];
const double safety_factor = (wells[w]->wellType() == INJECTOR) ? 1.01 : 0.99; const double safety_factor = (wells[w]->wellType() == INJECTOR) ? 1.01 : 0.99;
bhp_[w] = safety_factor* state.pressure()[first_cell]; bhp()[w] = safety_factor* state.pressure()[first_cell];
} }
// 3. Thp: // 3. Thp:
if (well_controls_get_current_type(ctrl) == THP) { if (well_controls_get_current_type(ctrl) == THP) {
thp_[w] = well_controls_get_current_target(ctrl); thp()[w] = well_controls_get_current_target(ctrl);
} else { } else {
thp_[w] = bhp_[w]; thp()[w] = bhp()[w];
} }
// 4. Perf rates and pressures // 4. Perf rates and pressures
int number_of_perforations = wellMapEntry.number_of_perforations; int number_of_perforations = wellMapEntry.number_of_perforations;
for (int i = 0; i < number_of_perforations; ++i) { for (int i = 0; i < number_of_perforations; ++i) {
for (int p = 0; p < np; ++p) { for (int p = 0; p < np; ++p) {
perfPhaseRates()[np * (i + start_perforation) + p] = wellrates_[np * w + p] / double(number_of_perforations); perfPhaseRates()[np * (i + start_perforation) + p] = wellRates()[np * w + p] / double(number_of_perforations);
} }
perfpress_[i + start_perforation] = state.pressure()[wells[w]->wellCells()[i]]; perfPress()[i + start_perforation] = state.pressure()[wells[w]->wellCells()[i]];
} }
// 5. Segment rates and pressures // 5. Segment rates and pressures
@@ -222,13 +197,13 @@ namespace Opm
// when under bhp control. // when under bhp control.
// the seg_rates will related to the sum of the perforation rates, and also trying to keep consistent with the // the seg_rates will related to the sum of the perforation rates, and also trying to keep consistent with the
// well rates. Most importantly, the segment rates of the top segment is the same with the well rates // well rates. Most importantly, the segment rates of the top segment is the same with the well rates
segpress_[start_segment] = bhp_[w]; segpress_[start_segment] = bhp()[w];
for (int i = 1; i < number_of_segments; ++i) { for (int i = 1; i < number_of_segments; ++i) {
/* for (int p = 0; p < np; ++p) { /* for (int p = 0; p < np; ++p) {
segphaserates_[np * (i + start_segment) + p] = 0.; segphaserates_[np * (i + start_segment) + p] = 0.;
} */ } */
int first_perforation_segment = start_perforation + wellMapEntry.start_perforation_segment[i]; int first_perforation_segment = start_perforation + wellMapEntry.start_perforation_segment[i];
segpress_[i + start_segment] = perfpress_[first_perforation_segment]; segpress_[i + start_segment] = perfPress()[first_perforation_segment];
// the segmnent pressure of the top segment should be the bhp // the segmnent pressure of the top segment should be the bhp
} }
@@ -275,17 +250,17 @@ namespace Opm
// initialize wells that have been there before // initialize wells that have been there before
// order can change so the mapping is based on the well names // order can change so the mapping is based on the well names
if ( !(prevState.wellMap().empty()) ) if ( !(prevState.segmentedWellMap().empty()) )
{ {
typedef typename WellMapType::const_iterator const_iterator; typedef typename SegmentedWellMapType::const_iterator const_iterator;
const_iterator end_old = prevState.wellMap().end(); const_iterator end_old = prevState.segmentedWellMap().end();
for (int w = 0; w < nw; ++w) { for (int w = 0; w < nw; ++w) {
std::string well_name(wells[w]->name()); std::string well_name(wells[w]->name());
const_iterator it_old = prevState.wellMap().find(well_name); const_iterator it_old = prevState.segmentedWellMap().find(well_name);
const_iterator it_this = wellMap().find(well_name); const_iterator it_this = segmentedWellMap().find(well_name);
assert(it_this != wellMap().end()); // the current well must be present in the current well map assert(it_this != segmentedWellMap().end()); // the current well must be present in the current well map
if (it_old != end_old) { if (it_old != end_old) {
const int oldIndex = (*it_old).second.well_number; const int oldIndex = (*it_old).second.well_number;
@@ -328,7 +303,7 @@ namespace Opm
// perf_pressures_ // perf_pressures_
for (int i = 0; i < num_perf_this_well; ++i) { for (int i = 0; i < num_perf_this_well; ++i) {
// p // p
perfpress_[this_start_perforation + i] = prevState.perfPress()[old_start_perforation + i]; perfPress()[this_start_perforation + i] = prevState.perfPress()[old_start_perforation + i];
} }
// segpress_ // segpress_
@@ -370,8 +345,8 @@ namespace Opm
#if 0 #if 0
// Debugging output. // Debugging output.
std::cout << " output all the well state informations after initialization " << std::endl; std::cout << " output all the well state informations after initialization " << std::endl;
const int nperf_total = numberOfPerforations(); const int nperf_total = numPerforations();
const int nseg_total = numberOfSegments(); const int nseg_total = numSegments();
std::cout << " number of wells : " << nw << " nubmer of segments : " << nseg_total << std::endl; std::cout << " number of wells : " << nw << " nubmer of segments : " << nseg_total << std::endl;
std::cout << " number of phase : " << np << " nubmer of perforations " << nperf_total << std::endl; std::cout << " number of phase : " << np << " nubmer of perforations " << nperf_total << std::endl;
@@ -419,9 +394,9 @@ namespace Opm
std::cout << i << " " << top_segment_loc_[i] << std::endl; std::cout << i << " " << top_segment_loc_[i] << std::endl;
} }
std::cout << " output all the information from the wellMap " << std::endl; std::cout << " output all the information from the segmentedWellMap " << std::endl;
for (WellMapType::const_iterator iter = wellMap().begin(); iter != wellMap().end(); ++iter) { for (auto iter = segmentedWellMap().begin(); iter != segmentedWellMap().end(); ++iter) {
std::cout << " well name : " << iter->first << std::endl; std::cout << " well name : " << iter->first << std::endl;
const MapentryType &wellmapInfo = iter->second; const MapentryType &wellmapInfo = iter->second;
std::cout << " well number : " << wellmapInfo.well_number << " start segment " << wellmapInfo.start_segment std::cout << " well number : " << wellmapInfo.well_number << " start segment " << wellmapInfo.start_segment
@@ -438,80 +413,41 @@ namespace Opm
#endif #endif
} }
std::vector<double>& segPhaseRates() { return segphaserates_; }
const std::vector<double>& segPhaseRates() const { return segphaserates_; }
std::vector<double>& segPress() { return segpress_; } std::vector<double>& segPress() { return segpress_; }
const std::vector<double>& segPress() const { return segpress_; } const std::vector<double>& segPress() const { return segpress_; }
std::vector<double>& perfPress() { return perfpress_; } std::vector<double>& segPhaseRates() { return segphaserates_; }
const std::vector<double>& perfPress() const { return perfpress_; } const std::vector<double>& segPhaseRates() const { return segphaserates_; }
// std::vector<double>& perfPhaseRates() { return perfphaserates_; }
// const std::vector<double>& perfPhaseRates() const { return perfphaserates_; }
using Base::perfPhaseRates;
std::vector<double>& bhp() { return bhp_; }
const std::vector<double>& bhp() const { return bhp_; }
std::vector<double>& thp() { return thp_; }
const std::vector<double>& thp() const { return thp_; }
std::vector<double>& wellRates() { return wellrates_; }
const std::vector<double>& wellRates() const { return wellrates_; }
// One temperature per well.
std::vector<double>& temperature() { return temperature_; };
const std::vector<double>& temperature() const { return temperature_; }
const std::vector<int>& topSegmentLoc() const { return top_segment_loc_; }; const std::vector<int>& topSegmentLoc() const { return top_segment_loc_; };
// std::vector<int>& currentControls() { return current_controls_; } const SegmentedWellMapType& segmentedWellMap() const { return segmentedWellMap_; }
// const std::vector<int>& currentControls() const { return current_controls_; } SegmentedWellMapType& segmentedWellMap() { return segmentedWellMap_; }
using Base::currentControls;
// wellrate should be the out segment rates for the top segments int numSegments() const { return nseg_; }
int numPerforations() const { return nperf_; }
const WellMapType& wellMap() const { return wellMap_; }
WellMapType& wellMap() { return wellMap_; }
int numberOfPhases() const { return np_; }
int numberOfSegments() const { return nseg_; }
int numberOfPerforations() const { return nperf_; }
int numberOfWells() const { return nwells_; }
private: private:
std::vector<double> bhp_;
std::vector<double> thp_;
std::vector<double> wellrates_;
std::vector<double> temperature_;
// pressure for the segment nodes // pressure for the segment nodes
std::vector<double> segpress_; std::vector<double> segpress_;
// phase rates for the segments // phase rates for the segments
std::vector<double> segphaserates_; std::vector<double> segphaserates_;
// phase rates for the completions
// std::vector<double> perfphaserates_;
// pressure for the perforatins
std::vector<double> perfpress_;
// TODO: MIGHT NOT USE THE FOLLOWING VARIABLES AT THE // TODO: MIGHT NOT USE THE FOLLOWING VARIABLES AT THE
// fractions for each segments (W, O, G) // fractions for each segments (W, O, G)
std::vector<double> segphasefrac_; std::vector<double> segphasefrac_;
// total flow rates for each segments, G_T // total flow rates for each segments, G_T
std::vector<double> segtotalrate_; std::vector<double> segtotalrate_;
// std::vector<int> current_controls_;
// the location of the top segments within the whole segment list // the location of the top segments within the whole segment list
// it is better in the Wells class if we have a class instead of // it is better in the Wells class if we have a class instead of
// using a vector for all the wells // using a vector for all the wells
std::vector<int> top_segment_loc_; std::vector<int> top_segment_loc_;
WellMapType wellMap_; SegmentedWellMapType segmentedWellMap_;
int nseg_; int nseg_;
int np_;
int nperf_; int nperf_;
int nwells_;
}; };
} // namespace Opm } // namespace Opm