1769 lines
48 KiB
C++
1769 lines
48 KiB
C++
//===========================================================================
|
|
//
|
|
// File: SpecialEclipseFields.hpp
|
|
//
|
|
// Created: Mon Sep 21 14:09:54 2009
|
|
//
|
|
// Author(s): Atgeirr F Rasmussen <atgeirr@sintef.no>
|
|
// Bård Skaflestad <bard.skaflestad@sintef.no>
|
|
// Bjørn Spjelkavik <bsp@sintef.no>
|
|
//
|
|
// $Date$
|
|
//
|
|
// $Revision$
|
|
//
|
|
//===========================================================================
|
|
|
|
/*
|
|
Copyright 2009, 2010 SINTEF ICT, Applied Mathematics.
|
|
Copyright 2009, 2010 Statoil ASA.
|
|
|
|
This file is part of The Open Reservoir Simulator Project (OpenRS).
|
|
|
|
OpenRS 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.
|
|
|
|
OpenRS 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 OpenRS. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef OPENRS_SPECIALECLIPSEFIELDS_HEADER
|
|
#define OPENRS_SPECIALECLIPSEFIELDS_HEADER
|
|
|
|
#include <string>
|
|
#include <fstream>
|
|
#include <limits>
|
|
#include <opm/core/utility/ErrorMacros.hpp>
|
|
#include <opm/core/eclipse/EclipseGridParserHelpers.hpp>
|
|
#include <opm/core/eclipse/EclipseUnits.hpp>
|
|
|
|
namespace Opm
|
|
{
|
|
|
|
// Abstract base class for special fields.
|
|
struct SpecialBase {
|
|
virtual ~SpecialBase() {} // Default destructor
|
|
//virtual std::string name() const = 0; // Keyword name
|
|
virtual void read(std::istream& is) = 0; // Reads data
|
|
//virtual void write(std::ostream& os) const = 0; // Writes data
|
|
virtual void convertToSI(const EclipseUnits&)
|
|
{
|
|
THROW("Default conversion not defined.");
|
|
}
|
|
typedef std::vector<std::vector<std::vector<double> > > table_t;
|
|
};
|
|
|
|
|
|
|
|
|
|
/// Class for keyword SPECGRID
|
|
struct SPECGRID : public SpecialBase
|
|
{
|
|
std::vector<int> dimensions; // Number of grid blocks in x-, y- and z-directions.
|
|
int numres; // Number of reservoirs.
|
|
char qrdial; // Coordinates. F=cartesian, T=Cylindrical(radial).
|
|
|
|
SPECGRID()
|
|
{
|
|
dimensions.resize(3,1);
|
|
numres = 1;
|
|
qrdial = 'F';
|
|
}
|
|
|
|
virtual ~SPECGRID()
|
|
{
|
|
}
|
|
|
|
virtual std::string name() const {return std::string("SPECGRID");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
const int ndim = 3;
|
|
std::vector<int> data(ndim+1,1);
|
|
int nread = readDefaultedVectorData(is , data, ndim+1);
|
|
int nd = std::min(nread, ndim);
|
|
copy(data.begin(), data.begin()+nd, &dimensions[0]);
|
|
numres = data[ndim];
|
|
std::string candidate;
|
|
is >> candidate;
|
|
if (candidate == "/") {
|
|
return;
|
|
} else {
|
|
qrdial = candidate[0];
|
|
}
|
|
|
|
if (ignoreSlashLine(is)) {
|
|
return;
|
|
} else {
|
|
THROW("End of file reading" << name());
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << std::endl;
|
|
os << dimensions[0] << " " << dimensions[1] << " "
|
|
<< dimensions[2] << " " << numres << " " << qrdial << std::endl;
|
|
os << std::endl;
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits&)
|
|
{}
|
|
};
|
|
|
|
|
|
|
|
|
|
/// Class holding segment data of keyword FAULTS.
|
|
struct FaultSegment
|
|
{
|
|
std::string fault_name; // Fault name
|
|
std::vector<int> ijk_coord; // ijk-coordinates of segment cells
|
|
std::string face; // Fault face of cells
|
|
};
|
|
|
|
/// Class for keyword FAULTS.
|
|
struct FAULTS : public SpecialBase
|
|
{
|
|
std::vector<FaultSegment> faults;
|
|
|
|
FAULTS()
|
|
{
|
|
}
|
|
|
|
virtual ~FAULTS()
|
|
{
|
|
}
|
|
|
|
virtual std::string name() const {return std::string("FAULTS");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while(is) {
|
|
std::string fltname;
|
|
is >> fltname;
|
|
if (fltname[0] == '/') {
|
|
is >> ignoreLine;
|
|
break;
|
|
}
|
|
while (fltname.find("--") == 0) {
|
|
// This line is a comment
|
|
is >> ignoreLine >> fltname;
|
|
}
|
|
FaultSegment fault_segment;
|
|
fault_segment.ijk_coord.resize(6);
|
|
fault_segment.fault_name = fltname;
|
|
int nread = readDefaultedVectorData(is, fault_segment.ijk_coord, 6);
|
|
if (nread != 6) {
|
|
THROW("Error reading fault_segment " << fltname);
|
|
}
|
|
is >> fault_segment.face;
|
|
faults.push_back(fault_segment);
|
|
ignoreSlashLine(is);
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << std::endl;
|
|
for (int i=0; i<(int)faults.size(); ++i) {
|
|
os << faults[i].fault_name << " ";
|
|
copy(faults[i].ijk_coord.begin(), faults[i].ijk_coord.end(),
|
|
std::ostream_iterator<int>(os, " "));
|
|
os << faults[i].face << std::endl;
|
|
}
|
|
os << std::endl;
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits&)
|
|
{}
|
|
};
|
|
|
|
|
|
|
|
|
|
/// Class holding a data line of keyword MULTFLT
|
|
struct MultfltLine
|
|
{
|
|
std::string fault_name; // Fault name, as in FAULTS
|
|
double transmis_multiplier; // Transmissibility multiplier
|
|
double diffusivity_multiplier; // Diffusivity multiplier;
|
|
MultfltLine() :
|
|
fault_name(""), transmis_multiplier(1.0), diffusivity_multiplier(1.0)
|
|
{}
|
|
};
|
|
|
|
/// Class for keyword MULFLT
|
|
struct MULTFLT : public SpecialBase
|
|
{
|
|
std::vector<MultfltLine> multflts;
|
|
|
|
MULTFLT()
|
|
{
|
|
}
|
|
|
|
virtual ~MULTFLT()
|
|
{}
|
|
|
|
virtual std::string name() const {return std::string("MULTFLT");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while(is) {
|
|
std::string fltname;
|
|
is >> fltname;
|
|
if (fltname[0] == '/') {
|
|
is >> ignoreLine;
|
|
break;
|
|
}
|
|
while (fltname == "--") {
|
|
// This line is a comment
|
|
is >> ignoreLine >> fltname;
|
|
}
|
|
MultfltLine multflt_line;
|
|
multflt_line.fault_name = fltname;
|
|
std::vector<double> data(2,1.0);
|
|
if (readDefaultedVectorData(is, data, 2) == 2) {
|
|
ignoreSlashLine(is);
|
|
}
|
|
multflt_line.transmis_multiplier = data[0];
|
|
multflt_line.diffusivity_multiplier = data[1];
|
|
multflts.push_back(multflt_line);
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << std::endl;
|
|
for (int i=0; i<(int)multflts.size(); ++i) {
|
|
os << multflts[i].fault_name << " "
|
|
<< multflts[i].transmis_multiplier << " "
|
|
<< multflts[i].diffusivity_multiplier << std::endl;
|
|
}
|
|
os << std::endl;
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits&)
|
|
{}
|
|
};
|
|
|
|
|
|
|
|
|
|
struct TITLE : public SpecialBase
|
|
{
|
|
std::string title;
|
|
virtual std::string name() const
|
|
{ return std::string("TITLE"); }
|
|
virtual void read(std::istream& is)
|
|
{ is >> ignoreLine; std::getline(is, title); }
|
|
virtual void write(std::ostream& os) const
|
|
{ os << name() << '\n' << title << '\n'; }
|
|
virtual void convertToSI(const EclipseUnits&)
|
|
{}
|
|
};
|
|
|
|
|
|
|
|
|
|
struct START : public SpecialBase
|
|
{
|
|
boost::gregorian::date date;
|
|
virtual std::string name() const
|
|
{ return std::string("START"); }
|
|
virtual void read(std::istream& is)
|
|
{ date = readDate(is); }
|
|
virtual void write(std::ostream& os) const
|
|
{ os << name() << '\n' << date << '\n'; }
|
|
virtual void convertToSI(const EclipseUnits&)
|
|
{}
|
|
};
|
|
|
|
|
|
|
|
|
|
struct DATES : public SpecialBase
|
|
{
|
|
std::vector<boost::gregorian::date> dates;
|
|
virtual std::string name() const
|
|
{ return std::string("DATES"); }
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while(is) {
|
|
dates.push_back(readDate(is));
|
|
is >> ignoreWhitespace;
|
|
if (is.peek() == int('/')) {
|
|
is >> ignoreLine;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
copy(dates.begin(), dates.end(),
|
|
std::ostream_iterator<boost::gregorian::date>(os, "\n"));
|
|
}
|
|
virtual void convertToSI(const EclipseUnits&)
|
|
{}
|
|
};
|
|
|
|
|
|
struct DENSITY : public SpecialBase
|
|
{
|
|
std::vector<std::vector<double> > densities_;
|
|
|
|
virtual std::string name() const {return std::string("DENSITY");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while (!is.eof()) {
|
|
std::vector<double> density(3,-1e100);
|
|
if (readDefaultedVectorData(is, density, 3) == 3) {
|
|
ignoreSlashLine(is);
|
|
}
|
|
densities_.push_back(density);
|
|
|
|
int action = next_action(is); // 0:continue 1:return 2:throw
|
|
if (action == 1) {
|
|
return; // Alphabetic char. Read next keyword.
|
|
} else if (action == 2) {
|
|
THROW("Error reading DENSITY. Next character is "
|
|
<< (char)is.peek());
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int i=0; i<(int)densities_.size(); ++i) {
|
|
os << densities_[i][0] << " " << densities_[i][1] << " "
|
|
<< densities_[i][2] << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
for (int i=0; i<(int)densities_.size(); ++i) {
|
|
densities_[i][0] *= units.density;
|
|
densities_[i][1] *= units.density;
|
|
densities_[i][2] *= units.density;
|
|
}
|
|
}
|
|
};
|
|
|
|
struct PVDG : public SpecialBase
|
|
{
|
|
table_t pvdg_;
|
|
|
|
virtual std::string name() const {return std::string("PVDG");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
readPvdTable(is, pvdg_, name(), 3);
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int rn=0; rn<(int)pvdg_.size(); ++rn) {
|
|
for (int i=0; i<(int)pvdg_[rn][0].size(); ++i) {
|
|
os << pvdg_[rn][0][i] << " " << pvdg_[rn][1][i] << " "
|
|
<< pvdg_[rn][2][i] << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
double volfac = units.gasvol_r/units.gasvol_s;
|
|
for (int rn=0; rn<(int)pvdg_.size(); ++rn) {
|
|
for (int i=0; i<(int)pvdg_[rn][0].size(); ++i) {
|
|
pvdg_[rn][0][i] *= units.pressure;
|
|
pvdg_[rn][1][i] *= volfac;
|
|
pvdg_[rn][2][i] *= units.viscosity;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
struct PVDO : public SpecialBase
|
|
{
|
|
table_t pvdo_;
|
|
|
|
virtual std::string name() const {return std::string("PVDO");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
readPvdTable(is, pvdo_, name(), 3);
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int rn=0; rn<(int)pvdo_.size(); ++rn) {
|
|
for (int i=0; i<(int)pvdo_[rn][0].size(); ++i) {
|
|
os << pvdo_[rn][0][i] << " " << pvdo_[rn][1][i] << " "
|
|
<< pvdo_[rn][2][i] << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
double volfac = units.liqvol_r/units.liqvol_s;
|
|
for (int rn=0; rn<(int)pvdo_.size(); ++rn) {
|
|
for (int i=0; i<(int)pvdo_[rn][0].size(); ++i) {
|
|
pvdo_[rn][0][i] *= units.pressure;
|
|
pvdo_[rn][1][i] *= volfac;
|
|
pvdo_[rn][2][i] *= units.viscosity;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
struct PVTG : public SpecialBase
|
|
{
|
|
table_t pvtg_;
|
|
|
|
virtual std::string name() const {return std::string("PVTG");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
readPvtTable(is, pvtg_, name());
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int rn=0; rn<(int)pvtg_.size(); ++rn) {
|
|
for (int i=0; i<(int)pvtg_[rn].size(); ++i) {
|
|
int nl = (pvtg_[rn][i].size()-1) / 3;
|
|
os << pvtg_[rn][i][0] << " " << pvtg_[rn][i][1] << " "
|
|
<< pvtg_[rn][i][2] << " " << pvtg_[rn][i][3] << '\n';
|
|
for (int j=1, n=3; j<nl; ++j, n+=3) {
|
|
os << '\t' << pvtg_[rn][i][n+1] << " "
|
|
<< pvtg_[rn][i][n+2] << " " << pvtg_[rn][i][n+3]
|
|
<< '\n';
|
|
}
|
|
}
|
|
os << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
double oilgasratio = units.liqvol_s/units.gasvol_s;
|
|
double volfac = units.gasvol_r/units.gasvol_s;
|
|
for (int rn=0; rn<(int)pvtg_.size(); ++rn) {
|
|
for (int i=0; i<(int)pvtg_[rn].size(); ++i) {
|
|
int nl = (pvtg_[rn][i].size()-1) / 3;
|
|
pvtg_[rn][i][0] *= units.pressure;
|
|
pvtg_[rn][i][1] *= oilgasratio;
|
|
pvtg_[rn][i][2] *= volfac;
|
|
pvtg_[rn][i][3] *= units.viscosity;
|
|
for (int j=1, n=3; j<nl; ++j, n+=3) {
|
|
pvtg_[rn][i][n+1] *= oilgasratio;
|
|
pvtg_[rn][i][n+2] *= volfac;
|
|
pvtg_[rn][i][n+3] *= units.viscosity;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
struct PVTO : public SpecialBase
|
|
{
|
|
table_t pvto_;
|
|
|
|
virtual std::string name() const {return std::string("PVTO");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
readPvtTable(is, pvto_, name());
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int rn=0; rn<(int)pvto_.size(); ++rn) {
|
|
for (int i=0; i<(int)pvto_[rn].size(); ++i) {
|
|
int nl = (pvto_[rn][i].size()-1) / 3;
|
|
os << pvto_[rn][i][0] << " " << pvto_[rn][i][1] << " "
|
|
<< pvto_[rn][i][2] << " " << pvto_[rn][i][3] << '\n';
|
|
for (int j=1, n=3; j<nl; ++j, n+=3) {
|
|
os << '\t' << pvto_[rn][i][n+1] << " "
|
|
<< pvto_[rn][i][n+2] << " " << pvto_[rn][i][n+3]
|
|
<< '\n';
|
|
}
|
|
}
|
|
os << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
double gasoilratio = units.gasvol_s/units.liqvol_s;
|
|
double volfac = units.liqvol_r/units.liqvol_s;
|
|
for (int rn=0; rn<(int)pvto_.size(); ++rn) {
|
|
for (int i=0; i<(int)pvto_[rn].size(); ++i) {
|
|
int nl = (pvto_[rn][i].size()-1) / 3;
|
|
pvto_[rn][i][0] *= gasoilratio;
|
|
pvto_[rn][i][1] *= units.pressure;
|
|
pvto_[rn][i][2] *= volfac;
|
|
pvto_[rn][i][3] *= units.viscosity;
|
|
for (int j=1, n=3; j<nl; ++j, n+=3) {
|
|
pvto_[rn][i][n+1] *= units.pressure;
|
|
pvto_[rn][i][n+2] *= volfac;
|
|
pvto_[rn][i][n+3] *= units.viscosity;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
struct PVTW : public SpecialBase
|
|
{
|
|
std::vector<std::vector<double> > pvtw_;
|
|
|
|
virtual std::string name() const {return std::string("PVTW");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while (!is.eof()) {
|
|
std::vector<double> pvtw;
|
|
readVectorData(is, pvtw);
|
|
if (pvtw.size() == 4) {
|
|
pvtw.push_back(0.0); // Not used by frontsim
|
|
}
|
|
pvtw_.push_back(pvtw);
|
|
|
|
int action = next_action(is); // 0:continue 1:return 2:throw
|
|
if (action == 1) {
|
|
return; // Alphabetic char. Read next keyword.
|
|
} else if (action == 2) {
|
|
THROW("Error reading PVTW. Next character is "
|
|
<< (char)is.peek());
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int i=0; i<(int)pvtw_.size(); ++i) {
|
|
os << pvtw_[i][0] << " " << pvtw_[i][1] << " " << pvtw_[i][2]
|
|
<< " " << pvtw_[i][3] << " " << pvtw_[i][4] << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
double volfac = units.liqvol_r/units.liqvol_s;
|
|
for (int i=0; i<(int)pvtw_.size(); ++i) {
|
|
pvtw_[i][0] *= units.pressure;
|
|
pvtw_[i][1] *= volfac;
|
|
pvtw_[i][2] *= units.compressibility;
|
|
pvtw_[i][3] *= units.viscosity;
|
|
pvtw_[i][4] *= units.compressibility;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
struct ROCK : public SpecialBase
|
|
{
|
|
std::vector<std::vector<double> > rock_compressibilities_;
|
|
|
|
virtual std::string name() const {return std::string("ROCK");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while (!is.eof()) {
|
|
std::vector<double> rock;
|
|
readVectorData(is, rock);
|
|
rock_compressibilities_.push_back(rock);
|
|
|
|
int action = next_action(is); // 0:continue 1:return 2:throw
|
|
if (action == 1) {
|
|
return; // Alphabetic char. Read next keyword.
|
|
} else if (action == 2) {
|
|
THROW("Error reading ROCK. Next character is "
|
|
<< (char)is.peek());
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int i=0; i<(int)rock_compressibilities_.size(); ++i) {
|
|
os << rock_compressibilities_[i][0] << " "
|
|
<< rock_compressibilities_[i][1] << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
for (int i=0; i<(int)rock_compressibilities_.size(); ++i) {
|
|
rock_compressibilities_[i][0] *= units.pressure;
|
|
rock_compressibilities_[i][1] *= units.compressibility;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
struct ROCKTAB : public SpecialBase
|
|
{
|
|
table_t rocktab_;
|
|
|
|
virtual std::string name() const {return std::string("ROCKTAB");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
readPvdTable(is, rocktab_, name(), 3);
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int rn=0; rn<(int)rocktab_.size(); ++rn) {
|
|
for (int i=0; i<(int)rocktab_[rn][0].size(); ++i) {
|
|
os << rocktab_[rn][0][i] << " " << rocktab_[rn][1][i] << " "
|
|
<< rocktab_[rn][2][i] << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
for (int rn=0; rn<(int)rocktab_.size(); ++rn) {
|
|
for (int i=0; i<(int)rocktab_[rn][0].size(); ++i) {
|
|
rocktab_[rn][0][i] *= units.pressure;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
struct SGOF : public SpecialBase
|
|
{
|
|
table_t sgof_;
|
|
|
|
virtual std::string name() const {return std::string("SGOF");}
|
|
|
|
virtual void read(std::istream& is) {readSGWOF(is, sgof_, name(), 4);}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int rn=0; rn<(int)sgof_.size(); ++rn) {
|
|
for (int i=0; i<(int)sgof_[rn][0].size(); ++i) {
|
|
os << sgof_[rn][0][i] << " " << sgof_[rn][1][i] << " "
|
|
<< sgof_[rn][2][i] << " " << sgof_[rn][3][i] << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
for (int rn=0; rn<(int)sgof_.size(); ++rn) {
|
|
for (int i=0; i<(int)sgof_[rn][0].size(); ++i) {
|
|
sgof_[rn][3][i] *= units.pressure;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
struct SWOF : public SpecialBase
|
|
{
|
|
table_t swof_;
|
|
|
|
virtual std::string name() const {return std::string("SWOF");}
|
|
|
|
virtual void read(std::istream& is) {readSGWOF(is, swof_, name(), 4);}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int rn=0; rn<(int)swof_.size(); ++rn) {
|
|
for (int i=0; i<(int)swof_[rn][0].size(); ++i) {
|
|
os << swof_[rn][0][i] << " " << swof_[rn][1][i] << " "
|
|
<< swof_[rn][2][i] << " " << swof_[rn][3][i] << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
for (int rn=0; rn<(int)swof_.size(); ++rn) {
|
|
for (int i=0; i<(int)swof_[rn][0].size(); ++i) {
|
|
swof_[rn][3][i] *= units.pressure;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/// Class holding a data line of keyword WELSPECS
|
|
struct WelspecsLine
|
|
{
|
|
std::string name_; // Well name
|
|
std::string group_; // Group name
|
|
int I_; // I-location of well head or heel
|
|
int J_; // J-location of well head or heel
|
|
double datum_depth_BHP_; // Datum depth for bottom hole pressure
|
|
std::string pref_phase_; // Preferred phase for the well
|
|
double drain_rad_; // Drainage radius for prod/inj index calculation
|
|
std::string spec_inflow_; // Flag for special inflow equation
|
|
std::string shut_in_; // Instructions for automatic shut-in
|
|
std::string crossflow_; // Crossflow ability flag
|
|
int pressure_table_number_; // Pressure table number for wellbore fluid properties
|
|
std::string density_calc_type_; // Type of density calculation for wellbore hydrostatic head
|
|
int fluids_in_place_reg_numb_; // Fluids in place region number
|
|
|
|
WelspecsLine() :
|
|
datum_depth_BHP_(-1.0), drain_rad_(0.0), spec_inflow_("STD"),
|
|
shut_in_("SHUT"), crossflow_("YES"), pressure_table_number_(0),
|
|
density_calc_type_("SEG"), fluids_in_place_reg_numb_(0)
|
|
{}
|
|
};
|
|
|
|
/// Class for keyword WELSPECS
|
|
struct WELSPECS : public SpecialBase
|
|
{
|
|
std::vector<WelspecsLine> welspecs;
|
|
|
|
WELSPECS()
|
|
{
|
|
}
|
|
|
|
virtual ~WELSPECS()
|
|
{}
|
|
|
|
virtual std::string name() const {return std::string("WELSPECS");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while(is) {
|
|
std::string wellname = readString(is);
|
|
if (wellname[0] == '/') {
|
|
is >> ignoreLine;
|
|
break;
|
|
}
|
|
while (wellname.find("--") == 0) {
|
|
// This line is a comment
|
|
is >> ignoreLine;
|
|
wellname = readString(is);
|
|
}
|
|
WelspecsLine welspecs_line;
|
|
welspecs_line.name_ = wellname;
|
|
welspecs_line.group_ = readString(is);
|
|
std::vector<int> int_data(2,1);
|
|
readDefaultedVectorData(is, int_data, 2);
|
|
welspecs_line.I_ = int_data[0];
|
|
welspecs_line.J_ = int_data[1];
|
|
std::vector<double> double_data(1,-1.0);
|
|
readDefaultedVectorData(is, double_data, 1);
|
|
welspecs_line.datum_depth_BHP_ = double_data[0];
|
|
welspecs_line.pref_phase_ = readString(is);
|
|
|
|
// HACK! Ignore items 7-13.
|
|
ignoreSlashLine(is);
|
|
welspecs.push_back(welspecs_line);
|
|
|
|
// double_data[0] = 0.0;
|
|
// readDefaultedVectorData(is, double_data, 1);
|
|
// welspecs_line.drain_rad_ = double_data[0];
|
|
// welspecs_line.spec_inflow_ = readString(is);
|
|
// welspecs_line.shut_in_ = readString(is);
|
|
// welspecs_line.crossflow_ = readString(is);
|
|
// int_data[0] = 0;
|
|
// readDefaultedVectorData(is, int_data, 1);
|
|
// welspecs_line.pressure_table_number_ = int_data[0];
|
|
// welspecs_line.density_calc_type_ = readString(is);
|
|
// int_data[0] = 0;
|
|
// readDefaultedVectorData(is, int_data, 1);
|
|
// welspecs_line.fluids_in_place_reg_numb_ = int_data[0];
|
|
// welspecs.push_back(welspecs_line);
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << std::endl;
|
|
for (int i=0; i<(int)welspecs.size(); ++i) {
|
|
os << welspecs[i].name_ << " "
|
|
<< welspecs[i].group_ << " "
|
|
<< welspecs[i].I_ << " "
|
|
<< welspecs[i].J_ << " "
|
|
<< welspecs[i].datum_depth_BHP_ << " "
|
|
<< welspecs[i].pref_phase_ << " "
|
|
<< welspecs[i].drain_rad_ << " "
|
|
<< welspecs[i].spec_inflow_ << " "
|
|
<< welspecs[i].shut_in_ << " "
|
|
<< welspecs[i].crossflow_ << " "
|
|
<< welspecs[i].pressure_table_number_ << " "
|
|
<< welspecs[i].density_calc_type_ << " "
|
|
<< welspecs[i].fluids_in_place_reg_numb_ << " "
|
|
<< std::endl;
|
|
}
|
|
os << std::endl;
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
for (int i=0; i<(int)welspecs.size(); ++i) {
|
|
welspecs[i].datum_depth_BHP_ *= units.length;
|
|
welspecs[i].drain_rad_ *= units.length;
|
|
}
|
|
}
|
|
};
|
|
|
|
/// Class holding a data line of keyword COMPDAT
|
|
struct CompdatLine
|
|
{
|
|
std::string well_; // Well name
|
|
std::vector<int> grid_ind_; // Grid block location
|
|
std::string open_shut_flag_; // Open/shut flag of connection
|
|
int sat_table_number_; // Saturation table number
|
|
double connect_trans_fac_; // Connection transmillibilty factor
|
|
double diameter_; // Well bore internal diameter
|
|
double Kh_; // Effective Kh value of the connection
|
|
double skin_factor_; // Skin factor
|
|
double D_factor_; // D-factor, for non-Darcy flow of free gas
|
|
std::string penetration_direct_; // Penetration direction
|
|
double r0_; // Pressure equivalent radius
|
|
|
|
// Default values
|
|
CompdatLine() :
|
|
open_shut_flag_("OPEN"),
|
|
sat_table_number_(0),
|
|
connect_trans_fac_(0.0),
|
|
diameter_(0.0),
|
|
Kh_(-1.0),
|
|
skin_factor_(0.0),
|
|
D_factor_(-1e100),
|
|
penetration_direct_("Z"),
|
|
r0_(-1.0)
|
|
{
|
|
grid_ind_.resize(4);
|
|
}
|
|
};
|
|
|
|
/// Class for keyword COMPDAT
|
|
struct COMPDAT : public SpecialBase
|
|
{
|
|
std::vector<CompdatLine> compdat;
|
|
|
|
COMPDAT()
|
|
{
|
|
}
|
|
|
|
virtual ~COMPDAT()
|
|
{}
|
|
|
|
virtual std::string name() const {return std::string("COMPDAT");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while(is) {
|
|
std::string wellname = readString(is);
|
|
if (wellname[0] == '/') {
|
|
is >> ignoreLine;
|
|
break;
|
|
}
|
|
while (wellname.find("--") == 0) {
|
|
// This line is a comment
|
|
is >> ignoreLine;
|
|
wellname = readString(is);
|
|
}
|
|
CompdatLine compdat_line;
|
|
compdat_line.well_ = wellname;
|
|
readDefaultedVectorData(is, compdat_line.grid_ind_, 4);
|
|
compdat_line.open_shut_flag_ = readString(is);
|
|
std::vector<int> int_data(1,-1);
|
|
readDefaultedVectorData(is, int_data, 1);
|
|
compdat_line.sat_table_number_ = int_data[0];
|
|
std::vector<double> double_data(2, 0.0);
|
|
int num_to_read = 2;
|
|
int num_read = readDefaultedVectorData(is, double_data, num_to_read);
|
|
compdat_line.connect_trans_fac_ = double_data[0];
|
|
compdat_line.diameter_ = double_data[1];
|
|
|
|
// HACK! Ignore items 10-14.
|
|
if (num_read == num_to_read) {
|
|
ignoreSlashLine(is);
|
|
}
|
|
compdat.push_back(compdat_line);
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << std::endl;
|
|
for (int i=0; i<(int)compdat.size(); ++i) {
|
|
os << compdat[i].well_ << " "
|
|
<< compdat[i].grid_ind_[0] << " "
|
|
<< compdat[i].grid_ind_[1] << " "
|
|
<< compdat[i].grid_ind_[2] << " "
|
|
<< compdat[i].grid_ind_[3] << " "
|
|
<< compdat[i].open_shut_flag_ << " "
|
|
<< compdat[i].sat_table_number_ << " "
|
|
<< compdat[i].connect_trans_fac_ << " "
|
|
<< compdat[i].diameter_ << " "
|
|
<< compdat[i].Kh_ << " "
|
|
<< compdat[i].skin_factor_ << " "
|
|
<< compdat[i].D_factor_ << " "
|
|
<< compdat[i].penetration_direct_ << " "
|
|
<< compdat[i].r0_
|
|
<< std::endl;
|
|
}
|
|
os << std::endl;
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
for (int i=0; i<(int)compdat.size(); ++i) {
|
|
compdat[i].connect_trans_fac_ *= units.transmissibility;
|
|
compdat[i].diameter_ *= units.length;
|
|
compdat[i].Kh_ *= units.permeability*units.length;
|
|
compdat[i].r0_ *= units.length;
|
|
}
|
|
}
|
|
};
|
|
|
|
/// Class holding a data line of keyword WCONINJE
|
|
struct WconinjeLine
|
|
{
|
|
std::string well_; // Well name or well name root
|
|
std::string injector_type_; // Injector type
|
|
std::string open_shut_flag_; // Open/shut flag for the well
|
|
std::string control_mode_; // Control mode
|
|
double surface_flow_max_rate_; // Surface flow rate target or upper limit
|
|
double fluid_volume_max_rate_; // Reservoir fluid volume rate target or
|
|
// upper limit
|
|
double BHP_limit_; // BHP target or upper limit
|
|
double THP_limit_; // THP target or upper limit
|
|
int VFP_table_number_; // Injection well VFP table number
|
|
double concentration_; // Vaporised oil concentration in the
|
|
// injected gas, or dissolved gas
|
|
// concentration in the injected oil
|
|
|
|
// Default values
|
|
WconinjeLine() :
|
|
open_shut_flag_("OPEN"), surface_flow_max_rate_(1.0E20),
|
|
fluid_volume_max_rate_(1.0E20), BHP_limit_(6895), THP_limit_(1.0E20),
|
|
VFP_table_number_(0), concentration_(0.0)
|
|
{
|
|
}
|
|
};
|
|
|
|
/// Class for keyword WCONINJE
|
|
struct WCONINJE : public SpecialBase
|
|
{
|
|
std::vector<WconinjeLine> wconinje;
|
|
|
|
WCONINJE()
|
|
{
|
|
}
|
|
|
|
virtual ~WCONINJE()
|
|
{}
|
|
|
|
virtual std::string name() const {return std::string("WCONINJE");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while(is) {
|
|
std::string wellname = readString(is);
|
|
if (wellname[0] == '/') {
|
|
is >> ignoreLine;
|
|
break;
|
|
}
|
|
while (wellname.find("--") == 0) {
|
|
// This line is a comment
|
|
is >> ignoreLine;
|
|
wellname = readString(is);
|
|
}
|
|
WconinjeLine wconinje_line;
|
|
wconinje_line.well_ = wellname;
|
|
wconinje_line.injector_type_ = readString(is);
|
|
wconinje_line.open_shut_flag_ = readString(is);
|
|
wconinje_line.control_mode_ = readString(is);
|
|
std::vector<double> double_data(6, 1.0E20);
|
|
double_data[2] = wconinje_line.BHP_limit_;
|
|
double_data[4] = wconinje_line.VFP_table_number_;
|
|
double_data[5] = wconinje_line.concentration_;
|
|
const int num_to_read = 6;
|
|
int num_read = readDefaultedVectorData(is, double_data, num_to_read);
|
|
wconinje_line.surface_flow_max_rate_ = double_data[0];
|
|
wconinje_line.fluid_volume_max_rate_ = double_data[1];
|
|
wconinje_line.BHP_limit_ = double_data[2];
|
|
wconinje_line.THP_limit_ = double_data[3];
|
|
wconinje_line.VFP_table_number_ = (int)double_data[4];
|
|
wconinje_line.concentration_ = double_data[5];
|
|
// HACK! Ignore any further items
|
|
if (num_read == num_to_read) {
|
|
ignoreSlashLine(is);
|
|
}
|
|
wconinje.push_back(wconinje_line);
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << std::endl;
|
|
for (int i=0; i<(int) wconinje.size(); ++i) {
|
|
os << wconinje[i].well_ << " "
|
|
<< wconinje[i].injector_type_ << " "
|
|
<< wconinje[i].open_shut_flag_ << " "
|
|
<< wconinje[i].control_mode_ << " "
|
|
<< wconinje[i].surface_flow_max_rate_ << " "
|
|
<< wconinje[i].fluid_volume_max_rate_ << " "
|
|
<< wconinje[i].BHP_limit_ << " "
|
|
<< wconinje[i].THP_limit_ << " "
|
|
<< wconinje[i].VFP_table_number_ << " "
|
|
<< wconinje[i].concentration_
|
|
<< std::endl;
|
|
}
|
|
os << std::endl;
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
for (int i=0; i<(int) wconinje.size(); ++i) {
|
|
if (wconinje[i].injector_type_ == "GAS") {
|
|
wconinje[i].surface_flow_max_rate_ *= units.gasvol_s/units.time;
|
|
} else {
|
|
wconinje[i].surface_flow_max_rate_ *= units.liqvol_s/units.time;
|
|
}
|
|
wconinje[i].fluid_volume_max_rate_ *= units.liqvol_r/units.time;
|
|
wconinje[i].BHP_limit_ *= units.pressure;
|
|
wconinje[i].THP_limit_ *= units.pressure;
|
|
wconinje[i].concentration_ *= units.gasvol_s/units.liqvol_s; // ??? @bsp 10
|
|
}
|
|
}
|
|
};
|
|
|
|
/// Class holding a data line of keyword WCONPROD
|
|
struct WconprodLine
|
|
{
|
|
std::string well_; // Well name or well name root
|
|
std::string open_shut_flag_; // Open/shut flag for the well
|
|
std::string control_mode_; // Control mode
|
|
double oil_max_rate_; // Oil rate target or upper limit
|
|
double water_max_rate_; // Water rate target or upper limit
|
|
double gas_max_rate_; // Gas rate target or upper limit
|
|
double liquid_max_rate_; // Liquid rate target or upper limit
|
|
double fluid_volume_max_rate_; // Reservoir fluid volume rate target or
|
|
// upper limit
|
|
double BHP_limit_; // BHP target or upper limit
|
|
double THP_limit_; // THP target or upper limit
|
|
int VFP_table_number_; // Injection well VFP table number
|
|
double artif_lift_quantity_; // Artificial lift quantity in THP calculations
|
|
|
|
// Default values
|
|
WconprodLine() :
|
|
open_shut_flag_("OPEN"), oil_max_rate_(1.0E20), water_max_rate_(1.0E20),
|
|
gas_max_rate_(1.0E20), liquid_max_rate_(1.0E20),
|
|
fluid_volume_max_rate_(1.0E20), BHP_limit_(-1.0), THP_limit_(0.0),
|
|
VFP_table_number_(0), artif_lift_quantity_(0.0)
|
|
{
|
|
}
|
|
};
|
|
|
|
/// Class for keyword WCONPROD
|
|
struct WCONPROD : public SpecialBase
|
|
{
|
|
std::vector<WconprodLine> wconprod;
|
|
|
|
WCONPROD()
|
|
{
|
|
}
|
|
|
|
virtual ~WCONPROD()
|
|
{}
|
|
|
|
virtual std::string name() const {return std::string("WCONPROD");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while(is) {
|
|
std::string wellname = readString(is);
|
|
if (wellname[0] == '/') {
|
|
is >> ignoreLine;
|
|
break;
|
|
}
|
|
while (wellname.find("--") == 0) {
|
|
// This line is a comment
|
|
is >> ignoreLine;
|
|
wellname = readString(is);
|
|
}
|
|
WconprodLine wconprod_line;
|
|
wconprod_line.well_ = wellname;
|
|
wconprod_line.open_shut_flag_ = readString(is);
|
|
wconprod_line.control_mode_ = readString(is);
|
|
std::vector<double> double_data(9, 1.0E20);
|
|
double_data[5] = wconprod_line.BHP_limit_;
|
|
double_data[6] = wconprod_line.THP_limit_;
|
|
double_data[7] = wconprod_line.VFP_table_number_;
|
|
double_data[8] = wconprod_line.artif_lift_quantity_;
|
|
const int num_to_read = 9;
|
|
int num_read = readDefaultedVectorData(is, double_data, num_to_read);
|
|
wconprod_line.oil_max_rate_ = double_data[0];
|
|
wconprod_line.water_max_rate_ = double_data[1];
|
|
wconprod_line.gas_max_rate_ = double_data[2];
|
|
wconprod_line.liquid_max_rate_ = double_data[3];
|
|
wconprod_line.fluid_volume_max_rate_ = double_data[4];
|
|
wconprod_line.BHP_limit_ = double_data[5];
|
|
wconprod_line.THP_limit_ = double_data[6];
|
|
wconprod_line.VFP_table_number_ = (int)double_data[7];
|
|
wconprod_line.artif_lift_quantity_ = double_data[8];
|
|
wconprod.push_back(wconprod_line);
|
|
// HACK! Ignore any further items
|
|
if (num_read == num_to_read) {
|
|
ignoreSlashLine(is);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << std::endl;
|
|
for (int i=0; i<(int) wconprod.size(); ++i) {
|
|
os << wconprod[i].well_ << " "
|
|
<< wconprod[i].open_shut_flag_ << " "
|
|
<< wconprod[i].control_mode_ << " "
|
|
<< wconprod[i].oil_max_rate_ << " "
|
|
<< wconprod[i].water_max_rate_ << " "
|
|
<< wconprod[i].gas_max_rate_ << " "
|
|
<< wconprod[i].liquid_max_rate_ << " "
|
|
<< wconprod[i].fluid_volume_max_rate_ << " "
|
|
<< wconprod[i].BHP_limit_ << " "
|
|
<< wconprod[i].THP_limit_ << " "
|
|
<< wconprod[i].VFP_table_number_ << " "
|
|
<< wconprod[i].artif_lift_quantity_
|
|
<< std::endl;
|
|
}
|
|
os << std::endl;
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
double lrat = units.liqvol_s / units.time;
|
|
double grat = units.gasvol_s / units.time;
|
|
double resv = units.liqvol_r / units.time;
|
|
for (int i=0; i<(int) wconprod.size(); ++i) {
|
|
wconprod[i].oil_max_rate_ *= lrat;
|
|
wconprod[i].water_max_rate_ *= lrat;
|
|
wconprod[i].gas_max_rate_ *= grat;
|
|
wconprod[i].liquid_max_rate_ *= lrat;
|
|
wconprod[i].fluid_volume_max_rate_ *= resv;
|
|
wconprod[i].BHP_limit_ *= units.pressure;
|
|
wconprod[i].THP_limit_ *= units.pressure;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/// Class holding a data line of keyword WELTARG
|
|
struct WeltargLine
|
|
{
|
|
std::string well_; // Well name or well name root
|
|
std::string control_change_; // Definition of the control or constraint
|
|
// quantity to be changed
|
|
double new_value_; // New value of this quantity
|
|
|
|
WeltargLine()
|
|
{
|
|
}
|
|
};
|
|
|
|
/// Class for keyword WELTARG
|
|
struct WELTARG : public SpecialBase
|
|
{
|
|
std::vector<WeltargLine> weltarg;
|
|
|
|
WELTARG()
|
|
{
|
|
}
|
|
|
|
virtual ~WELTARG()
|
|
{}
|
|
|
|
virtual std::string name() const {return std::string("WELTARG");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while(is) {
|
|
std::string wellname = readString(is);
|
|
if (wellname[0] == '/') {
|
|
is >> ignoreLine;
|
|
break;
|
|
}
|
|
while (wellname.find("--") == 0) {
|
|
// This line is a comment
|
|
is >> ignoreLine;
|
|
wellname = readString(is);
|
|
}
|
|
WeltargLine weltarg_line;
|
|
weltarg_line.well_ = wellname;
|
|
weltarg_line.control_change_ = readString(is);
|
|
is >> weltarg_line.new_value_;
|
|
ignoreSlashLine(is);
|
|
weltarg.push_back(weltarg_line);
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << std::endl;
|
|
for (int i=0; i<(int)weltarg.size(); ++i) {
|
|
os << weltarg[i].well_ << " "
|
|
<< weltarg[i].control_change_ << " "
|
|
<< weltarg[i].new_value_ << " "
|
|
<< std::endl;
|
|
}
|
|
os << std::endl;
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
double lrat = units.liqvol_s / units.time;
|
|
double grat = units.gasvol_s / units.time;
|
|
double resv = units.liqvol_r / units.time;
|
|
for (int i=0; i<(int) weltarg.size(); ++i) {
|
|
if (weltarg[i].control_change_[0] == 'O' ||
|
|
weltarg[i].control_change_[0] == 'W' ||
|
|
weltarg[i].control_change_[0] == 'L') {
|
|
weltarg[i].new_value_ *= lrat;
|
|
} else if (weltarg[i].control_change_[0] == 'G') {
|
|
weltarg[i].new_value_ *= grat;
|
|
} else if (weltarg[i].control_change_[0] == 'R') {
|
|
weltarg[i].new_value_ *= resv;
|
|
} else if (weltarg[i].control_change_[0] == 'B' ||
|
|
weltarg[i].control_change_[0] == 'T') {
|
|
weltarg[i].new_value_ *= units.pressure;
|
|
} else {
|
|
THROW("WELTARG. Unknown control or constraint "
|
|
<< weltarg[i].control_change_[0]);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/// Class holding a data line of keyword EQUIL
|
|
struct EquilLine
|
|
{
|
|
double datum_depth_; // Datum depth
|
|
double datum_depth_pressure_; // Pressure at datum depth.
|
|
double water_oil_contact_depth_; // Depth of water oil contact.
|
|
double oil_water_cap_pressure_; // Oil-water capillary pressure at the
|
|
// water-oil contact or Gas-water capillary
|
|
// pressure at the gas-water contact contact.
|
|
double gas_oil_contact_depth_; // Depth of the gas-oil contact.
|
|
double gas_oil_cap_pressure_; // Gas-oil capillary pressure at the gas-oil
|
|
// contact.
|
|
int live_oil_table_index_; // Rs v Depth or Pb v Depth table index for
|
|
// under-saturated live oil.
|
|
int wet_gas_table_index_; // Rv v Depth or Pd v Depth table index for
|
|
// under-saturated wet gas.
|
|
int N_; // Integer defining the accuracy of the
|
|
// initial fluids in place calculation.
|
|
EquilLine()
|
|
{
|
|
}
|
|
};
|
|
|
|
/// Class for keyword EQUIL
|
|
struct EQUIL : public SpecialBase
|
|
{
|
|
std::vector<EquilLine> equil;
|
|
|
|
EQUIL()
|
|
{
|
|
}
|
|
|
|
virtual ~EQUIL()
|
|
{}
|
|
|
|
virtual std::string name() const {return std::string("EQUIL");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
// Note. This function assumes that NTEQUL = 1, and reads only one line.
|
|
int num_to_read = 9;
|
|
std::vector<double> data(num_to_read,0);
|
|
int num_read = readDefaultedVectorData(is, data, num_to_read);
|
|
if (num_read == num_to_read) {
|
|
ignoreSlashLine(is);
|
|
}
|
|
|
|
EquilLine equil_line;
|
|
equil_line.datum_depth_ = data[0];
|
|
equil_line.datum_depth_pressure_ = data[1];
|
|
equil_line.water_oil_contact_depth_ = data[2];
|
|
equil_line.oil_water_cap_pressure_ = data[3];
|
|
equil_line.gas_oil_contact_depth_ = data[4];
|
|
equil_line.gas_oil_cap_pressure_ = data[5];
|
|
equil_line.live_oil_table_index_ = int(data[6]);
|
|
equil_line.wet_gas_table_index_ = int(data[7]);
|
|
equil_line.N_ = int(data[8]);
|
|
equil.push_back(equil_line);
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << std::endl;
|
|
for (int i=0; i<(int)equil.size(); ++i) {
|
|
os << equil[i].datum_depth_ << " "
|
|
<< equil[i].datum_depth_pressure_ << " "
|
|
<< equil[i].water_oil_contact_depth_ << " "
|
|
<< equil[i].oil_water_cap_pressure_ << " "
|
|
<< equil[i].gas_oil_contact_depth_ << " "
|
|
<< equil[i].gas_oil_cap_pressure_ << " "
|
|
<< equil[i].live_oil_table_index_ << " "
|
|
<< equil[i].wet_gas_table_index_ << " "
|
|
<< equil[i].N_ << " "
|
|
|
|
<< std::endl;
|
|
}
|
|
os << std::endl;
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
for (int i=0; i<(int)equil.size(); ++i) {
|
|
equil[i].datum_depth_ *= units.length;
|
|
equil[i].datum_depth_pressure_ *= units.pressure;
|
|
equil[i].water_oil_contact_depth_ *= units.length;
|
|
equil[i].oil_water_cap_pressure_ *= units.pressure;
|
|
equil[i].gas_oil_contact_depth_ *= units.length;
|
|
equil[i].gas_oil_cap_pressure_ *= units.pressure;
|
|
}
|
|
}
|
|
};
|
|
|
|
struct PVCDO : public SpecialBase
|
|
{
|
|
std::vector<std::vector<double> > pvcdo_;
|
|
|
|
virtual std::string name() const {return std::string("PVCDO");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while (!is.eof()) {
|
|
std::vector<double> pvcdo;
|
|
readVectorData(is, pvcdo);
|
|
if (pvcdo.size() == 4) {
|
|
pvcdo.push_back(0.0);
|
|
}
|
|
pvcdo_.push_back(pvcdo);
|
|
|
|
int action = next_action(is); // 0:continue 1:return 2:throw
|
|
if (action == 1) {
|
|
return; // Alphabetic char. Read next keyword.
|
|
} else if (action == 2) {
|
|
THROW("Error reading PVCDO. Next character is "
|
|
<< (char)is.peek());
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int i=0; i<(int)pvcdo_.size(); ++i) {
|
|
os << pvcdo_[i][0] << " " << pvcdo_[i][1] << " " << pvcdo_[i][2]
|
|
<< " " << pvcdo_[i][3] << " " << pvcdo_[i][4] << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
double volfac = units.liqvol_r/units.liqvol_s;
|
|
for (int i=0; i<(int)pvcdo_.size(); ++i) {
|
|
pvcdo_[i][0] *= units.pressure;
|
|
pvcdo_[i][1] *= volfac;
|
|
pvcdo_[i][2] *= units.compressibility;
|
|
pvcdo_[i][3] *= units.viscosity;
|
|
pvcdo_[i][4] *= units.compressibility;
|
|
}
|
|
}
|
|
};
|
|
|
|
struct TSTEP : public SpecialBase
|
|
{
|
|
std::vector<double> tstep_;
|
|
|
|
virtual std::string name() const {return std::string("TSTEP");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
std::vector<double> tstep;
|
|
readVectorData(is, tstep);
|
|
if (!tstep.empty()) {
|
|
tstep_.insert(tstep_.end(), tstep.begin(), tstep.end());
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
copy(tstep_.begin(), tstep_.end(),
|
|
std::ostream_iterator<double>(os, " "));
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
int num_steps = tstep_.size();
|
|
for (int i = 0; i < num_steps; ++i) {
|
|
tstep_[i] *= units.time;
|
|
}
|
|
}
|
|
};
|
|
|
|
struct MultRec : public SpecialBase
|
|
{
|
|
virtual void read(std::istream& is)
|
|
{
|
|
#ifdef VERBOSE
|
|
std::cout << "(dummy implementation)" << std::endl;
|
|
#endif
|
|
const std::ctype<char>& ct = std::use_facet< std::ctype<char> >(std::locale::classic());
|
|
is >> ignoreSlashLine;
|
|
while (!is.eof()) {
|
|
is >> ignoreWhitespace;
|
|
std::streampos pos = is.tellg();
|
|
char c;
|
|
is.get(c);
|
|
if (is.eof()) {
|
|
return;
|
|
}
|
|
if (ct.is(std::ctype_base::alpha, c)) {
|
|
std::string name; // Unquoted name or new keyword?
|
|
std::getline(is, name);
|
|
if (name.rfind('/') != std::string::npos) {
|
|
continue; // Unquoted name
|
|
} else {
|
|
is.seekg(pos);
|
|
break; // Read next keyword
|
|
}
|
|
} else if (ct.is(std::ctype_base::digit, c) || c== '.') {
|
|
is >> ignoreSlashLine; // Decimal digit. Ignore data.
|
|
continue;
|
|
} else if (c== '\'') {
|
|
is >> ignoreSlashLine; // Quote. Ignore data.
|
|
continue;
|
|
} else if(c == '-' && is.peek() == int('-')) {
|
|
is >> ignoreLine; // This line is a comment
|
|
continue;
|
|
} else if (c == '/' ) {
|
|
is >> ignoreLine; // This line is a null record.
|
|
continue; // (No data before slash)
|
|
} else {
|
|
is.putback(c);
|
|
std::string temp;
|
|
is >> temp;
|
|
std::cout << "READ ERROR! Next word is " << temp << std::endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits&)
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
struct PLYVISC : public SpecialBase
|
|
{
|
|
std::vector<double> concentration_;
|
|
std::vector<double> factor_;
|
|
|
|
virtual std::string name() const {return std::string("PLYVISC");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
// Note. This function assumes that NTPVT = 1, and reads only one table.
|
|
std::vector<double> plyvisc;
|
|
readVectorData(is, plyvisc);
|
|
for (int i=0; i<(int)plyvisc.size(); i+=2) {
|
|
concentration_.push_back(plyvisc[i]);
|
|
factor_.push_back(plyvisc[i+1]);
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int i=0; i<(int)concentration_.size(); ++i) {
|
|
os << concentration_[i] << " " << factor_[i] << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
for (int i=0; i<(int)concentration_.size(); ++i) {
|
|
concentration_[i] *= units.polymer_density;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
struct PLYROCK : public SpecialBase
|
|
{
|
|
std::vector<double> plyrock_;
|
|
|
|
virtual std::string name() const {return std::string("PLYROCK");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
// Note. This function assumes that NTSFUN = 1, and reads only one line.
|
|
plyrock_.resize(5,-1e00);
|
|
plyrock_[3] = 1; // Default value
|
|
int num_to_read = 5;
|
|
int num_read = readDefaultedVectorData(is, plyrock_, num_to_read);
|
|
if (num_read == num_to_read) {
|
|
ignoreSlashLine(is);
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int i=0; i<(int)plyrock_.size(); ++i) {
|
|
os << plyrock_[i] << " ";
|
|
}
|
|
os << "\n\n";
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
|
|
plyrock_[2] *= units.polymer_density;
|
|
}
|
|
};
|
|
|
|
|
|
struct PLYADS : public SpecialBase
|
|
{
|
|
std::vector<double> local_concentration_;
|
|
std::vector<double> adsorbed_concentration_;
|
|
|
|
virtual std::string name() const {return std::string("PLYADS");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
// Note. This function assumes that NTSFUN = 1, and reads only one table.
|
|
std::vector<double> plyads;
|
|
readVectorData(is, plyads);
|
|
for (int i=0; i<(int)plyads.size(); i+=2) {
|
|
local_concentration_.push_back(plyads[i]);
|
|
adsorbed_concentration_.push_back(plyads[i+1]);
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int i=0; i<(int)local_concentration_.size(); ++i) {
|
|
os << local_concentration_[i] << " " << adsorbed_concentration_[i] << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
for (int i=0; i<(int)local_concentration_.size(); ++i) {
|
|
local_concentration_[i] *= units.polymer_density;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
struct PLYMAX : public SpecialBase
|
|
{
|
|
std::vector<double> plymax_;
|
|
|
|
virtual std::string name() const {return std::string("PLYMAX");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
// Note. This function assumes that NTMISC = 1, and reads only one line.
|
|
plymax_.resize(2);
|
|
readVectorData(is, plymax_);
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int i=0; i<(int)plymax_.size(); ++i) {
|
|
os << plymax_[i] << " ";
|
|
}
|
|
os << "\n\n";
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
plymax_[0] *= units.polymer_density;
|
|
plymax_[1] *= units.polymer_density;
|
|
}
|
|
};
|
|
|
|
|
|
struct TLMIXPAR : public SpecialBase
|
|
{
|
|
std::vector<double> tlmixpar_;
|
|
|
|
virtual std::string name() const {return std::string("TLMIXPAR");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
// Note. This function assumes that NTMISC = 1, and reads only one record.
|
|
tlmixpar_.resize(2, -1e100);
|
|
int num_to_read = 2;
|
|
int num_read = readDefaultedVectorData(is, tlmixpar_, num_to_read);
|
|
if (tlmixpar_[1] < 0) {
|
|
tlmixpar_[1] = tlmixpar_[0];
|
|
}
|
|
if (num_read == num_to_read) {
|
|
ignoreSlashLine(is);
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int i=0; i<(int)tlmixpar_.size(); ++i) {
|
|
os << tlmixpar_[i] << " ";
|
|
}
|
|
os << "\n\n";
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
static_cast<void>(units); // Suppress "unused parameter" warning.
|
|
}
|
|
};
|
|
|
|
/// Class holding a data line of keyword WPOLYMER
|
|
struct WpolymerLine
|
|
{
|
|
std::string well_; // Well name, well name template or well list template
|
|
double polymer_concentration_;
|
|
double salt_concentration_;
|
|
std::string polymer_group_;
|
|
std::string salt_group_;
|
|
|
|
WpolymerLine()
|
|
{
|
|
well_ = polymer_group_ = salt_group_ = "";
|
|
}
|
|
};
|
|
|
|
struct WPOLYMER : public SpecialBase
|
|
{
|
|
std::vector<WpolymerLine> wpolymer_;
|
|
|
|
virtual std::string name() const {return std::string("WPOLYMER");}
|
|
|
|
virtual void read(std::istream& is)
|
|
{
|
|
while(is) {
|
|
std::string wellname = readString(is);
|
|
if (wellname[0] == '/') {
|
|
is >> ignoreLine;
|
|
break;
|
|
}
|
|
while (wellname.find("--") == 0) {
|
|
// This line is a comment
|
|
is >> ignoreLine;
|
|
wellname = readString(is);
|
|
}
|
|
WpolymerLine wpolymer_line;
|
|
wpolymer_line.well_ = wellname;
|
|
is >> wpolymer_line.polymer_concentration_;
|
|
is >> wpolymer_line.salt_concentration_;
|
|
std::string group = readString(is);
|
|
if (group[0] == '/') {
|
|
is >> ignoreLine;
|
|
} else {
|
|
wpolymer_line.polymer_group_ = group;
|
|
group = readString(is);
|
|
if (group[0] == '/') {
|
|
is >> ignoreLine;
|
|
} else {
|
|
wpolymer_line.salt_group_ = group;
|
|
is >> ignoreLine;
|
|
}
|
|
}
|
|
wpolymer_.push_back(wpolymer_line);
|
|
}
|
|
}
|
|
|
|
virtual void write(std::ostream& os) const
|
|
{
|
|
os << name() << '\n';
|
|
for (int i=0; i<(int)wpolymer_.size(); ++i) {
|
|
os << wpolymer_[i].well_
|
|
<< " " << wpolymer_[i].polymer_concentration_
|
|
<< " " << wpolymer_[i].salt_concentration_
|
|
<< " " << wpolymer_[i].polymer_group_
|
|
<< " " << wpolymer_[i].salt_group_;
|
|
os << '\n';
|
|
}
|
|
os << '\n';
|
|
}
|
|
|
|
virtual void convertToSI(const EclipseUnits& units)
|
|
{
|
|
for (int i=0; i<(int)wpolymer_.size(); ++i) {
|
|
wpolymer_[i].polymer_concentration_ *= units.polymer_density;
|
|
wpolymer_[i].salt_concentration_ *= units.polymer_density;
|
|
}
|
|
}
|
|
};
|
|
|
|
// The following fields only have a dummy implementation
|
|
// that allows us to ignore them.
|
|
struct SWFN : public MultRec {};
|
|
struct SOF2 : public MultRec {};
|
|
struct TUNING : public MultRec {};
|
|
|
|
|
|
} // End of namespace Opm
|
|
|
|
#endif // OPENRS_SPECIALECLIPSEFIELDS_HEADER
|
|
|