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

Merge remote-tracking branch 'upstream/master'

Browse Source
This commit is contained in:
Kai Bao 2014-05-07 14:31:07 +02:00
commit 176086c61e
17 changed files with 133 additions and 674 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CMakeLists_files.cmake
View File

@ -50,12 +50,6 @@ list (APPEND TEST_SOURCE_FILES
tests/test_welldensitysegmented.cpp tests/test_welldensitysegmented.cpp
) )
if (INCLUDE_NON_PUBLIC_TESTS)
list (APPEND TEST_SOURCE_FILES
tests/integration_tests/sim_fibo_ad_test.cpp
)
endif()
list (APPEND TEST_DATA_FILES list (APPEND TEST_DATA_FILES
tests/fluid.data tests/fluid.data
) )

74
examples/sim_2p_comp_ad.cpp
View File

@ -51,9 +51,9 @@
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp> #include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
#include <memory>
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
#include <vector> #include <vector>
@ -92,10 +92,10 @@ try
// The current code for the non-deck case fails for unknown reasons. // The current code for the non-deck case fails for unknown reasons.
OPM_THROW(std::runtime_error, "This simulator cannot run without a deck with wells. Use deck_filename to specify deck."); OPM_THROW(std::runtime_error, "This simulator cannot run without a deck with wells. Use deck_filename to specify deck.");
} }
boost::scoped_ptr<EclipseGridParser> deck; Opm::DeckConstPtr deck;
boost::scoped_ptr<GridManager> grid; std::unique_ptr<GridManager> grid;
boost::scoped_ptr<BlackoilPropertiesInterface> props; std::unique_ptr<BlackoilPropertiesInterface> props;
boost::scoped_ptr<RockCompressibility> rock_comp; std::unique_ptr<RockCompressibility> rock_comp;
EclipseStateConstPtr eclipseState; EclipseStateConstPtr eclipseState;
BlackoilState state; BlackoilState state;
// bool check_well_controls = false; // bool check_well_controls = false;
@ -103,27 +103,25 @@ try
double gravity[3] = { 0.0 }; double gravity[3] = { 0.0 };
if (use_deck) { if (use_deck) {
std::string deck_filename = param.get<std::string>("deck_filename"); std::string deck_filename = param.get<std::string>("deck_filename");
deck.reset(new EclipseGridParser(deck_filename)); Opm::ParserPtr parser(new Opm::Parser());
Opm::ParserPtr newParser(new Opm::Parser() ); Opm::DeckConstPtr deck = parser->parseFile( deck_filename );
Opm::DeckConstPtr newParserDeck = newParser->parseFile( deck_filename ); eclipseState.reset(new EclipseState(deck));
eclipseState.reset( new EclipseState(newParserDeck ));
// Grid init // Grid init
grid.reset(new GridManager(newParserDeck)); grid.reset(new GridManager(deck));
// Rock and fluid init // Rock and fluid init
props.reset(new BlackoilPropertiesFromDeck(newParserDeck, *grid->c_grid(), param)); props.reset(new BlackoilPropertiesFromDeck(deck, *grid->c_grid(), param));
// check_well_controls = param.getDefault("check_well_controls", false); // check_well_controls = param.getDefault("check_well_controls", false);
// max_well_control_iterations = param.getDefault("max_well_control_iterations", 10); // max_well_control_iterations = param.getDefault("max_well_control_iterations", 10);
// Rock compressibility. // Rock compressibility.
rock_comp.reset(new RockCompressibility(newParserDeck)); rock_comp.reset(new RockCompressibility(deck));
// Gravity. // Gravity.
gravity[2] = deck->hasField("NOGRAV") ? 0.0 : unit::gravity; gravity[2] = deck->hasKeyword("NOGRAV") ? 0.0 : unit::gravity;
// Init state variables (saturation and pressure). // Init state variables (saturation and pressure).
if (param.has("init_saturation")) { if (param.has("init_saturation")) {
initStateBasic(*grid->c_grid(), *props, param, gravity[2], state); initStateBasic(*grid->c_grid(), *props, param, gravity[2], state);
} else { } else {
initStateFromDeck(*grid->c_grid(), *props, *deck, gravity[2], state); initStateFromDeck(*grid->c_grid(), *props, deck, gravity[2], state);
} }
initBlackoilSurfvol(*grid->c_grid(), *props, state); initBlackoilSurfvol(*grid->c_grid(), *props, state);
} else { } else {
@ -207,10 +205,7 @@ try
param.writeParam(output_dir + "/simulation.param"); param.writeParam(output_dir + "/simulation.param");
} }
std::cout << "\n\n================ Starting main simulation loop ===============\n";
std::cout << "\n\n================ Starting main simulation loop ===============\n"
<< " (number of epochs: "
<< (use_deck ? deck->numberOfEpochs() : 1) << ")\n\n" << std::flush;
SimulatorReport rep; SimulatorReport rep;
if (!use_deck) { if (!use_deck) {
@ -232,42 +227,26 @@ try
} else { } else {
// With a deck, we may have more epochs etc. // With a deck, we may have more epochs etc.
WellState well_state; WellState well_state;
int step = 0; Opm::TimeMapPtr timeMap(new Opm::TimeMap(deck));
SimulatorTimer simtimer; 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();
for (int epoch = 0; epoch < deck->numberOfEpochs(); ++epoch) {
// Set epoch index.
deck->setCurrentEpoch(epoch);
// Update the timer. for (size_t reportStepIdx = 0; reportStepIdx < timeMap->numTimesteps(); ++reportStepIdx) {
if (deck->hasField("TSTEP")) { // Report on start of report step.
simtimer.init(*deck); std::cout << "\n\n-------------- Starting report step " << reportStepIdx << " --------------"
} else { << "\n (number of steps left: "
if (epoch != 0) { << timeMap->numTimesteps() - reportStepIdx << ")\n\n" << std::flush;
OPM_THROW(std::runtime_error, "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, well_state // Create new wells, well_state
WellsManager wells(eclipseState , epoch , *grid->c_grid(), props->permeability()); WellsManager wells(eclipseState, reportStepIdx, *grid->c_grid(), props->permeability());
// @@@ HACK: we should really make a new well state and // @@@ HACK: we should really make a new well state and
// properly transfer old well state to it every epoch, // properly transfer old well state to it every report step,
// since number of wells may change etc. // since number of wells may change etc.
if (epoch == 0) { if (reportStepIdx == 0) {
well_state.init(wells.c_wells(), state); well_state.init(wells.c_wells(), state);
} }
simtimer.setCurrentStepNum(reportStepIdx);
// Create and run simulator. // Create and run simulator.
SimulatorCompressibleAd simulator(param, SimulatorCompressibleAd simulator(param,
*grid->c_grid(), *grid->c_grid(),
@ -276,7 +255,7 @@ try
wells, wells,
linsolver, linsolver,
grav); grav);
if (epoch == 0) { if (reportStepIdx == 0) {
warnIfUnusedParams(param); warnIfUnusedParams(param);
} }
SimulatorReport epoch_rep = simulator.run(simtimer, state, well_state); SimulatorReport epoch_rep = simulator.run(simtimer, state, well_state);
@ -285,7 +264,6 @@ try
} }
// Update total timing report and remember step number. // Update total timing report and remember step number.
rep += epoch_rep; rep += epoch_rep;
step = simtimer.currentStepNum();
} }
} }

