/// Solve the pressure equation. The nonlinear equations ares /// solved by a Newton-Raphson scheme. May throw an exception if /// the number of iterations exceed maxiter (set in constructor). void CompressibleTpfaPolymer::solve(const double dt, PolymerBlackoilState& state, WellState& well_state) { c_ = &state.concentration(); cmax_ = &state.maxconcentration(); CompressibleTpfa::solve(dt, state.blackoilState(), well_state); }
/// Solve the pressure equation. The nonlinear equations ares /// solved by a Newton-Raphson scheme. May throw an exception if /// the number of iterations exceed maxiter (set in constructor). void CompressibleTpfaPolymer::solve(const double dt, PolymerBlackoilState& state, WellState& well_state) { c_ = &state.getCellData( state.CONCENTRATION ); cmax_ = &state.getCellData( state.CMAX ); CompressibleTpfa::solve(dt, state, well_state); }
/// @brief Computes total absorbed polymer mass over all grid cells. /// With compressibility /// @param[in] grid grid /// @param[in] props fluid and rock properties. /// @param[in] polyprops polymer properties /// @param[in] state fluid state variable /// @param[in] rock_comp rock compressibility (depends on pressure) /// @return total absorbed polymer mass. double computePolymerAdsorbed(const UnstructuredGrid& grid, const BlackoilPropertiesInterface& props, const Opm::PolymerProperties& polyprops, const PolymerBlackoilState& state, const RockCompressibility* rock_comp ) { const int num_cells = props.numCells(); const double rhor = polyprops.rockDensity(); std::vector<double> porosity; if (rock_comp && rock_comp->isActive()) { computePorosity(grid, props.porosity(), *rock_comp, state.pressure(), porosity); } else { porosity.assign(props.porosity(), props.porosity() + num_cells); } double abs_mass = 0.0; const std::vector<double>& cmax = state.getCellData( state.CMAX ); for (int cell = 0; cell < num_cells; ++cell) { double c_ads; polyprops.simpleAdsorption(cmax[cell], c_ads); abs_mass += c_ads*grid.cell_volumes[cell]*(1.0 - porosity[cell])*rhor; } return abs_mass; }
void outputStateMatlab(const Grid& grid, const PolymerBlackoilState& state, const int step, const std::string& output_dir) { Opm::DataMap dm; dm["saturation"] = &state.saturation(); dm["pressure"] = &state.pressure(); dm["surfvolume"] = &state.surfacevol(); dm["rs"] = &state.gasoilratio(); dm["rv"] = &state.rv(); dm["concentration"] = &state.concentration(); dm["maxconcentration"] = &state.maxconcentration(); std::vector<double> cell_velocity; Opm::estimateCellVelocity(AutoDiffGrid::numCells(grid), AutoDiffGrid::numFaces(grid), AutoDiffGrid::beginFaceCentroids(grid), UgGridHelpers::faceCells(grid), AutoDiffGrid::beginCellCentroids(grid), AutoDiffGrid::beginCellVolumes(grid), AutoDiffGrid::dimensions(grid), state.faceflux(), cell_velocity); dm["velocity"] = &cell_velocity; // Write data (not grid) in Matlab format for (Opm::DataMap::const_iterator it = dm.begin(); it != dm.end(); ++it) { std::ostringstream fname; fname << output_dir << "/" << it->first; boost::filesystem::path fpath = fname.str(); try { create_directories(fpath); } catch (...) { OPM_THROW(std::runtime_error, "Creating directories failed: " << fpath); } fname << "/" << std::setw(3) << std::setfill('0') << step << ".txt"; std::ofstream file(fname.str().c_str()); if (!file) { OPM_THROW(std::runtime_error, "Failed to open " << fname.str()); } file.precision(15); const std::vector<double>& d = *(it->second); std::copy(d.begin(), d.end(), std::ostream_iterator<double>(file, "\n")); } }
SimulatorReport SimulatorCompressiblePolymer::Impl::run(SimulatorTimer& timer, PolymerBlackoilState& state, WellState& well_state) { std::vector<double> transport_src(grid_.number_of_cells); std::vector<double> polymer_inflow_c(grid_.number_of_cells); // Initialisation. std::vector<double> initial_pressure; std::vector<double> porevol; if (rock_comp_props_ && rock_comp_props_->isActive()) { computePorevolume(grid_, props_.porosity(), *rock_comp_props_, state.pressure(), porevol); } else { computePorevolume(grid_, props_.porosity(), porevol); } const double tot_porevol_init = std::accumulate(porevol.begin(), porevol.end(), 0.0); std::vector<double> initial_porevol = porevol; // Main simulation loop. Opm::time::StopWatch pressure_timer; double ptime = 0.0; Opm::time::StopWatch transport_timer; double ttime = 0.0; Opm::time::StopWatch total_timer; total_timer.start(); double init_surfvol[2] = { 0.0 }; double inplace_surfvol[2] = { 0.0 }; double polymass = computePolymerMass(porevol, state.saturation(), state.getCellData( state.CONCENTRATION ), poly_props_.deadPoreVol()); double polymass_adsorbed = computePolymerAdsorbed(grid_, props_, poly_props_, state, rock_comp_props_); double init_polymass = polymass + polymass_adsorbed; double tot_injected[2] = { 0.0 }; double tot_produced[2] = { 0.0 }; double tot_polyinj = 0.0; double tot_polyprod = 0.0; Opm::computeSaturatedVol(porevol, state.surfacevol(), init_surfvol); Opm::Watercut watercut; watercut.push(0.0, 0.0, 0.0); Opm::WellReport wellreport; std::vector<double> fractional_flows; std::vector<double> well_resflows_phase; if (wells_) { well_resflows_phase.resize((wells_->number_of_phases)*(wells_->number_of_wells), 0.0); wellreport.push(props_, *wells_, state.pressure(), state.surfacevol(), state.saturation(), 0.0, well_state.bhp(), well_state.perfRates()); } // Report timestep and (optionally) write state to disk. timer.report(std::cout); if (output_ && (timer.currentStepNum() % output_interval_ == 0)) { if (output_vtk_) { outputStateVtk(grid_, state, timer.currentStepNum(), output_dir_); } outputStateMatlab(grid_, state, timer.currentStepNum(), output_dir_); } initial_pressure = state.pressure(); // Solve pressure equation. if (check_well_controls_) { computeFractionalFlow(props_, poly_props_, allcells_, state.pressure(), state.temperature(), state.surfacevol(), state.saturation(), state.getCellData( state.CONCENTRATION ), state.getCellData( state.CMAX ) , fractional_flows); wells_manager_.applyExplicitReinjectionControls(well_resflows_phase, well_resflows_phase); } bool well_control_passed = !check_well_controls_; int well_control_iteration = 0; do { // Run solver pressure_timer.start(); psolver_.solve(timer.currentStepLength(), state, well_state); // Renormalize pressure if both fluids and rock are // incompressible, and there are no pressure // conditions (bcs or wells). It is deemed sufficient // for now to renormalize using geometric volume // instead of pore volume. if (psolver_.singularPressure()) { // Compute average pressures of previous and last // step, and total volume. double av_prev_press = 0.0; double av_press = 0.0; double tot_vol = 0.0; const int num_cells = grid_.number_of_cells; for (int cell = 0; cell < num_cells; ++cell) { av_prev_press += initial_pressure[cell]*grid_.cell_volumes[cell]; av_press += state.pressure()[cell]*grid_.cell_volumes[cell]; tot_vol += grid_.cell_volumes[cell]; } // Renormalization constant const double ren_const = (av_prev_press - av_press)/tot_vol; for (int cell = 0; cell < num_cells; ++cell) { state.pressure()[cell] += ren_const; } const int num_wells = (wells_ == NULL) ? 0 : wells_->number_of_wells; for (int well = 0; well < num_wells; ++well) { well_state.bhp()[well] += ren_const; } } // Stop timer and report pressure_timer.stop(); double pt = pressure_timer.secsSinceStart(); std::cout << "Pressure solver took: " << pt << " seconds." << std::endl; ptime += pt; // Optionally, check if well controls are satisfied. if (check_well_controls_) { Opm::computePhaseFlowRatesPerWell(*wells_, well_state.perfRates(), fractional_flows, well_resflows_phase); std::cout << "Checking well conditions." << std::endl; // For testing we set surface := reservoir well_control_passed = wells_manager_.conditionsMet(well_state.bhp(), well_resflows_phase, well_resflows_phase); ++well_control_iteration; if (!well_control_passed && well_control_iteration > max_well_control_iterations_) { OPM_THROW(std::runtime_error, "Could not satisfy well conditions in " << max_well_control_iterations_ << " tries."); } if (!well_control_passed) { std::cout << "Well controls not passed, solving again." << std::endl; } else { std::cout << "Well conditions met." << std::endl; } } } while (!well_control_passed); // Update pore volumes if rock is compressible. if (rock_comp_props_ && rock_comp_props_->isActive()) { initial_porevol = porevol; computePorevolume(grid_, props_.porosity(), *rock_comp_props_, state.pressure(), porevol); } // Process transport sources (to include bdy terms and well flows). Opm::computeTransportSource(props_, wells_, well_state, transport_src); // Find inflow rate. const double current_time = timer.simulationTimeElapsed(); double stepsize = timer.currentStepLength(); polymer_inflow_.getInflowValues(current_time, current_time + stepsize, polymer_inflow_c); // Solve transport. transport_timer.start(); if (num_transport_substeps_ != 1) { stepsize /= double(num_transport_substeps_); std::cout << "Making " << num_transport_substeps_ << " transport substeps." << std::endl; } double injected[2] = { 0.0 }; double produced[2] = { 0.0 }; double polyinj = 0.0; double polyprod = 0.0; for (int tr_substep = 0; tr_substep < num_transport_substeps_; ++tr_substep) { tsolver_.solve(&state.faceflux()[0], initial_pressure, state.pressure(), state.temperature(), &initial_porevol[0], &porevol[0], &transport_src[0], &polymer_inflow_c[0], stepsize, state.saturation(), state.surfacevol(), state.getCellData( state.CONCENTRATION ), state.getCellData( state.CMAX )); double substep_injected[2] = { 0.0 }; double substep_produced[2] = { 0.0 }; double substep_polyinj = 0.0; double substep_polyprod = 0.0; Opm::computeInjectedProduced(props_, poly_props_, state, transport_src, polymer_inflow_c, stepsize, substep_injected, substep_produced, substep_polyinj, substep_polyprod); injected[0] += substep_injected[0]; injected[1] += substep_injected[1]; produced[0] += substep_produced[0]; produced[1] += substep_produced[1]; polyinj += substep_polyinj; polyprod += substep_polyprod; if (gravity_ != 0 && use_segregation_split_) { tsolver_.solveGravity(columns_, stepsize, state.saturation(), state.surfacevol(), state.getCellData( state.CONCENTRATION ), state.getCellData( state.CMAX )); } } transport_timer.stop(); double tt = transport_timer.secsSinceStart(); std::cout << "Transport solver took: " << tt << " seconds." << std::endl; ttime += tt; // Report volume balances. Opm::computeSaturatedVol(porevol, state.surfacevol(), inplace_surfvol); polymass = Opm::computePolymerMass(porevol, state.saturation(), state.getCellData( state.CONCENTRATION ), poly_props_.deadPoreVol()); polymass_adsorbed = Opm::computePolymerAdsorbed(grid_, props_, poly_props_, state, rock_comp_props_); tot_injected[0] += injected[0]; tot_injected[1] += injected[1]; tot_produced[0] += produced[0]; tot_produced[1] += produced[1]; tot_polyinj += polyinj; tot_polyprod += polyprod; std::cout.precision(5); const int width = 18; std::cout << "\nMass balance: " " water(surfvol) oil(surfvol) polymer(kg)\n"; std::cout << " In-place: " << std::setw(width) << inplace_surfvol[0] << std::setw(width) << inplace_surfvol[1] << std::setw(width) << polymass << std::endl; std::cout << " Adsorbed: " << std::setw(width) << 0.0 << std::setw(width) << 0.0 << std::setw(width) << polymass_adsorbed << std::endl; std::cout << " Injected: " << std::setw(width) << injected[0] << std::setw(width) << injected[1] << std::setw(width) << polyinj << std::endl; std::cout << " Produced: " << std::setw(width) << produced[0] << std::setw(width) << produced[1] << std::setw(width) << polyprod << std::endl; std::cout << " Total inj: " << std::setw(width) << tot_injected[0] << std::setw(width) << tot_injected[1] << std::setw(width) << tot_polyinj << std::endl; std::cout << " Total prod: " << std::setw(width) << tot_produced[0] << std::setw(width) << tot_produced[1] << std::setw(width) << tot_polyprod << std::endl; const double balance[3] = { init_surfvol[0] - inplace_surfvol[0] - tot_produced[0] + tot_injected[0], init_surfvol[1] - inplace_surfvol[1] - tot_produced[1] + tot_injected[1], init_polymass - polymass - tot_polyprod + tot_polyinj - polymass_adsorbed }; std::cout << " Initial - inplace + inj - prod: " << std::setw(width) << balance[0] << std::setw(width) << balance[1] << std::setw(width) << balance[2] << std::endl; std::cout << " Relative mass error: " << std::setw(width) << balance[0]/(init_surfvol[0] + tot_injected[0]) << std::setw(width) << balance[1]/(init_surfvol[1] + tot_injected[1]) << std::setw(width) << balance[2]/(init_polymass + tot_polyinj) << std::endl; std::cout.precision(8); watercut.push(timer.simulationTimeElapsed() + timer.currentStepLength(), produced[0]/(produced[0] + produced[1]), tot_produced[0]/tot_porevol_init); if (wells_) { wellreport.push(props_, *wells_, state.pressure(), state.surfacevol(), state.saturation(), timer.simulationTimeElapsed() + timer.currentStepLength(), well_state.bhp(), well_state.perfRates()); } if (output_) { if (output_vtk_) { outputStateVtk(grid_, state, timer.currentStepNum(), output_dir_); } outputStateMatlab(grid_, state, timer.currentStepNum(), output_dir_); outputWaterCut(watercut, output_dir_); if (wells_) { outputWellReport(wellreport, output_dir_); } } total_timer.stop(); SimulatorReport report; report.pressure_time = ptime; report.transport_time = ttime; report.total_time = total_timer.secsSinceStart(); return report; }
// ----------------- Main program ----------------- int main(int argc, char** argv) try { using namespace Opm; { std::string version = moduleVersionName(); std::cout << "**********************************************************************\n"; std::cout << "* *\n"; std::cout << "* This is Flow-Polymer (version " << version << ")" << std::string(18 - version.size(), ' ') << "*\n"; std::cout << "* *\n"; std::cout << "* Flow-Polymer is a simulator for fully implicit three-phase, *\n"; std::cout << "* four-component (black-oil + polymer) flow, and is part of OPM. *\n"; std::cout << "* For more information see http://opm-project.org *\n"; std::cout << "* *\n"; std::cout << "**********************************************************************\n\n"; } // Read parameters, see if a deck was specified on the command line. std::cout << "--------------- Reading parameters ---------------" << std::endl; parameter::ParameterGroup param(argc, argv, false); if (!param.unhandledArguments().empty()) { if (param.unhandledArguments().size() != 1) { OPM_THROW(std::runtime_error, "You can only specify a single input deck on the command line."); } else { param.insertParameter("deck_filename", param.unhandledArguments()[0]); } } // We must have an input deck. Grid and props will be read from that. if (!param.has("deck_filename")) { std::cerr << "This program must be run with an input deck.\n" "Specify the deck filename either\n" " a) as a command line argument by itself\n" " b) as a command line parameter with the syntax deck_filename=<path to your deck>, or\n" " c) as a parameter in a parameter file (.param or .xml) passed to the program.\n"; OPM_THROW(std::runtime_error, "Input deck required."); } std::shared_ptr<GridManager> grid; std::shared_ptr<BlackoilPropertiesFromDeck> props; std::shared_ptr<BlackoilPropsAdFromDeck> new_props; std::shared_ptr<RockCompressibility> rock_comp; PolymerBlackoilState state; // bool check_well_controls = false; // int max_well_control_iterations = 0; double gravity[3] = { 0.0 }; std::string deck_filename = param.get<std::string>("deck_filename"); // Write parameters used for later reference. bool output = param.getDefault("output", true); std::string output_dir; if (output) { // Create output directory if needed. output_dir = param.getDefault("output_dir", std::string("output")); boost::filesystem::path fpath(output_dir); try { create_directories(fpath); } catch (...) { OPM_THROW(std::runtime_error, "Creating directories failed: " << fpath); } // Write simulation parameters. param.writeParam(output_dir + "/simulation.param"); } std::string logFile = output_dir + "/LOGFILE.txt"; Opm::ParserPtr parser(new Opm::Parser()); { std::shared_ptr<Opm::StreamLog> streamLog = std::make_shared<Opm::StreamLog>(logFile , Opm::Log::DefaultMessageTypes); std::shared_ptr<Opm::CounterLog> counterLog = std::make_shared<Opm::CounterLog>(Opm::Log::DefaultMessageTypes); Opm::OpmLog::addBackend( "STREAM" , streamLog ); Opm::OpmLog::addBackend( "COUNTER" , counterLog ); } Opm::DeckConstPtr deck; std::shared_ptr<EclipseState> eclipseState; Opm::ParseMode parseMode; try { deck = parser->parseFile(deck_filename , parseMode); Opm::checkDeck(deck); eclipseState.reset(new Opm::EclipseState(deck , parseMode)); } catch (const std::invalid_argument& e) { std::cerr << "Failed to create valid ECLIPSESTATE object. See logfile: " << logFile << std::endl; std::cerr << "Exception caught: " << e.what() << std::endl; return EXIT_FAILURE; } // Grid init std::vector<double> porv = eclipseState->getDoubleGridProperty("PORV")->getData(); grid.reset(new GridManager(eclipseState->getEclipseGrid(), porv)); auto &cGrid = *grid->c_grid(); const PhaseUsage pu = Opm::phaseUsageFromDeck(deck); // Rock and fluid init std::vector<int> compressedToCartesianIdx; Opm::createGlobalCellArray(*grid->c_grid(), compressedToCartesianIdx); typedef BlackoilPropsAdFromDeck::MaterialLawManager MaterialLawManager; auto materialLawManager = std::make_shared<MaterialLawManager>(); materialLawManager->initFromDeck(deck, eclipseState, compressedToCartesianIdx); props.reset(new BlackoilPropertiesFromDeck( deck, eclipseState, materialLawManager, Opm::UgGridHelpers::numCells(cGrid), Opm::UgGridHelpers::globalCell(cGrid), Opm::UgGridHelpers::cartDims(cGrid), param)); new_props.reset(new BlackoilPropsAdFromDeck(deck, eclipseState, materialLawManager, cGrid)); const bool polymer = deck->hasKeyword("POLYMER"); const bool use_wpolymer = deck->hasKeyword("WPOLYMER"); PolymerProperties polymer_props(deck, eclipseState); PolymerPropsAd polymer_props_ad(polymer_props); // check_well_controls = param.getDefault("check_well_controls", false); // max_well_control_iterations = param.getDefault("max_well_control_iterations", 10); // Rock compressibility. rock_comp.reset(new RockCompressibility(deck, eclipseState)); // Gravity. gravity[2] = deck->hasKeyword("NOGRAV") ? 0.0 : unit::gravity; // Init state variables (saturation and pressure). if (param.has("init_saturation")) { initStateBasic(*grid->c_grid(), *props, param, gravity[2], state); initBlackoilSurfvol(*grid->c_grid(), *props, state); enum { Oil = BlackoilPhases::Liquid, Gas = BlackoilPhases::Vapour }; if (pu.phase_used[Oil] && pu.phase_used[Gas]) { const int np = props->numPhases(); const int nc = grid->c_grid()->number_of_cells; for (int c = 0; c < nc; ++c) { state.gasoilratio()[c] = state.surfacevol()[c*np + pu.phase_pos[Gas]] / state.surfacevol()[c*np + pu.phase_pos[Oil]]; } } } else if (deck->hasKeyword("EQUIL") && props->numPhases() == 3) { state.init(*grid->c_grid(), props->numPhases()); const double grav = param.getDefault("gravity", unit::gravity); initStateEquil(*grid->c_grid(), *props, deck, eclipseState, grav, state); state.faceflux().resize(grid->c_grid()->number_of_faces, 0.0); } else { initBlackoilStateFromDeck(*grid->c_grid(), *props, deck, gravity[2], state); } // The capillary pressure is scaled in new_props to match the scaled capillary pressure in props. if (deck->hasKeyword("SWATINIT")) { const int nc = grid->c_grid()->number_of_cells; std::vector<int> cells(nc); for (int c = 0; c < nc; ++c) { cells[c] = c; } std::vector<double> pc = state.saturation(); props->capPress(nc, state.saturation().data(), cells.data(), pc.data(),NULL); new_props->setSwatInitScaling(state.saturation(),pc); } bool use_gravity = (gravity[0] != 0.0 || gravity[1] != 0.0 || gravity[2] != 0.0); const double *grav = use_gravity ? &gravity[0] : 0; // Solver for Newton iterations. std::unique_ptr<NewtonIterationBlackoilInterface> fis_solver; if (param.getDefault("use_cpr", true)) { fis_solver.reset(new NewtonIterationBlackoilCPR(param)); } else { fis_solver.reset(new NewtonIterationBlackoilSimple(param)); } Opm::ScheduleConstPtr schedule = eclipseState->getSchedule(); Opm::TimeMapConstPtr timeMap(schedule->getTimeMap()); SimulatorTimer simtimer; // initialize variables simtimer.init(timeMap); if (polymer){ if (!use_wpolymer) { OPM_MESSAGE("Warning: simulate polymer injection without WPOLYMER."); } else { if (param.has("polymer_start_days")) { OPM_MESSAGE("Warning: Using WPOLYMER to control injection since it was found in deck." "You seem to be trying to control it via parameter poly_start_days (etc.) as well."); } } } else { if (use_wpolymer) { OPM_MESSAGE("Warning: use WPOLYMER in a non-polymer scenario."); } } bool use_local_perm = param.getDefault("use_local_perm", true); Opm::DerivedGeology geology(*grid->c_grid(), *new_props, eclipseState, use_local_perm, grav); std::map<std::pair<int, int>, double> maxDp; computeMaxDp(maxDp, deck, eclipseState, *grid->c_grid(), state, *props, gravity[2]); std::vector<double> threshold_pressures = thresholdPressures(deck, eclipseState, *grid->c_grid(), maxDp); Opm::BlackoilOutputWriter outputWriter(cGrid, param, eclipseState, pu, new_props->permeability()); SimulatorFullyImplicitBlackoilPolymer<UnstructuredGrid> simulator(param, *grid->c_grid(), geology, *new_props, polymer_props_ad, rock_comp->isActive() ? rock_comp.get() : 0, *fis_solver, grav, deck->hasKeyword("DISGAS"), deck->hasKeyword("VAPOIL"), polymer, deck->hasKeyword("PLYSHLOG"), deck->hasKeyword("SHRATE"), eclipseState, outputWriter, deck, threshold_pressures); if (!schedule->initOnly()){ std::cout << "\n\n================ Starting main simulation loop ===============\n" << std::flush; SimulatorReport fullReport = simulator.run(simtimer, state); std::cout << "\n\n================ End of simulation ===============\n\n"; fullReport.report(std::cout); if (output) { std::string filename = output_dir + "/walltime.txt"; std::fstream tot_os(filename.c_str(),std::fstream::trunc | std::fstream::out); fullReport.reportParam(tot_os); warnIfUnusedParams(param); } } else { outputWriter.writeInit( simtimer ); std::cout << "\n\n================ Simulation turned off ===============\n" << std::flush; } } catch (const std::exception &e) { std::cerr << "Program threw an exception: " << e.what() << "\n"; throw; }
// ----------------- Main program ----------------- int main(int argc, char** argv) try { using namespace Opm; std::cout << "\n================ Test program for weakly compressible two-phase flow with polymer ===============\n\n"; parameter::ParameterGroup param(argc, argv, false); std::cout << "--------------- Reading parameters ---------------" << std::endl; // If we have a "deck_filename", grid and props will be read from that. bool use_deck = param.has("deck_filename"); boost::scoped_ptr<GridManager> grid; boost::scoped_ptr<BlackoilPropertiesInterface> props; boost::scoped_ptr<RockCompressibility> rock_comp; Opm::DeckConstPtr deck; EclipseStateConstPtr eclipseState; PolymerBlackoilState state; Opm::PolymerProperties poly_props; // bool check_well_controls = false; // int max_well_control_iterations = 0; double gravity[3] = { 0.0 }; if (use_deck) { std::string deck_filename = param.get<std::string>("deck_filename"); ParserPtr parser(new Opm::Parser()); ParseMode parseMode; deck = parser->parseFile(deck_filename , parseMode); eclipseState.reset(new Opm::EclipseState(deck , parseMode)); // Grid init grid.reset(new GridManager(deck)); // Rock and fluid init props.reset(new BlackoilPropertiesFromDeck(deck, eclipseState, *grid->c_grid())); // check_well_controls = param.getDefault("check_well_controls", false); // max_well_control_iterations = param.getDefault("max_well_control_iterations", 10); // Rock compressibility. rock_comp.reset(new RockCompressibility(deck, eclipseState)); // Gravity. gravity[2] = deck->hasKeyword("NOGRAV") ? 0.0 : unit::gravity; // Init state variables (saturation and pressure). if (param.has("init_saturation")) { initStateBasic(*grid->c_grid(), *props, param, gravity[2], state); } else { initStateFromDeck(*grid->c_grid(), *props, deck, gravity[2], state); } initBlackoilSurfvol(*grid->c_grid(), *props, state); // Init polymer properties. poly_props.readFromDeck(deck, eclipseState); } else { // Grid init. const int nx = param.getDefault("nx", 100); const int ny = param.getDefault("ny", 100); const int nz = param.getDefault("nz", 1); const double dx = param.getDefault("dx", 1.0); const double dy = param.getDefault("dy", 1.0); const double dz = param.getDefault("dz", 1.0); grid.reset(new GridManager(nx, ny, nz, dx, dy, dz)); // Rock and fluid init. props.reset(new BlackoilPropertiesBasic(param, grid->c_grid()->dimensions, grid->c_grid()->number_of_cells)); // Rock compressibility. rock_comp.reset(new RockCompressibility(param)); // Gravity. gravity[2] = param.getDefault("gravity", 0.0); // Init state variables (saturation and pressure). initStateBasic(*grid->c_grid(), *props, param, gravity[2], state); initBlackoilSurfvol(*grid->c_grid(), *props, state); // Init Polymer state if (param.has("poly_init")) { double poly_init = param.getDefault("poly_init", 0.0); for (int cell = 0; cell < grid->c_grid()->number_of_cells; ++cell) { double smin[2], smax[2]; props->satRange(1, &cell, smin, smax); if (state.saturation()[2*cell] > 0.5*(smin[0] + smax[0])) { state.concentration()[cell] = poly_init; state.maxconcentration()[cell] = poly_init; } else { state.saturation()[2*cell + 0] = 0.; state.saturation()[2*cell + 1] = 1.; state.concentration()[cell] = 0.; state.maxconcentration()[cell] = 0.; } } } // Init polymer properties. // Setting defaults to provide a simple example case. double c_max = param.getDefault("c_max_limit", 5.0); double mix_param = param.getDefault("mix_param", 1.0); double rock_density = param.getDefault("rock_density", 1000.0); double dead_pore_vol = param.getDefault("dead_pore_vol", 0.15); double res_factor = param.getDefault("res_factor", 1.) ; // res_factor = 1 gives no change in permeability double c_max_ads = param.getDefault("c_max_ads", 1.); int ads_index = param.getDefault<int>("ads_index", Opm::PolymerProperties::NoDesorption); std::vector<double> c_vals_visc(2, -1e100); c_vals_visc[0] = 0.0; c_vals_visc[1] = 7.0; std::vector<double> visc_mult_vals(2, -1e100); visc_mult_vals[0] = 1.0; // poly_props.visc_mult_vals[1] = param.getDefault("c_max_viscmult", 30.0); visc_mult_vals[1] = 20.0; std::vector<double> c_vals_ads(3, -1e100); c_vals_ads[0] = 0.0; c_vals_ads[1] = 2.0; c_vals_ads[2] = 8.0; std::vector<double> ads_vals(3, -1e100); ads_vals[0] = 0.0; ads_vals[1] = 0.0015; ads_vals[2] = 0.0025; // ads_vals[1] = 0.0; // ads_vals[2] = 0.0; std::vector<double> water_vel_vals(2, -1e100); water_vel_vals[0] = 0.0; water_vel_vals[1] = 10.0; std::vector<double> shear_vrf_vals(2, -1e100); shear_vrf_vals[0] = 1.0; shear_vrf_vals[1] = 1.0; poly_props.set(c_max, mix_param, rock_density, dead_pore_vol, res_factor, c_max_ads, static_cast<Opm::PolymerProperties::AdsorptionBehaviour>(ads_index), c_vals_visc, visc_mult_vals, c_vals_ads, ads_vals, water_vel_vals, shear_vrf_vals); } bool use_gravity = (gravity[0] != 0.0 || gravity[1] != 0.0 || gravity[2] != 0.0); const double *grav = use_gravity ? &gravity[0] : 0; // Linear solver. LinearSolverFactory linsolver(param); // Write parameters used for later reference. bool output = param.getDefault("output", true); if (output) { std::string output_dir = param.getDefault("output_dir", std::string("output")); boost::filesystem::path fpath(output_dir); try { create_directories(fpath); } catch (...) { OPM_THROW(std::runtime_error, "Creating directories failed: " << fpath); } param.writeParam(output_dir + "/simulation.param"); } std::cout << "\n\n================ Starting main simulation loop ===============\n" << std::flush; SimulatorReport rep; if (!use_deck) { // Simple simulation without a deck. PolymerInflowBasic polymer_inflow(param.getDefault("poly_start_days", 300.0)*Opm::unit::day, param.getDefault("poly_end_days", 800.0)*Opm::unit::day, param.getDefault("poly_amount", poly_props.cMax())); WellsManager wells; SimulatorCompressiblePolymer simulator(param, *grid->c_grid(), *props, poly_props, rock_comp->isActive() ? rock_comp.get() : 0, wells, polymer_inflow, linsolver, grav); SimulatorTimer simtimer; simtimer.init(param); warnIfUnusedParams(param); WellState well_state; well_state.init(0, state); rep = simulator.run(simtimer, state, well_state); } else { // With a deck, we may have more epochs etc. WellState well_state; int step = 0; Opm::TimeMapPtr timeMap(new Opm::TimeMap(deck)); SimulatorTimer simtimer; simtimer.init(timeMap); // Check for WPOLYMER presence in last report step to decide // polymer injection control type. const bool use_wpolymer = deck->hasKeyword("WPOLYMER"); if (use_wpolymer) { if (param.has("poly_start_days")) { OPM_MESSAGE("Warning: Using WPOLYMER to control injection since it was found in deck. " "You seem to be trying to control it via parameter poly_start_days (etc.) as well."); } } for (size_t reportStepIdx = 0; reportStepIdx < timeMap->numTimesteps(); ++reportStepIdx) { simtimer.setCurrentStepNum(reportStepIdx); // Report on start of report step. std::cout << "\n\n-------------- Starting report step " << reportStepIdx << " --------------" << "\n (number of remaining steps: " << simtimer.numSteps() - step << ")\n\n" << std::flush; // Create new wells, polymer inflow controls. WellsManager wells(eclipseState , reportStepIdx , *grid->c_grid(), props->permeability()); boost::scoped_ptr<PolymerInflowInterface> polymer_inflow; if (use_wpolymer) { if (wells.c_wells() == 0) { OPM_THROW(std::runtime_error, "Cannot control polymer injection via WPOLYMER without wells."); } polymer_inflow.reset(new PolymerInflowFromDeck(deck, eclipseState, *wells.c_wells(), props->numCells(), simtimer.currentStepNum())); } else { polymer_inflow.reset(new PolymerInflowBasic(param.getDefault("poly_start_days", 300.0)*Opm::unit::day, param.getDefault("poly_end_days", 800.0)*Opm::unit::day, param.getDefault("poly_amount", poly_props.cMax()))); } // @@@ HACK: we should really make a new well state and // properly transfer old well state to it every report step, // since number of wells may change etc. if (reportStepIdx == 0) { well_state.init(wells.c_wells(), state); } // Create and run simulator. SimulatorCompressiblePolymer simulator(param, *grid->c_grid(), *props, poly_props, rock_comp->isActive() ? rock_comp.get() : 0, wells, *polymer_inflow, linsolver, grav); if (reportStepIdx == 0) { warnIfUnusedParams(param); } SimulatorReport epoch_rep = simulator.run(simtimer, state, well_state); // Update total timing report and remember step number. rep += epoch_rep; step = simtimer.currentStepNum(); } } std::cout << "\n\n================ End of simulation ===============\n\n"; rep.report(std::cout); } catch (const std::exception &e) { std::cerr << "Program threw an exception: " << e.what() << "\n"; throw; }
SimulatorReport SimulatorFullyImplicitCompressiblePolymer::Impl::run(SimulatorTimer& timer, PolymerBlackoilState& state) { WellStateFullyImplicitBlackoil prev_well_state; // Initialisation. std::vector<double> porevol; if (rock_comp_props_ && rock_comp_props_->isActive()) { computePorevolume(grid_, props_.porosity(), *rock_comp_props_, state.pressure(), porevol); } else { computePorevolume(grid_, props_.porosity(), porevol); } std::vector<double> initial_porevol = porevol; std::vector<double> polymer_inflow_c(grid_.number_of_cells); // Main simulation loop. Opm::time::StopWatch solver_timer; double stime = 0.0; Opm::time::StopWatch step_timer; Opm::time::StopWatch total_timer; total_timer.start(); std::string tstep_filename = output_dir_ + "/step_timing.txt"; std::ofstream tstep_os(tstep_filename.c_str()); //Main simulation loop. while (!timer.done()) { #if 0 double tot_injected[2] = { 0.0 }; double tot_produced[2] = { 0.0 }; Opm::Watercut watercut; watercut.push(0.0, 0.0, 0.0); std::vector<double> fractional_flows; std::vector<double> well_resflows_phase; if (wells_) { well_resflows_phase.resize((wells_->number_of_phases)*(wells_->number_of_wells), 0.0); } std::fstream tstep_os; if (output_) { std::string filename = output_dir_ + "/step_timing.param"; tstep_os.open(filename.c_str(), std::fstream::out | std::fstream::app); } #endif // Report timestep and (optionally) write state to disk. step_timer.start(); timer.report(std::cout); WellsManager wells_manager(eclipse_state_, timer.currentStepNum(), Opm::UgGridHelpers::numCells(grid_), Opm::UgGridHelpers::globalCell(grid_), Opm::UgGridHelpers::cartDims(grid_), Opm::UgGridHelpers::dimensions(grid_), Opm::UgGridHelpers::cell2Faces(grid_), Opm::UgGridHelpers::beginFaceCentroids(grid_), props_.permeability()); const Wells* wells = wells_manager.c_wells(); WellStateFullyImplicitBlackoil well_state; well_state.init(wells, state.blackoilState(), prev_well_state); //Compute polymer inflow. std::unique_ptr<PolymerInflowInterface> polymer_inflow_ptr; if (deck_->hasKeyword("WPOLYMER")) { if (wells_manager.c_wells() == 0) { OPM_THROW(std::runtime_error, "Cannot control polymer injection via WPOLYMER without wells."); } polymer_inflow_ptr.reset(new PolymerInflowFromDeck(deck_, eclipse_state_, *wells, Opm::UgGridHelpers::numCells(grid_), timer.currentStepNum())); } else { polymer_inflow_ptr.reset(new PolymerInflowBasic(0.0*Opm::unit::day, 1.0*Opm::unit::day, 0.0)); } std::vector<double> polymer_inflow_c(Opm::UgGridHelpers::numCells(grid_)); polymer_inflow_ptr->getInflowValues(timer.simulationTimeElapsed(), timer.simulationTimeElapsed() + timer.currentStepLength(), polymer_inflow_c); if (output_ && (timer.currentStepNum() % output_interval_ == 0)) { if (output_vtk_) { outputStateVtk(grid_, state, timer.currentStepNum(), output_dir_); } outputStateMatlab(grid_, state, timer.currentStepNum(), output_dir_); } if (output_) { if (timer.currentStepNum() == 0) { output_writer_.writeInit(timer); } output_writer_.writeTimeStep(timer, state.blackoilState(), well_state); } // Run solver. solver_timer.start(); FullyImplicitCompressiblePolymerSolver solver(grid_, props_, geo_, rock_comp_props_, polymer_props_, *wells_manager.c_wells(), linsolver_); solver.step(timer.currentStepLength(), state, well_state, polymer_inflow_c); // Stop timer and report. solver_timer.stop(); const double st = solver_timer.secsSinceStart(); std::cout << "Fully implicit solver took: " << st << " seconds." << std::endl; stime += st; // Update pore volumes if rock is compressible. if (rock_comp_props_ && rock_comp_props_->isActive()) { initial_porevol = porevol; computePorevolume(grid_, props_.porosity(), *rock_comp_props_, state.pressure(), porevol); } /* double injected[2] = { 0.0 }; double produced[2] = { 0.0 }; double polyinj = 0; double polyprod = 0; Opm::computeInjectedProduced(props_, polymer_props_, state, transport_src, polymer_inflow_c, timer.currentStepLength(), injected, produced, polyinj, polyprod); tot_injected[0] += injected[0]; tot_injected[1] += injected[1]; tot_produced[0] += produced[0]; tot_produced[1] += produced[1]; watercut.push(timer.simulationTimeElapsed() + timer.currentStepLength(), produced[0]/(produced[0] + produced[1]), tot_produced[0]/tot_porevol_init); std::cout.precision(5); const int width = 18; std::cout << "\nMass balance report.\n"; std::cout << " Injected reservoir volumes: " << std::setw(width) << injected[0] << std::setw(width) << injected[1] << std::endl; std::cout << " Produced reservoir volumes: " << std::setw(width) << produced[0] << std::setw(width) << produced[1] << std::endl; std::cout << " Total inj reservoir volumes: " << std::setw(width) << tot_injected[0] << std::setw(width) << tot_injected[1] << std::endl; std::cout << " Total prod reservoir volumes: " << std::setw(width) << tot_produced[0] << std::setw(width) << tot_produced[1] << std::endl; */ if (output_) { SimulatorReport step_report; step_report.pressure_time = st; step_report.total_time = step_timer.secsSinceStart(); step_report.reportParam(tstep_os); } ++timer; prev_well_state = well_state; } // Write final simulation state. if (output_) { if (output_vtk_) { outputStateVtk(grid_, state, timer.currentStepNum(), output_dir_); } outputStateMatlab(grid_, state, timer.currentStepNum(), output_dir_); output_writer_.writeTimeStep(timer, state.blackoilState(), prev_well_state); } total_timer.stop(); SimulatorReport report; report.pressure_time = stime; report.transport_time = 0.0; report.total_time = total_timer.secsSinceStart(); return report; }
/// @brief Computes injected and produced volumes of all phases, /// and injected and produced polymer mass - in the compressible case. /// Note 1: assumes that only the first phase is injected. /// Note 2: assumes that transport has been done with an /// implicit method, i.e. that the current state /// gives the mobilities used for the preceding timestep. /// @param[in] props fluid and rock properties. /// @param[in] polyprops polymer properties /// @param[in] state state variables (pressure, fluxes etc.) /// @param[in] transport_src if < 0: total reservoir volume outflow, /// if > 0: first phase *surface volume* inflow. /// @param[in] inj_c injected concentration by cell /// @param[in] dt timestep used /// @param[out] injected must point to a valid array with P elements, /// where P = s.size()/transport_src.size(). /// @param[out] produced must also point to a valid array with P elements. /// @param[out] polyinj injected mass of polymer /// @param[out] polyprod produced mass of polymer void computeInjectedProduced(const BlackoilPropertiesInterface& props, const Opm::PolymerProperties& polyprops, const PolymerBlackoilState& state, const std::vector<double>& transport_src, const std::vector<double>& inj_c, const double dt, double* injected, double* produced, double& polyinj, double& polyprod) { const int num_cells = transport_src.size(); if (props.numCells() != num_cells) { OPM_THROW(std::runtime_error, "Size of transport_src vector does not match number of cells in props."); } const int np = props.numPhases(); if (int(state.saturation().size()) != num_cells*np) { OPM_THROW(std::runtime_error, "Sizes of state vectors do not match number of cells."); } const std::vector<double>& press = state.pressure(); const std::vector<double>& temp = state.temperature(); const std::vector<double>& s = state.saturation(); const std::vector<double>& z = state.surfacevol(); const std::vector<double>& c = state.getCellData( state.CONCENTRATION ); const std::vector<double>& cmax = state.getCellData( state.CMAX ); std::fill(injected, injected + np, 0.0); std::fill(produced, produced + np, 0.0); polyinj = 0.0; polyprod = 0.0; std::vector<double> visc(np); std::vector<double> kr_cell(np); std::vector<double> mob(np); std::vector<double> A(np*np); std::vector<double> prod_resv_phase(np); std::vector<double> prod_surfvol(np); double mc; for (int cell = 0; cell < num_cells; ++cell) { if (transport_src[cell] > 0.0) { // Inflowing transport source is a surface volume flux // for the first phase. injected[0] += transport_src[cell]*dt; polyinj += transport_src[cell]*dt*inj_c[cell]; } else if (transport_src[cell] < 0.0) { // Outflowing transport source is a total reservoir // volume flux. const double flux = -transport_src[cell]*dt; const double* sat = &s[np*cell]; props.relperm(1, sat, &cell, &kr_cell[0], 0); props.viscosity(1, &press[cell], &temp[cell], &z[np*cell], &cell, &visc[0], 0); props.matrix(1, &press[cell], &temp[cell], &z[np*cell], &cell, &A[0], 0); polyprops.effectiveMobilities(c[cell], cmax[cell], &visc[0], &kr_cell[0], &mob[0]); double totmob = 0.0; for (int p = 0; p < np; ++p) { totmob += mob[p]; } std::fill(prod_surfvol.begin(), prod_surfvol.end(), 0.0); for (int p = 0; p < np; ++p) { prod_resv_phase[p] = (mob[p]/totmob)*flux; for (int q = 0; q < np; ++q) { prod_surfvol[q] += prod_resv_phase[p]*A[q + np*p]; } } for (int p = 0; p < np; ++p) { produced[p] += prod_surfvol[p]; } polyprops.computeMc(c[cell], mc); polyprod += produced[0]*mc; } } }
/// @brief Computes injected and produced volumes of all phases, /// and injected and produced polymer mass - in the compressible case. /// Note 1: assumes that only the first phase is injected. /// Note 2: assumes that transport has been done with an /// implicit method, i.e. that the current state /// gives the mobilities used for the preceding timestep. /// @param[in] props fluid and rock properties. /// @param[in] polyprops polymer properties /// @param[in] state state variables (pressure, fluxes etc.) /// @param[in] transport_src if < 0: total reservoir volume outflow, /// if > 0: first phase *surface volume* inflow. /// @param[in] inj_c injected concentration by cell /// @param[in] dt timestep used /// @param[out] injected must point to a valid array with P elements, /// where P = s.size()/transport_src.size(). /// @param[out] produced must also point to a valid array with P elements. /// @param[out] polyinj injected mass of polymer /// @param[out] polyprod produced mass of polymer void computeInjectedProduced(const BlackoilPropsAdInterface& props, const Opm::PolymerPropsAd& polymer_props, const PolymerBlackoilState& state, const std::vector<double>& transport_src, const std::vector<double>& inj_c, const double dt, double* injected, double* produced, double& polyinj, double& polyprod) { const int num_cells = transport_src.size(); if (props.numCells() != num_cells) { OPM_THROW(std::runtime_error, "Size of transport_src vector does not match number of cells in props."); } const int np = props.numPhases(); if (int(state.saturation().size()) != num_cells*np) { OPM_THROW(std::runtime_error, "Sizes of state vectors do not match number of cells."); } std::vector<int> cells(num_cells); const V p = Eigen::Map<const V>(&state.pressure()[0], num_cells, 1); const DataBlock s = Eigen::Map<const DataBlock>(&state.saturation()[0], num_cells, np); const V sw = s.col(0); const V so = s.col(1); const V c = Eigen::Map<const V>(&state.concentration()[0], num_cells, 1); const V cmax = Eigen::Map<const V>(&state.maxconcentration()[0], num_cells, 1); const V trans_src = Eigen::Map<const V>(&transport_src[0], num_cells, 1); V src = V::Constant(num_cells, -1.0); // negative is injec, positive is producer. for (int cell = 0; cell < num_cells; ++cell) { cells[cell] = cell; if(transport_src[cell] > 0.0) { src[cell] = 1.0; } } //Add PhasePresence make muOil() happy. std::vector<PhasePresence> phaseCondition(num_cells); for (int c = 0; c < num_cells; ++c) { phaseCondition[c] = PhasePresence(); phaseCondition[c].setFreeWater(); phaseCondition[c].setFreeOil(); } const Selector<double> src_selector(src); const V one = V::Constant(num_cells, 1.0); const V zero = V::Zero(num_cells); const std::vector<V> kr = props.relperm(sw, so, zero, cells); const V muw = props.muWat(p, cells); const V muo = props.muOil(p, zero, phaseCondition, cells); const V krw_eff = polymer_props.effectiveRelPerm(c, cmax, kr[0]); const V inv_muw_eff = polymer_props.effectiveInvWaterVisc(c, muw.data()); std::vector<V> mob(np); mob[0] = krw_eff * inv_muw_eff; mob[1] = kr[1] / muo; const V watmob_c = src_selector.select(mob[0], one); const V oilmob_c = src_selector.select(mob[1], zero); const V flux = trans_src * dt; const V totmob_c = watmob_c + oilmob_c; const V wat_src = flux * (watmob_c / totmob_c); const V oil_src = flux * (oilmob_c / totmob_c); const V mc = polymer_props.polymerWaterVelocityRatio(c); polyinj = 0.0; polyprod = 0.0; std::fill(injected, injected + np , 0.0); std::fill(produced, produced + np , 0.0); for (int cell = 0; cell < num_cells; ++cell) { if (wat_src[cell] < 0) { injected[0] += wat_src[cell]; polyinj += injected[0] * inj_c[cell]; } else { produced[0] += wat_src[cell]; produced[1] += oil_src[cell]; polyprod += produced[0] * mc[cell]; } } }
// ----------------- Main program ----------------- int main(int argc, char** argv) { using namespace Opm; std::cout << "\n================ Test program for weakly compressible two-phase flow with polymer ===============\n\n"; parameter::ParameterGroup param(argc, argv, false); std::cout << "--------------- Reading parameters ---------------" << std::endl; // If we have a "deck_filename", grid and props will be read from that. bool use_deck = param.has("deck_filename"); boost::scoped_ptr<EclipseGridParser> deck; boost::scoped_ptr<GridManager> grid; boost::scoped_ptr<BlackoilPropertiesInterface> props; boost::scoped_ptr<RockCompressibility> rock_comp; PolymerBlackoilState state; Opm::PolymerProperties poly_props; // bool check_well_controls = false; // int max_well_control_iterations = 0; double gravity[3] = { 0.0 }; if (use_deck) { std::string deck_filename = param.get<std::string>("deck_filename"); deck.reset(new EclipseGridParser(deck_filename)); // Grid init grid.reset(new GridManager(*deck)); // Rock and fluid init props.reset(new BlackoilPropertiesFromDeck(*deck, *grid->c_grid())); // check_well_controls = param.getDefault("check_well_controls", false); // max_well_control_iterations = param.getDefault("max_well_control_iterations", 10); // Rock compressibility. rock_comp.reset(new RockCompressibility(*deck)); // Gravity. gravity[2] = deck->hasField("NOGRAV") ? 0.0 : unit::gravity; // Init state variables (saturation and pressure). if (param.has("init_saturation")) { initStateBasic(*grid->c_grid(), *props, param, gravity[2], state); } else { initStateFromDeck(*grid->c_grid(), *props, *deck, gravity[2], state); } initBlackoilSurfvol(*grid->c_grid(), *props, state); // Init polymer properties. poly_props.readFromDeck(*deck); } else { // Grid init. const int nx = param.getDefault("nx", 100); const int ny = param.getDefault("ny", 100); const int nz = param.getDefault("nz", 1); const double dx = param.getDefault("dx", 1.0); const double dy = param.getDefault("dy", 1.0); const double dz = param.getDefault("dz", 1.0); grid.reset(new GridManager(nx, ny, nz, dx, dy, dz)); // Rock and fluid init. props.reset(new BlackoilPropertiesBasic(param, grid->c_grid()->dimensions, grid->c_grid()->number_of_cells)); // Rock compressibility. rock_comp.reset(new RockCompressibility(param)); // Gravity. gravity[2] = param.getDefault("gravity", 0.0); // Init state variables (saturation and pressure). initStateBasic(*grid->c_grid(), *props, param, gravity[2], state); initBlackoilSurfvol(*grid->c_grid(), *props, state); // Init Polymer state if (param.has("poly_init")) { double poly_init = param.getDefault("poly_init", 0.0); for (int cell = 0; cell < grid->c_grid()->number_of_cells; ++cell) { double smin[2], smax[2]; props->satRange(1, &cell, smin, smax); if (state.saturation()[2*cell] > 0.5*(smin[0] + smax[0])) { state.concentration()[cell] = poly_init; state.maxconcentration()[cell] = poly_init; } else { state.saturation()[2*cell + 0] = 0.; state.saturation()[2*cell + 1] = 1.; state.concentration()[cell] = 0.; state.maxconcentration()[cell] = 0.; } } } // Init polymer properties. // Setting defaults to provide a simple example case. double c_max = param.getDefault("c_max_limit", 5.0); double mix_param = param.getDefault("mix_param", 1.0); double rock_density = param.getDefault("rock_density", 1000.0); double dead_pore_vol = param.getDefault("dead_pore_vol", 0.15); double res_factor = param.getDefault("res_factor", 1.) ; // res_factor = 1 gives no change in permeability double c_max_ads = param.getDefault("c_max_ads", 1.); int ads_index = param.getDefault<int>("ads_index", Opm::PolymerProperties::NoDesorption); std::vector<double> c_vals_visc(2, -1e100); c_vals_visc[0] = 0.0; c_vals_visc[1] = 7.0; std::vector<double> visc_mult_vals(2, -1e100); visc_mult_vals[0] = 1.0; // poly_props.visc_mult_vals[1] = param.getDefault("c_max_viscmult", 30.0); visc_mult_vals[1] = 20.0; std::vector<double> c_vals_ads(3, -1e100); c_vals_ads[0] = 0.0; c_vals_ads[1] = 2.0; c_vals_ads[2] = 8.0; std::vector<double> ads_vals(3, -1e100); ads_vals[0] = 0.0; ads_vals[1] = 0.0015; ads_vals[2] = 0.0025; // ads_vals[1] = 0.0; // ads_vals[2] = 0.0; poly_props.set(c_max, mix_param, rock_density, dead_pore_vol, res_factor, c_max_ads, static_cast<Opm::PolymerProperties::AdsorptionBehaviour>(ads_index), c_vals_visc, visc_mult_vals, c_vals_ads, ads_vals); } bool use_gravity = (gravity[0] != 0.0 || gravity[1] != 0.0 || gravity[2] != 0.0); const double *grav = use_gravity ? &gravity[0] : 0; // Initialising src int num_cells = grid->c_grid()->number_of_cells; std::vector<double> src(num_cells, 0.0); if (use_deck) { // Do nothing, wells will be the driving force, not source terms. } else { // Compute pore volumes, in order to enable specifying injection rate // terms of total pore volume. std::vector<double> porevol; if (rock_comp->isActive()) { computePorevolume(*grid->c_grid(), props->porosity(), *rock_comp, state.pressure(), porevol); } else { computePorevolume(*grid->c_grid(), props->porosity(), porevol); } const double tot_porevol_init = std::accumulate(porevol.begin(), porevol.end(), 0.0); const double default_injection = use_gravity ? 0.0 : 0.1; const double flow_per_sec = param.getDefault<double>("injected_porevolumes_per_day", default_injection) *tot_porevol_init/unit::day; src[0] = flow_per_sec; src[num_cells - 1] = -flow_per_sec; } // Boundary conditions. FlowBCManager bcs; if (param.getDefault("use_pside", false)) { int pside = param.get<int>("pside"); double pside_pressure = param.get<double>("pside_pressure"); bcs.pressureSide(*grid->c_grid(), FlowBCManager::Side(pside), pside_pressure); } // Linear solver. LinearSolverFactory linsolver(param); // Write parameters used for later reference. bool output = param.getDefault("output", true); if (output) { std::string output_dir = param.getDefault("output_dir", std::string("output")); boost::filesystem::path fpath(output_dir); try { create_directories(fpath); } catch (...) { THROW("Creating directories failed: " << fpath); } param.writeParam(output_dir + "/simulation.param"); } std::cout << "\n\n================ Starting main simulation loop ===============\n" << " (number of epochs: " << (use_deck ? deck->numberOfEpochs() : 1) << ")\n\n" << std::flush; SimulatorReport rep; if (!use_deck) { // Simple simulation without a deck. PolymerInflowBasic polymer_inflow(param.getDefault("poly_start_days", 300.0)*Opm::unit::day, param.getDefault("poly_end_days", 800.0)*Opm::unit::day, param.getDefault("poly_amount", poly_props.cMax())); WellsManager wells; SimulatorCompressiblePolymer simulator(param, *grid->c_grid(), *props, poly_props, rock_comp->isActive() ? rock_comp.get() : 0, wells, polymer_inflow, src, bcs.c_bcs(), linsolver, grav); SimulatorTimer simtimer; simtimer.init(param); warnIfUnusedParams(param); WellState well_state; well_state.init(0, state); rep = simulator.run(simtimer, state, well_state); } else { // With a deck, we may have more epochs etc. WellState well_state; int step = 0; SimulatorTimer simtimer; // Use timer for last epoch to obtain total time. deck->setCurrentEpoch(deck->numberOfEpochs() - 1); simtimer.init(*deck); const double total_time = simtimer.totalTime(); // Check for WPOLYMER presence in last epoch to decide // polymer injection control type. const bool use_wpolymer = deck->hasField("WPOLYMER"); if (use_wpolymer) { if (param.has("poly_start_days")) { MESSAGE("Warning: Using WPOLYMER to control injection since it was found in deck. " "You seem to be trying to control it via parameter poly_start_days (etc.) as well."); } } for (int epoch = 0; epoch < deck->numberOfEpochs(); ++epoch) { // Set epoch index. deck->setCurrentEpoch(epoch); // Update the timer. if (deck->hasField("TSTEP")) { simtimer.init(*deck); } else { if (epoch != 0) { THROW("No TSTEP in deck for epoch " << epoch); } simtimer.init(param); } simtimer.setCurrentStepNum(step); simtimer.setTotalTime(total_time); // Report on start of epoch. std::cout << "\n\n-------------- Starting epoch " << epoch << " --------------" << "\n (number of steps: " << simtimer.numSteps() - step << ")\n\n" << std::flush; // Create new wells, polymer inflow controls. WellsManager wells(*deck, *grid->c_grid(), props->permeability()); boost::scoped_ptr<PolymerInflowInterface> polymer_inflow; if (use_wpolymer) { if (wells.c_wells() == 0) { THROW("Cannot control polymer injection via WPOLYMER without wells."); } polymer_inflow.reset(new PolymerInflowFromDeck(*deck, *wells.c_wells(), props->numCells())); } else { polymer_inflow.reset(new PolymerInflowBasic(param.getDefault("poly_start_days", 300.0)*Opm::unit::day, param.getDefault("poly_end_days", 800.0)*Opm::unit::day, param.getDefault("poly_amount", poly_props.cMax()))); } // @@@ HACK: we should really make a new well state and // properly transfer old well state to it every epoch, // since number of wells may change etc. if (epoch == 0) { well_state.init(wells.c_wells(), state); } // Create and run simulator. SimulatorCompressiblePolymer simulator(param, *grid->c_grid(), *props, poly_props, rock_comp->isActive() ? rock_comp.get() : 0, wells, *polymer_inflow, src, bcs.c_bcs(), linsolver, grav); if (epoch == 0) { warnIfUnusedParams(param); } SimulatorReport epoch_rep = simulator.run(simtimer, state, well_state); // Update total timing report and remember step number. rep += epoch_rep; step = simtimer.currentStepNum(); } } std::cout << "\n\n================ End of simulation ===============\n\n"; rep.report(std::cout); }