int main(int argc, char* argv[]) { const Opm::parameter::ParameterGroup param(argc, argv, false); const Opm::GridManager gm(5, 5); const UnstructuredGrid* g = gm.c_grid(); const int nc = g->number_of_cells; const Opm::BlackoilPropertiesBasic oldprops(param, 2, nc); const Opm::BlackoilPropsAd props(oldprops); typedef AutoDiff::ForwardBlock<double> ADB; Wells* wells = create_wells(2, 2, 5); const double inj_frac[] = { 1.0, 0.0 }; const double prod_frac[] = { 0.0, 0.0 }; const int num_inj = 3; const int inj_cells[num_inj] = { 0, 1, 2 }; const int num_prod = 2; const int prod_cells[num_prod] = { 20, 21 }; const double WI[3] = { 1e-12, 1e-12, 1e-12 }; bool ok = add_well(INJECTOR, 0.0, num_inj, inj_frac, inj_cells, WI, "Inj", wells); ok = ok && add_well(PRODUCER, 0.0, num_prod, prod_frac, prod_cells, WI, "Prod", wells); ok = ok && append_well_controls(BHP, 500.0*Opm::unit::barsa, 0, 0, wells); // ok = ok && append_well_controls(BHP, 200.0*Opm::unit::barsa, 0, 1, wells); double oildistr[2] = { 0.0, 1.0 }; ok = ok && append_well_controls(SURFACE_RATE, 1e-3, oildistr, 1, wells); if (!ok) { THROW("Something went wrong with well init."); } set_current_control(0, 0, wells); set_current_control(1, 0, wells); double grav[] = { /*1.0*/ 0.0, 0.0 }; Opm::DerivedGeology geo(*g, props, grav); Opm::LinearSolverFactory linsolver(param); Opm::ImpesTPFAAD ps(*g, props, geo, *wells, linsolver); Opm::BlackoilState state; initStateBasic(*g, oldprops, param, 0.0, state); initBlackoilSurfvol(*g, oldprops, state); Opm::WellState well_state; well_state.init(wells, state); ps.solve(1.0, state, well_state); std::cout << "Cell pressure:" << std::endl; std::copy(state.pressure().begin(), state.pressure().end(), std::ostream_iterator<double>(std::cout, " ")); std::cout << std::endl; std::cout << "Face flux:" << std::endl; std::copy(state.faceflux().begin(), state.faceflux().end(), std::ostream_iterator<double>(std::cout, " ")); std::cout << std::endl; std::cout << "Well bhp pressure:" << std::endl; std::copy(well_state.bhp().begin(), well_state.bhp().end(), std::ostream_iterator<double>(std::cout, " ")); std::cout << std::endl; return 0; }
int main(int argc, char* argv[]) try { const Opm::parameter::ParameterGroup param(argc, argv, false); const Opm::GridManager gm(20, 1); const UnstructuredGrid* g = gm.c_grid(); const int nc = g->number_of_cells; const Opm::BlackoilPropertiesBasic props0(param, 2, nc); const Opm::BlackoilPropsAd props(props0); boost::shared_ptr<Wells> wells = createWellConfig(); double grav[] = { 0.0, 0.0 }; Opm::DerivedGeology geo(*g, props, grav); Opm::LinearSolverFactory linsolver(param); Opm::FullyImplicitBlackoilSolver solver(*g, props, geo, 0, *wells, linsolver); Opm::BlackoilState state; initStateBasic(*g, props0, param, 0.0, state); initBlackoilSurfvol(*g, props0, state); Opm::WellState well_state; well_state.init(wells.get(), state); solver.step(1.0, state, well_state); std::cout << state.pressure() << '\n' << well_state.bhp() << '\n'; return 0; } catch (const std::exception &e) { std::cerr << "Program threw an exception: " << e.what() << "\n"; throw; }
int main() try { typedef Opm::AutoDiffBlock<double> ADB; typedef ADB::V V; typedef Eigen::SparseMatrix<double> S; Opm::time::StopWatch clock; clock.start(); const Opm::GridManager gm(3,3);//(50, 50, 10); const UnstructuredGrid& grid = *gm.c_grid(); using namespace Opm::unit; using namespace Opm::prefix; // const Opm::IncompPropertiesBasic props(2, Opm::SaturationPropsBasic::Linear, // { 1000.0, 800.0 }, // { 1.0*centi*Poise, 5.0*centi*Poise }, // 0.2, 100*milli*darcy, // grid.dimensions, grid.number_of_cells); // const Opm::IncompPropertiesBasic props(2, Opm::SaturationPropsBasic::Linear, // { 1000.0, 1000.0 }, // { 1.0, 1.0 }, // 1.0, 1.0, // grid.dimensions, grid.number_of_cells); const Opm::IncompPropertiesBasic props(2, Opm::SaturationPropsBasic::Linear, { 1000.0, 1000.0 }, { 1.0, 30.0 }, 1.0, 1.0, grid.dimensions, grid.number_of_cells); V htrans(grid.cell_facepos[grid.number_of_cells]); tpfa_htrans_compute(const_cast<UnstructuredGrid*>(&grid), props.permeability(), htrans.data()); V trans_all(grid.number_of_faces); // tpfa_trans_compute(const_cast<UnstructuredGrid*>(&grid), htrans.data(), trans_all.data()); const int nc = grid.number_of_cells; std::vector<int> allcells(nc); for (int i = 0; i < nc; ++i) { allcells[i] = i; } std::cerr << "Opm core " << clock.secsSinceLast() << std::endl; // Define neighbourhood-derived operator matrices. const Opm::HelperOps ops(grid); const int num_internal = ops.internal_faces.size(); std::cerr << "Topology matrices " << clock.secsSinceLast() << std::endl; typedef Opm::AutoDiffBlock<double> ADB; typedef ADB::V V; // q V q(nc); q.setZero(); q[0] = 1.0; q[nc-1] = -1.0; // s0 - this is explicit now typedef Eigen::Array<double, Eigen::Dynamic, 2, Eigen::RowMajor> TwoCol; TwoCol s0(nc, 2); s0.leftCols<1>().setZero(); s0.rightCols<1>().setOnes(); // totmob - explicit as well TwoCol kr(nc, 2); props.relperm(nc, s0.data(), allcells.data(), kr.data(), 0); const V krw = kr.leftCols<1>(); const V kro = kr.rightCols<1>(); const double* mu = props.viscosity(); const V totmob = krw/mu[0] + kro/mu[1]; // Moved down here because we need total mobility. tpfa_eff_trans_compute(const_cast<UnstructuredGrid*>(&grid), totmob.data(), htrans.data(), trans_all.data()); // Still explicit, and no upwinding! V mobtransf(num_internal); for (int fi = 0; fi < num_internal; ++fi) { mobtransf[fi] = trans_all[ops.internal_faces[fi]]; } std::cerr << "Property arrays " << clock.secsSinceLast() << std::endl; // Initial pressure. V p0(nc,1); p0.fill(200*Opm::unit::barsa); // First actual AD usage: defining pressure variable. const std::vector<int> bpat = { nc }; // Could actually write { nc } instead of bpat below, // but we prefer a named variable since we will repeat it. const ADB p = ADB::variable(0, p0, bpat); const ADB ngradp = ops.ngrad*p; // We want flux = totmob*trans*(p_i - p_j) for the ij-face. const ADB flux = mobtransf*ngradp; const ADB residual = ops.div*flux - q; std::cerr << "Construct AD residual " << clock.secsSinceLast() << std::endl; // It's the residual we want to be zero. We know it's linear in p, // so we just need a single linear solve. Since we have formulated // ourselves with a residual and jacobian we do this with a single // Newton step (hopefully easy to extend later): // p = p0 - J(p0) \ R(p0) // Where R(p0) and J(p0) are contained in residual.value() and // residual.derived()[0]. #if HAVE_SUITESPARSE_UMFPACK_H typedef Eigen::UmfPackLU<S> LinSolver; #else typedef Eigen::BiCGSTAB<S> LinSolver; #endif // HAVE_SUITESPARSE_UMFPACK_H LinSolver solver; S pmatr; residual.derivative()[0].toSparse(pmatr); pmatr.coeffRef(0,0) *= 2.0; pmatr.makeCompressed(); solver.compute(pmatr); if (solver.info() != Eigen::Success) { std::cerr << "Pressure/flow Jacobian decomposition error\n"; return EXIT_FAILURE; } // const Eigen::VectorXd dp = solver.solve(residual.value().matrix()); ADB::V residual_v = residual.value(); const V dp = solver.solve(residual_v.matrix()).array(); if (solver.info() != Eigen::Success) { std::cerr << "Pressure/flow solve failure\n"; return EXIT_FAILURE; } const V p1 = p0 - dp; std::cerr << "Solve " << clock.secsSinceLast() << std::endl; // std::cout << p1 << std::endl; // ------ Transport solve ------ // Now we'll try to do a transport step as well. // Residual formula is // R_w = s_w - s_w^0 + dt/pv * (div v_w) // where // v_w = f_w v // and f_w is (for now) based on averaged mobilities, not upwind. double res_norm = 1e100; const V sw0 = s0.leftCols<1>(); // V sw1 = sw0; V sw1 = 0.5*V::Ones(nc,1); const V ndp = (ops.ngrad * p1.matrix()).array(); const V dflux = mobtransf * ndp; const Opm::UpwindSelector<double> upwind(grid, ops, dflux); const V pv = Eigen::Map<const V>(props.porosity(), nc, 1) * Eigen::Map<const V>(grid.cell_volumes, nc, 1); const double dt = 0.0005; const V dtpv = dt/pv; const V qneg = q.min(V::Zero(nc,1)); const V qpos = q.max(V::Zero(nc,1)); std::cout.setf(std::ios::scientific); std::cout.precision(16); int it = 0; do { const ADB sw = ADB::variable(0, sw1, bpat); const std::vector<ADB> pmobc = phaseMobility<ADB>(props, allcells, sw.value()); const std::vector<ADB> pmobf = upwind.select(pmobc); const ADB fw_cell = fluxFunc(pmobc); const ADB fw_face = fluxFunc(pmobf); const ADB flux1 = fw_face * dflux; const ADB qtr_ad = qpos + fw_cell*qneg; const ADB transport_residual = sw - sw0 + dtpv*(ops.div*flux1 - qtr_ad); res_norm = transport_residual.value().matrix().norm(); std::cout << "res_norm[" << it << "] = " << res_norm << std::endl; S smatr; transport_residual.derivative()[0].toSparse(smatr); smatr.makeCompressed(); solver.compute(smatr); if (solver.info() != Eigen::Success) { std::cerr << "Transport Jacobian decomposition error\n"; return EXIT_FAILURE; } ADB::V transport_residual_v = transport_residual.value(); const V ds = solver.solve(transport_residual_v.matrix()).array(); if (solver.info() != Eigen::Success) { std::cerr << "Transport solve failure\n"; return EXIT_FAILURE; } sw1 = sw.value() - ds; std::cerr << "Solve for s[" << it << "]: " << clock.secsSinceLast() << '\n'; sw1 = sw1.min(V::Ones(nc,1)).max(V::Zero(nc,1)); it += 1; } while (res_norm > 1e-7); std::cout << "Saturation solution:\n" << "function s1 = solution\n" << "s1 = [\n" << sw1 << "\n];\n"; } catch (const std::exception &e) { std::cerr << "Program threw an exception: " << e.what() << "\n"; throw; }