74
examples/sim_2p_incomp_ad.cpp
View File

@ -49,9 +49,9 @@
#include <opm/parser/eclipse/Parser/Parser.hpp> #include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp> #include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
#include <memory>
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
#include <vector> #include <vector>
@ -99,10 +99,11 @@ try
// If we have a "deck_filename", grid and props will be read from that. // If we have a "deck_filename", grid and props will be read from that.
bool use_deck = param.has("deck_filename"); bool use_deck = param.has("deck_filename");
boost::scoped_ptr<EclipseGridParser> deck; Opm::ParserPtr parser(new Opm::Parser());
boost::scoped_ptr<GridManager> grid; Opm::DeckConstPtr deck;
boost::scoped_ptr<IncompPropertiesInterface> props; std::unique_ptr<GridManager> grid;
boost::scoped_ptr<RockCompressibility> rock_comp; std::unique_ptr<IncompPropertiesInterface> props;
std::unique_ptr<RockCompressibility> rock_comp;
EclipseStateConstPtr eclipseState; EclipseStateConstPtr eclipseState;
TwophaseState state; TwophaseState state;
// bool check_well_controls = false; // bool check_well_controls = false;
@ -110,25 +111,24 @@ try
double gravity[3] = { 0.0 }; double gravity[3] = { 0.0 };
if (use_deck) { if (use_deck) {
std::string deck_filename = param.get<std::string>("deck_filename"); std::string deck_filename = param.get<std::string>("deck_filename");
ParserPtr parser(new Opm::Parser()); deck = parser->parseFile(deck_filename);
eclipseState.reset( new EclipseState(parser->parseFile(deck_filename))); eclipseState.reset(new EclipseState(deck));
deck.reset(new EclipseGridParser(deck_filename));
// Grid init // Grid init
grid.reset(new GridManager(*deck)); grid.reset(new GridManager(deck));
// Rock and fluid init // Rock and fluid init
props.reset(new IncompPropertiesFromDeck(*deck, *grid->c_grid())); props.reset(new IncompPropertiesFromDeck(deck, *grid->c_grid()));
// check_well_controls = param.getDefault("check_well_controls", false); // check_well_controls = param.getDefault("check_well_controls", false);
// max_well_control_iterations = param.getDefault("max_well_control_iterations", 10); // max_well_control_iterations = param.getDefault("max_well_control_iterations", 10);
// Rock compressibility. // Rock compressibility.
rock_comp.reset(new RockCompressibility(*deck)); rock_comp.reset(new RockCompressibility(deck));
// Gravity. // Gravity.
gravity[2] = deck->hasField("NOGRAV") ? 0.0 : unit::gravity; gravity[2] = deck->hasKeyword("NOGRAV") ? 0.0 : unit::gravity;
// Init state variables (saturation and pressure). // Init state variables (saturation and pressure).
if (param.has("init_saturation")) { if (param.has("init_saturation")) {
initStateBasic(*grid->c_grid(), *props, param, gravity[2], state); initStateBasic(*grid->c_grid(), *props, param, gravity[2], state);
} else { } else {
initStateFromDeck(*grid->c_grid(), *props, *deck, gravity[2], state); initStateFromDeck(*grid->c_grid(), *props, deck, gravity[2], state);
} }
} else { } else {
// Grid init. // Grid init.
@ -215,9 +215,7 @@ try
} }
std::cout << "\n\n================ Starting main simulation loop ===============\n" std::cout << "\n\n================ Starting main simulation loop ===============\n";
<< " (number of epochs: "
<< (use_deck ? deck->numberOfEpochs() : 1) << ")\n\n" << std::flush;
SimulatorReport rep; SimulatorReport rep;
if (!use_deck) { if (!use_deck) {
@ -239,44 +237,27 @@ try
well_state.init(0, state); well_state.init(0, state);
rep = simulator.run(simtimer, state, well_state); rep = simulator.run(simtimer, state, well_state);
} else { } else {
// With a deck, we may have more epochs etc. // With a deck, we may have more report steps etc.
WellState well_state; WellState well_state;
int step = 0; Opm::TimeMapPtr timeMap(new Opm::TimeMap(deck));
SimulatorTimer simtimer; SimulatorTimer simtimer;
// Use timer for last epoch to obtain total time. for (size_t reportStepIdx = 0; reportStepIdx < timeMap->numTimesteps(); ++reportStepIdx) {
deck->setCurrentEpoch(deck->numberOfEpochs() - 1); // Report on start of report step.
simtimer.init(*deck); std::cout << "\n\n-------------- Starting report step " << reportStepIdx << " --------------"
const double total_time = simtimer.totalTime(); << "\n (number of steps left: "
for (int epoch = 0; epoch < deck->numberOfEpochs(); ++epoch) { << timeMap->numTimesteps() - reportStepIdx << ")\n\n" << std::flush;
// Set epoch index.
deck->setCurrentEpoch(epoch);
// Update the timer.
if (deck->hasField("TSTEP")) {
simtimer.init(*deck);
} else {
if (epoch != 0) {
OPM_THROW(std::runtime_error, "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, well_state // Create new wells, well_state
WellsManager wells(eclipseState , epoch , *grid->c_grid(), props->permeability()); WellsManager wells(eclipseState , reportStepIdx , *grid->c_grid(), props->permeability());
// @@@ HACK: we should really make a new well state and // @@@ HACK: we should really make a new well state and
// properly transfer old well state to it every epoch, // properly transfer old well state to it every report step,
// since number of wells may change etc. // since number of wells may change etc.
if (epoch == 0) { if (reportStepIdx == 0) {
well_state.init(wells.c_wells(), state); well_state.init(wells.c_wells(), state);
} }
simtimer.setCurrentStepNum(reportStepIdx);
// Create and run simulator. // Create and run simulator.
SimulatorIncompTwophaseAd simulator(param, SimulatorIncompTwophaseAd simulator(param,
*grid->c_grid(), *grid->c_grid(),
@ -287,7 +268,7 @@ try
bcs.c_bcs(), bcs.c_bcs(),
linsolver, linsolver,
grav); grav);
if (epoch == 0) { if (reportStepIdx == 0) {
warnIfUnusedParams(param); warnIfUnusedParams(param);
} }
SimulatorReport epoch_rep = simulator.run(simtimer, state, well_state); SimulatorReport epoch_rep = simulator.run(simtimer, state, well_state);
@ -296,7 +277,6 @@ try
} }
// Update total timing report and remember step number. // Update total timing report and remember step number.
rep += epoch_rep; rep += epoch_rep;
step = simtimer.currentStepNum();
} }
} }

18
examples/sim_fibo_ad.cpp
View File

