OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2024-12-28 02:00:59 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #5209 from akva2/drop_ecl_typetags

Browse Source 
Rename typetags - drop Ecl prefix
This commit is contained in:
Markus Blatt 2024-02-23 10:01:26 +01:00 committed by GitHub
commit 72d8abb837
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
43 changed files with 442 additions and 450 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
flow/flow_blackoil_alugrid.cpp
View File

@ -40,13 +40,13 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowProblemAlugrid {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowProblemAlugrid {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct Grid<TypeTag, TTag::EclFlowProblemAlugrid> {
struct Grid<TypeTag, TTag::FlowProblemAlugrid> {
static const int dim = 3;
#if HAVE_MPI
using type = Dune::ALUGrid<dim, dim, Dune::cube, Dune::nonconforming,Dune::ALUGridMPIComm>;
@ -54,20 +54,22 @@ struct Grid<TypeTag, TTag::EclFlowProblemAlugrid> {
using type = Dune::ALUGrid<dim, dim, Dune::cube, Dune::nonconforming, Dune::ALUGridNoComm>;
#endif
};
// alugrid need cp grid as equilgrid
template<class TypeTag>
struct EquilGrid<TypeTag, TTag::EclFlowProblemAlugrid> {
struct EquilGrid<TypeTag, TTag::FlowProblemAlugrid> {
using type = Dune::CpGrid;
};
template<class TypeTag>
struct Vanguard<TypeTag, TTag::EclFlowProblemAlugrid> {
struct Vanguard<TypeTag, TTag::FlowProblemAlugrid> {
using type = Opm::EclAluGridVanguard<TypeTag>;
};
}
}
int main(int argc, char** argv)
{
using TypeTag = Opm::Properties::TTag::EclFlowProblemAlugrid;
using TypeTag = Opm::Properties::TTag::FlowProblemAlugrid;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

19
flow/flow_blackoil_polyhedralgrid.cpp
View File

@ -38,39 +38,40 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowProblemPoly {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowProblemPoly {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct Linearizer<TypeTag, TTag::EclFlowProblemPoly> { using type = TpfaLinearizer<TypeTag>; };
struct Linearizer<TypeTag, TTag::FlowProblemPoly> { using type = TpfaLinearizer<TypeTag>; };
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::EclFlowProblemPoly> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
struct LocalResidual<TypeTag, TTag::FlowProblemPoly> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
template<class TypeTag>
struct EnableDiffusion<TypeTag, TTag::EclFlowProblemPoly> { static constexpr bool value = false; };
struct EnableDiffusion<TypeTag, TTag::FlowProblemPoly> { static constexpr bool value = false; };
template<class TypeTag>
struct Grid<TypeTag, TTag::EclFlowProblemPoly> {
struct Grid<TypeTag, TTag::FlowProblemPoly> {
using type = Dune::PolyhedralGrid<3, 3>;
};
template<class TypeTag>
struct EquilGrid<TypeTag, TTag::EclFlowProblemPoly> {
struct EquilGrid<TypeTag, TTag::FlowProblemPoly> {
//using type = Dune::CpGrid;
using type = GetPropType<TypeTag, Properties::Grid>;
};
template<class TypeTag>
struct Vanguard<TypeTag, TTag::EclFlowProblemPoly> {
struct Vanguard<TypeTag, TTag::FlowProblemPoly> {
using type = Opm::EclPolyhedralGridVanguard<TypeTag>;
};
}
}
int main(int argc, char** argv)
{
using TypeTag = Opm::Properties::TTag::EclFlowProblemPoly;
using TypeTag = Opm::Properties::TTag::FlowProblemPoly;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

2
flow/flow_distribute_z.cpp
View File

@ -61,7 +61,7 @@ std::vector<int> loadBalanceInZOnly(const Dune::CpGrid& grid)
int main(int argc, char** argv)
{
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
Opm::EclCpGridVanguard<Opm::Properties::TTag::EclFlowProblem>::setExternalLoadBalancer(loadBalanceInZOnly);
Opm::EclCpGridVanguard<Opm::Properties::TTag::FlowProblem>::setExternalLoadBalancer(loadBalanceInZOnly);
auto ret = mainObject->runDynamic();
// Destruct mainObject as the destructor calls MPI_Finalize!
mainObject.reset();

14
flow/flow_ebos_blackoil.cpp
View File

@ -30,13 +30,13 @@ namespace Opm {
namespace Properties {
template<class TypeTag>
struct Linearizer<TypeTag, TTag::EclFlowProblemTPFA> { using type = TpfaLinearizer<TypeTag>; };
struct Linearizer<TypeTag, TTag::FlowProblemTPFA> { using type = TpfaLinearizer<TypeTag>; };
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::EclFlowProblemTPFA> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
struct LocalResidual<TypeTag, TTag::FlowProblemTPFA> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
template<class TypeTag>
struct EnableDiffusion<TypeTag, TTag::EclFlowProblemTPFA> { static constexpr bool value = false; };
struct EnableDiffusion<TypeTag, TTag::FlowProblemTPFA> { static constexpr bool value = false; };
}
}
@ -44,14 +44,14 @@ namespace Opm {
namespace Opm
{
std::unique_ptr<FlowMain<Properties::TTag::EclFlowProblemTPFA>>
std::unique_ptr<FlowMain<Properties::TTag::FlowProblemTPFA>>
flowEbosBlackoilTpfaMainInit(int argc, char** argv, bool outputCout, bool outputFiles)
{
// we always want to use the default locale, and thus spare us the trouble
// with incorrect locale settings.
resetLocale();
return std::make_unique<FlowMain<Properties::TTag::EclFlowProblemTPFA>>(
return std::make_unique<FlowMain<Properties::TTag::FlowProblemTPFA>>(
argc, argv, outputCout, outputFiles);
}
@ -62,14 +62,14 @@ int flowEbosBlackoilTpfaMain(int argc, char** argv, bool outputCout, bool output
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowProblemTPFA>
FlowMain<Properties::TTag::FlowProblemTPFA>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosBlackoilTpfaMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowProblemTPFA;
using TypeTag = Properties::TTag::FlowProblemTPFA;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

20
flow/flow_ebos_blackoil.hpp
View File

@ -19,30 +19,22 @@
#include <memory>
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowProblem;
struct EclFlowProblemTPFA {
using InheritsFrom = std::tuple<EclFlowProblem>;
};
}
}
namespace Opm::Properties::TTag {
struct FlowProblem;
struct FlowProblemTPFA {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
namespace Opm {
//! \brief Main function used in flow binary.
int flowEbosBlackoilTpfaMain(int argc, char** argv, bool outputCout, bool outputFiles);
template<class TypeTag> class FlowMain;
//! \brief Initialization function used in flow binary and python simulator.
std::unique_ptr<FlowMain<Properties::TTag::EclFlowProblemTPFA>>
std::unique_ptr<FlowMain<Properties::TTag::FlowProblemTPFA>>
flowEbosBlackoilTpfaMainInit(int argc, char** argv, bool outputCout, bool outputFiles);
//! \brief Main function used in flow_brine binary.

6
flow/flow_ebos_blackoil_legacyassembly.cpp
View File

@ -24,14 +24,14 @@
namespace Opm {
std::unique_ptr<FlowMain<Properties::TTag::EclFlowProblem>>
std::unique_ptr<FlowMain<Properties::TTag::FlowProblem>>
flowEbosBlackoilMainInit(int argc, char** argv, bool outputCout, bool outputFiles)
{
// we always want to use the default locale, and thus spare us the trouble
// with incorrect locale settings.
resetLocale();
return std::make_unique<FlowMain<Properties::TTag::EclFlowProblem>>(
return std::make_unique<FlowMain<Properties::TTag::FlowProblem>>(
argc, argv, outputCout, outputFiles);
}
@ -44,7 +44,7 @@ int flowEbosBlackoilMain(int argc, char** argv, bool outputCout, bool outputFile
int flowEbosBlackoilMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowProblem;
using TypeTag = Properties::TTag::FlowProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

4
flow/flow_ebos_blackoil_legacyassembly.hpp
View File

@ -26,13 +26,13 @@ template<class TypeTag> class FlowMain;
namespace Action {
class State;
}
namespace Properties { namespace TTag { struct EclFlowProblem; } }
namespace Properties { namespace TTag { struct FlowProblem; } }
//! \brief Main function used in flow binary.
int flowEbosBlackoilMain(int argc, char** argv, bool outputCout, bool outputFiles);
//! \brief Initialization function used in flow binary and python simulator.
std::unique_ptr<FlowMain<Properties::TTag::EclFlowProblem>>
std::unique_ptr<FlowMain<Properties::TTag::FlowProblem>>
flowEbosBlackoilMainInit(int argc, char** argv, bool outputCout, bool outputFiles);
//! \brief Main function used in flow_blackoil binary.

10
flow/flow_ebos_brine.cpp
View File

@ -26,12 +26,12 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowBrineProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowBrineProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableBrine<TypeTag, TTag::EclFlowBrineProblem> {
struct EnableBrine<TypeTag, TTag::FlowBrineProblem> {
static constexpr bool value = true;
};
}}
@ -45,14 +45,14 @@ int flowEbosBrineMain(int argc, char** argv, bool outputCout, bool outputFiles)
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowBrineProblem>
FlowMain<Properties::TTag::FlowBrineProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosBrineMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowBrineProblem;
using TypeTag = Properties::TTag::FlowBrineProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

10
flow/flow_ebos_brine_energy.cpp
View File

@ -20,23 +20,23 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowBrineProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowBrineEnergyProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableBrine<TypeTag, TTag::EclFlowBrineProblem> {
struct EnableBrine<TypeTag, TTag::FlowBrineEnergyProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableEnergy<TypeTag, TTag::EclFlowBrineProblem> {
struct EnableEnergy<TypeTag, TTag::FlowBrineEnergyProblem> {
static constexpr bool value = true;
};
}
int flowEbosBrineEnergyMain(int argc, char** argv)
{
using TypeTag = Opm::Properties::TTag::EclFlowBrineProblem;
using TypeTag = Opm::Properties::TTag::FlowBrineEnergyProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

14
flow/flow_ebos_brine_precsalt_vapwat.cpp
View File

@ -26,22 +26,22 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowBrinePrecsaltVapwatProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowBrinePrecsaltVapwatProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableBrine<TypeTag, TTag::EclFlowBrinePrecsaltVapwatProblem> {
struct EnableBrine<TypeTag, TTag::FlowBrinePrecsaltVapwatProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableSaltPrecipitation<TypeTag, TTag::EclFlowBrinePrecsaltVapwatProblem> {
struct EnableSaltPrecipitation<TypeTag, TTag::FlowBrinePrecsaltVapwatProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableVapwat<TypeTag, TTag::EclFlowBrinePrecsaltVapwatProblem> {
struct EnableVapwat<TypeTag, TTag::FlowBrinePrecsaltVapwatProblem> {
static constexpr bool value = true;
};
}}
@ -55,14 +55,14 @@ int flowEbosBrinePrecsaltVapwatMain(int argc, char** argv, bool outputCout, bool
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowBrinePrecsaltVapwatProblem>
FlowMain<Properties::TTag::FlowBrinePrecsaltVapwatProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosBrinePrecsaltVapwatMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowBrinePrecsaltVapwatProblem;
using TypeTag = Properties::TTag::FlowBrinePrecsaltVapwatProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

12
flow/flow_ebos_brine_saltprecipitation.cpp
View File

@ -26,17 +26,17 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowBrineSaltPrecipitationProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowBrineSaltPrecipitationProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableBrine<TypeTag, TTag::EclFlowBrineSaltPrecipitationProblem> {
struct EnableBrine<TypeTag, TTag::FlowBrineSaltPrecipitationProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableSaltPrecipitation<TypeTag, TTag::EclFlowBrineSaltPrecipitationProblem> {
struct EnableSaltPrecipitation<TypeTag, TTag::FlowBrineSaltPrecipitationProblem> {
static constexpr bool value = true;
};
}}
@ -50,14 +50,14 @@ int flowEbosBrineSaltPrecipitationMain(int argc, char** argv, bool outputCout, b
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowBrineSaltPrecipitationProblem>
FlowMain<Properties::TTag::FlowBrineSaltPrecipitationProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosBrineSaltPrecipitationMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowBrineSaltPrecipitationProblem;
using TypeTag = Properties::TTag::FlowBrineSaltPrecipitationProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

10
flow/flow_ebos_energy.cpp
View File

@ -26,13 +26,13 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowEnergyProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowEnergyProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableEnergy<TypeTag, TTag::EclFlowEnergyProblem> {
struct EnableEnergy<TypeTag, TTag::FlowEnergyProblem> {
static constexpr bool value = true;
};
}}
@ -46,14 +46,14 @@ int flowEbosEnergyMain(int argc, char** argv, bool outputCout, bool outputFiles)
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowEnergyProblem>
FlowMain<Properties::TTag::FlowEnergyProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosEnergyMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowEnergyProblem;
using TypeTag = Properties::TTag::FlowEnergyProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

10
flow/flow_ebos_extbo.cpp
View File

@ -26,12 +26,12 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowExtboProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowExtboProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableExtbo<TypeTag, TTag::EclFlowExtboProblem> {
struct EnableExtbo<TypeTag, TTag::FlowExtboProblem> {
static constexpr bool value = true;
};
}}
@ -45,14 +45,14 @@ int flowEbosExtboMain(int argc, char** argv, bool outputCout, bool outputFiles)
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowExtboProblem>
FlowMain<Properties::TTag::FlowExtboProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosExtboMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowExtboProblem;
using TypeTag = Properties::TTag::FlowExtboProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

10
flow/flow_ebos_foam.cpp
View File

@ -26,12 +26,12 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowFoamProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowFoamProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableFoam<TypeTag, TTag::EclFlowFoamProblem> {
struct EnableFoam<TypeTag, TTag::FlowFoamProblem> {
static constexpr bool value = true;
};
}}
@ -45,14 +45,14 @@ int flowEbosFoamMain(int argc, char** argv, bool outputCout, bool outputFiles)
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowFoamProblem>
FlowMain<Properties::TTag::FlowFoamProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosFoamMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowFoamProblem;
using TypeTag = Properties::TTag::FlowFoamProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

36
flow/flow_ebos_gasoil.cpp
View File

@ -31,41 +31,41 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowGasOilProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowGasOilProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct Linearizer<TypeTag, TTag::EclFlowGasOilProblem> { using type = TpfaLinearizer<TypeTag>; };
struct Linearizer<TypeTag, TTag::FlowGasOilProblem> { using type = TpfaLinearizer<TypeTag>; };
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::EclFlowGasOilProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
struct LocalResidual<TypeTag, TTag::FlowGasOilProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
template<class TypeTag>
struct EnableDiffusion<TypeTag, TTag::EclFlowGasOilProblem> { static constexpr bool value = false; };
struct EnableDiffusion<TypeTag, TTag::FlowGasOilProblem> { static constexpr bool value = false; };
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowGasOilProblem>
struct Indices<TypeTag, TTag::FlowGasOilProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::waterCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::waterCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -78,14 +78,14 @@ int flowEbosGasOilMain(int argc, char** argv, bool outputCout, bool outputFiles)
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowGasOilProblem>
FlowMain<Properties::TTag::FlowGasOilProblem>
mainfunc {argc, argv, outputCout, outputFiles} ;
return mainfunc.execute();
}
int flowEbosGasOilMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowGasOilProblem;
using TypeTag = Properties::TTag::FlowGasOilProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

40
flow/flow_ebos_gasoil_energy.cpp
View File

@ -30,48 +30,48 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowGasOilEnergyProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowGasOilEnergyProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowGasOilEnergyProblem>
struct Indices<TypeTag, TTag::FlowGasOilEnergyProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::waterCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::waterCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
template<class TypeTag>
struct EnableEnergy<TypeTag, TTag::EclFlowGasOilEnergyProblem> {
struct EnableEnergy<TypeTag, TTag::FlowGasOilEnergyProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct Linearizer<TypeTag, TTag::EclFlowGasOilEnergyProblem> { using type = TpfaLinearizer<TypeTag>; };
struct Linearizer<TypeTag, TTag::FlowGasOilEnergyProblem> { using type = TpfaLinearizer<TypeTag>; };
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::EclFlowGasOilEnergyProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
struct LocalResidual<TypeTag, TTag::FlowGasOilEnergyProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
template<class TypeTag>
struct EnableDiffusion<TypeTag, TTag::EclFlowGasOilEnergyProblem> { static constexpr bool value = true; };
struct EnableDiffusion<TypeTag, TTag::FlowGasOilEnergyProblem> { static constexpr bool value = true; };
template<class TypeTag>
struct EnableDispersion<TypeTag, TTag::EclFlowGasOilEnergyProblem> { static constexpr bool value = true; };
struct EnableDispersion<TypeTag, TTag::FlowGasOilEnergyProblem> { static constexpr bool value = true; };
}}
@ -84,14 +84,14 @@ int flowEbosGasOilEnergyMain(int argc, char** argv, bool outputCout, bool output
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowGasOilEnergyProblem>
FlowMain<Properties::TTag::FlowGasOilEnergyProblem>
mainfunc {argc, argv, outputCout, outputFiles} ;
return mainfunc.execute();
}
int flowEbosGasOilEnergyMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowGasOilEnergyProblem;
using TypeTag = Properties::TTag::FlowGasOilEnergyProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

38
flow/flow_ebos_gasoildiffuse.cpp
View File

@ -30,44 +30,44 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowGasOilDiffuseProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowGasOilDiffuseProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct Linearizer<TypeTag, TTag::EclFlowGasOilDiffuseProblem> { using type = TpfaLinearizer<TypeTag>; };
struct Linearizer<TypeTag, TTag::FlowGasOilDiffuseProblem> { using type = TpfaLinearizer<TypeTag>; };
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::EclFlowGasOilDiffuseProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
struct LocalResidual<TypeTag, TTag::FlowGasOilDiffuseProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
template<class TypeTag>
struct EnableDiffusion<TypeTag, TTag::EclFlowGasOilDiffuseProblem> { static constexpr bool value = true; };
struct EnableDiffusion<TypeTag, TTag::FlowGasOilDiffuseProblem> { static constexpr bool value = true; };
template<class TypeTag>
struct EnableDispersion<TypeTag, TTag::EclFlowGasOilDiffuseProblem> { static constexpr bool value = true; };
struct EnableDispersion<TypeTag, TTag::FlowGasOilDiffuseProblem> { static constexpr bool value = true; };
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowGasOilDiffuseProblem>
struct Indices<TypeTag, TTag::FlowGasOilDiffuseProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::waterCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::waterCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -80,14 +80,14 @@ int flowEbosGasOilDiffuseMain(int argc, char** argv, bool outputCout, bool outpu
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowGasOilDiffuseProblem>
FlowMain<Properties::TTag::FlowGasOilDiffuseProblem>
mainfunc {argc, argv, outputCout, outputFiles} ;
return mainfunc.execute();
}
int flowEbosGasOilDiffuseMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowGasOilDiffuseProblem;
using TypeTag = Properties::TTag::FlowGasOilDiffuseProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

36
flow/flow_ebos_gaswater.cpp
View File

@ -34,41 +34,41 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowGasWaterProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowGasWaterProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct Linearizer<TypeTag, TTag::EclFlowGasWaterProblem> { using type = TpfaLinearizer<TypeTag>; };
struct Linearizer<TypeTag, TTag::FlowGasWaterProblem> { using type = TpfaLinearizer<TypeTag>; };
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::EclFlowGasWaterProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
struct LocalResidual<TypeTag, TTag::FlowGasWaterProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
template<class TypeTag>
struct EnableDiffusion<TypeTag, TTag::EclFlowGasWaterProblem> { static constexpr bool value = false; };
struct EnableDiffusion<TypeTag, TTag::FlowGasWaterProblem> { static constexpr bool value = false; };
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowGasWaterProblem>
struct Indices<TypeTag, TTag::FlowGasWaterProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -82,14 +82,14 @@ int flowEbosGasWaterMain(int argc, char** argv, bool outputCout, bool outputFile
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowGasWaterProblem>
FlowMain<Properties::TTag::FlowGasWaterProblem>
mainfunc {argc, argv, outputCout, outputFiles} ;
return mainfunc.execute();
}
int flowEbosGasWaterMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowGasWaterProblem;
using TypeTag = Properties::TTag::FlowGasWaterProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

36
flow/flow_ebos_gaswater_brine.cpp
View File

@ -28,43 +28,43 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowGasWaterBrineProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowGasWaterBrineProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableBrine<TypeTag, TTag::EclFlowGasWaterBrineProblem> {
struct EnableBrine<TypeTag, TTag::FlowGasWaterBrineProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableDisgasInWater<TypeTag, TTag::EclFlowGasWaterBrineProblem> {
struct EnableDisgasInWater<TypeTag, TTag::FlowGasWaterBrineProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableVapwat<TypeTag, TTag::EclFlowGasWaterBrineProblem> {
struct EnableVapwat<TypeTag, TTag::FlowGasWaterBrineProblem> {
static constexpr bool value = true;
};
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowGasWaterBrineProblem>
struct Indices<TypeTag, TTag::FlowGasWaterBrineProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -77,14 +77,14 @@ int flowEbosGasWaterBrineMain(int argc, char** argv, bool outputCout, bool outpu
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowGasWaterBrineProblem>
FlowMain<Properties::TTag::FlowGasWaterBrineProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosGasWaterBrineMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowGasWaterBrineProblem;
using TypeTag = Properties::TTag::FlowGasWaterBrineProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

40
flow/flow_ebos_gaswater_dissolution.cpp
View File

@ -34,51 +34,51 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowGasWaterDissolutionProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowGasWaterDissolutionProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct Linearizer<TypeTag, TTag::EclFlowGasWaterDissolutionProblem> { using type = TpfaLinearizer<TypeTag>; };
struct Linearizer<TypeTag, TTag::FlowGasWaterDissolutionProblem> { using type = TpfaLinearizer<TypeTag>; };
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::EclFlowGasWaterDissolutionProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
struct LocalResidual<TypeTag, TTag::FlowGasWaterDissolutionProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
template<class TypeTag>
struct EnableDiffusion<TypeTag, TTag::EclFlowGasWaterDissolutionProblem> { static constexpr bool value = false; };
struct EnableDiffusion<TypeTag, TTag::FlowGasWaterDissolutionProblem> { static constexpr bool value = false; };
template<class TypeTag>
struct EnableDisgasInWater<TypeTag, TTag::EclFlowGasWaterDissolutionProblem> {
struct EnableDisgasInWater<TypeTag, TTag::FlowGasWaterDissolutionProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableVapwat<TypeTag, TTag::EclFlowGasWaterDissolutionProblem> {
struct EnableVapwat<TypeTag, TTag::FlowGasWaterDissolutionProblem> {
static constexpr bool value = true;
};
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowGasWaterDissolutionProblem>
struct Indices<TypeTag, TTag::FlowGasWaterDissolutionProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -92,14 +92,14 @@ int flowEbosGasWaterDissolutionMain(int argc, char** argv, bool outputCout, bool
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowGasWaterDissolutionProblem>
FlowMain<Properties::TTag::FlowGasWaterDissolutionProblem>
mainfunc {argc, argv, outputCout, outputFiles} ;
return mainfunc.execute();
}
int flowEbosGasWaterDissolutionMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowGasWaterDissolutionProblem;
using TypeTag = Properties::TTag::FlowGasWaterDissolutionProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

42
flow/flow_ebos_gaswater_dissolution_diffuse.cpp
View File

@ -34,54 +34,54 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowGasWaterDissolutionDiffuseProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowGasWaterDissolutionDiffuseProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct Linearizer<TypeTag, TTag::EclFlowGasWaterDissolutionDiffuseProblem> { using type = TpfaLinearizer<TypeTag>; };
struct Linearizer<TypeTag, TTag::FlowGasWaterDissolutionDiffuseProblem> { using type = TpfaLinearizer<TypeTag>; };
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::EclFlowGasWaterDissolutionDiffuseProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
struct LocalResidual<TypeTag, TTag::FlowGasWaterDissolutionDiffuseProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
template<class TypeTag>
struct EnableDiffusion<TypeTag, TTag::EclFlowGasWaterDissolutionDiffuseProblem> { static constexpr bool value = true; };
struct EnableDiffusion<TypeTag, TTag::FlowGasWaterDissolutionDiffuseProblem> { static constexpr bool value = true; };
template<class TypeTag>
struct EnableDispersion<TypeTag, TTag::EclFlowGasWaterDissolutionDiffuseProblem> { static constexpr bool value = true; };
struct EnableDispersion<TypeTag, TTag::FlowGasWaterDissolutionDiffuseProblem> { static constexpr bool value = true; };
template<class TypeTag>
struct EnableDisgasInWater<TypeTag, TTag::EclFlowGasWaterDissolutionDiffuseProblem> {
struct EnableDisgasInWater<TypeTag, TTag::FlowGasWaterDissolutionDiffuseProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableVapwat<TypeTag, TTag::EclFlowGasWaterDissolutionDiffuseProblem> {
struct EnableVapwat<TypeTag, TTag::FlowGasWaterDissolutionDiffuseProblem> {
static constexpr bool value = true;
};
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowGasWaterDissolutionDiffuseProblem>
struct Indices<TypeTag, TTag::FlowGasWaterDissolutionDiffuseProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -95,14 +95,14 @@ int flowEbosGasWaterDissolutionDiffuseMain(int argc, char** argv, bool outputCou
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowGasWaterDissolutionDiffuseProblem>
FlowMain<Properties::TTag::FlowGasWaterDissolutionDiffuseProblem>
mainfunc {argc, argv, outputCout, outputFiles} ;
return mainfunc.execute();
}
int flowEbosGasWaterDissolutionDiffuseMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowGasWaterDissolutionDiffuseProblem;
using TypeTag = Properties::TTag::FlowGasWaterDissolutionDiffuseProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

44
flow/flow_ebos_gaswater_energy.cpp
View File

@ -34,59 +34,59 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowGasWaterEnergyProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowGasWaterEnergyProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct Linearizer<TypeTag, TTag::EclFlowGasWaterEnergyProblem> { using type = TpfaLinearizer<TypeTag>; };
struct Linearizer<TypeTag, TTag::FlowGasWaterEnergyProblem> { using type = TpfaLinearizer<TypeTag>; };
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::EclFlowGasWaterEnergyProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
struct LocalResidual<TypeTag, TTag::FlowGasWaterEnergyProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
template<class TypeTag>
struct EnableDiffusion<TypeTag, TTag::EclFlowGasWaterEnergyProblem> { static constexpr bool value = true; };
struct EnableDiffusion<TypeTag, TTag::FlowGasWaterEnergyProblem> { static constexpr bool value = true; };
template<class TypeTag>
struct EnableDispersion<TypeTag, TTag::EclFlowGasWaterEnergyProblem> { static constexpr bool value = true; };
struct EnableDispersion<TypeTag, TTag::FlowGasWaterEnergyProblem> { static constexpr bool value = true; };
template<class TypeTag>
struct EnableEnergy<TypeTag, TTag::EclFlowGasWaterEnergyProblem> {
struct EnableEnergy<TypeTag, TTag::FlowGasWaterEnergyProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableDisgasInWater<TypeTag, TTag::EclFlowGasWaterEnergyProblem> {
struct EnableDisgasInWater<TypeTag, TTag::FlowGasWaterEnergyProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableVapwat<TypeTag, TTag::EclFlowGasWaterEnergyProblem> {
struct EnableVapwat<TypeTag, TTag::FlowGasWaterEnergyProblem> {
static constexpr bool value = true;
};
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowGasWaterEnergyProblem>
struct Indices<TypeTag, TTag::FlowGasWaterEnergyProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -100,14 +100,14 @@ int flowEbosGasWaterEnergyMain(int argc, char** argv, bool outputCout, bool outp
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowGasWaterEnergyProblem>
FlowMain<Properties::TTag::FlowGasWaterEnergyProblem>
mainfunc {argc, argv, outputCout, outputFiles} ;
return mainfunc.execute();
}
int flowEbosGasWaterEnergyMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowGasWaterEnergyProblem;
using TypeTag = Properties::TTag::FlowGasWaterEnergyProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

40
flow/flow_ebos_gaswater_saltprec_energy.cpp
View File

@ -28,56 +28,56 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowGasWaterSaltprecEnergyProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowGasWaterSaltprecEnergyProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableBrine<TypeTag, TTag::EclFlowGasWaterSaltprecEnergyProblem> {
struct EnableBrine<TypeTag, TTag::FlowGasWaterSaltprecEnergyProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableSaltPrecipitation<TypeTag, TTag::EclFlowGasWaterSaltprecEnergyProblem> {
struct EnableSaltPrecipitation<TypeTag, TTag::FlowGasWaterSaltprecEnergyProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableVapwat<TypeTag, TTag::EclFlowGasWaterSaltprecEnergyProblem> {
struct EnableVapwat<TypeTag, TTag::FlowGasWaterSaltprecEnergyProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableDisgasInWater<TypeTag, TTag::EclFlowGasWaterSaltprecEnergyProblem> {
struct EnableDisgasInWater<TypeTag, TTag::FlowGasWaterSaltprecEnergyProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableEnergy<TypeTag, TTag::EclFlowGasWaterSaltprecEnergyProblem> {
struct EnableEnergy<TypeTag, TTag::FlowGasWaterSaltprecEnergyProblem> {
static constexpr bool value = true;
};
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowGasWaterSaltprecEnergyProblem>
struct Indices<TypeTag, TTag::FlowGasWaterSaltprecEnergyProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -90,14 +90,14 @@ int flowEbosGasWaterSaltprecEnergyMain(int argc, char** argv, bool outputCout, b
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowGasWaterSaltprecEnergyProblem>
FlowMain<Properties::TTag::FlowGasWaterSaltprecEnergyProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosGasWaterSaltprecEnergyMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowGasWaterSaltprecEnergyProblem;
using TypeTag = Properties::TTag::FlowGasWaterSaltprecEnergyProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

38
flow/flow_ebos_gaswater_saltprec_vapwat.cpp
View File

@ -28,51 +28,51 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowGasWaterSaltprecVapwatProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowGasWaterSaltprecVapwatProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableBrine<TypeTag, TTag::EclFlowGasWaterSaltprecVapwatProblem> {
struct EnableBrine<TypeTag, TTag::FlowGasWaterSaltprecVapwatProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableSaltPrecipitation<TypeTag, TTag::EclFlowGasWaterSaltprecVapwatProblem> {
struct EnableSaltPrecipitation<TypeTag, TTag::FlowGasWaterSaltprecVapwatProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableVapwat<TypeTag, TTag::EclFlowGasWaterSaltprecVapwatProblem> {
struct EnableVapwat<TypeTag, TTag::FlowGasWaterSaltprecVapwatProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableDisgasInWater<TypeTag, TTag::EclFlowGasWaterSaltprecVapwatProblem> {
struct EnableDisgasInWater<TypeTag, TTag::FlowGasWaterSaltprecVapwatProblem> {
static constexpr bool value = true;
};
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowGasWaterSaltprecVapwatProblem>
struct Indices<TypeTag, TTag::FlowGasWaterSaltprecVapwatProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -85,14 +85,14 @@ int flowEbosGasWaterSaltprecVapwatMain(int argc, char** argv, bool outputCout, b
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowGasWaterSaltprecVapwatProblem>
FlowMain<Properties::TTag::FlowGasWaterSaltprecVapwatProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosGasWaterSaltprecVapwatMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowGasWaterSaltprecVapwatProblem;
using TypeTag = Properties::TTag::FlowGasWaterSaltprecVapwatProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

32
flow/flow_ebos_gaswater_solvent.cpp
View File

@ -31,37 +31,37 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowGasWaterSolventProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowGasWaterSolventProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableSolvent<TypeTag, TTag::EclFlowGasWaterSolventProblem> {
struct EnableSolvent<TypeTag, TTag::FlowGasWaterSolventProblem> {
static constexpr bool value = true;
};
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowGasWaterSolventProblem>
struct Indices<TypeTag, TTag::FlowGasWaterSolventProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::oilCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -75,14 +75,14 @@ int flowEbosGasWaterSolventMain(int argc, char** argv, bool outputCout, bool out
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowGasWaterSolventProblem>
FlowMain<Properties::TTag::FlowGasWaterSolventProblem>
mainfunc {argc, argv, outputCout, outputFiles} ;
return mainfunc.execute();
}
int flowEbosGasWaterSolventMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowGasWaterSolventProblem;
using TypeTag = Properties::TTag::FlowGasWaterSolventProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

18
flow/flow_ebos_micp.cpp
View File

@ -28,27 +28,27 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowMICPProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowMICPProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableMICP<TypeTag, TTag::EclFlowMICPProblem> {
struct EnableMICP<TypeTag, TTag::FlowMICPProblem> {
static constexpr bool value = true;
};
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowMICPProblem>
struct Indices<TypeTag, TTag::FlowMICPProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilOnePhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
using type = BlackOilOnePhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
@ -56,7 +56,7 @@ public:
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*enabledCompIdx=*/FluidSystem::waterCompIdx,
5> type; //Five MICP components
5>; //Five MICP components
};
}}
@ -69,14 +69,14 @@ int flowEbosMICPMain(int argc, char** argv, bool outputCout, bool outputFiles)
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowMICPProblem>
FlowMain<Properties::TTag::FlowMICPProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosMICPMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowMICPProblem;
using TypeTag = Properties::TTag::FlowMICPProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

40
flow/flow_ebos_oilwater.cpp
View File

@ -31,44 +31,42 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowOilWaterProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowOilWaterProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct Linearizer<TypeTag, TTag::FlowOilWaterProblem> { using type = TpfaLinearizer<TypeTag>; };
template<class TypeTag>
struct Linearizer<TypeTag, TTag::EclFlowOilWaterProblem> { using type = TpfaLinearizer<TypeTag>; };
struct LocalResidual<TypeTag, TTag::FlowOilWaterProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::EclFlowOilWaterProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
template<class TypeTag>
struct EnableDiffusion<TypeTag, TTag::EclFlowOilWaterProblem> { static constexpr bool value = false; };
struct EnableDiffusion<TypeTag, TTag::FlowOilWaterProblem> { static constexpr bool value = false; };
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowOilWaterProblem>
struct Indices<TypeTag, TTag::FlowOilWaterProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::gasCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::gasCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -81,14 +79,14 @@ int flowEbosOilWaterMain(int argc, char** argv, bool outputCout, bool outputFile
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowOilWaterProblem>
FlowMain<Properties::TTag::FlowOilWaterProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosOilWaterMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowOilWaterProblem;
using TypeTag = Properties::TTag::FlowOilWaterProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

32
flow/flow_ebos_oilwater_brine.cpp
View File

@ -28,35 +28,35 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowOilWaterBrineProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowOilWaterBrineProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableBrine<TypeTag, TTag::EclFlowOilWaterBrineProblem> {
struct EnableBrine<TypeTag, TTag::FlowOilWaterBrineProblem> {
static constexpr bool value = true;
};
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowOilWaterBrineProblem>
struct Indices<TypeTag, TTag::FlowOilWaterBrineProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::gasCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::gasCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -69,14 +69,14 @@ int flowEbosOilWaterBrineMain(int argc, char** argv, bool outputCout, bool outpu
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowOilWaterBrineProblem>
FlowMain<Properties::TTag::FlowOilWaterBrineProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosOilWaterBrineMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowOilWaterBrineProblem;
using TypeTag = Properties::TTag::FlowOilWaterBrineProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

32
flow/flow_ebos_oilwater_polymer.cpp
View File

@ -28,35 +28,35 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowOilWaterPolymerProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowOilWaterPolymerProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnablePolymer<TypeTag, TTag::EclFlowOilWaterPolymerProblem> {
struct EnablePolymer<TypeTag, TTag::FlowOilWaterPolymerProblem> {
static constexpr bool value = true;
};
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowOilWaterPolymerProblem>
struct Indices<TypeTag, TTag::FlowOilWaterPolymerProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::gasCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::gasCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -69,14 +69,14 @@ int flowEbosOilWaterPolymerMain(int argc, char** argv, bool outputCout, bool out
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowOilWaterPolymerProblem>
FlowMain<Properties::TTag::FlowOilWaterPolymerProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosOilWaterPolymerMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowOilWaterPolymerProblem;
using TypeTag = Properties::TTag::FlowOilWaterPolymerProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

35
flow/flow_ebos_oilwater_polymer_injectivity.cpp
View File

@ -28,41 +28,42 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowOilWaterPolymerInjectivityProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowOilWaterPolymerInjectivityProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnablePolymer<TypeTag, TTag::EclFlowOilWaterPolymerInjectivityProblem> {
struct EnablePolymer<TypeTag, TTag::FlowOilWaterPolymerInjectivityProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnablePolymerMW<TypeTag, TTag::EclFlowOilWaterPolymerInjectivityProblem> {
struct EnablePolymerMW<TypeTag, TTag::FlowOilWaterPolymerInjectivityProblem> {
static constexpr bool value = true;
};
//! The indices required by the model
// For this case, there will be two primary variables introduced for the polymer
// polymer concentration and polymer molecular weight
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowOilWaterPolymerInjectivityProblem>
struct Indices<TypeTag, TTag::FlowOilWaterPolymerInjectivityProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef BlackOilTwoPhaseIndices<0,
0,
2,
0,
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::gasCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()> type;
using type = BlackOilTwoPhaseIndices<0,
0,
2,
0,
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*disabledCompIdx=*/FluidSystem::gasCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
}}
@ -82,14 +83,14 @@ int flowEbosOilWaterPolymerInjectivityMain(int argc, char** argv, bool outputCou
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowOilWaterPolymerInjectivityProblem>
FlowMain<Properties::TTag::FlowOilWaterPolymerInjectivityProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosOilWaterPolymerInjectivityMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowOilWaterPolymerInjectivityProblem;
using TypeTag = Properties::TTag::FlowOilWaterPolymerInjectivityProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

19
flow/flow_ebos_onephase.cpp
View File

@ -29,32 +29,31 @@ namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowProblemWaterOnly {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowWaterOnlyProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct Linearizer<TypeTag, TTag::EclFlowProblemWaterOnly> { using type = TpfaLinearizer<TypeTag>; };
struct Linearizer<TypeTag, TTag::FlowWaterOnlyProblem> { using type = TpfaLinearizer<TypeTag>; };
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::EclFlowProblemWaterOnly> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
struct LocalResidual<TypeTag, TTag::FlowWaterOnlyProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
template<class TypeTag>
struct EnableDiffusion<TypeTag, TTag::EclFlowProblemWaterOnly> { static constexpr bool value = false; };
struct EnableDiffusion<TypeTag, TTag::FlowWaterOnlyProblem> { static constexpr bool value = false; };
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowProblemWaterOnly>
struct Indices<TypeTag, TTag::FlowWaterOnlyProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
public:
using type = BlackOilOnePhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
@ -76,14 +75,14 @@ int flowEbosWaterOnlyMain(int argc, char** argv, bool outputCout, bool outputFil
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowProblemWaterOnly>
FlowMain<Properties::TTag::FlowWaterOnlyProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosWaterOnlyMainStandalone(int argc, char** argv)
{
using TypeTag = Opm::Properties::TTag::EclFlowProblemWaterOnly;
using TypeTag = Opm::Properties::TTag::FlowWaterOnlyProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

33
flow/flow_ebos_onephase_energy.cpp
View File

@ -30,36 +30,35 @@ namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowProblemWaterOnlyEnergy {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowWaterOnlyEnergyProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableEnergy<TypeTag, TTag::EclFlowProblemWaterOnlyEnergy> {
struct EnableEnergy<TypeTag, TTag::FlowWaterOnlyEnergyProblem> {
static constexpr bool value = true;
};
//! The indices required by the model
template<class TypeTag>
struct Indices<TypeTag, TTag::EclFlowProblemWaterOnlyEnergy>
struct Indices<TypeTag, TTag::FlowWaterOnlyEnergyProblem>
{
private:
// it is unfortunately not possible to simply use 'TypeTag' here because this leads
// to cyclic definitions of some properties. if this happens the compiler error
// messages unfortunately are *really* confusing and not really helpful.
using BaseTypeTag = TTag::EclFlowProblem;
using BaseTypeTag = TTag::FlowProblem;
using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
public:
typedef Opm::BlackOilOnePhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*enebledCompIdx=*/FluidSystem::waterCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>
type;
using type = Opm::BlackOilOnePhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
getPropValue<TypeTag, Properties::EnableExtbo>(),
getPropValue<TypeTag, Properties::EnablePolymer>(),
getPropValue<TypeTag, Properties::EnableEnergy>(),
getPropValue<TypeTag, Properties::EnableFoam>(),
getPropValue<TypeTag, Properties::EnableBrine>(),
/*PVOffset=*/0,
/*enebledCompIdx=*/FluidSystem::waterCompIdx,
getPropValue<TypeTag, Properties::EnableMICP>()>;
};
} // namespace Opm::Properties
@ -71,14 +70,14 @@ int flowEbosWaterOnlyEnergyMain(int argc, char** argv, bool outputCout, bool out
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowProblemWaterOnlyEnergy>
FlowMain<Properties::TTag::FlowWaterOnlyEnergyProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosWaterOnlyEnergyMainStandalone(int argc, char** argv)
{
using TypeTag = Opm::Properties::TTag::EclFlowProblemWaterOnlyEnergy;
using TypeTag = Opm::Properties::TTag::FlowWaterOnlyEnergyProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

10
flow/flow_ebos_polymer.cpp
View File

@ -26,12 +26,12 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowPolymerProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowPolymerProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnablePolymer<TypeTag, TTag::EclFlowPolymerProblem> {
struct EnablePolymer<TypeTag, TTag::FlowPolymerProblem> {
static constexpr bool value = true;
};
}}
@ -45,14 +45,14 @@ int flowEbosPolymerMain(int argc, char** argv, bool outputCout, bool outputFiles
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowPolymerProblem>
FlowMain<Properties::TTag::FlowPolymerProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosPolymerMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowPolymerProblem;
using TypeTag = Properties::TTag::FlowPolymerProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

10
flow/flow_ebos_solvent.cpp
View File

@ -26,12 +26,12 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowSolventProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowSolventProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableSolvent<TypeTag, TTag::EclFlowSolventProblem> {
struct EnableSolvent<TypeTag, TTag::FlowSolventProblem> {
static constexpr bool value = true;
};
}}
@ -45,14 +45,14 @@ int flowEbosSolventMain(int argc, char** argv, bool outputCout, bool outputFiles
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowSolventProblem>
FlowMain<Properties::TTag::FlowSolventProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosSolventMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowSolventProblem;
using TypeTag = Properties::TTag::FlowSolventProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

12
flow/flow_ebos_solvent_foam.cpp
View File

@ -26,17 +26,17 @@
namespace Opm {
namespace Properties {
namespace TTag {
struct EclFlowSolventFoamProblem {
using InheritsFrom = std::tuple<EclFlowProblem>;
struct FlowSolventFoamProblem {
using InheritsFrom = std::tuple<FlowProblem>;
};
}
template<class TypeTag>
struct EnableSolvent<TypeTag, TTag::EclFlowSolventFoamProblem> {
struct EnableSolvent<TypeTag, TTag::FlowSolventFoamProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableFoam<TypeTag, TTag::EclFlowSolventFoamProblem> {
struct EnableFoam<TypeTag, TTag::FlowSolventFoamProblem> {
static constexpr bool value = true;
};
}}
@ -50,14 +50,14 @@ int flowEbosSolventFoamMain(int argc, char** argv, bool outputCout, bool outputF
// with incorrect locale settings.
resetLocale();
FlowMain<Properties::TTag::EclFlowSolventFoamProblem>
FlowMain<Properties::TTag::FlowSolventFoamProblem>
mainfunc {argc, argv, outputCout, outputFiles};
return mainfunc.execute();
}
int flowEbosSolventFoamMainStandalone(int argc, char** argv)
{
using TypeTag = Properties::TTag::EclFlowSolventFoamProblem;
using TypeTag = Properties::TTag::FlowSolventFoamProblem;
auto mainObject = std::make_unique<Opm::Main>(argc, argv);
auto ret = mainObject->runStatic<TypeTag>();
// Destruct mainObject as the destructor calls MPI_Finalize!

34
opm/simulators/flow/BlackoilModel.hpp
View File

@ -74,79 +74,79 @@
namespace Opm::Properties {
namespace TTag {
struct EclFlowProblem {
struct FlowProblem {
using InheritsFrom = std::tuple<FlowTimeSteppingParameters, FlowModelParameters,
FlowNonLinearSolver, EclBaseProblem, BlackOilModel>;
};
}
template<class TypeTag>
struct OutputDir<TypeTag, TTag::EclFlowProblem> {
struct OutputDir<TypeTag, TTag::FlowProblem> {
static constexpr auto value = "";
};
template<class TypeTag>
struct EnableDebuggingChecks<TypeTag, TTag::EclFlowProblem> {
struct EnableDebuggingChecks<TypeTag, TTag::FlowProblem> {
static constexpr bool value = false;
};
// default in flow is to formulate the equations in surface volumes
template<class TypeTag>
struct BlackoilConserveSurfaceVolume<TypeTag, TTag::EclFlowProblem> {
struct BlackoilConserveSurfaceVolume<TypeTag, TTag::FlowProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct UseVolumetricResidual<TypeTag, TTag::EclFlowProblem> {
struct UseVolumetricResidual<TypeTag, TTag::FlowProblem> {
static constexpr bool value = false;
};
template<class TypeTag>
struct EclAquiferModel<TypeTag, TTag::EclFlowProblem> {
struct EclAquiferModel<TypeTag, TTag::FlowProblem> {
using type = BlackoilAquiferModel<TypeTag>;
};
// disable all extensions supported by black oil model. this should not really be
// necessary but it makes things a bit more explicit
template<class TypeTag>
struct EnablePolymer<TypeTag, TTag::EclFlowProblem> {
struct EnablePolymer<TypeTag, TTag::FlowProblem> {
static constexpr bool value = false;
};
template<class TypeTag>
struct EnableSolvent<TypeTag, TTag::EclFlowProblem> {
struct EnableSolvent<TypeTag, TTag::FlowProblem> {
static constexpr bool value = false;
};
template<class TypeTag>
struct EnableTemperature<TypeTag, TTag::EclFlowProblem> {
struct EnableTemperature<TypeTag, TTag::FlowProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableEnergy<TypeTag, TTag::EclFlowProblem> {
struct EnableEnergy<TypeTag, TTag::FlowProblem> {
static constexpr bool value = false;
};
template<class TypeTag>
struct EnableFoam<TypeTag, TTag::EclFlowProblem> {
struct EnableFoam<TypeTag, TTag::FlowProblem> {
static constexpr bool value = false;
};
template<class TypeTag>
struct EnableBrine<TypeTag, TTag::EclFlowProblem> {
struct EnableBrine<TypeTag, TTag::FlowProblem> {
static constexpr bool value = false;
};
template<class TypeTag>
struct EnableSaltPrecipitation<TypeTag, TTag::EclFlowProblem> {
struct EnableSaltPrecipitation<TypeTag, TTag::FlowProblem> {
static constexpr bool value = false;
};
template<class TypeTag>
struct EnableMICP<TypeTag, TTag::EclFlowProblem> {
struct EnableMICP<TypeTag, TTag::FlowProblem> {
static constexpr bool value = false;
};
template<class TypeTag>
struct EnableDispersion<TypeTag, TTag::EclFlowProblem> {
struct EnableDispersion<TypeTag, TTag::FlowProblem> {
static constexpr bool value = false;
};
template<class TypeTag>
struct EclWellModel<TypeTag, TTag::EclFlowProblem> {
struct EclWellModel<TypeTag, TTag::FlowProblem> {
using type = BlackoilWellModel<TypeTag>;
};
template<class TypeTag>
struct LinearSolverSplice<TypeTag, TTag::EclFlowProblem> {
struct LinearSolverSplice<TypeTag, TTag::FlowProblem> {
using type = TTag::FlowIstlSolver;
};

6
opm/simulators/flow/FlowMain.hpp
View File

@ -58,16 +58,16 @@ struct EnableLoggingFalloutWarning {
// TODO: enumeration parameters. we use strings for now.
template<class TypeTag>
struct EnableDryRun<TypeTag, TTag::EclFlowProblem> {
struct EnableDryRun<TypeTag, TTag::FlowProblem> {
static constexpr auto value = "auto";
};
// Do not merge parallel output files or warn about them
template<class TypeTag>
struct EnableLoggingFalloutWarning<TypeTag, TTag::EclFlowProblem> {
struct EnableLoggingFalloutWarning<TypeTag, TTag::FlowProblem> {
static constexpr bool value = false;
};
template<class TypeTag>
struct OutputInterval<TypeTag, TTag::EclFlowProblem> {
struct OutputInterval<TypeTag, TTag::FlowProblem> {
static constexpr int value = 1;
};

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

@ -93,7 +93,7 @@ namespace Opm::Properties {
// simulator.
namespace TTag {
struct FlowEarlyBird {
using InheritsFrom = std::tuple<EclFlowProblem>;
using InheritsFrom = std::tuple<FlowProblem>;
};
}
@ -170,7 +170,7 @@ public:
return exitCode;
}
using FlowMainType = FlowMain<Properties::TTag::EclFlowProblemTPFA>;
using FlowMainType = FlowMain<Properties::TTag::FlowProblemTPFA>;
// To be called from the Python interface code. Only do the
// initialization and then return a pointer to the FlowEbosMain
// object that can later be accessed directly from the Python interface

14
opm/simulators/flow/SimulatorFullyImplicitBlackoil.hpp
View File

@ -95,40 +95,40 @@ struct LoadFile
};
template<class TypeTag>
struct EnableTerminalOutput<TypeTag, TTag::EclFlowProblem> {
struct EnableTerminalOutput<TypeTag, TTag::FlowProblem> {
static constexpr bool value = true;
};
template<class TypeTag>
struct EnableAdaptiveTimeStepping<TypeTag, TTag::EclFlowProblem> {
struct EnableAdaptiveTimeStepping<TypeTag, TTag::FlowProblem> {
static constexpr bool value = true;
};
template <class TypeTag>
struct OutputExtraConvergenceInfo<TypeTag, TTag::EclFlowProblem>
struct OutputExtraConvergenceInfo<TypeTag, TTag::FlowProblem>
{
static constexpr auto* value = "none";
};
template <class TypeTag>
struct SaveStep<TypeTag, TTag::EclFlowProblem>
struct SaveStep<TypeTag, TTag::FlowProblem>
{
static constexpr auto* value = "";
};
template <class TypeTag>
struct SaveFile<TypeTag, TTag::EclFlowProblem>
struct SaveFile<TypeTag, TTag::FlowProblem>
{
static constexpr auto* value = "";
};
template <class TypeTag>
struct LoadFile<TypeTag, TTag::EclFlowProblem>
struct LoadFile<TypeTag, TTag::FlowProblem>
{
static constexpr auto* value = "";
};
template <class TypeTag>
struct LoadStep<TypeTag, TTag::EclFlowProblem>
struct LoadStep<TypeTag, TTag::FlowProblem>
{
static constexpr int value = -1;
};

2
opm/simulators/flow/python/PyBlackOilSimulator.hpp
View File

@ -33,7 +33,7 @@ namespace Opm::Pybind {
class PyBlackOilSimulator
{
private:
using TypeTag = Opm::Properties::TTag::EclFlowProblemTPFA;
using TypeTag = Opm::Properties::TTag::FlowProblemTPFA;
using Simulator = Opm::GetPropType<TypeTag, Opm::Properties::Simulator>;
public:

2
python/simulators/PyBlackOilSimulator.cpp
View File

@ -101,7 +101,7 @@ py::array_t<double> PyBlackOilSimulator::getPorosity()
int PyBlackOilSimulator::run()
{
auto main_object = Opm::Main( this->deck_filename_ );
return main_object.runStatic<Opm::Properties::TTag::EclFlowProblemTPFA>();
return main_object.runStatic<Opm::Properties::TTag::FlowProblemTPFA>();
}
void PyBlackOilSimulator::setPorosity( py::array_t<double,

4
tests/test_glift1.cpp
View File

@ -107,7 +107,7 @@ struct GliftFixture {
Dune::MPIHelper::instance(argc, argv);
#endif
Opm::EclGenericVanguard::setCommunication(std::make_unique<Opm::Parallel::Communication>());
using TypeTag = Opm::Properties::TTag::EclFlowProblem;
using TypeTag = Opm::Properties::TTag::FlowProblem;
Opm::registerAllParameters_<TypeTag>();
}
};
@ -118,7 +118,7 @@ BOOST_GLOBAL_FIXTURE(GliftFixture);
BOOST_AUTO_TEST_CASE(G1)
{
//using TypeTag = Opm::Properties::TTag::EclFlowProblem;
//using TypeTag = Opm::Properties::TTag::FlowProblem;
using TypeTag = Opm::Properties::TTag::TestGliftTypeTag;
//using EclProblem = Opm::EclProblem<TypeTag>;
//using EclWellModel = typename EclProblem::EclWellModel;

8
tests/test_wellmodel.cpp
View File

@ -58,7 +58,7 @@
using StandardWell = Opm::StandardWell<Opm::Properties::TTag::EclFlowProblem>;
using StandardWell = Opm::StandardWell<Opm::Properties::TTag::FlowProblem>;
struct SetupTest {
@ -101,7 +101,7 @@ struct GlobalFixture {
Dune::MPIHelper::instance(argcDummy, argvDummy);
#endif
Opm::FlowMain<Opm::Properties::TTag::EclFlowProblem>::setupParameters_(argcDummy, argvDummy, Dune::MPIHelper::getCommunication());
Opm::FlowMain<Opm::Properties::TTag::FlowProblem>::setupParameters_(argcDummy, argvDummy, Dune::MPIHelper::getCommunication());
}
};
@ -112,7 +112,7 @@ BOOST_AUTO_TEST_CASE(TestStandardWellInput) {
const auto& wells_ecl = setup_test.schedule->getWells(setup_test.current_timestep);
BOOST_CHECK_EQUAL( wells_ecl.size(), 2);
const Opm::Well& well = wells_ecl[1];
const Opm::BlackoilModelParameters<Opm::Properties::TTag::EclFlowProblem> param;
const Opm::BlackoilModelParameters<Opm::Properties::TTag::FlowProblem> param;
// For the conversion between the surface volume rate and resrevoir voidage rate
typedef Opm::BlackOilFluidSystem<double> FluidSystem;
@ -145,7 +145,7 @@ BOOST_AUTO_TEST_CASE(TestBehavoir) {
{
const int nw = wells_ecl.size();
const Opm::BlackoilModelParameters<Opm::Properties::TTag::EclFlowProblem> param;
const Opm::BlackoilModelParameters<Opm::Properties::TTag::FlowProblem> param;
for (int w = 0; w < nw; ++w) {
// For the conversion between the surface volume rate and resrevoir voidage rate