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

Created tests for the VFPProperties class

Browse Source
This commit is contained in:
André R. Brodtkorb 2015-06-17 12:47:38 +02:00 committed by babrodtk
parent a54804c0cc
commit 67b55f873c
3 changed files with 704 additions and 289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists_files.cmake
View File

@ -55,6 +55,7 @@ list (APPEND TEST_SOURCE_FILES
tests/test_scalar_mult.cpp tests/test_scalar_mult.cpp
tests/test_transmissibilitymultipliers.cpp tests/test_transmissibilitymultipliers.cpp
tests/test_welldensitysegmented.cpp tests/test_welldensitysegmented.cpp
tests/test_vfpproperties.cpp
) )
list (APPEND TEST_DATA_FILES list (APPEND TEST_DATA_FILES

620
opm/autodiff/VFPProperties.hpp
View File

@ -26,121 +26,200 @@
namespace Opm { namespace Opm {
class VFPProperties { class VFPProperties {
public: public:
VFPProperties(DeckKeywordConstPtr table) { typedef boost::multi_array<double, 5> array_type;
typedef boost::array<array_type::index, 5> extents;
///Rate type
enum FLO_TYPE {
FLO_OIL, //< Oil rate
FLO_LIQ, //< Liquid rate
FLO_GAS, //< Gas rate
//FLO_WG
//FLO_TM
FLO_INVALID
};
///Water fraction variable
enum WFR_TYPE {
WFR_WOR, //< Water-oil ratio
WFR_WCT, //< Water cut
WFR_WGR, //< Water-gas ratio
WFR_INVALID
};
///Gas fraction variable
enum GFR_TYPE {
GFR_GOR, //< Gas-oil ratio
GFR_GLR, //< Gas-liquid ratio
GFR_OGR, //< Oil-gas ratio
GFR_INVALID
};
///Artificial lift quantity
enum ALQ_TYPE {
ALQ_GRAT, //< Lift as injection rate
ALQ_IGLR, //< Injection gas-liquid ratio
ALQ_TGLR, //< Total gas-liquid ratio
ALQ_PUMP, //< Pump rating
ALQ_COMP, //< Compressor power
ALQ_BEAN, //< Choke diameter
ALQ_UNDEF, //< Undefined
ALQ_INVALID
};
VFPProperties(int table_num,
double datum_depth,
FLO_TYPE flo_type,
WFR_TYPE wfr_type,
GFR_TYPE gfr_type,
ALQ_TYPE alq_type,
const std::vector<double>& flo_data,
const std::vector<double>& thp_data,
const std::vector<double>& wfr_data,
const std::vector<double>& gfr_data,
const std::vector<double>& alq_data,
array_type data
) :
table_num_(table_num),
datum_depth_(datum_depth),
flo_type_(flo_type),
wfr_type_(wfr_type),
gfr_type_(gfr_type),
alq_type_(alq_type),
flo_data_(flo_data),
thp_data_(thp_data),
wfr_data_(wfr_data),
gfr_data_(gfr_data),
alq_data_(alq_data),
data_(data) {
}
VFPProperties(DeckKeywordConstPtr table) {
auto iter = table->begin(); auto iter = table->begin();
auto header = (*iter++); auto header = (*iter++);
table_num_ = header->getItem("TABLE")->getInt(0); table_num_ = header->getItem("TABLE")->getInt(0);
datum_depth_ = header->getItem("DATUM_DEPTH")->getRawDouble(0); datum_depth_ = header->getItem("DATUM_DEPTH")->getRawDouble(0);
//Rate type //Rate type
std::string flo_string = header->getItem("RATE_TYPE")->getString(0); try {
if (flo_string == "OIL") { std::string flo_string = header->getItem("RATE_TYPE")->getString(0);
flo_type_ = FLO_OIL; if (flo_string == "OIL") {
} flo_type_ = FLO_OIL;
else if (flo_string == "LIQ") { }
flo_type_ = FLO_LIQ; else if (flo_string == "LIQ") {
} flo_type_ = FLO_LIQ;
else if (flo_string == "GAS") { }
flo_type_ = FLO_GAS; else if (flo_string == "GAS") {
} flo_type_ = FLO_GAS;
else { }
flo_type_ = FLO_INVALID; else {
} flo_type_ = FLO_INVALID;
}
//Water fraction }
std::string wfr_string = header->getItem("WFR")->getString(0); catch (std::invalid_argument& e) {
if (wfr_string == "WOR") { //TODO: log here
wfr_type_ = WFR_WOR; flo_type_ = FLO_INVALID;
}
else if (wfr_string == "WCT") {
wfr_type_ = WFR_WCT;
}
else if (wfr_string == "WGR") {
wfr_type_ = WFR_WGR;
} }
else {
wfr_type_ = WFR_INVALID;
}
//Gas fraction //Water fraction
std::string gfr_string = header->getItem("GFR")->getString(0); try {
if (gfr_string == "GOR") { std::string wfr_string = header->getItem("WFR")->getString(0);
gfr_type_ = GFR_GOR; if (wfr_string == "WOR") {
} wfr_type_ = WFR_WOR;
else if (gfr_string == "GLR") { }
gfr_type_ = GFR_GLR; else if (wfr_string == "WCT") {
} wfr_type_ = WFR_WCT;
else if (gfr_string == "OGR") { }
gfr_type_ = GFR_OGR; else if (wfr_string == "WGR") {
} wfr_type_ = WFR_WGR;
else { }
gfr_type_ = GFR_INVALID; else {
} wfr_type_ = WFR_INVALID;
}
//Artificial lift }
/* catch (std::invalid_argument& e) {
* ALQ not implemented properly in parser? //TODO: log here
wfr_type_ = WFR_INVALID;
std::string alq_string = header->getItem("ALQ")->getString(0);
if (alq_string == "GRAT") {
alq_type_ = ALQ_GRAT;
}
else if (alq_string == "IGLR") {
alq_type_ = ALQ_IGLR;
}
else if (alq_string == "TGLR") {
alq_type_ = ALQ_TGLR;
} }
else if (alq_string == "PUMP") {
alq_type_ = ALQ_PUMP; //Gas fraction
try {
std::string gfr_string = header->getItem("GFR")->getString(0);
if (gfr_string == "GOR") {
gfr_type_ = GFR_GOR;
}
else if (gfr_string == "GLR") {
gfr_type_ = GFR_GLR;
}
else if (gfr_string == "OGR") {
gfr_type_ = GFR_OGR;
}
else {
gfr_type_ = GFR_INVALID;
}
}
catch (std::invalid_argument& e) {
//TODO: log here
gfr_type_ = GFR_INVALID;
}
//Artificial lift
try {
std::string alq_string = header->getItem("ALQ")->getString(0);
if (alq_string == "GRAT") {
alq_type_ = ALQ_GRAT;
}
else if (alq_string == "IGLR") {
alq_type_ = ALQ_IGLR;
}
else if (alq_string == "TGLR") {
alq_type_ = ALQ_TGLR;
}
else if (alq_string == "PUMP") {
alq_type_ = ALQ_PUMP;
}
else if (alq_string == "COMP") {
alq_type_ = ALQ_COMP;
}
else if (alq_string == "BEAN") {
alq_type_ = ALQ_BEAN;
}
else if (alq_string == "UNDEF") {
alq_type_ = ALQ_UNDEF;
}
else {
alq_type_ = ALQ_INVALID;
}
}
catch (std::invalid_argument& e) {
//TODO: log here
alq_type_ = ALQ_INVALID;
} }
else if (alq_string == "COMP") {
alq_type_ = ALQ_COMP;
}
else if (alq_string == "BEAN") {
alq_type_ = ALQ_BEAN;
}
else if (alq_string == "UNDEF") {
alq_type_ = ALQ_UNDEF;
}
else {
alq_type_ = ALQ_INVALID;
}
*/
//Get actual rate / flow values //Get actual rate / flow values
const std::vector<double>& flo = (*iter++)->getItem("FLOW_VALUES")->getRawDoubleData(); flo_data_ = (*iter++)->getItem("FLOW_VALUES")->getRawDoubleData();
flo_data_.resize(flo.size());
std::copy(flo.begin(), flo.end(), flo_data_.begin());
//Get actual tubing head pressure values //Get actual tubing head pressure values
const std::vector<double>& thp = (*iter++)->getItem("THP_VALUES")->getRawDoubleData(); thp_data_ = (*iter++)->getItem("THP_VALUES")->getRawDoubleData();
thp_data_.resize(thp.size());
std::copy(thp.begin(), thp.end(), thp_data_.begin());
//Get actual water fraction values //Get actual water fraction values
const std::vector<double>& wfr = (*iter++)->getItem("WFR_VALUES")->getRawDoubleData(); wfr_data_ = (*iter++)->getItem("WFR_VALUES")->getRawDoubleData();
wfr_data_.resize(wfr.size());
std::copy(wfr.begin(), wfr.end(), wfr_data_.begin());
//Get actual gas fraction values //Get actual gas fraction values
const std::vector<double>& gfr = (*iter++)->getItem("GFR_VALUES")->getRawDoubleData(); gfr_data_ = (*iter++)->getItem("GFR_VALUES")->getRawDoubleData();
gfr_data_.resize(gfr.size());
std::copy(gfr.begin(), gfr.end(), gfr_data_.begin());
//Get actual gas fraction values //Get actual gas fraction values
const std::vector<double>& alq = (*iter++)->getItem("ALQ_VALUES")->getRawDoubleData(); alq_data_ = (*iter++)->getItem("ALQ_VALUES")->getRawDoubleData();
alq_data_.resize(alq.size());
std::copy(alq.begin(), alq.end(), alq_data_.begin());
//Finally, read the actual table itself. //Finally, read the actual table itself.
unsigned int nt = thp_data_.size(); size_t nt = thp_data_.size();
unsigned int nw = wfr_data_.size(); size_t nw = wfr_data_.size();
unsigned int ng = gfr_data_.size(); size_t ng = gfr_data_.size();
unsigned int na = alq_data_.size(); size_t na = alq_data_.size();
unsigned int nf = flo_data_.size(); size_t nf = flo_data_.size();
extents shape; extents shape;
shape[0] = nt; shape[0] = nt;
shape[1] = nw; shape[1] = nw;
@ -149,218 +228,181 @@ namespace Opm {
shape[4] = nf; shape[4] = nf;
data_.resize(shape); data_.resize(shape);
for (; iter!=table->end(); ++iter) { for (; iter!=table->end(); ++iter) {
//Get indices (subtract 1 to get 0-based index) //Get indices (subtract 1 to get 0-based index)
unsigned int t = (*iter)->getItem("THP_INDEX")->getInt(0) - 1; int t = (*iter)->getItem("THP_INDEX")->getInt(0) - 1;
unsigned int w = (*iter)->getItem("WFR_INDEX")->getInt(0) - 1; int w = (*iter)->getItem("WFR_INDEX")->getInt(0) - 1;
unsigned int g = (*iter)->getItem("GFR_INDEX")->getInt(0) - 1; int g = (*iter)->getItem("GFR_INDEX")->getInt(0) - 1;
unsigned int a = (*iter)->getItem("ALQ_INDEX")->getInt(0) - 1; int a = (*iter)->getItem("ALQ_INDEX")->getInt(0) - 1;
//Rest of values (bottom hole pressure or tubing head temperature) have index of flo value //Rest of values (bottom hole pressure or tubing head temperature) have index of flo value
const std::vector<double>& bhp_tht = (*iter)->getItem("VALUES")->getRawDoubleData(); const std::vector<double>& bhp_tht = (*iter)->getItem("VALUES")->getRawDoubleData();
std::copy(bhp_tht.begin(), bhp_tht.end(), &data_[t][w][g][a][0]); std::copy(bhp_tht.begin(), bhp_tht.end(), &data_[t][w][g][a][0]);
//Check for large values //Check for large values
for (unsigned int i = 0; i<bhp_tht.size(); ++i) { for (size_t i = 0; i<bhp_tht.size(); ++i) {
if (bhp_tht[i] > 1.0e10) { if (bhp_tht[i] > 1.0e10) {
//TODO: Replace with proper log message //TODO: Replace with proper log message
std::cerr << "Too large value encountered in VFPPROD in [" std::cerr << "Too large value encountered in VFPPROD in ["
<< t << "," << w << "," << g << "," << a << "]=" << t << "," << w << "," << g << "," << a << "]="
<< bhp_tht[i] << std::endl; << bhp_tht[i] << std::endl;
} }
} }
} }
} }
struct InterpData { /**
InterpData() : ind_({0}), factor_(0.0) {} * Linear interpolation of bhp as a function of the input parameters
unsigned int ind_[2]; //[First element greater than or equal to value, Last element smaller than or equal to value] * @param flo Production rate of oil, gas or liquid
double factor_; //Interpolation factor * @param thp Tubing head pressure
}; * @param wfr Water-oil ratio, water cut, or water-gas ratio
* @param gfr Gas-oil ratio, gas-liquid ratio, or oil-gas ratio
* @param alq Artificial lift or other parameter
*
* @return The bottom hole pressure, interpolated linearly using
* the above parameters from the values in the input table.
*/
double bhp(double flo, double thp, float wfr, float gfr, float alq) {
//First, find the floor value of the inputs
auto flo_i = find_interp_data(flo, flo_data_);
auto thp_i = find_interp_data(thp, thp_data_);
auto wfr_i = find_interp_data(wfr, wfr_data_);
auto gfr_i = find_interp_data(gfr, gfr_data_);
auto alq_i = find_interp_data(alq, alq_data_);
InterpData find_interp_data(double value, const std::vector<double>& values) { return interpolate(flo_i, thp_i, wfr_i, gfr_i, alq_i);
InterpData retval; }
//First element greater than or equal to value private:
//Don't access out-of-range, therefore values.end()-1 struct InterpData {
auto ceil_iter = std::lower_bound(values.begin(), values.end()-1, value); InterpData() : factor_(0.0) {}
int ind_[2]; //[First element greater than or equal to value, Last element smaller than or equal to value]
double factor_; //Interpolation factor
};
//Find last element smaller than or equal to range InterpData find_interp_data(double value, const std::vector<double>& values) {
auto floor_iter = ceil_iter; InterpData retval;
if (*floor_iter == value) {
// floor_iter == ceil_iter == value
}
else if (floor_iter > values.begin()) {
// floor_iter <= value <= ceil_iter
--floor_iter;
}
//Now set these in the retval struct //First element greater than or equal to value
retval.ind_[0] = floor_iter - values.begin(); //Don't access out-of-range, therefore values.end()-1
retval.ind_[1] = ceil_iter - values.begin(); auto ceil_iter = std::lower_bound(values.begin(), values.end()-1, value);
//Find interpolation ratio //Find last element smaller than or equal to range
double dist = (*ceil_iter - *floor_iter); auto floor_iter = ceil_iter;
if (dist > 0) { if (*floor_iter == value) {
retval.factor_ = (value-*floor_iter) / dist; // floor_iter == ceil_iter == value
} }
else { else if (floor_iter > values.begin()) {
retval.factor_ = 1.0; // floor_iter <= value <= ceil_iter
} --floor_iter;
}
return retval; //Now set these in the retval struct
} retval.ind_[0] = floor_iter - values.begin();
retval.ind_[1] = ceil_iter - values.begin();
double interpolate(const InterpData& flo_i, const InterpData& thp_i, //Find interpolation ratio
const InterpData& wfr_i, const InterpData& gfr_i, const InterpData& alq_i) { double dist = (*ceil_iter - *floor_iter);
extents shape({{2, 2, 2, 2, 2}}); if (dist > 0) {
array_type nn(shape); //Possible source for floating point error here if value and floor are large,
//but very close to each other
retval.factor_ = (value-*floor_iter) / dist;
}
else {
retval.factor_ = 1.0;
}
//Pick out nearest neighbors (nn) to our evaluation point return retval;
//The following ladder of for loops will presumably be unrolled by a reasonable compiler. }
//This is not really required, but performance-wise it may pay off, since the 32-elements
//we copy to (nn) will fit better in cache than the full original table for the
//interpolation below.
for (unsigned int t=0; t<=1; ++t) {
for (unsigned int w=0; w<=1; ++w) {
for (unsigned int g=0; g<=1; ++g) {
for (unsigned int a=0; a<=1; ++a) {
for (unsigned int f=0; f<=1; ++f) {
//Shorthands for indexing
unsigned int ti = thp_i.ind_[t];
unsigned int wi = wfr_i.ind_[w];
unsigned int gi = gfr_i.ind_[g];
unsigned int ai = alq_i.ind_[a];
unsigned int fi = flo_i.ind_[f];
//Copy element double interpolate(const InterpData& flo_i, const InterpData& thp_i,
nn[t][w][g][a][f] = data_[ti][wi][gi][ai][fi]; const InterpData& wfr_i, const InterpData& gfr_i, const InterpData& alq_i) {
} //extents shape({{2, 2, 2, 2, 2}});
} //array_type nn(shape);
} double nn[2][2][2][2][2];
}
}
//Remove dimensions iteratively //Pick out nearest neighbors (nn) to our evaluation point
// Example: going from 3D to 2D to 1D, we start by interpolating along //The following ladder of for loops will presumably be unrolled by a reasonable compiler.
// the z axis first, leaving a 2D problem. Then interpolating along the y //This is not really required, but performance-wise it may pay off, since the 32-elements
// axis, leaving a 1D, problem, etc. //we copy to (nn) will fit better in cache than the full original table for the
double tf = flo_i.factor_; //interpolation below.
for (unsigned int t=0; t<=1; ++t) { for (int t=0; t<=1; ++t) {
for (unsigned int w=0; w<=1; ++w) { for (int w=0; w<=1; ++w) {
for (unsigned int g=0; g<=1; ++g) { for (int g=0; g<=1; ++g) {
for (unsigned int a=0; a<=1; ++a) { for (int a=0; a<=1; ++a) {
nn[t][w][g][a][0] = (1.0-tf)*nn[t][w][g][a][0] + tf*nn[t][w][g][a][1]; for (int f=0; f<=1; ++f) {
} //Shorthands for indexing
} int ti = thp_i.ind_[t];
} int wi = wfr_i.ind_[w];
} int gi = gfr_i.ind_[g];
int ai = alq_i.ind_[a];
int fi = flo_i.ind_[f];
tf = alq_i.factor_; //Copy element
for (unsigned int t=0; t<=1; ++t) { nn[t][w][g][a][f] = data_[ti][wi][gi][ai][fi];
for (unsigned int w=0; w<=1; ++w) { }
for (unsigned int g=0; g<=1; ++g) { }
nn[t][w][g][0][0] = (1.0-tf)*nn[t][w][g][0][0] + tf*nn[t][w][g][1][0]; }
} }
} }
}
tf = gfr_i.factor_; //Remove dimensions iteratively
for (unsigned int t=0; t<=1; ++t) { // Example: going from 3D to 2D to 1D, we start by interpolating along
for (unsigned int w=0; w<=1; ++w) { // the z axis first, leaving a 2D problem. Then interpolating along the y
nn[t][w][0][0][0] = (1.0-tf)*nn[t][w][0][0][0] + tf*nn[t][w][1][0][0]; // axis, leaving a 1D, problem, etc.
} double tf = flo_i.factor_;
} for (int t=0; t<=1; ++t) {
for (int w=0; w<=1; ++w) {
for (int g=0; g<=1; ++g) {
for (int a=0; a<=1; ++a) {
nn[t][w][g][a][0] = (1.0-tf)*nn[t][w][g][a][0] + tf*nn[t][w][g][a][1];
}
}
}
}
tf = wfr_i.factor_; tf = alq_i.factor_;
for (unsigned int t=0; t<=1; ++t) { for (int t=0; t<=1; ++t) {
nn[t][0][0][0][0] = (1.0-tf)*nn[t][0][0][0][0] + tf*nn[t][1][0][0][0]; for (int w=0; w<=1; ++w) {
} for (int g=0; g<=1; ++g) {
nn[t][w][g][0][0] = (1.0-tf)*nn[t][w][g][0][0] + tf*nn[t][w][g][1][0];
}
}
}
tf = thp_i.factor_; tf = gfr_i.factor_;
return (1.0-tf)*nn[0][0][0][0][0] + tf*nn[1][0][0][0][0]; for (int t=0; t<=1; ++t) {
} for (int w=0; w<=1; ++w) {
nn[t][w][0][0][0] = (1.0-tf)*nn[t][w][0][0][0] + tf*nn[t][w][1][0][0];
}
}
/** tf = wfr_i.factor_;
* Linear interpolation of bhp as a function of the input parameters for (int t=0; t<=1; ++t) {
* @param flo Production rate of oil, gas or liquid nn[t][0][0][0][0] = (1.0-tf)*nn[t][0][0][0][0] + tf*nn[t][1][0][0][0];
* @param thp Tubing head pressure }
* @param wfr Water-oil ratio, water cut, or water-gas ratio
* @param gfr Gas-oil ratio, gas-liquid ratio, or oil-gas ratio
* @param alq Artificial lift or other parameter
*
* @return The bottom hole pressure, interpolated linearly using
* the above parameters from the values in the input table.
*/
double bhp(double flo, double thp, float wfr, float gfr, float alq) {
//First, find the floor value of the inputs
auto flo_i = find_interp_data(flo, flo_data_);
auto thp_i = find_interp_data(thp, thp_data_);
auto wfr_i = find_interp_data(wfr, wfr_data_);
auto gfr_i = find_interp_data(gfr, gfr_data_);
auto alq_i = find_interp_data(alq, alq_data_);
return interpolate(flo_i, thp_i, wfr_i, gfr_i, alq_i); tf = thp_i.factor_;
} return (1.0-tf)*nn[0][0][0][0][0] + tf*nn[1][0][0][0][0];
}
///Rate type //"Header" variables
enum FLO_TYPE { int table_num_;
FLO_OIL, double datum_depth_;
FLO_LIQ, FLO_TYPE flo_type_;
FLO_GAS, WFR_TYPE wfr_type_;
//FLO_WG GFR_TYPE gfr_type_;
//FLO_TM ALQ_TYPE alq_type_;
FLO_INVALID
};
///Water fraction variable //The actual table axes
enum WFR_TYPE { std::vector<double> flo_data_;
WFR_WOR, //< Water-oil ratio std::vector<double> thp_data_;
WFR_WCT, //< Water cut std::vector<double> wfr_data_;
WFR_WGR, //< Water-gas ratio std::vector<double> gfr_data_;
WFR_INVALID std::vector<double> alq_data_;
};
///Gas fraction variable //The data itself
enum GFR_TYPE { array_type data_;
GFR_GOR, //< Gas-oil ratio
GFR_GLR, //< Gas-liquid ratio
GFR_OGR, //< Oil-gas ratio
GFR_INVALID
};
///Artificial lift quantity
enum ALQ_TYPE {
ALQ_GRAT, //< Lift as injection rate
ALQ_IGLR, //< Injection gas-liquid ratio
ALQ_TGLR, //< Total gas-liquid ratio
ALQ_PUMP, //< Pump rating
ALQ_COMP, //< Compressor power
ALQ_BEAN, //< Choke diameter
ALQ_UNDEF, //< Undefined
ALQ_INVALID
};
private:
//"Header" variables
int table_num_;
double datum_depth_;
FLO_TYPE flo_type_;
WFR_TYPE wfr_type_;
GFR_TYPE gfr_type_;
ALQ_TYPE alq_type_;
//The actual table axes
std::vector<double> flo_data_;
std::vector<double> thp_data_;
std::vector<double> wfr_data_;
std::vector<double> gfr_data_;
std::vector<double> alq_data_;
//The data itself
typedef boost::multi_array<double, 5> array_type;
typedef boost::array<array_type::index, 5> extents;
array_type data_;
}; };
} }

372
tests/test_vfpproperties.cpp Normal file
View File

File diff suppressed because one or more lines are too long