@ -101,24 +101,24 @@ try
std::string deck_filename = param.get<std::string>("deck_filename"); std::string deck_filename = param.get<std::string>("deck_filename");
Opm::ParserPtr newParser(new Opm::Parser() ); Opm::ParserPtr newParser(new Opm::Parser() );
Opm::DeckConstPtr newParserDeck = newParser->parseFile( deck_filename ); Opm::DeckConstPtr deck = newParser->parseFile( deck_filename );
std::shared_ptr<EclipseState> eclipseState(new EclipseState(newParserDeck)); std::shared_ptr<EclipseState> eclipseState(new EclipseState(deck));
// Grid init // Grid init
grid.reset(new GridManager(eclipseState->getEclipseGrid())); grid.reset(new GridManager(eclipseState->getEclipseGrid()));
Opm::EclipseWriter outputWriter(param, newParserDeck, share_obj(*grid->c_grid())); Opm::EclipseWriter outputWriter(param, deck, share_obj(*grid->c_grid()));
// Rock and fluid init // Rock and fluid init
props.reset(new BlackoilPropertiesFromDeck(newParserDeck, *grid->c_grid(), param)); props.reset(new BlackoilPropertiesFromDeck(deck, *grid->c_grid(), param));
new_props.reset(new BlackoilPropsAdFromDeck(newParserDeck, *grid->c_grid())); new_props.reset(new BlackoilPropsAdFromDeck(deck, *grid->c_grid()));
// check_well_controls = param.getDefault("check_well_controls", false); // check_well_controls = param.getDefault("check_well_controls", false);
// max_well_control_iterations = param.getDefault("max_well_control_iterations", 10); // max_well_control_iterations = param.getDefault("max_well_control_iterations", 10);
// Rock compressibility. // Rock compressibility.
rock_comp.reset(new RockCompressibility(newParserDeck)); rock_comp.reset(new RockCompressibility(deck));
// Gravity. // Gravity.
gravity[2] = newParserDeck->hasKeyword("NOGRAV") ? 0.0 : unit::gravity; gravity[2] = deck->hasKeyword("NOGRAV") ? 0.0 : unit::gravity;
// Init state variables (saturation and pressure). // Init state variables (saturation and pressure).
if (param.has("init_saturation")) { if (param.has("init_saturation")) {
@ -135,7 +135,7 @@ try
} }
} }
} else { } else {
initBlackoilStateFromDeck(*grid->c_grid(), *props, newParserDeck, gravity[2], state); initBlackoilStateFromDeck(*grid->c_grid(), *props, deck, gravity[2], state);
} }
bool use_gravity = (gravity[0] != 0.0 || gravity[1] != 0.0 || gravity[2] != 0.0); bool use_gravity = (gravity[0] != 0.0 || gravity[1] != 0.0 || gravity[2] != 0.0);
@ -172,7 +172,7 @@ try
<< std::flush; << std::flush;
WellStateFullyImplicitBlackoil well_state; WellStateFullyImplicitBlackoil well_state;
Opm::TimeMapPtr timeMap(new Opm::TimeMap(newParserDeck)); Opm::TimeMapPtr timeMap(new Opm::TimeMap(deck));
SimulatorTimer simtimer; SimulatorTimer simtimer;
// initialize variables // initialize variables

20
examples/sim_fibo_ad_cp.cpp
View File

@ -129,13 +129,13 @@ try
std::string deck_filename = param.get<std::string>("deck_filename"); std::string deck_filename = param.get<std::string>("deck_filename");
Opm::ParserPtr newParser(new Opm::Parser() ); Opm::ParserPtr newParser(new Opm::Parser() );
Opm::DeckConstPtr newParserDeck = newParser->parseFile( deck_filename ); Opm::DeckConstPtr deck = newParser->parseFile( deck_filename );
// Grid init // Grid init
grid.reset(new Dune::CpGrid()); grid.reset(new Dune::CpGrid());
{ {
grdecl g = {}; grdecl g = {};
GridManager::createGrdecl(newParserDeck, g); GridManager::createGrdecl(deck, g);
grid->processEclipseFormat(g, 2e-12, false); grid->processEclipseFormat(g, 2e-12, false);
@ -143,26 +143,26 @@ try
} }
Opm::EclipseWriter outputWriter(param, newParserDeck, Opm::EclipseWriter outputWriter(param, deck,
Opm::UgGridHelpers::numCells(*grid), Opm::UgGridHelpers::numCells(*grid),
Opm::UgGridHelpers::globalCell(*grid), Opm::UgGridHelpers::globalCell(*grid),
Opm::UgGridHelpers::cartDims(*grid), Opm::UgGridHelpers::cartDims(*grid),
Opm::UgGridHelpers::dimensions(*grid)); Opm::UgGridHelpers::dimensions(*grid));
// Rock and fluid init // Rock and fluid init
props.reset(new BlackoilPropertiesFromDeck(newParserDeck, Opm::UgGridHelpers::numCells(*grid), props.reset(new BlackoilPropertiesFromDeck(deck, Opm::UgGridHelpers::numCells(*grid),
Opm::UgGridHelpers::globalCell(*grid), Opm::UgGridHelpers::globalCell(*grid),
Opm::UgGridHelpers::cartDims(*grid), Opm::UgGridHelpers::cartDims(*grid),
Opm::UgGridHelpers::beginCellCentroids(*grid), Opm::UgGridHelpers::beginCellCentroids(*grid),
Opm::UgGridHelpers::dimensions(*grid), param)); Opm::UgGridHelpers::dimensions(*grid), param));
new_props.reset(new BlackoilPropsAdFromDeck(newParserDeck, *grid)); new_props.reset(new BlackoilPropsAdFromDeck(deck, *grid));
// check_well_controls = param.getDefault("check_well_controls", false); // check_well_controls = param.getDefault("check_well_controls", false);
// max_well_control_iterations = param.getDefault("max_well_control_iterations", 10); // max_well_control_iterations = param.getDefault("max_well_control_iterations", 10);
// Rock compressibility. // Rock compressibility.
rock_comp.reset(new RockCompressibility(newParserDeck)); rock_comp.reset(new RockCompressibility(deck));
// Gravity. // Gravity.
gravity[2] = newParserDeck->hasKeyword("NOGRAV") ? 0.0 : unit::gravity; gravity[2] = deck->hasKeyword("NOGRAV") ? 0.0 : unit::gravity;
// Init state variables (saturation and pressure). // Init state variables (saturation and pressure).
if (param.has("init_saturation")) { if (param.has("init_saturation")) {
@ -188,7 +188,7 @@ try
grid->numFaces(), AutoDiffGrid::faceCells(*grid), grid->numFaces(), AutoDiffGrid::faceCells(*grid),
grid->beginFaceCentroids(), grid->beginFaceCentroids(),
grid->beginCellCentroids(), Dune::CpGrid::dimension, grid->beginCellCentroids(), Dune::CpGrid::dimension,
*props, newParserDeck, gravity[2], state); *props, deck, gravity[2], state);
} }
bool use_gravity = (gravity[0] != 0.0 || gravity[1] != 0.0 || gravity[2] != 0.0); bool use_gravity = (gravity[0] != 0.0 || gravity[1] != 0.0 || gravity[2] != 0.0);
@ -225,9 +225,9 @@ try
<< std::flush; << std::flush;
WellStateFullyImplicitBlackoil well_state; WellStateFullyImplicitBlackoil well_state;
Opm::TimeMapPtr timeMap(new Opm::TimeMap(newParserDeck)); Opm::TimeMapPtr timeMap(new Opm::TimeMap(deck));
SimulatorTimer simtimer; SimulatorTimer simtimer;
std::shared_ptr<EclipseState> eclipseState(new EclipseState(newParserDeck)); std::shared_ptr<EclipseState> eclipseState(new EclipseState(deck));
// initialize variables // initialize variables
simtimer.init(timeMap); simtimer.init(timeMap);

