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 pull request #3941 from akva2/remove_int_sim_config

Browse Source 
Remove support for internal simulator configuration
This commit is contained in:
Markus Blatt
2022-06-27 11:05:18 +02:00
committed by GitHub
parent 25a92c2c2c 32eb467ead
commit e14823c6d8
47 changed files with 125 additions and 877 deletions
Download Patch File Download Diff File Expand all files Collapse all files

212
ebos/eclgenericvanguard.cc
View File

@@ -29,6 +29,7 @@
#include <opm/input/eclipse/Deck/Deck.hpp>
#include <opm/input/eclipse/EclipseState/Aquifer/NumericalAquifer/NumericalAquiferCell.hpp>
#include <opm/input/eclipse/EclipseState/EclipseState.hpp>
#include <opm/input/eclipse/Parser/ErrorGuard.hpp>
#include <opm/input/eclipse/Schedule/Action/State.hpp>
#include <opm/input/eclipse/Schedule/OilVaporizationProperties.hpp>
#include <opm/input/eclipse/Schedule/Schedule.hpp>
@@ -36,13 +37,12 @@
#include <opm/input/eclipse/Schedule/SummaryState.hpp>
#include <opm/input/eclipse/Schedule/UDQ/UDQState.hpp>
#include <opm/input/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp>
#include <opm/input/eclipse/Parser/ErrorGuard.hpp>
#include <opm/input/eclipse/Parser/ParseContext.hpp>
#include <opm/input/eclipse/Python/Python.hpp>
#include <opm/simulators/utils/readDeck.hpp>
#include <dune/common/version.hh>
#include <dune/common/parallel/mpihelper.hh>
#include <dune/common/timer.hh>
#if HAVE_MPI
#include <mpi.h>
@@ -53,17 +53,14 @@
namespace Opm {
double EclGenericVanguard::externalSetupTime_ = 0.0;
std::unique_ptr<ParseContext> EclGenericVanguard::externalParseContext_;
std::unique_ptr<ErrorGuard> EclGenericVanguard::externalErrorGuard_;
std::shared_ptr<Deck> EclGenericVanguard::externalDeck_;
bool EclGenericVanguard::externalDeckSet_ = false;
std::shared_ptr<EclipseState> EclGenericVanguard::externalEclState_;
std::shared_ptr<Schedule> EclGenericVanguard::externalEclSchedule_;
std::shared_ptr<SummaryConfig> EclGenericVanguard::externalEclSummaryConfig_;
std::unique_ptr<UDQState> EclGenericVanguard::externalUDQState_;
std::unique_ptr<Action::State> EclGenericVanguard::externalActionState_;
std::unique_ptr<WellTestState> EclGenericVanguard::externalWTestState_;
double EclGenericVanguard::setupTime_ = 0.0;
std::shared_ptr<Deck> EclGenericVanguard::deck_;
std::shared_ptr<EclipseState> EclGenericVanguard::eclState_;
std::shared_ptr<Schedule> EclGenericVanguard::eclSchedule_;
std::shared_ptr<SummaryConfig> EclGenericVanguard::eclSummaryConfig_;
std::unique_ptr<UDQState> EclGenericVanguard::udqState_;
std::unique_ptr<Action::State> EclGenericVanguard::actionState_;
std::unique_ptr<WellTestState> EclGenericVanguard::wtestState_;
std::unique_ptr<Parallel::Communication> EclGenericVanguard::comm_;
EclGenericVanguard::EclGenericVanguard()
@@ -73,73 +70,56 @@ EclGenericVanguard::EclGenericVanguard()
EclGenericVanguard::~EclGenericVanguard() = default;
void EclGenericVanguard::setExternalParseContext(std::unique_ptr<ParseContext> parseContext)
void EclGenericVanguard::setParams(double setupTime,
std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::unique_ptr<UDQState> udqState,
std::unique_ptr<Action::State> actionState,
std::unique_ptr<WellTestState> wtestState,
std::shared_ptr<SummaryConfig> summaryConfig)
{
externalParseContext_ = std::move(parseContext);
EclGenericVanguard::setupTime_ = setupTime;
EclGenericVanguard::deck_ = std::move(deck);
EclGenericVanguard::eclState_ = std::move(eclState);
EclGenericVanguard::eclSchedule_ = std::move(schedule);
EclGenericVanguard::udqState_ = std::move(udqState);
EclGenericVanguard::actionState_ = std::move(actionState);
EclGenericVanguard::wtestState_ = std::move(wtestState);
EclGenericVanguard::eclSummaryConfig_ = std::move(summaryConfig);
}
void EclGenericVanguard::setExternalErrorGuard(std::unique_ptr<ErrorGuard> errorGuard)
void EclGenericVanguard::readDeck(const std::string& filename)
{
externalErrorGuard_ = std::move(errorGuard);
}
Dune::Timer setupTimer;
setupTimer.start();
void EclGenericVanguard::setExternalSchedule(std::shared_ptr<Schedule> schedule)
{
externalEclSchedule_ = std::move(schedule);
}
std::shared_ptr<Opm::Deck> deck;
std::shared_ptr<Opm::EclipseState> eclipseState;
std::shared_ptr<Opm::Schedule> schedule;
std::unique_ptr<Opm::UDQState> udqState;
std::unique_ptr<Opm::Action::State> actionState;
std::unique_ptr<Opm::WellTestState> wtestState;
std::shared_ptr<Opm::SummaryConfig> summaryConfig;
void EclGenericVanguard::setExternalSchedule(std::unique_ptr<Schedule> schedule)
{
externalEclSchedule_ = std::move(schedule);
}
auto parseContext =
std::make_unique<ParseContext>(std::vector<std::pair<std::string , InputError::Action>>
{{ParseContext::PARSE_RANDOM_SLASH, InputError::IGNORE},
{ParseContext::PARSE_MISSING_DIMS_KEYWORD, InputError::WARN},
{ParseContext::SUMMARY_UNKNOWN_WELL, InputError::WARN},
{ParseContext::SUMMARY_UNKNOWN_GROUP, InputError::WARN}});
void EclGenericVanguard::setExternalSummaryConfig(
std::shared_ptr<SummaryConfig> summaryConfig)
{
externalEclSummaryConfig_ = std::move(summaryConfig);
}
Opm::readDeck(EclGenericVanguard::comm(),
filename, deck, eclipseState, schedule, udqState,
actionState, wtestState,
summaryConfig, nullptr, nullptr, std::move(parseContext),
false, false, {});
void EclGenericVanguard::setExternalSummaryConfig(
std::unique_ptr<SummaryConfig> summaryConfig)
{
externalEclSummaryConfig_ = std::move(summaryConfig);
}
void EclGenericVanguard::setExternalDeck(std::shared_ptr<Deck> deck)
{
externalDeck_ = std::move(deck);
externalDeckSet_ = true;
}
void EclGenericVanguard::setExternalDeck(std::unique_ptr<Deck> deck)
{
externalDeck_ = std::move(deck);
externalDeckSet_ = true;
}
void EclGenericVanguard::setExternalEclState(std::shared_ptr<EclipseState> eclState)
{
externalEclState_ = std::move(eclState);
}
void EclGenericVanguard::setExternalEclState(std::unique_ptr<EclipseState> eclState)
{
externalEclState_ = std::move(eclState);
}
void EclGenericVanguard::setExternalUDQState(std::unique_ptr<UDQState> udqState)
{
externalUDQState_ = std::move(udqState);
}
void EclGenericVanguard::setExternalActionState(std::unique_ptr<Action::State> actionState)
{
externalActionState_ = std::move(actionState);
}
void EclGenericVanguard::setExternalWTestState(std::unique_ptr<WellTestState> wtestState)
{
externalWTestState_ = std::move(wtestState);
EclGenericVanguard::setParams(setupTimer.elapsed(),
deck, eclipseState, schedule,
std::move(udqState),
std::move(actionState),
std::move(wtestState), summaryConfig);
}
std::string EclGenericVanguard::canonicalDeckPath(const std::string& caseName)
@@ -167,40 +147,6 @@ std::string EclGenericVanguard::canonicalDeckPath(const std::string& caseName)
throw std::invalid_argument("Cannot find input case '"+caseName+"'");
}
std::unique_ptr<ParseContext> EclGenericVanguard::createParseContext(const std::string& ignoredKeywords,
bool eclStrictParsing)
{
typedef std::pair<std::string, InputError::Action> ParseModePair;
typedef std::vector<ParseModePair> ParseModePairs;
ParseModePairs tmp;
tmp.emplace_back(ParseContext::PARSE_RANDOM_SLASH, InputError::IGNORE);
tmp.emplace_back(ParseContext::PARSE_MISSING_DIMS_KEYWORD, InputError::WARN);
tmp.emplace_back(ParseContext::SUMMARY_UNKNOWN_WELL, InputError::WARN);
tmp.emplace_back(ParseContext::SUMMARY_UNKNOWN_GROUP, InputError::WARN);
tmp.emplace_back(ParseContext::PARSE_EXTRA_RECORDS, InputError::WARN);
auto parseContext = std::make_unique<ParseContext>(tmp);
if (!ignoredKeywords.empty()) {
size_t pos;
size_t offset = 0;
while (true) {
pos = ignoredKeywords.find(':', offset);
if (pos == std::string::npos) {
parseContext->ignoreKeyword(ignoredKeywords.substr(offset));
break;
}
parseContext->ignoreKeyword(ignoredKeywords.substr(offset, pos - offset));
offset = pos + 1;
}
}
if (eclStrictParsing)
parseContext->update(InputError::DELAYED_EXIT1);
return parseContext;
}
void EclGenericVanguard::updateOutputDir_(std::string outputDir,
bool enableEclCompatFile)
{
@@ -262,60 +208,6 @@ void EclGenericVanguard::init()
std::transform(caseName_.begin(), caseName_.end(), caseName_.begin(), ::toupper);
}
std::unique_ptr<ErrorGuard> errorGuard = nullptr;
// Check that we are in one of the known configurations for external variables
// and move them to internal
if (externalDeck_)
{
deck_ = std::move(externalDeck_);
if (externalParseContext_ && externalErrorGuard_ )
{
parseContext_ = std::move(externalParseContext_);
errorGuard = std::move(externalErrorGuard_);
}
else if(externalEclState_ && externalEclSchedule_ && externalEclSummaryConfig_)
{
eclState_ = std::move(externalEclState_);
eclSchedule_ = std::move(externalEclSchedule_);
eclSummaryConfig_ = std::move(externalEclSummaryConfig_);
}
else
{
OPM_THROW(std::logic_error, "Either parse context and error guard or ECL state, schedule, and summary config need to be"
<< " set externally.");
}
}
else if (externalParseContext_)
{
parseContext_ = std::move(externalParseContext_);
}
else
{
parseContext_ = createParseContext(ignoredKeywords_, eclStrictParsing_);
}
readDeck(EclGenericVanguard::comm(), fileName_, deck_, eclState_, eclSchedule_, udqState_, actionState_, wtestState_,
eclSummaryConfig_, std::move(errorGuard), python,
std::move(parseContext_), /* initFromRestart = */ false,
/* checkDeck = */ enableExperiments_, outputInterval_);
if (EclGenericVanguard::externalUDQState_)
this->udqState_ = std::move(EclGenericVanguard::externalUDQState_);
else
this->udqState_ = std::make_unique<UDQState>( this->eclSchedule_->getUDQConfig(0).params().undefinedValue() );
if (EclGenericVanguard::externalActionState_)
this->actionState_ = std::move(EclGenericVanguard::externalActionState_);
else
this->actionState_ = std::make_unique<Action::State>();
if (EclGenericVanguard::externalWTestState_)
this->wtestState_ = std::move(EclGenericVanguard::externalWTestState_);
else
this->wtestState_ = std::make_unique<WellTestState>();
this->summaryState_ = std::make_unique<SummaryState>( TimeService::from_time_t(this->eclSchedule_->getStartTime() ));
// Initialize parallelWells with all local wells

