int main(int argc, char** argv)
{
Opm::parameter::ParameterGroup param(argc, argv);
Dune::MPIHelper::instance(argc,argv);
// Make a grid
Dune::CpGrid grid;
Opm::EclipseGridParser parser(param.get<std::string>("filename"));
double z_tol = param.getDefault<double>("z_tolerance", 0.0);
std::tr1::array<int,3> cartDims;
build_grid(parser, z_tol, grid, cartDims);
// Make the grid interface
Opm::GridInterfaceEuler<Dune::CpGrid> g(grid);
// Reservoir properties.
typedef ReservoirPropertyCapillaryAnisotropicRelperm<3> RP;
RP res_prop;
res_prop.init(parser, grid.globalCell());
assign_permeability<3>(res_prop, g.numberOfCells(), 0.1*Opm::unit::darcy);
test_flowsolver<3>(g, res_prop);
#if 0
// Make flow equation boundary conditions.
// Pressure 1.0e5 on the left, 0.0 on the right.
// Recall that the boundary ids range from 1 to 6 for the cartesian edges,
// and that boundary id 0 means interiour face/intersection.
typedef FlowBoundaryCondition BC;
FlowBoundaryConditions flow_bcond(7);
flow_bcond[1] = BC(BC::Dirichlet, 1.0e5);
flow_bcond[2] = BC(BC::Dirichlet, 0.0);
// Make transport equation boundary conditions.
// The default one is fine (sat = 1.0 on inflow).
SaturationBoundaryConditions sat_bcond(7);
// No injection or production.
SparseVector<double> injection_rates(g.numberOfCells());
// Make a solver.
typedef EulerUpstream<GridInterface,
RP,
SaturationBoundaryConditions> TransportSolver;
TransportSolver transport_solver(g, res_prop, sat_bcond, injection_rates);
// Define a flow field with constant velocity
Dune::FieldVector<double, 3> vel(0.0);
vel[0] = 2.0;
vel[1] = 1.0;
TestSolution<GridInterface> flow_solution(g, vel);
// Solve a step.
double time = 1.0;
std::vector<double> sat(g.numberOfCells(), 0.0);
Dune::FieldVector<double, 3> gravity(0.0);
gravity[2] = -9.81;
transport_solver.transportSolve(sat, time, gravity, flow_solution);
#endif
}
inline void setupGridAndPropsEclipse(Opm::DeckConstPtr deck,
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,
Dune::CpGrid& grid,
ResProp<3>& res_prop)
{
grid.processEclipseFormat(deck, periodic_extension, turn_normals, clip_z);
const std::string* rl_ptr = (rock_list == "no_list") ? 0 : &rock_list;
res_prop.init(deck, grid.globalCell(), perm_threshold, rl_ptr, use_jfunction_scaling, sigma, theta);
if (unique_bids) {
grid.setUniqueBoundaryIds(true);
}
}
inline void setupGridAndProps(const Opm::parameter::ParameterGroup& param,
Dune::CpGrid& grid,
ResProp<3>& res_prop)
{
// Initialize grid and reservoir properties.
// Parts copied from Dune::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);
OPM_MESSAGE("Warning: We do not yet read legacy reservoir properties. Using defaults.");
res_prop.init(grid.size(0));
} else if (fileformat == "eclipse") {
std::string ecl_file = param.get<std::string>("filename");
Opm::ParseContext parseContext;
Opm::ParserPtr parser(new Opm::Parser());
Opm::DeckConstPtr deck(parser->parseFile(ecl_file , parseContext));
if (param.has("z_tolerance")) {
std::cerr << "****** Warning: z_tolerance parameter is obsolete, use PINCH in deck input instead\n";
}
bool periodic_extension = param.getDefault<bool>("periodic_extension", false);
bool turn_normals = param.getDefault<bool>("turn_normals", false);
grid.processEclipseFormat(deck, periodic_extension, turn_normals);
// Save EGRID file in case we are writing ECL output.
if (param.getDefault("output_ecl", false)) {
OPM_THROW(std::runtime_error, "Saving to EGRID files is not yet implemented");
/*
boost::filesystem::path ecl_path(ecl_file);
const std::vector<int>& globalCell = grid.globalCell();
ecl_path.replace_extension(".EGRID");
parser.saveEGRID(ecl_path.string() , (int) globalCell.size() , &globalCell[0]);
*/
}
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(deck, grid.globalCell(), perm_threshold, rl_ptr,
use_j, sigma, theta);
} else if (fileformat == "cartesian") {
std::array<int, 3> dims = {{ param.getDefault<int>("nx", 1),
param.getDefault<int>("ny", 1),
param.getDefault<int>("nz", 1) }};
std::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);
OPM_MESSAGE("Warning: For generated cartesian grids, we use uniform reservoir properties.");
res_prop.init(grid.size(0), default_poro, default_perm);
} else {
OPM_THROW(std::runtime_error, "Unknown file format string: " << fileformat);
}
if (param.getDefault("use_unique_boundary_ids", false)) {
grid.setUniqueBoundaryIds(true);
}
}