9
examples/test_implicit_ad.cpp
View File

@ -41,17 +41,16 @@
#include <opm/core/simulator/BlackoilState.hpp> #include <opm/core/simulator/BlackoilState.hpp>
#include <opm/core/simulator/initState.hpp> #include <opm/core/simulator/initState.hpp>
#include <boost/shared_ptr.hpp> #include <memory>
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
namespace { namespace {
boost::shared_ptr<Wells> std::shared_ptr<Wells>
createWellConfig() createWellConfig()
{ {
boost::shared_ptr<Wells> wells(create_wells(2, 2, 2), std::shared_ptr<Wells> wells(create_wells(2, 2, 2),
destroy_wells); destroy_wells);
const double inj_frac[] = { 1.0, 0.0 }; const double inj_frac[] = { 1.0, 0.0 };
@ -98,7 +97,7 @@ try
const Opm::BlackoilPropertiesBasic props0(param, 2, nc); const Opm::BlackoilPropertiesBasic props0(param, 2, nc);
const Opm::BlackoilPropsAd props(props0); const Opm::BlackoilPropsAd props(props0);
boost::shared_ptr<Wells> wells = createWellConfig(); std::shared_ptr<Wells> wells = createWellConfig();
double grav[] = { 0.0, 0.0 }; double grav[] = { 0.0, 0.0 };
Opm::DerivedGeology geo(*g, props, grav); Opm::DerivedGeology geo(*g, props, grav);

176
opm/autodiff/BlackoilPropsAdFromDeck.cpp
View File

@ -33,8 +33,10 @@
#include <opm/core/utility/Units.hpp> #include <opm/core/utility/Units.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp> #include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Utility/PvdoTable.hpp> #include <opm/parser/eclipse/Utility/PvtoTable.hpp>
#include <opm/parser/eclipse/Utility/PvtgTable.hpp> #include <opm/parser/eclipse/Utility/PvtgTable.hpp>
#include <opm/parser/eclipse/Utility/PvtwTable.hpp>
#include <opm/parser/eclipse/Utility/PvdoTable.hpp>
#include <opm/parser/eclipse/Utility/PvcdoTable.hpp> #include <opm/parser/eclipse/Utility/PvcdoTable.hpp>
namespace Opm namespace Opm
@ -48,7 +50,7 @@ namespace Opm
Vapour = BlackoilPhases::Vapour }; Vapour = BlackoilPhases::Vapour };
/// Constructor wrapping an opm-core black oil interface. /// Constructor wrapping an opm-core black oil interface.
BlackoilPropsAdFromDeck::BlackoilPropsAdFromDeck(const EclipseGridParser& deck, BlackoilPropsAdFromDeck::BlackoilPropsAdFromDeck(Opm::DeckConstPtr deck,
const UnstructuredGrid& grid, const UnstructuredGrid& grid,
const bool init_rock) const bool init_rock)
{ {
@ -56,19 +58,9 @@ namespace Opm
grid.cell_centroids, grid.dimensions, init_rock); grid.cell_centroids, grid.dimensions, init_rock);
} }
/// Constructor wrapping an opm-core black oil interface.
BlackoilPropsAdFromDeck::BlackoilPropsAdFromDeck(Opm::DeckConstPtr newParserDeck,
const UnstructuredGrid& grid,
const bool init_rock)
{
init(newParserDeck, grid.number_of_cells, grid.global_cell, grid.cartdims,
grid.cell_centroids, grid.dimensions, init_rock);
}
#ifdef HAVE_DUNE_CORNERPOINT #ifdef HAVE_DUNE_CORNERPOINT
/// Constructor wrapping an opm-core black oil interface. /// Constructor wrapping an opm-core black oil interface.
BlackoilPropsAdFromDeck::BlackoilPropsAdFromDeck(const EclipseGridParser& deck, BlackoilPropsAdFromDeck::BlackoilPropsAdFromDeck(Opm::DeckConstPtr deck,
const Dune::CpGrid& grid, const Dune::CpGrid& grid,
const bool init_rock ) const bool init_rock )
{ {
@ -76,141 +68,30 @@ namespace Opm
static_cast<const int*>(&grid.logicalCartesianSize()[0]), static_cast<const int*>(&grid.logicalCartesianSize()[0]),
grid.beginCellCentroids(), Dune::CpGrid::dimension, init_rock); grid.beginCellCentroids(), Dune::CpGrid::dimension, init_rock);
} }
/// Constructor wrapping an opm-core black oil interface.
BlackoilPropsAdFromDeck::BlackoilPropsAdFromDeck(Opm::DeckConstPtr newParserDeck,
const Dune::CpGrid& grid,
const bool init_rock )
{
init(newParserDeck, grid.numCells(), static_cast<const int*>(&grid.globalCell()[0]),
static_cast<const int*>(&grid.logicalCartesianSize()[0]),
grid.beginCellCentroids(), Dune::CpGrid::dimension, init_rock);
}
#endif #endif
/// Constructor wrapping an opm-core black oil interface. /// Initializes the properties.
template<class T> template <class CentroidIterator>
BlackoilPropsAdFromDeck::BlackoilPropsAdFromDeck(Opm::DeckConstPtr newParserDeck, void BlackoilPropsAdFromDeck::init(Opm::DeckConstPtr deck,
int number_of_cells,
const int* global_cell,
const int* cart_dims,
T begin_cell_centroids,
int dimensions,
const bool init_rock)
{
init(newParserDeck, number_of_cells, global_cell, cart_dims, begin_cell_centroids,
dimensions, init_rock);
}
template<class T>
void BlackoilPropsAdFromDeck::init(const EclipseGridParser& deck,
int number_of_cells, int number_of_cells,
const int* global_cell, const int* global_cell,
const int* cart_dims, const int* cart_dims,
T begin_cell_centroids, const CentroidIterator& begin_cell_centroids,
int dimensions, int dimension,
const bool init_rock) const bool init_rock)
{ {
if (init_rock){ if (init_rock){
rock_.init(deck, number_of_cells, global_cell, cart_dims); rock_.init(deck, number_of_cells, global_cell, cart_dims);
} }
const int samples = 0; const int samples = 0;
const int region_number = 0; const int region_number = 0;
phase_usage_ = phaseUsageFromDeck(deck); phase_usage_ = phaseUsageFromDeck(deck);
// Surface densities. Accounting for different orders in eclipse and our code. // Surface densities. Accounting for different orders in eclipse and our code.
if (deck.hasField("DENSITY")) { if (deck->hasKeyword("DENSITY")) {
const std::vector<double>& d = deck.getDENSITY().densities_[region_number]; const auto keyword = deck->getKeyword("DENSITY");
enum { ECL_oil = 0, ECL_water = 1, ECL_gas = 2 };
if (phase_usage_.phase_used[Aqua]) {
densities_[phase_usage_.phase_pos[Aqua]] = d[ECL_water];
}
if (phase_usage_.phase_used[Vapour]) {
densities_[phase_usage_.phase_pos[Vapour]] = d[ECL_gas];
}
if (phase_usage_.phase_used[Liquid]) {
densities_[phase_usage_.phase_pos[Liquid]] = d[ECL_oil];
}
} else {
OPM_THROW(std::runtime_error, "Input is missing DENSITY\n");
}
// Set the properties.
props_.resize(phase_usage_.num_phases);
// Water PVT
if (phase_usage_.phase_used[Aqua]) {
if (deck.hasField("PVTW")) {
props_[phase_usage_.phase_pos[Aqua]].reset(new SinglePvtConstCompr(deck.getPVTW().pvtw_));
} else {
// Eclipse 100 default.
props_[phase_usage_.phase_pos[Aqua]].reset(new SinglePvtConstCompr(0.5*Opm::prefix::centi*Opm::unit::Poise));
}
}
// Oil PVT
if (phase_usage_.phase_used[Liquid]) {
if (deck.hasField("PVDO")) {
if (samples > 0) {
props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtDeadSpline(deck.getPVDO().pvdo_, samples));
} else {
props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtDead(deck.getPVDO().pvdo_));
}
} else if (deck.hasField("PVTO")) {
props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtLiveOil(deck.getPVTO().pvto_));
} else if (deck.hasField("PVCDO")) {
props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtConstCompr(deck.getPVCDO().pvcdo_));
} else {
OPM_THROW(std::runtime_error, "Input is missing PVDO, PVTO or PVCDO\n");
}
}
// Gas PVT
if (phase_usage_.phase_used[Vapour]) {
if (deck.hasField("PVDG")) {
if (samples > 0) {
props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtDeadSpline(deck.getPVDG().pvdg_, samples));
} else {
props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtDead(deck.getPVDG().pvdg_));
}
} else if (deck.hasField("PVTG")) {
props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtLiveGas(deck.getPVTG().pvtg_));
} else {
OPM_THROW(std::runtime_error, "Input is missing PVDG or PVTG\n");
}
}
SaturationPropsFromDeck<SatFuncGwsegNonuniform>* ptr
= new SaturationPropsFromDeck<SatFuncGwsegNonuniform>();
satprops_.reset(ptr);
ptr->init(deck, number_of_cells, global_cell, begin_cell_centroids, dimensions, -1);
if (phase_usage_.num_phases != satprops_->numPhases()) {
OPM_THROW(std::runtime_error, "BlackoilPropsAdFromDeck::BlackoilPropsAdFromDeck() - "
"Inconsistent number of phases in pvt data (" << phase_usage_.num_phases
<< ") and saturation-dependent function data (" << satprops_->numPhases() << ").");
}
}
template<class T>
void BlackoilPropsAdFromDeck::init(Opm::DeckConstPtr newParserDeck,
int number_of_cells,
const int* global_cell,
const int* cart_dims,
T begin_cell_centroids,
int dimensions,
const bool init_rock)
{
if (init_rock){
rock_.init(newParserDeck, number_of_cells, global_cell, cart_dims);
}
const int samples = 0;
const int region_number = 0;
phase_usage_ = phaseUsageFromDeck(newParserDeck);
// Surface densities. Accounting for different orders in eclipse and our code.
if (newParserDeck->hasKeyword("DENSITY")) {
const auto keyword = newParserDeck->getKeyword("DENSITY");
const auto record = keyword->getRecord(region_number); const auto record = keyword->getRecord(region_number);
enum { ECL_oil = 0, ECL_water = 1, ECL_gas = 2 }; enum { ECL_oil = 0, ECL_water = 1, ECL_gas = 2 };
if (phase_usage_.phase_used[Aqua]) { if (phase_usage_.phase_used[Aqua]) {
@ -230,8 +111,8 @@ namespace Opm
props_.resize(phase_usage_.num_phases); props_.resize(phase_usage_.num_phases);
// Water PVT // Water PVT
if (phase_usage_.phase_used[Aqua]) { if (phase_usage_.phase_used[Aqua]) {
if (newParserDeck->hasKeyword("PVTW")) { if (deck->hasKeyword("PVTW")) {
Opm::PvtwTable pvtwTable(newParserDeck->getKeyword("PVTW"), region_number); Opm::PvtwTable pvtwTable(deck->getKeyword("PVTW"), region_number);
props_[phase_usage_.phase_pos[Aqua]].reset(new SinglePvtConstCompr(pvtwTable)); props_[phase_usage_.phase_pos[Aqua]].reset(new SinglePvtConstCompr(pvtwTable));
} else { } else {
// Eclipse 100 default. // Eclipse 100 default.
@ -241,19 +122,19 @@ namespace Opm
// Oil PVT // Oil PVT
if (phase_usage_.phase_used[Liquid]) { if (phase_usage_.phase_used[Liquid]) {
if (newParserDeck->hasKeyword("PVDO")) { if (deck->hasKeyword("PVDO")) {
Opm::PvdoTable pvdoTable(newParserDeck->getKeyword("PVDO"), region_number); Opm::PvdoTable pvdoTable(deck->getKeyword("PVDO"), region_number);
if (samples > 0) { if (samples > 0) {
props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtDeadSpline(pvdoTable, samples)); props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtDeadSpline(pvdoTable, samples));
} else { } else {
props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtDead(pvdoTable)); props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtDead(pvdoTable));
} }
} }
else if (newParserDeck->hasKeyword("PVTO")) { else if (deck->hasKeyword("PVTO")) {
Opm::PvtoTable pvtoTable(newParserDeck->getKeyword("PVTO"), /*tableIdx=*/0); Opm::PvtoTable pvtoTable(deck->getKeyword("PVTO"), /*tableIdx=*/0);
props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtLiveOil(pvtoTable)); props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtLiveOil(pvtoTable));
} else if (newParserDeck->hasKeyword("PVCDO")) { } else if (deck->hasKeyword("PVCDO")) {
Opm::PvcdoTable pvdcoTable(newParserDeck->getKeyword("PVCDO"), region_number); Opm::PvcdoTable pvdcoTable(deck->getKeyword("PVCDO"), region_number);
props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtConstCompr(pvdcoTable)); props_[phase_usage_.phase_pos[Liquid]].reset(new SinglePvtConstCompr(pvdcoTable));
} else { } else {
OPM_THROW(std::runtime_error, "Input is missing PVDO, PVTO or PVCDO\n"); OPM_THROW(std::runtime_error, "Input is missing PVDO, PVTO or PVCDO\n");
@ -262,15 +143,15 @@ namespace Opm
// Gas PVT // Gas PVT
if (phase_usage_.phase_used[Vapour]) { if (phase_usage_.phase_used[Vapour]) {
if (newParserDeck->hasKeyword("PVDG")) { if (deck->hasKeyword("PVDG")) {
Opm::PvdoTable pvdgTable(newParserDeck->getKeyword("PVDG"), region_number); Opm::PvdoTable pvdgTable(deck->getKeyword("PVDG"), region_number);
if (samples > 0) { if (samples > 0) {
props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtDeadSpline(pvdgTable, samples)); props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtDeadSpline(pvdgTable, samples));
} else { } else {
props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtDead(pvdgTable)); props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtDead(pvdgTable));
} }
} else if (newParserDeck->hasKeyword("PVTG")) { } else if (deck->hasKeyword("PVTG")) {
Opm::PvtgTable pvtgTable(newParserDeck->getKeyword("PVTG"), /*tableIdx=*/0); Opm::PvtgTable pvtgTable(deck->getKeyword("PVTG"), /*tableIdx=*/0);
props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtLiveGas(pvtgTable)); props_[phase_usage_.phase_pos[Vapour]].reset(new SinglePvtLiveGas(pvtgTable));
} else { } else {
OPM_THROW(std::runtime_error, "Input is missing PVDG or PVTG\n"); OPM_THROW(std::runtime_error, "Input is missing PVDG or PVTG\n");
@ -280,16 +161,15 @@ namespace Opm
SaturationPropsFromDeck<SatFuncGwsegNonuniform>* ptr SaturationPropsFromDeck<SatFuncGwsegNonuniform>* ptr
= new SaturationPropsFromDeck<SatFuncGwsegNonuniform>(); = new SaturationPropsFromDeck<SatFuncGwsegNonuniform>();
satprops_.reset(ptr); satprops_.reset(ptr);
ptr->init(newParserDeck, number_of_cells, global_cell, begin_cell_centroids, dimensions, -1); ptr->init(deck, number_of_cells, global_cell, begin_cell_centroids, dimension, -1);
if (phase_usage_.num_phases != satprops_->numPhases()) { if (phase_usage_.num_phases != satprops_->numPhases()) {
OPM_THROW(std::runtime_error, "BlackoilPropsAdFromDeck::BlackoilPropsAdFromDeck() - " OPM_THROW(std::runtime_error, "BlackoilPropsAdFromDeck::BlackoilPropsAdFromDeck() - "
"Inconsistent number of phases in pvt data (" << phase_usage_.num_phases "Inconsistent number of phases in pvt data (" << phase_usage_.num_phases
<< ") and saturation-dependent function data (" << satprops_->numPhases() << ")."); << ") and saturation-dependent function data (" << satprops_->numPhases() << ").");
} }
} }
//////////////////////////// ////////////////////////////
// Rock interface // // Rock interface //
//////////////////////////// ////////////////////////////

59
opm/autodiff/BlackoilPropsAdFromDeck.hpp
View File

@ -23,15 +23,12 @@
#include <opm/autodiff/BlackoilPropsAdInterface.hpp> #include <opm/autodiff/BlackoilPropsAdInterface.hpp>
#include <opm/autodiff/AutoDiffBlock.hpp> #include <opm/autodiff/AutoDiffBlock.hpp>
#include <opm/core/props/BlackoilPhases.hpp>
#include <opm/core/props/satfunc/SaturationPropsFromDeck.hpp> #include <opm/core/props/satfunc/SaturationPropsFromDeck.hpp>
#include <opm/core/io/eclipse/EclipseGridParser.hpp>
#include <opm/core/props/rock/RockFromDeck.hpp> #include <opm/core/props/rock/RockFromDeck.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp> #include <opm/parser/eclipse/Deck/Deck.hpp>
#include <boost/shared_ptr.hpp> #include <memory>
#include <boost/scoped_ptr.hpp>
#ifdef HAVE_DUNE_CORNERPOINT #ifdef HAVE_DUNE_CORNERPOINT
#include "disable_warning_pragmas.h" #include "disable_warning_pragmas.h"
@ -57,49 +54,17 @@ namespace Opm
{ {
public: public:
/// Constructor wrapping an opm-core black oil interface. /// Constructor wrapping an opm-core black oil interface.
BlackoilPropsAdFromDeck(const EclipseGridParser& deck, BlackoilPropsAdFromDeck(Opm::DeckConstPtr deck,
const UnstructuredGrid& grid,
const bool init_rock = true );
/// Constructor wrapping an opm-core black oil interface.
BlackoilPropsAdFromDeck(Opm::DeckConstPtr newParserDeck,
const UnstructuredGrid& grid, const UnstructuredGrid& grid,
const bool init_rock = true ); const bool init_rock = true );
#ifdef HAVE_DUNE_CORNERPOINT #ifdef HAVE_DUNE_CORNERPOINT
/// Constructor wrapping an opm-core black oil interface. /// Constructor wrapping an opm-core black oil interface.
BlackoilPropsAdFromDeck(const EclipseGridParser& deck, BlackoilPropsAdFromDeck(Opm::DeckConstPtr deck,
const Dune::CpGrid& grid, const Dune::CpGrid& grid,
const bool init_rock = true ); const bool init_rock = true );
/// Constructor wrapping an opm-core black oil interface.
BlackoilPropsAdFromDeck(Opm::DeckConstPtr newParserDeck,
const Dune::CpGrid& grid,
const bool init_rock = true );
#endif #endif
/// Constructor taking not a grid but only the needed information
template<class T>
BlackoilPropsAdFromDeck(Opm::DeckConstPtr newParserDeck,
int number_of_cells,
const int* global_cell,
const int* cart_dims,
T begin_cell_centroids,
int dimensions,
const bool init_rock);
/// Constructor taking not a grid but only the needed information
template<class T>
BlackoilPropsAdFromDeck(const EclipseGridParser& deck,
int number_of_cells,
const int* global_cell,
const int* cart_dims,
T begin_cell_centroids,
int dimensions,
const bool init_rock);
//////////////////////////// ////////////////////////////
// Rock interface // // Rock interface //
@ -371,27 +336,19 @@ namespace Opm
private: private:
/// Initializes the properties. /// Initializes the properties.
template<class T> template <class CentroidIterator>
void init(const EclipseGridParser& deck,
int number_of_cells,
const int* global_cell,
const int* cart_dims,
T begin_cell_centroids,
int dimension,
const bool init_rock);
/// Initializes the properties.
template<class T>
void init(Opm::DeckConstPtr deck, void init(Opm::DeckConstPtr deck,
int number_of_cells, int number_of_cells,
const int* global_cell, const int* global_cell,
const int* cart_dims, const int* cart_dims,
T begin_cell_centroids, const CentroidIterator& begin_cell_centroids,
int dimension, int dimension,
const bool init_rock); const bool init_rock);
RockFromDeck rock_; RockFromDeck rock_;
boost::scoped_ptr<SaturationPropsInterface> satprops_; std::unique_ptr<SaturationPropsInterface> satprops_;
PhaseUsage phase_usage_; PhaseUsage phase_usage_;
std::vector<boost::shared_ptr<SinglePvtInterface> > props_; std::vector<std::shared_ptr<SinglePvtInterface> > props_;
double densities_[BlackoilPhases::MaxNumPhases]; double densities_[BlackoilPhases::MaxNumPhases];
}; };

2
opm/autodiff/SimulatorCompressibleAd.cpp
View File

@ -51,9 +51,9 @@
#include <opm/core/transport/reorder/TransportSolverCompressibleTwophaseReorder.hpp> #include <opm/core/transport/reorder/TransportSolverCompressibleTwophaseReorder.hpp>
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <memory>
#include <numeric> #include <numeric>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>

4
opm/autodiff/SimulatorCompressibleAd.hpp
View File

@ -20,7 +20,7 @@
#ifndef OPM_SIMULATORCOMPRESSIBLEAD_HEADER_INCLUDED #ifndef OPM_SIMULATORCOMPRESSIBLEAD_HEADER_INCLUDED
#define OPM_SIMULATORCOMPRESSIBLEAD_HEADER_INCLUDED #define OPM_SIMULATORCOMPRESSIBLEAD_HEADER_INCLUDED
#include <boost/shared_ptr.hpp> #include <memory>
#include <vector> #include <vector>
struct UnstructuredGrid; struct UnstructuredGrid;
@ -87,7 +87,7 @@ namespace Opm
private: private:
class Impl; class Impl;
// Using shared_ptr instead of scoped_ptr since scoped_ptr requires complete type for Impl. // Using shared_ptr instead of scoped_ptr since scoped_ptr requires complete type for Impl.
boost::shared_ptr<Impl> pimpl_; std::shared_ptr<Impl> pimpl_;
}; };
} // namespace Opm } // namespace Opm