106
ebos/eclgenericvanguard.hh
View File

@@ -87,78 +87,29 @@ public:
*/
static std::string canonicalDeckPath(const std::string& caseName);
/*!
* \brief Creates an Opm::parseContext object assuming that the parameters are ready.
*/
static std::unique_ptr<ParseContext> createParseContext(const std::string& ignoredKeywords,
bool eclStrictParsing);
/*!
* \brief Set the wall time which was spend externally to set up the external data structures
*
* i.e., the objects specified via the other setExternal*() methods.
*/
static void setExternalSetupTime(double t)
{ externalSetupTime_ = t; }
/*!
* \brief Returns the wall time required to set up the simulator before it was born.
*/
static double externalSetupTime()
{ return externalSetupTime_; }
static double setupTime()
{ return setupTime_; }
/*!
* \brief Set the Opm::ParseContext object which ought to be used for parsing the deck and creating the Opm::EclipseState object.
* \brief Read a deck.
* \param filename file to read
*/
static void setExternalParseContext(std::unique_ptr<ParseContext> parseContext);
static void readDeck(const std::string& filename);
/*!
* \brief Set the Opm::ErrorGuard object which ought to be used for parsing the deck and creating the Opm::EclipseState object.
* \brief Set the simulation configuration objects.
*/
static void setExternalErrorGuard(std::unique_ptr<ErrorGuard> errorGuard);
/*!
* \brief Set the Opm::Deck object which ought to be used when the simulator vanguard
* is instantiated.
*
* This is basically an optimization: In cases where the ECL input deck must be
* examined to decide which simulator ought to be used, this avoids having to parse
* the input twice. When this method is used, the caller is responsible for lifetime
* management of these two objects, i.e., they are not allowed to be deleted as long
* as the simulator vanguard object is alive.
*/
static void setExternalDeck(std::shared_ptr<Deck> deck);
static void setExternalDeck(std::unique_ptr<Deck> deck);
/*!
* \brief Set the Opm::EclipseState object which ought to be used when the simulator
* vanguard is instantiated.
*/
static void setExternalEclState(std::shared_ptr<EclipseState> eclState);
static void setExternalEclState(std::unique_ptr<EclipseState> eclState);
/*!
* \brief Set the schedule object.
*
* The lifetime of this object is not managed by the vanguard, i.e., the object must
* stay valid until after the vanguard gets destroyed.
*/
static void setExternalSchedule(std::shared_ptr<Schedule> schedule);
static void setExternalSchedule(std::unique_ptr<Schedule> schedule);
/*!
* \brief Set the summary configuration object.
*
* The lifetime of this object is not managed by the vanguard, i.e., the object must
* stay valid until after the vanguard gets destroyed.
*/
static void setExternalSummaryConfig(std::shared_ptr<SummaryConfig> summaryConfig);
static void setExternalSummaryConfig(std::unique_ptr<SummaryConfig> summaryConfig);
static void setExternalUDQState(std::unique_ptr<UDQState> udqState);
static void setExternalActionState(std::unique_ptr<Action::State> actionState);
static void setExternalWTestState(std::unique_ptr<WellTestState> wtestState);
static void setParams(double setupTime,
std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::unique_ptr<UDQState> udqState,
std::unique_ptr<Action::State> actionState,
std::unique_ptr<WellTestState> wtestState,
std::shared_ptr<SummaryConfig> summaryConfig);
/*!
* \brief Return a reference to the parsed ECL deck.
@@ -316,20 +267,9 @@ protected:
void init();
static double externalSetupTime_;
static std::unique_ptr<ParseContext> externalParseContext_;
static std::unique_ptr<ErrorGuard> externalErrorGuard_;
static double setupTime_;
// These variables may be owned by both Python and the simulator
static std::shared_ptr<Deck> externalDeck_;
static std::shared_ptr<EclipseState> externalEclState_;
static std::shared_ptr<Schedule> externalEclSchedule_;
static std::shared_ptr<SummaryConfig> externalEclSummaryConfig_;
static bool externalDeckSet_;
static std::unique_ptr<UDQState> externalUDQState_;
static std::unique_ptr<Action::State> externalActionState_;
static std::unique_ptr<WellTestState> externalWTestState_;
static std::unique_ptr<Parallel::Communication> comm_;
std::string caseName_;
@@ -351,25 +291,23 @@ protected:
bool enableExperiments_;
std::unique_ptr<SummaryState> summaryState_;
std::unique_ptr<UDQState> udqState_;
std::unique_ptr<Action::State> actionState_;
static std::unique_ptr<UDQState> udqState_;
static std::unique_ptr<Action::State> actionState_;
// Observe that this instance is handled differently from the other state
// variables, it will only be initialized for a restart run. While
// initializing a restarted run this instance is transferred to the WGState
// member in the well model.
std::unique_ptr<WellTestState> wtestState_;
static std::unique_ptr<WellTestState> wtestState_;
// these attributes point either to the internal or to the external version of the
// parser objects.
std::unique_ptr<ParseContext> parseContext_;
std::unique_ptr<ErrorGuard> errorGuard_;
std::shared_ptr<Python> python;
// These variables may be owned by both Python and the simulator
std::shared_ptr<Deck> deck_;
std::shared_ptr<EclipseState> eclState_;
std::shared_ptr<Schedule> eclSchedule_;
std::shared_ptr<SummaryConfig> eclSummaryConfig_;
static std::shared_ptr<Deck> deck_;
static std::shared_ptr<EclipseState> eclState_;
static std::shared_ptr<Schedule> eclSchedule_;
static std::shared_ptr<SummaryConfig> eclSummaryConfig_;
/*! \brief Information about wells in parallel
*

2
ebos/eclwriter.hh
View File

@@ -177,7 +177,7 @@ public:
const Scalar totalCpuTime =
simulator_.executionTimer().realTimeElapsed() +
simulator_.setupTimer().realTimeElapsed() +
simulator_.vanguard().externalSetupTime();
simulator_.vanguard().setupTime();
const auto localWellData = simulator_.problem().wellModel().wellData();
const auto localGroupAndNetworkData = simulator_.problem().wellModel()

21
flow/flow_ebos_blackoil.cpp
View File

@@ -24,27 +24,6 @@
namespace Opm {
void flowEbosBlackoilSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::unique_ptr<UDQState> udqState,
std::unique_ptr<Action::State> actionState,
std::unique_ptr<WellTestState> wtestState,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalUDQState(std::move(udqState));
Vanguard::setExternalActionState(std::move(actionState));
Vanguard::setExternalWTestState(std::move(wtestState));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
std::unique_ptr<FlowMainEbos<Properties::TTag::EclFlowProblem>>
flowEbosBlackoilMainInit(int argc, char** argv, bool outputCout, bool outputFiles)
{

15
flow/flow_ebos_blackoil.hpp
View File

@@ -21,26 +21,13 @@
namespace Opm {
class Deck;
class EclipseState;
template<class TypeTag> class FlowMainEbos;
class Schedule;
class SummaryConfig;
class UDQState;
class WellTestState;
namespace Action {
class State;
}
namespace Properties { namespace TTag { struct EclFlowProblem; } }
void flowEbosBlackoilSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::unique_ptr<UDQState> udqState,
std::unique_ptr<Action::State> actionState,
std::unique_ptr<WellTestState> wtestState,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosBlackoilMain(int argc, char** argv, bool outputCout, bool outputFiles);

15
flow/flow_ebos_brine.cpp
View File

@@ -37,21 +37,6 @@ struct EnableBrine<TypeTag, TTag::EclFlowBrineProblem> {
}}
namespace Opm {
void flowEbosBrineSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowBrineProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosBrineMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_brine.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_BRINE_HPP
#define FLOW_EBOS_BRINE_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosBrineSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosBrineMain(int argc, char** argv, bool outputCout, bool outputFiles);

15
flow/flow_ebos_brine_precsalt_vapwat.cpp
View File

@@ -47,21 +47,6 @@ struct EnableEvaporation<TypeTag, TTag::EclFlowBrinePrecsaltVapwatProblem> {
}}
namespace Opm {
void flowEbosBrinePrecsaltVapwatSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowBrinePrecsaltVapwatProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosBrinePrecsaltVapwatMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_brine_precsalt_vapwat.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_BRINE_PRECSALT_VAPWAT_HPP
#define FLOW_EBOS_BRINE_PRECSALT_VAPWAT_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosBrinePrecsaltVapwatSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosBrinePrecsaltVapwatMain(int argc, char** argv, bool outputCout, bool outputFiles);

15
flow/flow_ebos_brine_saltprecipitation.cpp
View File

@@ -42,21 +42,6 @@ struct EnableSaltPrecipitation<TypeTag, TTag::EclFlowBrineSaltPrecipitationProbl
}}
namespace Opm {
void flowEbosBrineSaltPrecipitationSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowBrineSaltPrecipitationProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosBrineSaltPrecipitationMain(int argc, char** argv, bool outputCout, bool outputFiles)

10
flow/flow_ebos_brine_saltprecipitation.hpp
View File

@@ -21,16 +21,6 @@
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosBrineSaltPrecipitationSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosBrineSaltPrecipitationMain(int argc, char** argv, bool outputCout, bool outputFiles);

14
flow/flow_ebos_energy.cpp
View File

@@ -37,20 +37,6 @@ struct EnableEnergy<TypeTag, TTag::EclFlowEnergyProblem> {
}}
namespace Opm {
void flowEbosEnergySetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowEnergyProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosEnergyMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_energy.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_ENERGY_HPP
#define FLOW_EBOS_ENERGY_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosEnergySetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosEnergyMain(int argc, char** argv, bool outputCout, bool outputFiles);

14
flow/flow_ebos_extbo.cpp
View File

@@ -37,20 +37,6 @@ struct EnableExtbo<TypeTag, TTag::EclFlowExtboProblem> {
}}
namespace Opm {
void flowEbosExtboSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowExtboProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosExtboMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_extbo.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_EXTBO_HPP
#define FLOW_EBOS_EXTBO_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosExtboSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosExtboMain(int argc, char** argv, bool outputCout, bool outputFiles);

15
flow/flow_ebos_foam.cpp
View File

@@ -37,21 +37,6 @@ struct EnableFoam<TypeTag, TTag::EclFlowFoamProblem> {
}}
namespace Opm {
void flowEbosFoamSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowFoamProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosFoamMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_foam.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_FOAM_HPP
#define FLOW_EBOS_FOAM_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosFoamSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosFoamMain(int argc, char** argv, bool outputCout, bool outputFiles);

15
flow/flow_ebos_gasoil.cpp
View File

@@ -58,21 +58,6 @@ public:
}}
namespace Opm {
void flowEbosGasOilSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowGasOilProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosGasOilMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_gasoil.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_GASOIL_HPP
#define FLOW_EBOS_GASOIL_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosGasOilSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosGasOilMain(int argc, char** argv, bool outputCout, bool outputFiles);

15
flow/flow_ebos_gasoil_energy.cpp
View File

@@ -62,21 +62,6 @@ struct EnableEnergy<TypeTag, TTag::EclFlowGasOilEnergyProblem> {
}}
namespace Opm {
void flowEbosGasOilEnergySetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowGasOilEnergyProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosGasOilEnergyMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_gasoil_energy.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_GASOIL_ENERGY_HPP
#define FLOW_EBOS_GASOIL_ENERGY_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosGasOilEnergySetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosGasOilEnergyMain(int argc, char** argv, bool outputCout, bool outputFiles);

14
flow/flow_ebos_gaswater.cpp
View File

@@ -61,20 +61,6 @@ public:
}}
namespace Opm {
void flowEbosGasWaterSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowGasWaterProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------

12
flow/flow_ebos_gaswater.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_GASWATER_HPP
#define FLOW_EBOS_GASWATER_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosGasWaterSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosGasWaterMain(int argc, char** argv, bool outputCout, bool outputFiles);

14
flow/flow_ebos_gaswater_brine.cpp
View File

@@ -61,20 +61,6 @@ public:
}}
namespace Opm {
void flowEbosGasWaterBrineSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowGasWaterBrineProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosGasWaterBrineMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_gaswater_brine.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_GASWATER_BRINE_HPP
#define FLOW_EBOS_GASWATER_BRINE_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosGasWaterBrineSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosGasWaterBrineMain(int argc, char** argv, bool outputCout, bool outputFiles);

14
flow/flow_ebos_gaswater_saltprec_vapwat.cpp
View File

@@ -72,20 +72,6 @@ public:
}}
namespace Opm {
void flowEbosGasWaterSaltprecVapwatSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowGasWaterSaltprecVapwatProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosGasWaterSaltprecVapwatMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_gaswater_saltprec_vapwat.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_GASWATERSALTPRECVAPWAT_BRINE_HPP
#define FLOW_EBOS_GASWATERSALTPRECVAPWAT_BRINE_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosGasWaterSaltprecVapwatSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosGasWaterSaltprecVapwatMain(int argc, char** argv, bool outputCout, bool outputFiles);

14
flow/flow_ebos_micp.cpp
View File

@@ -61,20 +61,6 @@ public:
}}
namespace Opm {
void flowEbosMICPSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowMICPProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosMICPMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_micp.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_MICP_HPP
#define FLOW_EBOS_MICP_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosMICPSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosMICPMain(int argc, char** argv, bool outputCout, bool outputFiles);

14
flow/flow_ebos_oilwater.cpp
View File

@@ -58,20 +58,6 @@ public:
}}
namespace Opm {
void flowEbosOilWaterSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowOilWaterProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosOilWaterMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_oilwater.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_OILWATER_HPP
#define FLOW_EBOS_OILWATER_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosOilWaterSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main functon used in main flow binary.
int flowEbosOilWaterMain(int argc, char** argv, bool outputCout, bool outputFiles);

14
flow/flow_ebos_oilwater_brine.cpp
View File

@@ -61,20 +61,6 @@ public:
}}
namespace Opm {
void flowEbosOilWaterBrineSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowOilWaterBrineProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosOilWaterBrineMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_oilwater_brine.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_OILWATER_BRINE_HPP
#define FLOW_EBOS_OILWATER_BRINE_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosOilWaterBrineSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosOilWaterBrineMain(int argc, char** argv, bool outputCout, bool outputFiles);

14
flow/flow_ebos_oilwater_polymer.cpp
View File

@@ -61,20 +61,6 @@ public:
}}
namespace Opm {
void flowEbosOilWaterPolymerSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowOilWaterPolymerProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosOilWaterPolymerMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_oilwater_polymer.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_OILWATER_POLYMER_HPP
#define FLOW_EBOS_OILWATER_POLYMER_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosOilWaterPolymerSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main functon used in main flow binary.
int flowEbosOilWaterPolymerMain(int argc, char** argv, bool outputCout, bool outputFiles);

15
flow/flow_ebos_onephase.cpp
View File

@@ -57,21 +57,6 @@ public:
} // namespace Opm::Properties
void flowEbosWaterOnlySetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowProblemWaterOnly;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosWaterOnlyMain(int argc, char** argv, bool outputCout, bool outputFiles)
{

20
flow/flow_ebos_onephase.hpp
View File

@@ -22,26 +22,12 @@
#ifndef FLOW_ONEPHASE_HPP
#define FLOW_ONEPHASE_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
template<class TypeTag> class FlowMainEbos;
class Schedule;
class SummaryConfig;
class UDQState;
class WellTestState;
namespace Action {
class State;
}
void flowEbosWaterOnlySetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main functon used in main flow binary.
int flowEbosWaterOnlyMain(int argc, char** argv, bool outputCout, bool outputFiles);
//! \brief Main function used in flow_onephase binary.
int flowEbosWaterOnlyMainStandalone(int argc, char** argv);
}

15
flow/flow_ebos_onephase_energy.cpp
View File

@@ -64,21 +64,6 @@ public:
} // namespace Opm::Properties
void flowEbosWaterOnlyEnergySetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowProblemWaterOnlyEnergy;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosWaterOnlyEnergyMain(int argc, char** argv, bool outputCout, bool outputFiles)
{

21
flow/flow_ebos_onephase_energy.hpp
View File

@@ -22,27 +22,14 @@
#ifndef FLOW_ONEPHASE_ENERGY_HPP
#define FLOW_ONEPHASE_ENERGY_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
template<class TypeTag> class FlowMainEbos;
class Schedule;
class SummaryConfig;
class UDQState;
class WellTestState;
namespace Action {
class State;
}
void flowEbosWaterOnlyEnergySetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main functon used in main flow binary.
int flowEbosWaterOnlyEnergyMain(int argc, char** argv, bool outputCout, bool outputFiles);
//! \brief Main function used in flow_onephase_energy binary.
int flowEbosWaterOnlyEnergyMainStandalone(int argc, char** argv);
}
#endif

14
flow/flow_ebos_polymer.cpp
View File

@@ -37,20 +37,6 @@ struct EnablePolymer<TypeTag, TTag::EclFlowPolymerProblem> {
}}
namespace Opm {
void flowEbosPolymerSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowPolymerProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosPolymerMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_polymer.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_POLYMER_HPP
#define FLOW_EBOS_POLYMER_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosPolymerSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosPolymerMain(int argc, char** argv, bool outputCout, bool outputFiles);

15
flow/flow_ebos_solvent.cpp
View File

@@ -37,21 +37,6 @@ struct EnableSolvent<TypeTag, TTag::EclFlowSolventProblem> {
}}
namespace Opm {
void flowEbosSolventSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using TypeTag = Properties::TTag::EclFlowSolventProblem;
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalSetupTime(setupTime);
Vanguard::setExternalDeck(std::move(deck));
Vanguard::setExternalEclState(std::move(eclState));
Vanguard::setExternalSchedule(std::move(schedule));
Vanguard::setExternalSummaryConfig(std::move(summaryConfig));
}
// ----------------- Main program -----------------
int flowEbosSolventMain(int argc, char** argv, bool outputCout, bool outputFiles)

12
flow/flow_ebos_solvent.hpp
View File

@@ -17,20 +17,8 @@
#ifndef FLOW_EBOS_SOLVENT_HPP
#define FLOW_EBOS_SOLVENT_HPP
#include <memory>
namespace Opm {
class Deck;
class EclipseState;
class Schedule;
class SummaryConfig;
void flowEbosSolventSetDeck(double setupTime, std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig);
//! \brief Main function used in flow binary.
int flowEbosSolventMain(int argc, char** argv, bool outoutCout, bool outputFiles);

92
opm/simulators/flow/Main.hpp
View File

@@ -96,20 +96,6 @@ struct FlowEarlyBird {
namespace Opm {
template <class TypeTag>
void flowEbosSetDeck(std::shared_ptr<Deck> deck,
std::shared_ptr<EclipseState> eclState,
std::shared_ptr<Schedule> schedule,
std::shared_ptr<SummaryConfig> summaryConfig)
{
using Vanguard = GetPropType<TypeTag, Properties::Vanguard>;
Vanguard::setExternalDeck(deck);
Vanguard::setExternalEclState(eclState);
Vanguard::setExternalSchedule(schedule);
Vanguard::setExternalSummaryConfig(summaryConfig);
}
// ----------------- Main program -----------------
template <class TypeTag>
int flowEbosMain(int argc, char** argv, bool outputCout, bool outputFiles)
@@ -260,7 +246,7 @@ public:
if (initialize_<Properties::TTag::FlowEarlyBird>(exitCode)) {
// TODO: check that this deck really represents a blackoil
// case. E.g. check that number of phases == 3
flowEbosBlackoilSetDeck(
EclGenericVanguard::setParams(
setupTime_,
deck_,
eclipseState_,
@@ -283,6 +269,15 @@ private:
const auto& rspec = this->eclipseState_->runspec();
const auto& phases = rspec.phases();
EclGenericVanguard::setParams(this->setupTime_,
this->deck_,
this->eclipseState_,
this->schedule_,
std::move(this->udqState_),
std::move(this->actionState_),
std::move(this->wtestState_),
this->summaryConfig_);
// run the actual simulator
//
// TODO: make sure that no illegal combinations like thermal and
@@ -357,8 +352,14 @@ private:
template <class TypeTag>
int dispatchStatic_()
{
flowEbosSetDeck<TypeTag>(
deck_, eclipseState_, schedule_, summaryConfig_);
EclGenericVanguard::setParams(this->setupTime_,
this->deck_,
this->eclipseState_,
this->schedule_,
std::move(this->udqState_),
std::move(this->actionState_),
std::move(this->wtestState_),
this->summaryConfig_);
return flowEbosMain<TypeTag>(argc_, argv_, outputCout_, outputFiles_);
}
@@ -584,12 +585,6 @@ private:
return EXIT_FAILURE;
}
flowEbosMICPSetDeck(this->setupTime_,
this->deck_,
this->eclipseState_,
this->schedule_,
this->summaryConfig_);
return flowEbosMICPMain(this->argc_,
this->argv_,
this->outputCout_,
@@ -600,22 +595,16 @@ private:
{
// oil-gas
if (phases.active( Phase::OIL ) && phases.active( Phase::GAS )) {
flowEbosGasOilSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosGasOilMain(argc_, argv_, outputCout_, outputFiles_);
}
// oil-water
else if ( phases.active( Phase::OIL ) && phases.active( Phase::WATER ) ) {
flowEbosOilWaterSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosOilWaterMain(argc_, argv_, outputCout_, outputFiles_);
}
// gas-water
else if ( phases.active( Phase::GAS ) && phases.active( Phase::WATER ) ) {
flowEbosGasWaterSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosGasWaterMain(argc_, argv_, outputCout_, outputFiles_);
}
else {
@@ -646,22 +635,15 @@ private:
}
if (phases.size() == 3) { // oil water polymer case
flowEbosOilWaterPolymerSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosOilWaterPolymerMain(argc_, argv_, outputCout_, outputFiles_);
}
else {
flowEbosPolymerSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosPolymerMain(argc_, argv_, outputCout_, outputFiles_);
}
}
int runFoam()
{
flowEbosFoamSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosFoamMain(argc_, argv_, outputCout_, outputFiles_);
}
@@ -674,8 +656,6 @@ private:
return EXIT_FAILURE;
}
flowEbosWaterOnlySetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosWaterOnlyMain(argc_, argv_, outputCout_, outputFiles_);
}
@@ -689,8 +669,6 @@ private:
return EXIT_FAILURE;
}
flowEbosWaterOnlyEnergySetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosWaterOnlyEnergyMain(argc_, argv_, outputCout_, outputFiles_);
}
@@ -708,21 +686,15 @@ private:
if (phases.size() == 3) {
if (phases.active(Phase::OIL)){ // oil water brine case
flowEbosOilWaterBrineSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosOilWaterBrineMain(argc_, argv_, outputCout_, outputFiles_);
}
if (phases.active(Phase::GAS)){ // gas water brine case
if (eclipseState_->getSimulationConfig().hasPRECSALT() &&
eclipseState_->getSimulationConfig().hasVAPWAT()) {
//case with water vaporization into gas phase and salt precipitation
flowEbosGasWaterSaltprecVapwatSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosGasWaterSaltprecVapwatMain(argc_, argv_, outputCout_, outputFiles_);
return flowEbosGasWaterSaltprecVapwatMain(argc_, argv_, outputCout_, outputFiles_);
}
else {
flowEbosGasWaterBrineSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosGasWaterBrineMain(argc_, argv_, outputCout_, outputFiles_);
}
}
@@ -730,19 +702,13 @@ private:
else if (eclipseState_->getSimulationConfig().hasPRECSALT()) {
if (eclipseState_->getSimulationConfig().hasVAPWAT()) {
//case with water vaporization into gas phase and salt precipitation
flowEbosBrinePrecsaltVapwatSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosBrinePrecsaltVapwatMain(argc_, argv_, outputCout_, outputFiles_);
}
else {
flowEbosBrineSaltPrecipitationSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosBrineSaltPrecipitationMain(argc_, argv_, outputCout_, outputFiles_);
}
}
else {
flowEbosBrineSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosBrineMain(argc_, argv_, outputCout_, outputFiles_);
}
@@ -751,17 +717,11 @@ private:
int runSolvent()
{
flowEbosSolventSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosSolventMain(argc_, argv_, outputCout_, outputFiles_);
}
int runExtendedBlackOil()
{
flowEbosExtboSetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosExtboMain(argc_, argv_, outputCout_, outputFiles_);
}
@@ -769,28 +729,14 @@ private:
{
// oil-gas-thermal
if (!phases.active( Phase::WATER ) && phases.active( Phase::OIL ) && phases.active( Phase::GAS )) {
flowEbosGasOilEnergySetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosGasOilEnergyMain(argc_, argv_, outputCout_, outputFiles_);
}
flowEbosEnergySetDeck(
setupTime_, deck_, eclipseState_, schedule_, summaryConfig_);
return flowEbosEnergyMain(argc_, argv_, outputCout_, outputFiles_);
}
int runBlackOil()
{
flowEbosBlackoilSetDeck(this->setupTime_,
this->deck_,
this->eclipseState_,
this->schedule_,
std::move(this->udqState_),
std::move(this->actionState_),
std::move(this->wtestState_),
this->summaryConfig_);
return flowEbosBlackoilMain(argc_, argv_, outputCout_, outputFiles_);
}

18
tests/test_ecl_output.cc
View File

@@ -26,22 +26,24 @@
#include <ebos/equil/equilibrationhelpers.hh>
#include <ebos/eclproblem.hh>
#include <opm/models/utils/start.hh>
#include <ebos/collecttoiorank.hh>
#include <ebos/ecloutputblackoilmodule.hh>
#include <ebos/eclwriter.hh>
#include <opm/grid/UnstructuredGrid.h>
#include <opm/grid/GridManager.hpp>
#include <opm/input/eclipse/Schedule/Action/State.hpp>
#include <opm/input/eclipse/Units/Units.hpp>
#include <opm/io/eclipse/ESmry.hpp>
#include <opm/models/utils/start.hh>
#include <opm/output/eclipse/Summary.hpp>
#include <ebos/collecttoiorank.hh>
#include <ebos/ecloutputblackoilmodule.hh>
#include <ebos/eclwriter.hh>
#include <opm/input/eclipse/Schedule/Action/State.hpp>
#include <opm/simulators/wells/BlackoilWellModel.hpp>
#include <opm/simulators/flow/BlackoilModelParametersEbos.hpp>
#include <opm/simulators/wells/BlackoilWellModel.hpp>
#if HAVE_DUNE_FEM
#include <dune/fem/misc/mpimanager.hh>
@@ -133,7 +135,9 @@ initSimulator(const char *filename)
Opm::setupParameters_<TypeTag>(/*argc=*/sizeof(argv)/sizeof(argv[0]), argv, /*registerParams=*/false);
return std::unique_ptr<Simulator>(new Simulator);
Opm::EclGenericVanguard::readDeck(filename);
return std::make_unique<Simulator>();
}
struct EclOutputFixture {

14
tests/test_equil.cc
View File

@@ -26,16 +26,18 @@
#include <ebos/equil/equilibrationhelpers.hh>
#include <ebos/eclproblem.hh>
#include <opm/models/utils/start.hh>
#include <opm/simulators/wells/BlackoilWellModel.hpp>
#include <opm/simulators/flow/BlackoilModelParametersEbos.hpp>
#include <ebos/eclgenericvanguard.hh>
#include <opm/grid/UnstructuredGrid.h>
#include <opm/grid/GridManager.hpp>
#include <opm/input/eclipse/Units/Units.hpp>
#include <opm/models/utils/start.hh>
#include <opm/simulators/flow/BlackoilModelParametersEbos.hpp>
#include <opm/simulators/wells/BlackoilWellModel.hpp>
#if HAVE_DUNE_FEM
#include <dune/fem/misc/mpimanager.hh>
#else
@@ -103,7 +105,9 @@ initSimulator(const char *filename)
Opm::setupParameters_<TypeTag>(/*argc=*/sizeof(argv)/sizeof(argv[0]), argv, /*registerParams=*/false);
return std::unique_ptr<Simulator>(new Simulator);
Opm::EclGenericVanguard::readDeck(filename);
return std::make_unique<Simulator>();
}
template <class GridView>

4
tests/test_glift1.cpp
View File

@@ -90,7 +90,9 @@ initSimulator(const char *filename)
Opm::setupParameters_<TypeTag>(/*argc=*/sizeof(argv)/sizeof(argv[0]), argv, /*registerParams=*/true);
return std::unique_ptr<Simulator>(new Simulator);
Opm::EclGenericVanguard::readDeck(filename);
return std::make_unique<Simulator>();
}