inline void setupGridAndProps(const Opm::parameter::ParameterGroup& param,
CpGrid& grid,
ResProp<3>& res_prop)
{
// Initialize grid and reservoir properties.
// Parts copied from CpGrid::init().
std::string fileformat = param.getDefault<std::string>("fileformat", "cartesian");
if (fileformat == "sintef_legacy") {
std::string grid_prefix = param.get<std::string>("grid_prefix");
grid.readSintefLegacyFormat(grid_prefix);
MESSAGE("Warning: We do not yet read legacy reservoir properties. Using defaults.");
res_prop.init(grid.size(0));
} else if (fileformat == "eclipse") {
Opm::EclipseGridParser parser(param.get<std::string>("filename"));
double z_tolerance = param.getDefault<double>("z_tolerance", 0.0);
bool periodic_extension = param.getDefault<bool>("periodic_extension", false);
bool turn_normals = param.getDefault<bool>("turn_normals", false);
grid.processEclipseFormat(parser, z_tolerance, periodic_extension, turn_normals);
double perm_threshold_md = param.getDefault("perm_threshold_md", 0.0);
double perm_threshold = Opm::unit::convert::from(perm_threshold_md, Opm::prefix::milli*Opm::unit::darcy);
std::string rock_list = param.getDefault<std::string>("rock_list", "no_list");
std::string* rl_ptr = (rock_list == "no_list") ? 0 : &rock_list;
bool use_j = param.getDefault("use_jfunction_scaling", useJ<ResProp<3> >());
double sigma = 1.0;
double theta = 0.0;
if (use_j) {
sigma = param.getDefault("sigma", sigma);
theta = param.getDefault("theta", theta);
}
if (param.has("viscosity1") || param.has("viscosity2")) {
double v1 = param.getDefault("viscosity1", 0.001);
double v2 = param.getDefault("viscosity2", 0.003);
res_prop.setViscosities(v1, v2);
}
res_prop.init(parser, grid.globalCell(), perm_threshold, rl_ptr,
use_j, sigma, theta);
} else if (fileformat == "cartesian") {
array<int, 3> dims = {{ param.getDefault<int>("nx", 1),
param.getDefault<int>("ny", 1),
param.getDefault<int>("nz", 1) }};
array<double, 3> cellsz = {{ param.getDefault<double>("dx", 1.0),
param.getDefault<double>("dy", 1.0),
param.getDefault<double>("dz", 1.0) }};
grid.createCartesian(dims, cellsz);
double default_poro = param.getDefault("default_poro", 0.2);
double default_perm_md = param.getDefault("default_perm_md", 100.0);
double default_perm = Opm::unit::convert::from(default_perm_md, Opm::prefix::milli*Opm::unit::darcy);
MESSAGE("Warning: For generated cartesian grids, we use uniform reservoir properties.");
res_prop.init(grid.size(0), default_poro, default_perm);
} else {
THROW("Unknown file format string: " << fileformat);
}
if (param.getDefault("use_unique_boundary_ids", false)) {
grid.setUniqueBoundaryIds(true);
}
}
CombinedGridWellGraph::CombinedGridWellGraph(const CpGrid& grid,
const Opm::EclipseStateConstPtr eclipseState,
const double* transmissibilities,
bool pretendEmptyGrid)
: grid_(grid), eclipseState_(eclipseState), transmissibilities_(transmissibilities)
{
if ( pretendEmptyGrid )
{
// wellsGraph not needed
return;
}
wellsGraph_.resize(grid.numCells());
const auto& cpgdim = grid.logicalCartesianSize();
// create compressed lookup from cartesian.
std::vector<Opm::WellConstPtr> wells = eclipseState->getSchedule()->getWells();
std::vector<int> cartesian_to_compressed(cpgdim[0]*cpgdim[1]*cpgdim[2], -1);
int last_time_step = eclipseState->getSchedule()->getTimeMap()->size()-1;
for( int i=0; i < grid.numCells(); ++i )
{
cartesian_to_compressed[grid.globalCell()[i]] = i;
}
// We assume that we know all the wells.
for (auto wellIter= wells.begin(); wellIter != wells.end(); ++wellIter) {
Opm::WellConstPtr well = (*wellIter);
std::set<int> well_indices;
Opm::CompletionSetConstPtr completionSet = well->getCompletions(last_time_step);
for (size_t c=0; c<completionSet->size(); c++) {
Opm::CompletionConstPtr completion = completionSet->get(c);
int i = completion->getI();
int j = completion->getJ();
int k = completion->getK();
int cart_grid_idx = i + cpgdim[0]*(j + cpgdim[1]*k);
int compressed_idx = cartesian_to_compressed[cart_grid_idx];
if ( compressed_idx >= 0 ) // Ignore completions in inactive cells.
{
well_indices.insert(compressed_idx);
}
}
addCompletionSetToGraph(well_indices);
}
}
inline void setupGridAndPropsEclipse(const Opm::EclipseGridParser& parser,
double z_tolerance,
bool periodic_extension,
bool turn_normals,
bool clip_z,
bool unique_bids,
double perm_threshold,
const std::string& rock_list,
bool use_jfunction_scaling,
double sigma,
double theta,
CpGrid& grid,
ResProp<3>& res_prop)
{
grid.processEclipseFormat(parser, z_tolerance, periodic_extension, turn_normals, clip_z);
const std::string* rl_ptr = (rock_list == "no_list") ? 0 : &rock_list;
res_prop.init(parser, grid.globalCell(), perm_threshold, rl_ptr, use_jfunction_scaling, sigma, theta);
if (unique_bids) {
grid.setUniqueBoundaryIds(true);
}
}
CombinedGridWellGraph::CombinedGridWellGraph(const CpGrid& grid,
const Opm::EclipseState* eclipseState,
const double* transmissibilities,
bool pretendEmptyGrid)
: grid_(grid), transmissibilities_(transmissibilities)
{
if ( pretendEmptyGrid )
{
// wellsGraph not needed
return;
}
wellsGraph_.resize(grid.numCells());
const auto& cpgdim = grid.logicalCartesianSize();
// create compressed lookup from cartesian.
std::vector<int> cartesian_to_compressed(cpgdim[0]*cpgdim[1]*cpgdim[2], -1);
for( int i=0; i < grid.numCells(); ++i )
{
cartesian_to_compressed[grid.globalCell()[i]] = i;
}
well_indices_.init(*eclipseState, cpgdim, cartesian_to_compressed);
std::vector<int>().swap(cartesian_to_compressed); // free memory.
addCompletionSetToGraph();
}
int main(int argc, char** argv)
try
{
Dune::MPIHelper::instance(argc,argv); // Dummy if no MPI.
CpGrid grid;
if (argc != 2) {
std::cout << "Usage: grdecl2vtu filename.grdecl" << std::endl;
exit(1);
}
const char* eclipsefilename = argv[1];
#if HAVE_OPM_PARSER
Opm::ParseContext parseContext;
Opm::Parser parser;
auto deck = parser.parseFile(eclipsefilename, parseContext);
// Get logical cartesian grid dimensions.
std::array<size_t, 3> dims;
if (deck.hasKeyword("SPECGRID")) {
const auto& specgridRecord = deck.getKeyword("SPECGRID").getRecord(0);
dims[0] = specgridRecord.getItem("NX").get< int >(0);
dims[1] = specgridRecord.getItem("NY").get< int >(0);
dims[2] = specgridRecord.getItem("NZ").get< int >(0);
} else if (deck.hasKeyword("DIMENS")) {
const auto& dimensRecord = deck.getKeyword("DIMENS").getRecord(0);
dims[0] = dimensRecord.getItem("NX").get< int >(0);
dims[1] = dimensRecord.getItem("NY").get< int >(0);
dims[2] = dimensRecord.getItem("NZ").get< int >(0);
} else {
OPM_THROW(std::runtime_error, "Found neither SPECGRID nor DIMENS in file. At least one is needed.");
}
{
const int* actnum = deck.hasKeyword("ACTNUM") ? deck.getKeyword("ACTNUM").getIntData().data() : nullptr;
Opm::EclipseGrid ecl_grid(deck , actnum);
grid.processEclipseFormat(ecl_grid, false);
}
#endif
VTKWriter<CpGrid::LeafGridView> vtkwriter(grid.leafGridView());
#if HAVE_OPM_PARSER
const std::vector<int>& global_cell = grid.globalCell();
std::vector<double> poros;
condWriteDoubleField(poros, "PORO", deck, global_cell, dims, vtkwriter);
std::vector<double> permxs;
condWriteDoubleField(permxs, "PERMX", deck, global_cell, dims, vtkwriter);
std::vector<double> permys;
condWriteDoubleField(permys, "PERMY", deck, global_cell, dims, vtkwriter);
std::vector<double> permzs;
condWriteDoubleField(permzs, "PERMZ", deck, global_cell, dims, vtkwriter);
std::vector<double> actnums;
condWriteIntegerField(actnums, "ACTNUM", deck, global_cell, dims, vtkwriter);
std::vector<double> satnums;
condWriteIntegerField(satnums, "SATNUM", deck, global_cell, dims, vtkwriter);
std::vector<double> regnums;
condWriteIntegerField(regnums, "REGNUM", deck, global_cell, dims, vtkwriter);
std::vector<double> swats;
condWriteDoubleField(swats, "SWAT", deck, global_cell, dims, vtkwriter);
#endif // #if HAVE_OPM_PARSER
std::string fname(eclipsefilename);
std::string fnamebase = fname.substr(0, fname.find_last_of('.'));
std::cout << "Writing to filename " << fnamebase << ".vtu" << std::endl;
vtkwriter.write(fnamebase, VTK::ascii);
}
catch (const std::exception &e) {
std::cerr << "Program threw an exception: " << e.what() << "\n";
throw;
}