4
opm/autodiff/SimulatorFullyImplicitBlackoil.hpp
View File

@ -20,7 +20,7 @@
#ifndef OPM_SIMULATORFULLYIMPLICITBLACKOIL_HEADER_INCLUDED #ifndef OPM_SIMULATORFULLYIMPLICITBLACKOIL_HEADER_INCLUDED
#define OPM_SIMULATORFULLYIMPLICITBLACKOIL_HEADER_INCLUDED #define OPM_SIMULATORFULLYIMPLICITBLACKOIL_HEADER_INCLUDED
#include <boost/shared_ptr.hpp> #include <memory>
#include <vector> #include <vector>
struct UnstructuredGrid; struct UnstructuredGrid;
@ -90,7 +90,7 @@ namespace Opm
private: private:
class Impl; class Impl;
// Using shared_ptr instead of scoped_ptr since scoped_ptr requires complete type for Impl. // Using shared_ptr instead of scoped_ptr since scoped_ptr requires complete type for Impl.
boost::shared_ptr<Impl> pimpl_; std::shared_ptr<Impl> pimpl_;
}; };
} // namespace Opm } // namespace Opm

2
opm/autodiff/SimulatorFullyImplicitBlackoil_impl.hpp
View File

@ -46,9 +46,9 @@
#include <opm/core/transport/reorder/TransportSolverCompressibleTwophaseReorder.hpp> #include <opm/core/transport/reorder/TransportSolverCompressibleTwophaseReorder.hpp>
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <memory>
#include <numeric> #include <numeric>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>

4
opm/autodiff/SimulatorIncompTwophaseAd.cpp
View File

@ -51,9 +51,9 @@
#include <opm/core/transport/implicit/TransportSolverTwophaseImplicit.hpp> #include <opm/core/transport/implicit/TransportSolverTwophaseImplicit.hpp>
#include <opm/autodiff/TransportSolverTwophaseAd.hpp> #include <opm/autodiff/TransportSolverTwophaseAd.hpp>
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <memory>
#include <numeric> #include <numeric>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
@ -103,7 +103,7 @@ namespace Opm
const FlowBoundaryConditions* bcs_; const FlowBoundaryConditions* bcs_;
// Solvers // Solvers
IncompTpfa psolver_; IncompTpfa psolver_;
boost::scoped_ptr<TransportSolverTwophaseInterface> tsolver_; std::unique_ptr<TransportSolverTwophaseInterface> tsolver_;
// Misc. data // Misc. data
std::vector<int> allcells_; std::vector<int> allcells_;
}; };

4
opm/autodiff/SimulatorIncompTwophaseAd.hpp
View File

@ -20,7 +20,7 @@
#ifndef OPM_SIMULATORINCOMPTWOPHASEAD_HEADER_INCLUDED #ifndef OPM_SIMULATORINCOMPTWOPHASEAD_HEADER_INCLUDED
#define OPM_SIMULATORINCOMPTWOPHASEAD_HEADER_INCLUDED #define OPM_SIMULATORINCOMPTWOPHASEAD_HEADER_INCLUDED
#include <boost/shared_ptr.hpp> #include <memory>
#include <vector> #include <vector>
struct UnstructuredGrid; struct UnstructuredGrid;
@ -91,7 +91,7 @@ namespace Opm
private: private:
class Impl; class Impl;
// Using shared_ptr instead of scoped_ptr since scoped_ptr requires complete type for Impl. // Using shared_ptr instead of scoped_ptr since scoped_ptr requires complete type for Impl.
boost::shared_ptr<Impl> pimpl_; std::shared_ptr<Impl> pimpl_;
}; };
} // namespace Opm } // namespace Opm

5
tests/fluid.data
View File

@ -47,6 +47,11 @@ PORO
-- ===================================================================== -- =====================================================================
PROPS PROPS
TABDIMS
-- use the default values for TABDIMS, but the keyword must be present
-- if any tables ought to be specified...
/
PVTW PVTW
-- Pw Bw(Pw) Cw muw Cv -- Pw Bw(Pw) Cw muw Cv
1 1 0 1000 0 1 1 0 1000 0

334
tests/integration_tests/sim_fibo_ad_test.cpp
View File

@ -1,334 +0,0 @@
/*
Copyright 2013 Statoil ASA
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#if HAVE_DYNAMIC_BOOST_TEST
#define BOOST_TEST_DYN_LINK
#endif
#define BOOST_TEST_MODULE SimFiboADTest
#include <boost/test/unit_test.hpp>
#include <opm/core/grid.h>
#include <opm/core/grid/GridManager.hpp>
#include <opm/core/wells.h>
#include <opm/core/wells/WellsManager.hpp>
#include <opm/core/utility/ErrorMacros.hpp>
#include <opm/core/simulator/initState.hpp>
#include <opm/core/simulator/SimulatorReport.hpp>
#include <opm/core/simulator/SimulatorTimer.hpp>
#include <opm/core/utility/miscUtilities.hpp>
#include <opm/core/utility/parameters/ParameterGroup.hpp>
#include <opm/core/io/eclipse/EclipseWriter.hpp>
#include <opm/core/props/BlackoilPropertiesBasic.hpp>
#include <opm/core/props/BlackoilPropertiesFromDeck.hpp>
#include <opm/core/props/rock/RockCompressibility.hpp>
#include <opm/core/linalg/LinearSolverFactory.hpp>
#include <opm/core/simulator/BlackoilState.hpp>
#include <opm/core/simulator/WellState.hpp>
#include <opm/autodiff/SimulatorFullyImplicitBlackoil.hpp>
#include <opm/autodiff/BlackoilPropsAdFromDeck.hpp>
#include <opm/core/utility/share_obj.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/filesystem.hpp>
#include <algorithm>
#include <iostream>
#include <vector>
#include <numeric>
using namespace Opm;
std::vector<BlackoilState> runWithOldParser(const parameter::ParameterGroup& param) {
boost::scoped_ptr<EclipseGridParser> deck;
boost::scoped_ptr<GridManager> grid;
boost::scoped_ptr<BlackoilPropertiesInterface> props;
boost::scoped_ptr<BlackoilPropsAdInterface> new_props;
boost::scoped_ptr<RockCompressibility> rock_comp;
BlackoilState state;
std::vector<BlackoilState> state_collection;
std::string deck_filename = param.get<std::string>("deck_filename");
deck.reset(new EclipseGridParser(deck_filename));
// Grid init
grid.reset(new GridManager(*deck));
Opm::EclipseWriter outputWriter(param, share_obj(*deck), share_obj(*grid->c_grid()));
// Rock and fluid init
props.reset(new BlackoilPropertiesFromDeck(*deck, *grid->c_grid(), param));
new_props.reset(new BlackoilPropsAdFromDeck(*deck, *grid->c_grid()));
rock_comp.reset(new RockCompressibility(*deck));
double gravity[3] = {0.0};
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);
initBlackoilSurfvol(*grid->c_grid(), *props, state);
enum { Oil = BlackoilPhases::Liquid, Gas = BlackoilPhases::Vapour };
const PhaseUsage pu = props->phaseUsage();
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 {
initBlackoilStateFromDeck(*grid->c_grid(), *props, *deck, gravity[2], state);
}
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);
std::cout << "\n\n================ Starting main simulation loop ===============\n"
<< " (number of epochs: "
<< (deck->numberOfEpochs()) << ")\n\n" << std::flush;
SimulatorReport rep;
// 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();
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) {
OPM_THROW(std::runtime_error, "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, well_state
WellsManager wells(*deck, *grid->c_grid(), props->permeability());
// @@@ 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.
SimulatorFullyImplicitBlackoil simulator(param,
*grid->c_grid(),
*new_props,
rock_comp->isActive() ? rock_comp.get() : 0,
wells,
linsolver,
grav,
outputWriter);
SimulatorReport epoch_rep = simulator.run(simtimer, state, well_state);
BlackoilState copy = state;
state_collection.push_back(copy);
// 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);
return state_collection;
}
std::vector<BlackoilState> runWithNewParser(const parameter::ParameterGroup& param) {
boost::scoped_ptr<EclipseGridParser> old_deck;
boost::scoped_ptr<GridManager> grid;
boost::scoped_ptr<BlackoilPropertiesInterface> props;
boost::scoped_ptr<BlackoilPropsAdInterface> new_props;
boost::scoped_ptr<RockCompressibility> rock_comp;
BlackoilState state;
std::vector<BlackoilState> state_collection;
std::string deck_filename = param.get<std::string>("deck_filename");
old_deck.reset(new EclipseGridParser(deck_filename));
// Grid init
grid.reset(new GridManager(*old_deck));
Opm::EclipseWriter outputWriter(param, share_obj(*old_deck), share_obj(*grid->c_grid()));
// Rock and fluid init
props.reset(new BlackoilPropertiesFromDeck(*old_deck, *grid->c_grid(), param));
new_props.reset(new BlackoilPropsAdFromDeck(*old_deck, *grid->c_grid()));
rock_comp.reset(new RockCompressibility(*old_deck));
double gravity[3] = {0.0};
gravity[2] = old_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);
initBlackoilSurfvol(*grid->c_grid(), *props, state);
enum { Oil = BlackoilPhases::Liquid, Gas = BlackoilPhases::Vapour };
const PhaseUsage pu = props->phaseUsage();
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 {
initBlackoilStateFromDeck(*grid->c_grid(), *props, *old_deck, gravity[2], state);
}
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);
std::cout << "\n\n================ Starting main simulation loop ===============\n"
<< " (number of epochs: "
<< (old_deck->numberOfEpochs()) << ")\n\n" << std::flush;
SimulatorReport rep;
// 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.
old_deck->setCurrentEpoch(old_deck->numberOfEpochs() - 1);
simtimer.init(*old_deck);
const double total_time = simtimer.totalTime();
ParserPtr parser(new Parser());
DeckConstPtr deck = parser->parseFile(deck_filename);
ScheduleConstPtr schedule_deck(new Schedule(deck));
//In the Schedule Deck, we have the start data as the 0th element.
for (size_t epoch = 0; epoch < schedule_deck->getTimeMap()->size() - 1; ++epoch) {
// Set epoch index.
old_deck->setCurrentEpoch(epoch);
// Update the timer.
if (old_deck->hasField("TSTEP")) {
simtimer.init(*old_deck);
} else {
if (epoch != 0) {
OPM_THROW(std::runtime_error, "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, well_state
WellsManager wells(*old_deck, *grid->c_grid(), props->permeability());
// @@@ 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.
SimulatorFullyImplicitBlackoil simulator(param,
*grid->c_grid(),
*new_props,
rock_comp->isActive() ? rock_comp.get() : 0,
wells,
linsolver,
grav,
outputWriter);
SimulatorReport epoch_rep = simulator.run(simtimer, state, well_state);
BlackoilState copy = state;
state_collection.push_back(copy);
// 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);
return state_collection;
}
BOOST_AUTO_TEST_CASE(SPE1_runWithOldAndNewParser_BlackOilStateEqual) {
const char* null = 0;
const char * argv[] = {"", "deck_filename=non_public/SPE1_opm.DATA", null};
parameter::ParameterGroup param(2, argv, false);
BOOST_ASSERT(param.has("deck_filename"));
std::vector<BlackoilState> runWithOldParserStates = runWithOldParser(param);
std::vector<BlackoilState> runWithNewParserStates = runWithNewParser(param);
std::cout << "======== Checking old parser vs new parser BlackoilState ==========\n\n";
for(size_t i=0; i<runWithOldParserStates.size(); i++) {
BOOST_CHECK(runWithOldParserStates[i].equals(runWithNewParserStates[i]));
}
}

12
tests/test_boprops_ad.cpp
View File

@ -30,23 +30,23 @@
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
#include <opm/core/io/eclipse/EclipseGridParser.hpp>
#include <opm/core/grid/GridManager.hpp> #include <opm/core/grid/GridManager.hpp>
#include <opm/core/props/BlackoilPropertiesFromDeck.hpp> #include <opm/core/props/BlackoilPropertiesFromDeck.hpp>
#include <opm/core/utility/Units.hpp> #include <opm/core/utility/Units.hpp>
#include <opm/core/utility/parameters/ParameterGroup.hpp> #include <opm/core/utility/parameters/ParameterGroup.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
struct SetupSimple { struct SetupSimple {
SetupSimple() SetupSimple()
: param()
, deck()
{ {
std::ifstream str("fluid.data"); Opm::ParserPtr parser(new Opm::Parser());
deck.read(str); deck = parser->parseFile("fluid.data");
param.disableOutput(); param.disableOutput();
param.insertParameter("init_rock" , "false" ); param.insertParameter("init_rock" , "false" );
@ -56,7 +56,7 @@ struct SetupSimple {
} }
Opm::parameter::ParameterGroup param; Opm::parameter::ParameterGroup param;
Opm::EclipseGridParser deck; Opm::DeckConstPtr deck;
}; };