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 #925 from akva2/typetag_free_params2

Browse Source 
Move parameters to typetag free parameter system: Batch 3
This commit is contained in:
Bård Skaflestad 2024-08-14 14:43:50 +02:00 committed by GitHub
commit d271cd3e06
62 changed files with 686 additions and 1899 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
examples/co2injection_flash_ecfv.cpp
View File

@ -75,21 +75,11 @@ struct Scalar<TypeTag, TTag::Co2InjectionFlashEcfvProblem>
} // namespace Opm::Properties
namespace Opm::Parameters {
#if ! HAVE_QUAD
template<class TypeTag>
struct NewtonTolerance<TypeTag, Properties::TTag::Co2InjectionFlashEcfvProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e-5;
};
#endif
} // namespace Opm::Parameters
int main(int argc, char **argv)
{
using EcfvProblemTypeTag = Opm::Properties::TTag::Co2InjectionFlashEcfvProblem;
#if ! HAVE_QUAD
Opm::Co2InjectionTolerance = 1e-5;
#endif
return Opm::start<EcfvProblemTypeTag>(argc, argv);
}

16
examples/co2injection_flash_ni_ecfv.cpp
View File

@ -77,21 +77,11 @@ struct Scalar<TypeTag, TTag::Co2InjectionFlashNiEcfvProblem>
} // namespace Opm::Properties
namespace Opm::Parameters {
#if ! HAVE_QUAD
template<class TypeTag>
struct NewtonTolerance<TypeTag, Properties::TTag::Co2InjectionFlashNiEcfvProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e-5;
};
#endif
} // namespace Opm::Parameters
int main(int argc, char **argv)
{
using EcfvProblemTypeTag = Opm::Properties::TTag::Co2InjectionFlashNiEcfvProblem;
#if ! HAVE_QUAD
Opm::Co2InjectionTolerance = 1e-5;
#endif
return Opm::start<EcfvProblemTypeTag>(argc, argv);
}

16
examples/co2injection_flash_ni_vcfv.cpp
View File

@ -73,21 +73,11 @@ struct Scalar<TypeTag, TTag::Co2InjectionFlashNiVcfvProblem>
} // namespace Opm::Properties
namespace Opm::Parameters {
#if ! HAVE_QUAD
template<class TypeTag>
struct NewtonTolerance<TypeTag, Properties::TTag::Co2InjectionFlashNiVcfvProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e-5;
};
#endif
} // namespace Opm::Parameters
int main(int argc, char **argv)
{
using VcfvProblemTypeTag = Opm::Properties::TTag::Co2InjectionFlashNiVcfvProblem;
#if ! HAVE_QUAD
Opm::Co2InjectionTolerance = 1e-5;
#endif
return Opm::start<VcfvProblemTypeTag>(argc, argv);
}

16
examples/co2injection_flash_vcfv.cpp
View File

@ -69,21 +69,11 @@ struct Scalar<TypeTag, TTag::Co2InjectionFlashVcfvProblem>
} // namespace Opm::Properties
namespace Opm::Parameters {
#if ! HAVE_QUAD
template<class TypeTag>
struct NewtonTolerance<TypeTag, Properties::TTag::Co2InjectionFlashVcfvProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e-5;
};
#endif
} // namespace Opm::Parameters
int main(int argc, char **argv)
{
using VcfvProblemTypeTag = Opm::Properties::TTag::Co2InjectionFlashVcfvProblem;
#if ! HAVE_QUAD
Opm::Co2InjectionTolerance = 1e-5;
#endif
return Opm::start<VcfvProblemTypeTag>(argc, argv);
}

140
examples/problems/co2injectionproblem.hh
View File

@ -141,101 +141,35 @@ struct LinearSolverSplice<TypeTag, TTag::Co2InjectionBaseProblem> { using type =
namespace Opm::Parameters {
// declare the CO2 injection problem specific property tags
template<class TypeTag, class MyTypeTag>
struct FluidSystemPressureLow { using type = Properties::UndefinedProperty; };
struct FluidSystemNumPressure { static constexpr unsigned value = 100; };
struct FluidSystemNumTemperature { static constexpr unsigned value = 100; };
template<class TypeTag, class MyTypeTag>
struct FluidSystemPressureHigh { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct FluidSystemPressureHigh { static constexpr Scalar value = 4e7; };
template<class TypeTag, class MyTypeTag>
struct FluidSystemNumPressure { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct FluidSystemPressureLow { static constexpr Scalar value = 3e7; };
template<class TypeTag, class MyTypeTag>
struct FluidSystemTemperatureLow { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct FluidSystemTemperatureHigh { static constexpr Scalar value = 500.0; };
template<class TypeTag, class MyTypeTag>
struct FluidSystemTemperatureHigh { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct FluidSystemTemperatureLow { static constexpr Scalar value = 290.0; };
template<class TypeTag, class MyTypeTag>
struct FluidSystemNumTemperature { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct MaxDepth { static constexpr Scalar value = 2500.0; };
template<class TypeTag, class MyTypeTag>
struct MaxDepth { using type = Properties::UndefinedProperty; };
struct SimulationName { static constexpr auto value = "co2injection"; };
template<class TypeTag, class MyTypeTag>
struct Temperature { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct SimulationName { using type = Properties::UndefinedProperty; };
// Enable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::Co2InjectionBaseProblem>
{ static constexpr bool value = true; };
template<class TypeTag>
struct FluidSystemNumPressure<TypeTag, Properties::TTag::Co2InjectionBaseProblem>
{ static constexpr unsigned value = 100; };
template<class TypeTag>
struct FluidSystemNumTemperature<TypeTag, Properties::TTag::Co2InjectionBaseProblem>
{ static constexpr unsigned value = 100; };
template<class TypeTag>
struct FluidSystemPressureHigh<TypeTag, Properties::TTag::Co2InjectionBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 4e7;
};
template<class TypeTag>
struct FluidSystemPressureLow<TypeTag, Properties::TTag::Co2InjectionBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 3e7;
};
template<class TypeTag>
struct FluidSystemTemperatureHigh<TypeTag, Properties::TTag::Co2InjectionBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 500;
};
template<class TypeTag>
struct FluidSystemTemperatureLow<TypeTag, Properties::TTag::Co2InjectionBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 290;
};
template<class TypeTag>
struct MaxDepth<TypeTag, Properties::TTag::Co2InjectionBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 2500;
};
// Write the Newton convergence behavior to disk?
template<class TypeTag>
struct NewtonWriteConvergence<TypeTag, Properties::TTag::Co2InjectionBaseProblem>
{ static constexpr bool value = false; };
template<class TypeTag>
struct SimulationName<TypeTag, Properties::TTag::Co2InjectionBaseProblem>
{ static constexpr auto value = "co2injection"; };
template<class TypeTag>
struct Temperature<TypeTag, Properties::TTag::Co2InjectionBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 293.15;
};
template<class Scalar>
struct Temperature { static constexpr Scalar value = 293.15; };
} // namespace Opm::Parameters
namespace Opm {
double Co2InjectionTolerance = 1e-8;
/*!
* \ingroup TestProblems
*
@ -314,16 +248,16 @@ public:
eps_ = 1e-6;
temperatureLow_ = Parameters::get<TypeTag, Parameters::FluidSystemTemperatureLow>();
temperatureHigh_ = Parameters::get<TypeTag, Parameters::FluidSystemTemperatureHigh>();
nTemperature_ = Parameters::get<TypeTag, Parameters::FluidSystemNumTemperature>();
temperatureLow_ = Parameters::Get<Parameters::FluidSystemTemperatureLow<Scalar>>();
temperatureHigh_ = Parameters::Get<Parameters::FluidSystemTemperatureHigh<Scalar>>();
nTemperature_ = Parameters::Get<Parameters::FluidSystemNumTemperature>();
pressureLow_ = Parameters::get<TypeTag, Parameters::FluidSystemPressureLow>();
pressureHigh_ = Parameters::get<TypeTag, Parameters::FluidSystemPressureHigh>();
nPressure_ = Parameters::get<TypeTag, Parameters::FluidSystemNumPressure>();
pressureLow_ = Parameters::Get<Parameters::FluidSystemPressureLow<Scalar>>();
pressureHigh_ = Parameters::Get<Parameters::FluidSystemPressureHigh<Scalar>>();
nPressure_ = Parameters::Get<Parameters::FluidSystemNumPressure>();
maxDepth_ = Parameters::get<TypeTag, Parameters::MaxDepth>();
temperature_ = Parameters::get<TypeTag, Parameters::Temperature>();
maxDepth_ = Parameters::Get<Parameters::MaxDepth<Scalar>>();
temperature_ = Parameters::Get<Parameters::Temperature<Scalar>>();
// initialize the tables of the fluid system
// FluidSystem::init();
@ -376,28 +310,30 @@ public:
{
ParentType::registerParameters();
Parameters::registerParam<TypeTag, Parameters::FluidSystemTemperatureLow>
Parameters::Register<Parameters::FluidSystemTemperatureLow<Scalar>>
("The lower temperature [K] for tabulation of the fluid system");
Parameters::registerParam<TypeTag, Parameters::FluidSystemTemperatureHigh>
Parameters::Register<Parameters::FluidSystemTemperatureHigh<Scalar>>
("The upper temperature [K] for tabulation of the fluid system");
Parameters::registerParam<TypeTag, Parameters::FluidSystemNumTemperature>
Parameters::Register<Parameters::FluidSystemNumTemperature>
("The number of intervals between the lower and upper temperature");
Parameters::registerParam<TypeTag, Parameters::FluidSystemPressureLow>
Parameters::Register<Parameters::FluidSystemPressureLow<Scalar>>
("The lower pressure [Pa] for tabulation of the fluid system");
Parameters::registerParam<TypeTag, Parameters::FluidSystemPressureHigh>
Parameters::Register<Parameters::FluidSystemPressureHigh<Scalar>>
("The upper pressure [Pa] for tabulation of the fluid system");
Parameters::registerParam<TypeTag, Parameters::FluidSystemNumPressure>
Parameters::Register<Parameters::FluidSystemNumPressure>
("The number of intervals between the lower and upper pressure");
Parameters::registerParam<TypeTag, Parameters::Temperature>
Parameters::Register<Parameters::Temperature<Scalar>>
("The temperature [K] in the reservoir");
Parameters::registerParam<TypeTag, Parameters::MaxDepth>
Parameters::Register<Parameters::MaxDepth<Scalar>>
("The maximum depth [m] of the reservoir");
Parameters::registerParam<TypeTag, Parameters::SimulationName>
Parameters::Register<Parameters::SimulationName>
("The name of the simulation used for the output files");
Parameters::SetDefault<Parameters::GridFile>("data/co2injection.dgf");
Parameters::SetDefault<Parameters::EndTime<Scalar>>(1e4);
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(250);
Parameters::SetDefault<Parameters::NewtonTolerance<Scalar>>(Scalar{Co2InjectionTolerance});
Parameters::SetDefault<Parameters::EnableGravity>(true);
}
/*!
@ -411,7 +347,7 @@ public:
std::string name() const
{
std::ostringstream oss;
oss << Parameters::get<TypeTag, Parameters::SimulationName>()
oss << Parameters::Get<Parameters::SimulationName>()
<< "_" << Model::name();
if (getPropValue<TypeTag, Properties::EnableEnergy>())
oss << "_ni";

141
examples/problems/co2ptflashproblem.hh
View File

@ -144,114 +144,18 @@ struct EnableEnergy<TypeTag, TTag::CO2PTBaseProblem> {
namespace Opm::Parameters {
template <class TypeTag, class MyTypeTag>
struct Temperature { using type = Properties::UndefinedProperty; };
template <class TypeTag, class MyTypeTag>
struct SimulationName { using type = Properties::UndefinedProperty; };
template <class TypeTag, class MyTypeTag>
struct EpisodeLength { using type = Properties::UndefinedProperty;};
template <class TypeTag, class MyTypeTag>
struct Initialpressure { using type = Properties::UndefinedProperty;};
// Enable gravity false
template <class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr bool value = false; };
// this is kinds of telling the report step length
template <class TypeTag>
struct EpisodeLength<TypeTag, Properties::TTag::CO2PTBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.1 * 60. * 60.;
};
template<class Scalar>
struct EpisodeLength { static constexpr Scalar value = 0.1 * 60. * 60.; };
template <class TypeTag>
struct Initialpressure<TypeTag, Properties::TTag::CO2PTBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 75.e5;
};
template<class Scalar>
struct Initialpressure { static constexpr Scalar value = 75e5; };
template <class TypeTag>
struct LinearSolverAbsTolerance<TypeTag, Properties::TTag::CO2PTBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.;
};
template <class TypeTag>
struct LinearSolverTolerance<TypeTag, Properties::TTag::CO2PTBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e-3;
};
// Write the Newton convergence behavior to disk?
template <class TypeTag>
struct NewtonWriteConvergence<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr bool value = false; };
template <class TypeTag>
struct NewtonTolerance<TypeTag, Properties::TTag::CO2PTBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e-3;
};
template <class TypeTag>
struct NewtonTargetIterations<TypeTag, Properties::TTag::CO2PTBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 6;
};
template <class TypeTag>
struct NewtonMaxIterations<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr int value = 30; };
template <class TypeTag>
struct SimulationName<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr auto value = "co2_ptflash"; };
struct SimulationName { static constexpr auto value = "co2_ptflash"; };
// set the defaults for the problem specific properties
template <class TypeTag>
struct Temperature<TypeTag, Properties::TTag::CO2PTBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 423.25; // TODO
};
template <class TypeTag>
struct VtkWriteEquilibriumConstants<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr bool value = true; };
template <class TypeTag>
struct VtkWriteFilterVelocities<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr bool value = true; };
template <class TypeTag>
struct VtkWriteFugacityCoeffs<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr bool value = true; };
template <class TypeTag>
struct VtkWriteLiquidMoleFractions<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr bool value = true; };
template <class TypeTag>
struct VtkWritePotentialGradients<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr bool value = true; };
template <class TypeTag>
struct VtkWriteTotalMassFractions<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr bool value = true; };
template <class TypeTag>
struct VtkWriteTotalMoleFractions<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr bool value = true; };
template<class Scalar>
struct Temperature { static constexpr Scalar value = 423.25; };
} // namespace Opm::Parameters
@ -307,7 +211,7 @@ public:
explicit CO2PTProblem(Simulator& simulator)
: ParentType(simulator)
{
const Scalar epi_len = Parameters::get<TypeTag, Parameters::EpisodeLength>();
const Scalar epi_len = Parameters::Get<Parameters::EpisodeLength<Scalar>>();
simulator.setEpisodeLength(epi_len);
FluidSystem::init();
using CompParm = typename FluidSystem::ComponentParam;
@ -325,7 +229,7 @@ public:
void initPetrophysics()
{
temperature_ = Parameters::get<TypeTag, Parameters::Temperature>();
temperature_ = Parameters::Get<Parameters::Temperature<Scalar>>();
K_ = this->toDimMatrix_(9.869232667160131e-14);
porosity_ = 0.1;
@ -362,13 +266,13 @@ public:
{
ParentType::registerParameters();
Parameters::registerParam<TypeTag, Parameters::Temperature>
Parameters::Register<Parameters::Temperature<Scalar>>
("The temperature [K] in the reservoir");
Parameters::registerParam<TypeTag, Parameters::Initialpressure>
Parameters::Register<Parameters::Initialpressure<Scalar>>
("The initial pressure [Pa s] in the reservoir");
Parameters::registerParam<TypeTag, Parameters::SimulationName>
Parameters::Register<Parameters::SimulationName>
("The name of the simulation used for the output files");
Parameters::registerParam<TypeTag, Parameters::EpisodeLength>
Parameters::Register<Parameters::EpisodeLength<Scalar>>
("Time interval [s] for episode length");
Parameters::SetDefault<Parameters::CellsX>(30);
@ -385,6 +289,19 @@ public:
Parameters::SetDefault<Parameters::EndTime<Scalar>>(60. * 60.);
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(0.1 * 60. * 60.);
Parameters::SetDefault<Parameters::NewtonMaxIterations>(30);
Parameters::SetDefault<Parameters::NewtonTargetIterations>(6);
Parameters::SetDefault<Parameters::NewtonTolerance<Scalar>>(1e-3);
Parameters::SetDefault<Parameters::VtkWriteFilterVelocities>(true);
Parameters::SetDefault<Parameters::VtkWriteFugacityCoeffs>(true);
Parameters::SetDefault<Parameters::VtkWritePotentialGradients>(true);
Parameters::SetDefault<Parameters::VtkWriteTotalMassFractions>(true);
Parameters::SetDefault<Parameters::VtkWriteTotalMoleFractions>(true);
Parameters::SetDefault<Parameters::VtkWriteEquilibriumConstants>(true);
Parameters::SetDefault<Parameters::VtkWriteLiquidMoleFractions>(true);
Parameters::SetDefault<Parameters::LinearSolverAbsTolerance<Scalar>>(0.0);
Parameters::SetDefault<Parameters::LinearSolverTolerance<Scalar>>(1e-3);
}
/*!
@ -393,7 +310,7 @@ public:
std::string name() const
{
std::ostringstream oss;
oss << Parameters::get<TypeTag, Parameters::SimulationName>();
oss << Parameters::Get<Parameters::SimulationName>();
return oss.str();
}
@ -402,7 +319,7 @@ public:
// the old one.
void endEpisode()
{
Scalar epi_len = Parameters::get<TypeTag, Parameters::EpisodeLength>();
Scalar epi_len = Parameters::Get<Parameters::EpisodeLength<Scalar>>();
this->simulator().startNextEpisode(epi_len);
}
@ -544,7 +461,7 @@ private:
sat[0] = 1.0;
sat[1] = 1.0 - sat[0];
Scalar p0 = Parameters::get<TypeTag, Parameters::Initialpressure>();
Scalar p0 = Parameters::Get<Parameters::Initialpressure<Scalar>>();
//\Note, for an AD variable, if we multiply it with 2, the derivative will also be scalced with 2,
//\Note, so we should not do it.

10
examples/problems/cuvetteproblem.hh
View File

@ -114,15 +114,6 @@ public:
} // namespace Opm::Properties
namespace Opm::Parameters {
// Enable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::CuvetteBaseProblem>
{ static constexpr bool value = true; };
} // namespace Opm::Parameters
namespace Opm {
/*!
* \ingroup TestProblems
@ -291,6 +282,7 @@ public:
Parameters::SetDefault<Parameters::EndTime<Scalar>>(100.0);
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(1.0);
Parameters::SetDefault<Parameters::MaxTimeStepSize<Scalar>>(600.0);
Parameters::SetDefault<Parameters::EnableGravity>(true);
}
/*!

9
examples/problems/diffusionproblem.hh
View File

@ -108,15 +108,6 @@ struct EnableDiffusion<TypeTag, TTag::DiffusionBaseProblem> { static constexpr b
} // namespace Opm::Properties
namespace Opm::Parameters {
// Disable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::DiffusionBaseProblem>
{ static constexpr bool value = false; };
} // namespace Opm::Parameters
namespace Opm {
/*!
* \ingroup TestProblems

70
examples/problems/fingerproblem.hh
View File

@ -28,32 +28,38 @@
#ifndef EWOMS_FINGER_PROBLEM_HH
#define EWOMS_FINGER_PROBLEM_HH
#include <opm/models/io/structuredgridvanguard.hh>
#include <opm/material/fluidmatrixinteractions/RegularizedVanGenuchten.hpp>
#include <opm/material/fluidmatrixinteractions/LinearMaterial.hpp>
#include <opm/material/fluidmatrixinteractions/EffToAbsLaw.hpp>
#include <opm/material/fluidmatrixinteractions/ParkerLenhard.hpp>
#include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
#include <opm/material/fluidsystems/TwoPhaseImmiscibleFluidSystem.hpp>
#include <opm/material/fluidstates/ImmiscibleFluidState.hpp>
#include <opm/material/components/SimpleH2O.hpp>
#include <opm/material/components/Air.hpp>
#include <opm/models/immiscible/immiscibleproperties.hh>
#include <opm/models/discretization/common/restrictprolong.hh>
#if HAVE_DUNE_ALUGRID
#include <dune/alugrid/grid.hh>
#endif
#include <dune/common/version.hh>
#include <dune/common/fvector.hh>
#include <dune/common/fmatrix.hh>
#include <dune/common/fvector.hh>
#include <dune/common/version.hh>
#include <dune/grid/utility/persistentcontainer.hh>
#include <vector>
#include <opm/material/components/Air.hpp>
#include <opm/material/components/SimpleH2O.hpp>
#include <opm/material/fluidmatrixinteractions/EffToAbsLaw.hpp>
#include <opm/material/fluidmatrixinteractions/LinearMaterial.hpp>
#include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
#include <opm/material/fluidmatrixinteractions/ParkerLenhard.hpp>
#include <opm/material/fluidmatrixinteractions/RegularizedVanGenuchten.hpp>
#include <opm/material/fluidstates/ImmiscibleFluidState.hpp>
#include <opm/material/fluidsystems/TwoPhaseImmiscibleFluidSystem.hpp>
#include <opm/models/common/multiphasebaseparameters.hh>
#include <opm/models/discretization/common/fvbasefdlocallinearizer.hh>
#include <opm/models/discretization/common/restrictprolong.hh>
#include <opm/models/immiscible/immiscibleproperties.hh>
#include <opm/models/io/structuredgridvanguard.hh>
#include <string>
namespace Opm {
@ -128,25 +134,8 @@ struct EnableConstraints<TypeTag, TTag::FingerBaseProblem> { static constexpr in
namespace Opm::Parameters {
template<class TypeTag, class MyTypeTag>
struct InitialWaterSaturation { using type = Properties::UndefinedProperty; };
// Enable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::FingerBaseProblem>
{ static constexpr bool value = true; };
template<class TypeTag>
struct InitialWaterSaturation<TypeTag, Properties::TTag::FingerBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.01;
};
// Write the solutions of individual newton iterations?
template<class TypeTag>
struct NewtonWriteConvergence<TypeTag, Properties::TTag::FingerBaseProblem>
{ static constexpr bool value = false; };
template<class Scalar>
struct InitialWaterSaturation { static constexpr Scalar value = 0.01; };
} // namespace Opm::Parameters
@ -263,7 +252,7 @@ public:
{
ParentType::registerParameters();
Parameters::registerParam<TypeTag, Parameters::InitialWaterSaturation>
Parameters::Register<Parameters::InitialWaterSaturation<Scalar>>
("The initial saturation in the domain [] of the wetting phase");
Parameters::SetDefault<Parameters::CellsX>(20);
@ -283,6 +272,7 @@ public:
Parameters::SetDefault<Parameters::EndTime<Scalar>>(215);
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(10);
Parameters::SetDefault<Parameters::EnableGravity>(true);
}
/*!
@ -534,7 +524,7 @@ private:
auto& fs = initialFluidState_;
fs.setPressure(wettingPhaseIdx, /*pressure=*/1e5);
Scalar Sw = Parameters::get<TypeTag, Parameters::InitialWaterSaturation>();
Scalar Sw = Parameters::Get<Parameters::InitialWaterSaturation<Scalar>>();
fs.setSaturation(wettingPhaseIdx, Sw);
fs.setSaturation(nonWettingPhaseIdx, 1 - Sw);

9
examples/problems/fractureproblem.hh
View File

@ -158,15 +158,6 @@ struct EnableConstraints<TypeTag, TTag::FractureProblem> { static constexpr bool
} // namespace Opm::Properties
namespace Opm::Parameters {
// Disable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::FractureProblem>
{ static constexpr bool value = false; };
} // namespace Opm::Parameters
namespace Opm {
/*!
* \ingroup TestProblems

143
examples/problems/groundwaterproblem.hh
View File

@ -28,19 +28,22 @@
#ifndef EWOMS_GROUND_WATER_PROBLEM_HH
#define EWOMS_GROUND_WATER_PROBLEM_HH
#include <opm/models/immiscible/immiscibleproperties.hh>
#include <opm/simulators/linalg/parallelistlbackend.hh>
#include <dune/common/fmatrix.hh>
#include <dune/common/fvector.hh>
#include <dune/common/version.hh>
#include <dune/grid/yaspgrid.hh>
#include <dune/grid/io/file/dgfparser/dgfyasp.hh>
#include <opm/material/components/SimpleH2O.hpp>
#include <opm/material/fluidstates/ImmiscibleFluidState.hpp>
#include <opm/material/fluidsystems/LiquidPhase.hpp>
#include <dune/grid/yaspgrid.hh>
#include <dune/grid/io/file/dgfparser/dgfyasp.hh>
#include <opm/models/common/multiphasebaseparameters.hh>
#include <dune/common/version.hh>
#include <dune/common/fmatrix.hh>
#include <dune/common/fvector.hh>
#include <opm/models/immiscible/immiscibleproperties.hh>
#include <opm/simulators/linalg/parallelistlbackend.hh>
#include <sstream>
#include <string>
@ -88,90 +91,29 @@ struct LinearSolverWrapper<TypeTag, TTag::GroundWaterBaseProblem>
namespace Opm::Parameters {
template<class TypeTag, class MyTypeTag>
struct LensLowerLeftX { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct LensLowerLeftX { static constexpr Scalar value = 0.25; };
template<class TypeTag, class MyTypeTag>
struct LensLowerLeftY { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct LensLowerLeftY { static constexpr Scalar value = 0.25; };
template<class TypeTag, class MyTypeTag>
struct LensLowerLeftZ { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct LensLowerLeftZ { static constexpr Scalar value = 0.25; };
template<class TypeTag, class MyTypeTag>
struct LensUpperRightX { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct LensUpperRightX { static constexpr Scalar value = 0.75; };
template<class TypeTag, class MyTypeTag>
struct LensUpperRightY { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct LensUpperRightY { static constexpr Scalar value = 0.75; };
template<class TypeTag, class MyTypeTag>
struct LensUpperRightZ { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct LensUpperRightZ { static constexpr Scalar value = 0.75; };
template<class TypeTag, class MyTypeTag>
struct Permeability { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct Permeability { static constexpr Scalar value = 1e-10; };
template<class TypeTag, class MyTypeTag>
struct PermeabilityLens { using type = Properties::UndefinedProperty; };
// Enable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::GroundWaterBaseProblem>
{ static constexpr bool value = true; };
template<class TypeTag>
struct LensLowerLeftX<TypeTag, Properties::TTag::GroundWaterBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.25;
};
template<class TypeTag>
struct LensLowerLeftY<TypeTag, Properties::TTag::GroundWaterBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.25;
};
template<class TypeTag>
struct LensLowerLeftZ<TypeTag, Properties::TTag::GroundWaterBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.25;
};
template<class TypeTag>
struct LensUpperRightX<TypeTag, Properties::TTag::GroundWaterBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.75;
};
template<class TypeTag>
struct LensUpperRightY<TypeTag, Properties::TTag::GroundWaterBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.75;
};
template<class TypeTag>
struct LensUpperRightZ<TypeTag, Properties::TTag::GroundWaterBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.75;
};
template<class TypeTag>
struct Permeability<TypeTag, Properties::TTag::GroundWaterBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e-10;
};
template<class TypeTag>
struct PermeabilityLens<TypeTag, Properties::TTag::GroundWaterBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e-12;
};
template<class Scalar>
struct PermeabilityLens { static constexpr Scalar value = 1e-12; };
} // namespace Opm::Parameters
@ -239,20 +181,20 @@ public:
eps_ = 1.0e-3;
lensLowerLeft_[0] = Parameters::get<TypeTag, Parameters::LensLowerLeftX>();
lensLowerLeft_[0] = Parameters::Get<Parameters::LensLowerLeftX<Scalar>>();
if (dim > 1)
lensLowerLeft_[1] = Parameters::get<TypeTag, Parameters::LensLowerLeftY>();
lensLowerLeft_[1] = Parameters::Get<Parameters::LensLowerLeftY<Scalar>>();
if (dim > 2)
lensLowerLeft_[2] = Parameters::get<TypeTag, Parameters::LensLowerLeftY>();
lensLowerLeft_[2] = Parameters::Get<Parameters::LensLowerLeftY<Scalar>>();
lensUpperRight_[0] = Parameters::get<TypeTag, Parameters::LensUpperRightX>();
lensUpperRight_[0] = Parameters::Get<Parameters::LensUpperRightX<Scalar>>();
if (dim > 1)
lensUpperRight_[1] = Parameters::get<TypeTag, Parameters::LensUpperRightY>();
lensUpperRight_[1] = Parameters::Get<Parameters::LensUpperRightY<Scalar>>();
if (dim > 2)
lensUpperRight_[2] = Parameters::get<TypeTag, Parameters::LensUpperRightY>();
lensUpperRight_[2] = Parameters::Get<Parameters::LensUpperRightY<Scalar>>();
intrinsicPerm_ = this->toDimMatrix_(Parameters::get<TypeTag, Parameters::Permeability>());
intrinsicPermLens_ = this->toDimMatrix_(Parameters::get<TypeTag, Parameters::PermeabilityLens>());
intrinsicPerm_ = this->toDimMatrix_(Parameters::Get<Parameters::Permeability<Scalar>>());
intrinsicPermLens_ = this->toDimMatrix_(Parameters::Get<Parameters::PermeabilityLens<Scalar>>());
}
/*!
@ -262,33 +204,34 @@ public:
{
ParentType::registerParameters();
Parameters::registerParam<TypeTag, Parameters::LensLowerLeftX>
Parameters::Register<Parameters::LensLowerLeftX<Scalar>>
("The x-coordinate of the lens' lower-left corner [m].");
Parameters::registerParam<TypeTag, Parameters::LensUpperRightX>
Parameters::Register<Parameters::LensUpperRightX<Scalar>>
("The x-coordinate of the lens' upper-right corner [m].");
if (dimWorld > 1) {
Parameters::registerParam<TypeTag, Parameters::LensLowerLeftY>
Parameters::Register<Parameters::LensLowerLeftY<Scalar>>
("The y-coordinate of the lens' lower-left corner [m].");
Parameters::registerParam<TypeTag, Parameters::LensUpperRightY>
Parameters::Register<Parameters::LensUpperRightY<Scalar>>
("The y-coordinate of the lens' upper-right corner [m].");
}
if (dimWorld > 2) {
Parameters::registerParam<TypeTag, Parameters::LensLowerLeftZ>
Parameters::Register<Parameters::LensLowerLeftZ<Scalar>>
("The z-coordinate of the lens' lower-left corner [m].");
Parameters::registerParam<TypeTag, Parameters::LensUpperRightZ>
Parameters::Register<Parameters::LensUpperRightZ<Scalar>>
("The z-coordinate of the lens' upper-right corner [m].");
}
Parameters::registerParam<TypeTag, Parameters::Permeability>
Parameters::Register<Parameters::Permeability<Scalar>>
("The intrinsic permeability [m^2] of the ambient material.");
Parameters::registerParam<TypeTag, Parameters::PermeabilityLens>
Parameters::Register<Parameters::PermeabilityLens<Scalar>>
("The intrinsic permeability [m^2] of the lens.");
Parameters::SetDefault<Parameters::GridFile>("./data/groundwater_2d.dgf");
Parameters::SetDefault<Parameters::EndTime<Scalar>>(1.0);
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(1.0);
Parameters::SetDefault<Parameters::EnableGravity>(true);
}
/*!

41
examples/problems/infiltrationproblem.hh
View File

@ -27,21 +27,25 @@
#ifndef EWOMS_INFILTRATION_PROBLEM_HH
#define EWOMS_INFILTRATION_PROBLEM_HH
#include <opm/models/pvs/pvsproperties.hh>
#include <opm/material/fluidstates/CompositionalFluidState.hpp>
#include <opm/material/fluidsystems/H2OAirMesityleneFluidSystem.hpp>
#include <opm/material/fluidmatrixinteractions/ThreePhaseParkerVanGenuchten.hpp>
#include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
#include <opm/material/constraintsolvers/ComputeFromReferencePhase.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <dune/common/fmatrix.hh>
#include <dune/common/fvector.hh>
#include <dune/common/version.hh>
#include <dune/grid/yaspgrid.hh>
#include <dune/grid/io/file/dgfparser/dgfyasp.hh>
#include <dune/common/version.hh>
#include <dune/common/fvector.hh>
#include <dune/common/fmatrix.hh>
#include <opm/material/common/Valgrind.hpp>
#include <opm/material/constraintsolvers/ComputeFromReferencePhase.hpp>
#include <opm/material/fluidmatrixinteractions/ThreePhaseParkerVanGenuchten.hpp>
#include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
#include <opm/material/fluidstates/CompositionalFluidState.hpp>
#include <opm/material/fluidsystems/H2OAirMesityleneFluidSystem.hpp>
#include <opm/models/common/multiphasebaseparameters.hh>
#include <opm/models/discretization/common/fvbasefdlocallinearizer.hh>
#include <opm/models/pvs/pvsproperties.hh>
#include <sstream>
#include <string>
@ -90,20 +94,6 @@ public:
} // namespace Opm::Properties
namespace Opm::Parameters {
// Enable gravity?
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::InfiltrationBaseProblem>
{ static constexpr bool value = true; };
// Write newton convergence?
template<class TypeTag>
struct NewtonWriteConvergence<TypeTag, Properties::TTag::InfiltrationBaseProblem>
{ static constexpr bool value = false; };
} // namespace Opm::Parameters
namespace Opm {
/*!
* \ingroup TestProblems
@ -229,6 +219,7 @@ public:
Parameters::SetDefault<Parameters::NumericDifferenceMethod>(1);
Parameters::SetDefault<Parameters::EndTime<Scalar>>(6e3);
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(60.0);
Parameters::SetDefault<Parameters::EnableGravity>(true);
}
/*!

133
examples/problems/lensproblem.hh
View File

@ -28,27 +28,33 @@
#ifndef EWOMS_LENS_PROBLEM_HH
#define EWOMS_LENS_PROBLEM_HH
#include <opm/models/io/structuredgridvanguard.hh>
#include <opm/models/immiscible/immiscibleproperties.hh>
#include <opm/models/discretization/common/fvbaseadlocallinearizer.hh>
#include <opm/models/discretization/ecfv/ecfvdiscretization.hh>
#include <opm/models/common/transfluxmodule.hh>
#include <dune/common/fmatrix.hh>
#include <dune/common/fvector.hh>
#include <dune/common/version.hh>
#include <opm/material/components/Dnapl.hpp>
#include <opm/material/components/SimpleH2O.hpp>
#include <opm/material/fluidmatrixinteractions/RegularizedVanGenuchten.hpp>
#include <opm/material/fluidmatrixinteractions/LinearMaterial.hpp>
#include <opm/material/fluidmatrixinteractions/EffToAbsLaw.hpp>
#include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
#include <opm/material/fluidsystems/TwoPhaseImmiscibleFluidSystem.hpp>
#include <opm/material/fluidstates/ImmiscibleFluidState.hpp>
#include <opm/material/components/SimpleH2O.hpp>
#include <opm/material/components/Dnapl.hpp>
#include <opm/material/fluidsystems/TwoPhaseImmiscibleFluidSystem.hpp>
#include <dune/common/version.hh>
#include <dune/common/fvector.hh>
#include <dune/common/fmatrix.hh>
#include <opm/models/common/multiphasebaseparameters.hh>
#include <opm/models/common/transfluxmodule.hh>
#include <opm/models/discretization/common/fvbaseadlocallinearizer.hh>
#include <opm/models/discretization/ecfv/ecfvdiscretization.hh>
#include <opm/models/immiscible/immiscibleproperties.hh>
#include <opm/models/io/structuredgridvanguard.hh>
#include <opm/models/io/vtkmultiphasemodule.hh>
#include <iostream>
#include <sstream>
#include <string>
#include <iostream>
namespace Opm {
template <class TypeTag>
@ -119,77 +125,24 @@ public:
namespace Opm::Parameters {
// declare the properties specific for the lens problem
template<class TypeTag, class MyTypeTag>
struct LensLowerLeftX { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct LensLowerLeftY { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct LensLowerLeftZ { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct LensUpperRightX { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct LensUpperRightY { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct LensUpperRightZ { using type = Properties::UndefinedProperty; };
// Enable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::LensBaseProblem>
{ static constexpr bool value = true; };
// define the properties specific for the lens problem
template<class TypeTag>
struct LensLowerLeftX<TypeTag, Properties::TTag::LensBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1.0;
};
template<class Scalar>
struct LensLowerLeftX { static constexpr Scalar value = 1.0; };
template<class TypeTag>
struct LensLowerLeftY<TypeTag, Properties::TTag::LensBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 2.0;
};
template<class Scalar>
struct LensLowerLeftY { static constexpr Scalar value = 2.0; };
template<class TypeTag>
struct LensLowerLeftZ<TypeTag, Properties::TTag::LensBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.0;
};
template<class Scalar>
struct LensLowerLeftZ { static constexpr Scalar value = 0.0; };
template<class TypeTag>
struct LensUpperRightX<TypeTag, Properties::TTag::LensBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 4.0;
};
template<class Scalar>
struct LensUpperRightX { static constexpr Scalar value = 4.0; };
template<class TypeTag>
struct LensUpperRightY<TypeTag, Properties::TTag::LensBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 3.0;
};
template<class Scalar>
struct LensUpperRightY { static constexpr Scalar value = 3.0; };
template<class TypeTag>
struct LensUpperRightZ<TypeTag, Properties::TTag::LensBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1.0;
};
// Write the solutions of individual newton iterations?
template<class TypeTag>
struct NewtonWriteConvergence<TypeTag, Properties::TTag::LensBaseProblem>
{ static constexpr bool value = false; };
template<class Scalar>
struct LensUpperRightZ { static constexpr Scalar value = 1.0; };
} // namespace Opm::Parameters
@ -279,14 +232,14 @@ public:
FluidSystem::init();
temperature_ = 273.15 + 20; // -> 20°C
lensLowerLeft_[0] = Parameters::get<TypeTag, Parameters::LensLowerLeftX>();
lensLowerLeft_[1] = Parameters::get<TypeTag, Parameters::LensLowerLeftY>();
lensUpperRight_[0] = Parameters::get<TypeTag, Parameters::LensUpperRightX>();
lensUpperRight_[1] = Parameters::get<TypeTag, Parameters::LensUpperRightY>();
lensLowerLeft_[0] = Parameters::Get<Parameters::LensLowerLeftX<Scalar>>();
lensLowerLeft_[1] = Parameters::Get<Parameters::LensLowerLeftY<Scalar>>();
lensUpperRight_[0] = Parameters::Get<Parameters::LensUpperRightX<Scalar>>();
lensUpperRight_[1] = Parameters::Get<Parameters::LensUpperRightY<Scalar>>();
if constexpr (dim == 3) {
lensLowerLeft_[2] = Parameters::get<TypeTag, Parameters::LensLowerLeftZ>();
lensUpperRight_[2] = Parameters::get<TypeTag, Parameters::LensUpperRightZ>();
lensLowerLeft_[2] = Parameters::Get<Parameters::LensLowerLeftZ<Scalar>>();
lensUpperRight_[2] = Parameters::Get<Parameters::LensUpperRightZ<Scalar>>();
}
// residual saturations
@ -320,19 +273,19 @@ public:
{
ParentType::registerParameters();
Parameters::registerParam<TypeTag, Parameters::LensLowerLeftX>
Parameters::Register<Parameters::LensLowerLeftX<Scalar>>
("The x-coordinate of the lens' lower-left corner [m].");
Parameters::registerParam<TypeTag, Parameters::LensLowerLeftY>
Parameters::Register<Parameters::LensLowerLeftY<Scalar>>
("The y-coordinate of the lens' lower-left corner [m].");
Parameters::registerParam<TypeTag, Parameters::LensUpperRightX>
Parameters::Register<Parameters::LensUpperRightX<Scalar>>
("The x-coordinate of the lens' upper-right corner [m].");
Parameters::registerParam<TypeTag, Parameters::LensUpperRightY>
Parameters::Register<Parameters::LensUpperRightY<Scalar>>
("The y-coordinate of the lens' upper-right corner [m].");
if constexpr (dim == 3) {
Parameters::registerParam<TypeTag, Parameters::LensLowerLeftZ>
Parameters::Register<Parameters::LensLowerLeftZ<Scalar>>
("The z-coordinate of the lens' lower-left corner [m].");
Parameters::registerParam<TypeTag, Parameters::LensUpperRightZ>
Parameters::Register<Parameters::LensUpperRightZ<Scalar>>
("The z-coordinate of the lens' upper-right corner [m].");
}
@ -357,6 +310,8 @@ public:
Parameters::SetDefault<Parameters::EnableIntensiveQuantityCache>(true);
Parameters::SetDefault<Parameters::EnableStorageCache>(true);
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(250.0);
Parameters::SetDefault<Parameters::VtkWriteIntrinsicPermeabilities>(true);
Parameters::SetDefault<Parameters::EnableGravity>(true);
}
/*!

42
examples/problems/obstacleproblem.hh
View File

@ -28,28 +28,30 @@
#ifndef EWOMS_OBSTACLE_PROBLEM_HH
#define EWOMS_OBSTACLE_PROBLEM_HH
#include <opm/models/ncp/ncpproperties.hh>
#include <opm/material/fluidsystems/H2ON2FluidSystem.hpp>
#include <opm/material/constraintsolvers/ComputeFromReferencePhase.hpp>
#include <opm/material/fluidstates/CompositionalFluidState.hpp>
#include <opm/material/fluidmatrixinteractions/RegularizedBrooksCorey.hpp>
#include <opm/material/fluidmatrixinteractions/EffToAbsLaw.hpp>
#include <opm/material/fluidmatrixinteractions/LinearMaterial.hpp>
#include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
#include <opm/material/thermal/ConstantSolidHeatCapLaw.hpp>
#include <opm/material/thermal/SomertonThermalConductionLaw.hpp>
#include <dune/common/fmatrix.hh>
#include <dune/common/fvector.hh>
#include <dune/common/version.hh>
#include <dune/grid/yaspgrid.hh>
#include <dune/grid/io/file/dgfparser/dgfyasp.hh>
#include <dune/common/version.hh>
#include <dune/common/fvector.hh>
#include <dune/common/fmatrix.hh>
#include <opm/material/constraintsolvers/ComputeFromReferencePhase.hpp>
#include <opm/material/fluidmatrixinteractions/EffToAbsLaw.hpp>
#include <opm/material/fluidmatrixinteractions/LinearMaterial.hpp>
#include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
#include <opm/material/fluidmatrixinteractions/RegularizedBrooksCorey.hpp>
#include <opm/material/fluidstates/CompositionalFluidState.hpp>
#include <opm/material/fluidsystems/H2ON2FluidSystem.hpp>
#include <opm/material/thermal/ConstantSolidHeatCapLaw.hpp>
#include <opm/material/thermal/SomertonThermalConductionLaw.hpp>
#include <opm/models/common/multiphasebaseparameters.hh>
#include <opm/models/ncp/ncpproperties.hh>
#include <iostream>
#include <sstream>
#include <string>
#include <iostream>
namespace Opm {
template <class TypeTag>
@ -113,15 +115,6 @@ struct SolidEnergyLaw<TypeTag, TTag::ObstacleBaseProblem>
} // namespace Opm::Properties
namespace Opm::Parameters {
// Enable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::ObstacleBaseProblem>
{ static constexpr bool value = true; };
} // namespace Opm::Parameters
namespace Opm {
/*!
* \ingroup TestProblems
@ -268,6 +261,7 @@ public:
Parameters::SetDefault<Parameters::GridFile>("./data/obstacle_24x16.dgf");
Parameters::SetDefault<Parameters::EndTime<Scalar>>(1e4);
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(250);
Parameters::SetDefault<Parameters::EnableGravity>(true);
}
/*!

16
examples/problems/outflowproblem.hh
View File

@ -74,20 +74,6 @@ public:
} // namespace Opm::Properties
namespace Opm::Parameters {
// Disable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::OutflowBaseProblem>
{ static constexpr bool value = false; };
// Also write mass fractions to the output
template<class TypeTag>
struct VtkWriteMassFractions<TypeTag, Properties::TTag::OutflowBaseProblem>
{ static constexpr bool value = true; };
} // namespac Opm::Parameters
namespace Opm {
/*!
* \ingroup TestProblems
@ -176,6 +162,8 @@ public:
Parameters::SetDefault<Parameters::GridFile>("./data/outflow.dgf");
Parameters::SetDefault<Parameters::EndTime<Scalar>>(100.0);
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(1.0);
Parameters::SetDefault<Parameters::VtkWriteMassFractions>(true);
}
/*!

15
examples/problems/powerinjectionproblem.hh
View File

@ -121,20 +121,6 @@ public:
} // namespace Opm::Properties
namespace Opm::Parameters {
// Disable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::PowerInjectionBaseProblem>
{ static constexpr bool value = false; };
// Write out the filter velocities for this problem
template<class TypeTag>
struct VtkWriteFilterVelocities<TypeTag, Properties::TTag::PowerInjectionBaseProblem>
{ static constexpr bool value = true; };
} // namespace Opm::Parameters
namespace Opm {
/*!
* \ingroup TestProblems
@ -241,6 +227,7 @@ public:
Parameters::SetDefault<Parameters::EndTime<Scalar>>(100.0);
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(1e-3);
Parameters::SetDefault<Parameters::VtkWriteFilterVelocities>(true);
}
/*!

71
examples/problems/reservoirproblem.hh
View File

@ -46,6 +46,8 @@
#include <opm/models/blackoil/blackoilproperties.hh>
#include <opm/models/common/multiphasebaseparameters.hh>
#include <opm/models/discretization/common/fvbaseparameters.hh>
#include <opm/models/discretization/common/fvbaseproperties.hh>
@ -124,57 +126,16 @@ public:
namespace Opm::Parameters {
// Maximum depth of the reservoir
template<class TypeTag, class MyTypeTag>
struct MaxDepth { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct MaxDepth { static constexpr Scalar value = 2500.0; };
// The temperature inside the reservoir
template<class TypeTag, class MyTypeTag>
struct Temperature { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct Temperature { static constexpr Scalar value = 293.15; };
// The width of producer/injector wells as a fraction of the width of the spatial domain
template<class TypeTag, class MyTypeTag>
struct WellWidth { using type = Properties::UndefinedProperty; };
// Enable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::ReservoirBaseProblem>
{ static constexpr bool value = true; };
// set the defaults for some problem specific properties
template<class TypeTag>
struct MaxDepth<TypeTag, Properties::TTag::ReservoirBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 2500;
};
// Write the Newton convergence behavior to disk?
template<class TypeTag>
struct NewtonWriteConvergence<TypeTag, Properties::TTag::ReservoirBaseProblem>
{ static constexpr bool value = false; };
// increase the tolerance for this problem to get larger time steps
template<class TypeTag>
struct NewtonTolerance<TypeTag, Properties::TTag::ReservoirBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e-6;
};
template<class TypeTag>
struct Temperature<TypeTag, Properties::TTag::ReservoirBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 293.15;
};
// The width of producer/injector wells as a fraction of the width of the spatial domain
template<class TypeTag>
struct WellWidth<TypeTag, Properties::TTag::ReservoirBaseProblem>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.01;
};
template<class Scalar>
struct WellWidth { static constexpr Scalar value = 0.01; };
} // namespace Opm::Parameters
@ -255,9 +216,9 @@ public:
{
ParentType::finishInit();
temperature_ = Parameters::get<TypeTag, Parameters::Temperature>();
maxDepth_ = Parameters::get<TypeTag, Parameters::MaxDepth>();
wellWidth_ = Parameters::get<TypeTag, Parameters::WellWidth>();
temperature_ = Parameters::Get<Parameters::Temperature<Scalar>>();
maxDepth_ = Parameters::Get<Parameters::MaxDepth<Scalar>>();
wellWidth_ = Parameters::Get<Parameters::WellWidth<Scalar>>();
std::vector<std::pair<Scalar, Scalar> > Bo = {
{ 101353, 1.062 },
@ -419,11 +380,11 @@ public:
{
ParentType::registerParameters();
Parameters::registerParam<TypeTag, Parameters::Temperature>
Parameters::Register<Parameters::Temperature<Scalar>>
("The temperature [K] in the reservoir");
Parameters::registerParam<TypeTag, Parameters::MaxDepth>
Parameters::Register<Parameters::MaxDepth<Scalar>>
("The maximum depth [m] of the reservoir");
Parameters::registerParam<TypeTag, Parameters::WellWidth>
Parameters::Register<Parameters::WellWidth<Scalar>>
("The width of producer/injector wells as a fraction of the width"
" of the spatial domain");
@ -436,6 +397,10 @@ public:
Parameters::SetDefault<Parameters::EnableStorageCache>(true);
Parameters::SetDefault<Parameters::GridFile>("data/reservoir.dgf");
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(100e3);
// increase the tolerance for this problem to get larger time steps
Parameters::SetDefault<Parameters::NewtonTolerance<Scalar>>(1e-6);
Parameters::SetDefault<Parameters::EnableGravity>(true);
}
/*!

27
examples/problems/richardslensproblem.hh
View File

@ -101,30 +101,6 @@ public:
} // namespace Opm::Properties
namespace Opm::Parameters {
// Enable gravitational acceleration
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::RichardsLensProblem>
{ static constexpr bool value = true; };
// Do not write the intermediate results of the newton method
template<class TypeTag>
struct NewtonWriteConvergence<TypeTag, Properties::TTag::RichardsLensProblem>
{ static constexpr bool value = false; };
// Set the "desireable" number of newton iterations of a time step
template<class TypeTag>
struct NewtonTargetIterations<TypeTag, Properties::TTag::RichardsLensProblem>
{ static constexpr int value = 18; };
// Set the maximum number of newton iterations of a time step
template<class TypeTag>
struct NewtonMaxIterations<TypeTag, Properties::TTag::RichardsLensProblem>
{ static constexpr int value = 28; };
} // namespace Opm::Parameters
namespace Opm {
/*!
@ -259,6 +235,9 @@ public:
Parameters::SetDefault<Parameters::EndTime<Scalar>>(3000.0);
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(100.0);
Parameters::SetDefault<Parameters::NewtonMaxIterations>(28);
Parameters::SetDefault<Parameters::NewtonTargetIterations>(18);
Parameters::SetDefault<Parameters::EnableGravity>(true);
}
/*!

18
examples/problems/waterairproblem.hh
View File

@ -45,6 +45,8 @@
#include <opm/material/thermal/ConstantSolidHeatCapLaw.hpp>
#include <opm/material/thermal/SomertonThermalConductionLaw.hpp>
#include <opm/models/common/multiphasebaseparameters.hh>
#include <opm/models/discretization/common/fvbasefdlocallinearizer.hh>
#include <opm/models/pvs/pvsproperties.hh>
@ -133,20 +135,6 @@ struct PreconditionerWrapper<TypeTag, TTag::WaterAirBaseProblem>
} // namespace Opm::Properties
namespace Opm::Parameters {
// Enable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::WaterAirBaseProblem>
{ static constexpr bool value = true; };
// Write newton convergence
template<class TypeTag>
struct NewtonWriteConvergence<TypeTag, Properties::TTag::WaterAirBaseProblem>
{ static constexpr bool value = false; };
} // namespace Opm::Parameters
namespace Opm {
/*!
* \ingroup TestProblems
@ -303,6 +291,8 @@ public:
Parameters::SetDefault<Parameters::EndTime<Scalar>>(1.0 * 365 * 24 * 60 * 60);
Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(250.0);
Parameters::SetDefault<Parameters::EnableGravity>(true);
Parameters::SetDefault<Parameters::PreconditionerOrder>(2);
}
/*!

10
examples/tutorial1problem.hh
View File

@ -122,16 +122,8 @@ public:
} // namespace Opm::Properties
namespace Opm::Parameters {
// Disable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::Tutorial1Problem>
{ static constexpr bool value = false; }; /*@\label{tutorial1:gravity}@*/
} // namespace Opm::Parameters
namespace Opm {
//! Tutorial problem using the "immiscible" model.
template <class TypeTag>
class Tutorial1Problem

2
opm/models/blackoil/blackoilfoammodules.hh
View File

@ -189,7 +189,7 @@ public:
Simulator&)
{
if constexpr (enableFoam) {
if (Parameters::get<TypeTag, Parameters::EnableVtkOutput>()) {
if (Parameters::Get<Parameters::EnableVtkOutput>()) {
OpmLog::warning("VTK output requested, currently unsupported by the foam module.");
}
}

63
opm/models/blackoil/blackoilmodel.hh
View File

@ -30,57 +30,52 @@
#include <opm/material/densead/Math.hpp>
#include "blackoilproblem.hh"
#include "blackoilindices.hh"
#include "blackoiltwophaseindices.hh"
#include "blackoilextensivequantities.hh"
#include "blackoilprimaryvariables.hh"
#include "blackoilintensivequantities.hh"
#include "blackoilratevector.hh"
#include "blackoilboundaryratevector.hh"
#include "blackoillocalresidual.hh"
#include "blackoilnewtonmethod.hh"
#include "blackoilproperties.hh"
#include "blackoilsolventmodules.hh"
#include "blackoilpolymermodules.hh"
#include "blackoilfoammodules.hh"
#include "blackoilbrinemodules.hh"
#include "blackoilextbomodules.hh"
#include "blackoildarcyfluxmodule.hh"
#include "blackoilmicpmodules.hh"
#include <opm/material/fluidsystems/BlackOilFluidSystem.hpp>
#include <opm/models/blackoil/blackoilboundaryratevector.hh>
#include <opm/models/blackoil/blackoilbrinemodules.hh>
#include <opm/models/blackoil/blackoildarcyfluxmodule.hh>
#include <opm/models/blackoil/blackoildiffusionmodule.hh>
#include <opm/models/blackoil/blackoildispersionmodule.hh>
#include <opm/models/blackoil/blackoilextbomodules.hh>
#include <opm/models/blackoil/blackoilextensivequantities.hh>
#include <opm/models/blackoil/blackoilfoammodules.hh>
#include <opm/models/blackoil/blackoilindices.hh>
#include <opm/models/blackoil/blackoilintensivequantities.hh>
#include <opm/models/blackoil/blackoillocalresidual.hh>
#include <opm/models/blackoil/blackoilmicpmodules.hh>
#include <opm/models/blackoil/blackoilnewtonmethod.hh>
#include <opm/models/blackoil/blackoilpolymermodules.hh>
#include <opm/models/blackoil/blackoilprimaryvariables.hh>
#include <opm/models/blackoil/blackoilproblem.hh>
#include <opm/models/blackoil/blackoilproperties.hh>
#include <opm/models/blackoil/blackoilratevector.hh>
#include <opm/models/blackoil/blackoilsolventmodules.hh>
#include <opm/models/blackoil/blackoiltwophaseindices.hh>
#include <opm/models/common/multiphasebasemodel.hh>
#include <opm/models/io/vtkcompositionmodule.hh>
#include <opm/models/io/vtkblackoilmodule.hh>
#include "blackoildiffusionmodule.hh"
#include "blackoildispersionmodule.hh"
#include <opm/models/io/vtkdiffusionmodule.hh>
#include <opm/material/fluidsystems/BlackOilFluidSystem.hpp>
#include <opm/models/io/vtkblackoilmodule.hh>
#include <opm/models/io/vtkcompositionmodule.hh>
#include <opm/models/io/vtkdiffusionmodule.hh>
#include <sstream>
#include <string>
namespace Opm {
template <class TypeTag>
class BlackOilModel;
template <class TypeTag>
class EclVanguard;
}
namespace Opm::Properties {
namespace TTag {
//! The type tag for the black-oil problems
struct BlackOilModel { using InheritsFrom = std::tuple<VtkComposition,
VtkBlackOilEnergy,
VtkDiffusion,
VtkBlackOilPolymer,
VtkBlackOilSolvent,
VtkBlackOil,
MultiPhaseBaseModel,
VtkBlackOilMICP>; };
struct BlackOilModel
{ using InheritsFrom = std::tuple<VtkBlackOilPolymer, MultiPhaseBaseModel>; };
} // namespace TTag
//! Set the local residual function

123
opm/models/blackoil/blackoilnewtonmethod.hh
View File

@ -44,84 +44,6 @@ struct DiscNewtonMethod;
} // namespace Opm::Properties
namespace Opm:: Parameters {
template<class TypeTag>
struct DpMaxRel<TypeTag, Properties::TTag::NewtonMethod>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.3;
};
template<class TypeTag>
struct DsMax<TypeTag, Properties::TTag::NewtonMethod>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.2;
};
template<class TypeTag>
struct PriVarOscilationThreshold<TypeTag, Properties::TTag::NewtonMethod>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e-5;
};
template<class TypeTag>
struct ProjectSaturations<TypeTag, Properties::TTag::NewtonMethod>
{ static constexpr bool value = false; };
template<class TypeTag>
struct MaxTemperatureChange<TypeTag, Properties::TTag::NewtonMethod>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 5; //Kelvin
};
template<class TypeTag>
struct TemperatureMax<TypeTag, Properties::TTag::NewtonMethod>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e9; // Kelvin
};
template<class TypeTag>
struct TemperatureMin<TypeTag, Properties::TTag::NewtonMethod>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 0.0; // Kelvin
};
template<class TypeTag>
struct PressureMax<TypeTag, Properties::TTag::NewtonMethod>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e99; // Kelvin
};
template<class TypeTag>
struct PressureMin<TypeTag, Properties::TTag::NewtonMethod>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = -1e99; // Kelvin
};
template<class TypeTag>
struct MaximumWaterSaturation<TypeTag, Properties::TTag::NewtonMethod>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1.0;
};
template<class TypeTag>
struct WaterOnlyThreshold<TypeTag, Properties::TTag::NewtonMethod>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1.0;
};
} // namespace Opm::Parameters
namespace Opm {
/*!
@ -150,17 +72,17 @@ class BlackOilNewtonMethod : public GetPropType<TypeTag, Properties::DiscNewtonM
public:
BlackOilNewtonMethod(Simulator& simulator) : ParentType(simulator)
{
priVarOscilationThreshold_ = Parameters::get<TypeTag, Parameters::PriVarOscilationThreshold>();
dpMaxRel_ = Parameters::get<TypeTag, Parameters::DpMaxRel>();
dsMax_ = Parameters::get<TypeTag, Parameters::DsMax>();
projectSaturations_ = Parameters::get<TypeTag, Parameters::ProjectSaturations>();
maxTempChange_ = Parameters::get<TypeTag, Parameters::MaxTemperatureChange>();
tempMax_ = Parameters::get<TypeTag, Parameters::TemperatureMax>();
tempMin_ = Parameters::get<TypeTag, Parameters::TemperatureMin>();
pressMax_ = Parameters::get<TypeTag, Parameters::PressureMax>();
pressMin_ = Parameters::get<TypeTag, Parameters::PressureMin>();
waterSaturationMax_ = Parameters::get<TypeTag, Parameters::MaximumWaterSaturation>();
waterOnlyThreshold_ = Parameters::get<TypeTag, Parameters::WaterOnlyThreshold>();
priVarOscilationThreshold_ = Parameters::Get<Parameters::PriVarOscilationThreshold<Scalar>>();
dpMaxRel_ = Parameters::Get<Parameters::DpMaxRel<Scalar>>();
dsMax_ = Parameters::Get<Parameters::DsMax<Scalar>>();
projectSaturations_ = Parameters::Get<Parameters::ProjectSaturations>();
maxTempChange_ = Parameters::Get<Parameters::MaxTemperatureChange<Scalar>>();
tempMax_ = Parameters::Get<Parameters::TemperatureMax<Scalar>>();
tempMin_ = Parameters::Get<Parameters::TemperatureMin<Scalar>>();
pressMax_ = Parameters::Get<Parameters::PressureMax<Scalar>>();
pressMin_ = Parameters::Get<Parameters::PressureMin<Scalar>>();
waterSaturationMax_ = Parameters::Get<Parameters::MaximumWaterSaturation<Scalar>>();
waterOnlyThreshold_ = Parameters::Get<Parameters::WaterOnlyThreshold<Scalar>>();
}
/*!
@ -181,28 +103,28 @@ public:
{
ParentType::registerParameters();
Parameters::registerParam<TypeTag, Parameters::DpMaxRel>
Parameters::Register<Parameters::DpMaxRel<Scalar>>
("Maximum relative change of pressure in a single iteration");
Parameters::registerParam<TypeTag, Parameters::DsMax>
Parameters::Register<Parameters::DsMax<Scalar>>
("Maximum absolute change of any saturation in a single iteration");
Parameters::registerParam<TypeTag, Parameters::PriVarOscilationThreshold>
Parameters::Register<Parameters::PriVarOscilationThreshold<Scalar>>
("The threshold value for the primary variable switching conditions "
"after its meaning has switched to hinder oscilations");
Parameters::registerParam<TypeTag, Parameters::ProjectSaturations>
Parameters::Register<Parameters::ProjectSaturations>
("Option for doing saturation projection");
Parameters::registerParam<TypeTag, Parameters::MaxTemperatureChange>
Parameters::Register<Parameters::MaxTemperatureChange<Scalar>>
("Maximum absolute change of temperature in a single iteration");
Parameters::registerParam<TypeTag, Parameters::TemperatureMax>
Parameters::Register<Parameters::TemperatureMax<Scalar>>
("Maximum absolute temperature");
Parameters::registerParam<TypeTag, Parameters::TemperatureMin>
Parameters::Register<Parameters::TemperatureMin<Scalar>>
("Minimum absolute temperature");
Parameters::registerParam<TypeTag, Parameters::PressureMax>
Parameters::Register<Parameters::PressureMax<Scalar>>
("Maximum absolute pressure");
Parameters::registerParam<TypeTag, Parameters::PressureMin>
Parameters::Register<Parameters::PressureMin<Scalar>>
("Minimum absolute pressure");
Parameters::registerParam<TypeTag, Parameters::MaximumWaterSaturation>
Parameters::Register<Parameters::MaximumWaterSaturation<Scalar>>
("Maximum water saturation");
Parameters::registerParam<TypeTag, Parameters::WaterOnlyThreshold>
Parameters::Register<Parameters::WaterOnlyThreshold<Scalar>>
("Cells with water saturation above or equal is considered one-phase water only");
}
@ -524,6 +446,7 @@ private:
// to detect and hinder oscillations
std::vector<bool> wasSwitched_;
};
} // namespace Opm
#endif

45
opm/models/blackoil/blackoilnewtonmethodparameters.hh
View File

@ -28,42 +28,39 @@
#ifndef EWOMS_BLACK_OIL_NEWTON_METHOD_PARAMETERS_HH
#define EWOMS_BLACK_OIL_NEWTON_METHOD_PARAMETERS_HH
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Parameters {
template<class TypeTag, class MyTypeTag>
struct DpMaxRel { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct DpMaxRel { static constexpr Scalar value = 0.3; };
template<class TypeTag, class MyTypeTag>
struct DsMax { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct DsMax { static constexpr Scalar value = 0.2; };
template<class TypeTag, class MyTypeTag>
struct PriVarOscilationThreshold { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct PriVarOscilationThreshold { static constexpr Scalar value = 1e-5; };
template<class TypeTag, class MyTypeTag>
struct ProjectSaturations { using type = Properties::UndefinedProperty; };
struct ProjectSaturations { static constexpr bool value = false; };
template<class TypeTag, class MyTypeTag>
struct MaxTemperatureChange { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct MaxTemperatureChange { static constexpr Scalar value = 5.0; }; // Kelvin
template<class TypeTag, class MyTypeTag>
struct TemperatureMax { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct TemperatureMax { static constexpr Scalar value = 1e9; }; // Kelvin
template<class TypeTag, class MyTypeTag>
struct TemperatureMin { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct TemperatureMin { static constexpr Scalar value = 0.0; }; // Kelvin
template<class TypeTag, class MyTypeTag>
struct PressureMax { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct PressureMax { static constexpr Scalar value = 1e99; };
template<class TypeTag, class MyTypeTag>
struct PressureMin { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct PressureMin { static constexpr Scalar value = -1e99; };
template<class TypeTag, class MyTypeTag>
struct MaximumWaterSaturation { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct MaximumWaterSaturation { static constexpr Scalar value = 1.0; };
template<class TypeTag, class MyTypeTag>
struct WaterOnlyThreshold { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct WaterOnlyThreshold { static constexpr Scalar value = 1.0; };
} // namespace Opm::Parameters

2
opm/models/blackoil/blackoilsolventmodules.hh
View File

@ -1369,7 +1369,7 @@ public:
Valgrind::CheckDefined(solventPGrad);
// correct the pressure gradients by the gravitational acceleration
if (Parameters::get<TypeTag, Parameters::EnableGravity>()) {
if (Parameters::Get<Parameters::EnableGravity>()) {
// estimate the gravitational acceleration at a given SCV face
// using the arithmetic mean
const auto& gIn = elemCtx.problem().gravity(elemCtx, i, timeIdx);

4
opm/models/common/darcyfluxmodule.hh
View File

@ -212,7 +212,7 @@ protected:
}
// correct the pressure gradients by the gravitational acceleration
if (Parameters::get<TypeTag, Parameters::EnableGravity>()) {
if (Parameters::Get<Parameters::EnableGravity>()) {
// estimate the gravitational acceleration at a given SCV face
// using the arithmetic mean
const auto& gIn = elemCtx.problem().gravity(elemCtx, i, timeIdx);
@ -362,7 +362,7 @@ protected:
K_ = intQuantsIn.intrinsicPermeability();
// correct the pressure gradients by the gravitational acceleration
if (Parameters::get<TypeTag, Parameters::EnableGravity>()) {
if (Parameters::Get<Parameters::EnableGravity>()) {
// estimate the gravitational acceleration at a given SCV face
// using the arithmetic mean
const auto& gIn = elemCtx.problem().gravity(elemCtx, i, timeIdx);

13
opm/models/common/multiphasebasemodel.hh
View File

@ -57,7 +57,9 @@ namespace Opm::Properties {
//! The generic type tag for problems using the immiscible multi-phase model
// Create new type tags
namespace TTag {
struct MultiPhaseBaseModel { using InheritsFrom = std::tuple<VtkTemperature, VtkMultiPhase>; };
struct MultiPhaseBaseModel {};
} // end namespace TTag
//! Specify the splices of the MultiPhaseBaseModel type tag
@ -139,15 +141,6 @@ struct ThermalConductionLawParams<TypeTag, TTag::MultiPhaseBaseModel>
} // namespace Opm::Properties
namespace Opm::Parameters {
//! disable gravity by default
template<class TypeTag>
struct EnableGravity<TypeTag, Properties::TTag::MultiPhaseBaseModel>
{ static constexpr bool value = false; };
}
namespace Opm {
/*!

9
opm/models/common/multiphasebaseparameters.hh
View File

@ -24,19 +24,16 @@
* \file
* \ingroup MultiPhaseBaseModel
*
* \brief Defines the common paramamters for the porous medium
* \brief Defines the common parameters for the porous medium
* multi-phase models.
*/
#ifndef EWOMS_MULTI_PHASE_BASE_PARAMETERS_HH
#define EWOMS_MULTI_PHASE_BASE_PARAMETERS_HH
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Parameters {
//! Returns whether gravity is considered in the problem
template<class TypeTag, class MyTypeTag>
struct EnableGravity { using type = Properties::UndefinedProperty; };
//! Returns whether gravity is considered in the problem.
struct EnableGravity { static constexpr bool value = false; };
} // namespace Opm::Parameters

5
opm/models/common/multiphasebaseproblem.hh
View File

@ -93,7 +93,7 @@ public:
{
ParentType::registerParameters();
Parameters::registerParam<TypeTag, Parameters::EnableGravity>
Parameters::Register<Parameters::EnableGravity>
("Use the gravity correction for the pressure gradients.");
}
@ -398,8 +398,9 @@ private:
void init_()
{
gravity_ = 0.0;
if (Parameters::get<TypeTag, Parameters::EnableGravity>())
if (Parameters::Get<Parameters::EnableGravity>()) {
gravity_[dimWorld-1] = -9.81;
}
}
};

2
opm/models/discretefracture/discretefracturemodel.hh
View File

@ -53,7 +53,7 @@ namespace Opm::Properties {
// Create new type tags
namespace TTag {
//! The generic type tag for problems using the immiscible multi-phase model
struct DiscreteFractureModel { using InheritsFrom = std::tuple<VtkDiscreteFracture, ImmiscibleTwoPhaseModel>; };
struct DiscreteFractureModel { using InheritsFrom = std::tuple<ImmiscibleTwoPhaseModel>; };
} // end namespace TTag
//! The class for the model

23
opm/models/discretization/common/fvbasediscretization.hh
View File

@ -282,29 +282,6 @@ struct DiscreteFunction<TypeTag, TTag::FvBaseDiscretization>
} // namespace Opm::Properties
namespace Opm::Parameters {
// use default initialization based on rule-of-thumb of Newton tolerance
template<class TypeTag>
struct LinearSolverAbsTolerance<TypeTag, Properties::TTag::FvBaseDiscretization>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = -1.;
};
// if the deflection of the newton method is large, we do not need to solve the linear
// approximation accurately. Assuming that the value for the current solution is quite
// close to the final value, a reduction of 3 orders of magnitude in the defect should be
// sufficient...
template<class TypeTag>
struct LinearSolverTolerance<TypeTag, Properties::TTag::FvBaseDiscretization>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e-3;
};
} // namespace Opm::Parameters
namespace Opm {
/*!

3
opm/models/discretization/common/fvbaseproperties.hh
View File

@ -36,7 +36,6 @@ namespace Opm::Properties {
namespace TTag {
struct FvBaseNewtonMethod;
struct VtkPrimaryVars;
struct FiniteDifferenceLocalLinearizer;
struct ParallelBiCGStabLinearSolver;
}
@ -45,7 +44,7 @@ namespace TTag {
//! The type tag for models based on the finite volume schemes
struct FvBaseDiscretization
{ using InheritsFrom = std::tuple<VtkPrimaryVars, FvBaseNewtonMethod, ImplicitModel>; };
{ using InheritsFrom = std::tuple<FvBaseNewtonMethod, ImplicitModel>; };
} // namespace TTag

9
opm/models/flash/flashmodel.hh
View File

@ -32,8 +32,8 @@
#include <opm/material/densead/Math.hpp>
#include <opm/material/fluidmatrixinteractions/NullMaterial.hpp>
#include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
#include <opm/material/fluidmatrixinteractions/NullMaterial.hpp>
#include <opm/models/common/energymodule.hh>
#include <opm/models/common/multiphasebasemodel.hh>
@ -44,8 +44,8 @@
#include <opm/models/flash/flashintensivequantities.hh>
#include <opm/models/flash/flashlocalresidual.hh>
#include <opm/models/flash/flashparameters.hh>
#include <opm/models/flash/flashproperties.hh>
#include <opm/models/flash/flashprimaryvariables.hh>
#include <opm/models/flash/flashproperties.hh>
#include <opm/models/flash/flashratevector.hh>
#include <opm/models/io/vtkcompositionmodule.hh>
@ -64,10 +64,7 @@ namespace Opm::Properties {
namespace TTag {
//! The type tag for the isothermal single phase problems
struct FlashModel { using InheritsFrom = std::tuple<VtkDiffusion,
VtkEnergy,
VtkComposition,
MultiPhaseBaseModel>; };
struct FlashModel { using InheritsFrom = std::tuple<MultiPhaseBaseModel>; };
} // namespace TTag
//! Use the FlashLocalResidual function for the flash model

24
opm/models/immiscible/immisciblemodel.hh
View File

@ -60,7 +60,7 @@ namespace Opm::Properties {
// Create new type tags
namespace TTag {
//! The generic type tag for problems using the immiscible multi-phase model
struct ImmiscibleModel { using InheritsFrom = std::tuple<VtkEnergy, MultiPhaseBaseModel>; };
struct ImmiscibleModel { using InheritsFrom = std::tuple<MultiPhaseBaseModel>; };
//! The type tag for single-phase immiscible problems
struct ImmiscibleSinglePhaseModel { using InheritsFrom = std::tuple<ImmiscibleModel>; };
@ -166,24 +166,6 @@ public:
} // namespace Opm::Properties
namespace Opm::Parameters {
// disable output of a few quantities which make sense in a
// multi-phase but not in a single-phase context
template<class TypeTag>
struct VtkWriteSaturations<TypeTag, Properties::TTag::ImmiscibleSinglePhaseModel>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteMobilities<TypeTag, Properties::TTag::ImmiscibleSinglePhaseModel>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteRelativePermeabilities<TypeTag, Properties::TTag::ImmiscibleSinglePhaseModel>
{ static constexpr bool value = false; };
} // namespace Opm::Parameters
namespace Opm {
/*!
@ -257,6 +239,10 @@ public:
if (enableEnergy)
Opm::VtkEnergyModule<TypeTag>::registerParameters();
Parameters::SetDefault<Parameters::VtkWriteSaturations>(false);
Parameters::SetDefault<Parameters::VtkWriteMobilities>(false);
Parameters::SetDefault<Parameters::VtkWriteRelativePermeabilities>(false);
}
/*!

55
opm/models/io/vtkblackoilenergymodule.hh
View File

@ -41,44 +41,13 @@
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Properties::TTag {
// create new type tag for the VTK multi-phase output
struct VtkBlackOilEnergy {};
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the energy module
template<class TypeTag, class MyTypeTag>
struct VtkWriteRockInternalEnergy { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteTotalThermalConductivity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFluidInternalEnergies { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFluidEnthalpies { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteRockInternalEnergy<TypeTag, Properties::TTag::VtkBlackOilEnergy>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteTotalThermalConductivity<TypeTag, Properties::TTag::VtkBlackOilEnergy>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteFluidInternalEnergies<TypeTag, Properties::TTag::VtkBlackOilEnergy>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteFluidEnthalpies<TypeTag, Properties::TTag::VtkBlackOilEnergy>
{ static constexpr bool value = true; };
struct VtkWriteRockInternalEnergy { static constexpr bool value = true; };
struct VtkWriteTotalThermalConductivity { static constexpr bool value = true; };
struct VtkWriteFluidInternalEnergies { static constexpr bool value = true; };
struct VtkWriteFluidEnthalpies { static constexpr bool value = true; };
} // namespace Opm::Parameters
@ -123,15 +92,15 @@ public:
if (!enableEnergy)
return;
Parameters::registerParam<TypeTag, Parameters::VtkWriteRockInternalEnergy>
Parameters::Register<Parameters::VtkWriteRockInternalEnergy>
("Include the volumetric internal energy of rock "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteTotalThermalConductivity>
Parameters::Register<Parameters::VtkWriteTotalThermalConductivity>
("Include the total thermal conductivity of the medium and the fluids "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteFluidInternalEnergies>
Parameters::Register<Parameters::VtkWriteFluidInternalEnergies>
("Include the internal energies of the fluids in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteFluidEnthalpies>
Parameters::Register<Parameters::VtkWriteFluidEnthalpies>
("Include the enthalpies of the fluids in the VTK output files");
}
@ -225,25 +194,25 @@ public:
private:
static bool rockInternalEnergyOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteRockInternalEnergy>();
static bool val = Parameters::Get<Parameters::VtkWriteRockInternalEnergy>();
return val;
}
static bool totalThermalConductivityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTotalThermalConductivity>();
static bool val = Parameters::Get<Parameters::VtkWriteTotalThermalConductivity>();
return val;
}
static bool fluidInternalEnergiesOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFluidInternalEnergies>();
static bool val = Parameters::Get<Parameters::VtkWriteFluidInternalEnergies>();
return val;
}
static bool fluidEnthalpiesOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFluidEnthalpies>();
static bool val = Parameters::Get<Parameters::VtkWriteFluidEnthalpies>();
return val;
}

67
opm/models/io/vtkblackoilmicpmodule.hh
View File

@ -41,51 +41,14 @@
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Properties::TTag {
// create new type tag for the VTK multi-phase output
struct VtkBlackOilMICP {};
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the MICP output module
template<class TypeTag, class MyTypeTag>
struct VtkWriteMicrobialConcentration { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteOxygenConcentration { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteUreaConcentration { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteBiofilmConcentration { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteCalciteConcentration { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteMicrobialConcentration<TypeTag, Properties::TTag::VtkBlackOilMICP>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteOxygenConcentration<TypeTag, Properties::TTag::VtkBlackOilMICP>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteUreaConcentration<TypeTag, Properties::TTag::VtkBlackOilMICP>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteBiofilmConcentration<TypeTag, Properties::TTag::VtkBlackOilMICP>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteCalciteConcentration<TypeTag, Properties::TTag::VtkBlackOilMICP>
{ static constexpr bool value = true; };
struct VtkWriteMicrobialConcentration { static constexpr bool value = true; };
struct VtkWriteOxygenConcentration { static constexpr bool value = true; };
struct VtkWriteUreaConcentration { static constexpr bool value = true; };
struct VtkWriteBiofilmConcentration { static constexpr bool value = true; };
struct VtkWriteCalciteConcentration { static constexpr bool value = true; };
} // namespace Opm::Parameters
@ -127,18 +90,18 @@ public:
if (!enableMICP)
return;
Parameters::registerParam<TypeTag, Parameters::VtkWriteMicrobialConcentration>
Parameters::Register<Parameters::VtkWriteMicrobialConcentration>
("Include the concentration of the microbial component in the water phase "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteOxygenConcentration>
Parameters::Register<Parameters::VtkWriteOxygenConcentration>
("Include the concentration of the oxygen component in the water phase "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteUreaConcentration>
Parameters::Register<Parameters::VtkWriteUreaConcentration>
("Include the concentration of the urea component in the water phase "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteBiofilmConcentration>
Parameters::Register<Parameters::VtkWriteBiofilmConcentration>
("Include the biofilm volume fraction in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteCalciteConcentration>
Parameters::Register<Parameters::VtkWriteCalciteConcentration>
("Include the calcite volume fraction in the VTK output files");
}
@ -239,31 +202,31 @@ public:
private:
static bool microbialConcentrationOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMicrobialConcentration>();
static bool val = Parameters::Get<Parameters::VtkWriteMicrobialConcentration>();
return val;
}
static bool oxygenConcentrationOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteOxygenConcentration>();
static bool val = Parameters::Get<Parameters::VtkWriteOxygenConcentration>();
return val;
}
static bool ureaConcentrationOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteUreaConcentration>();
static bool val = Parameters::Get<Parameters::VtkWriteUreaConcentration>();
return val;
}
static bool biofilmConcentrationOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteBiofilmConcentration>();
static bool val = Parameters::Get<Parameters::VtkWriteBiofilmConcentration>();
return val;
}
static bool calciteConcentrationOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteCalciteConcentration>();
static bool val = Parameters::Get<Parameters::VtkWriteCalciteConcentration>();
return val;
}

139
opm/models/io/vtkblackoilmodule.hh
View File

@ -41,93 +41,20 @@
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Properties::TTag {
// create new type tag for the VTK multi-phase output
struct VtkBlackOil {};
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the multi phase module
template<class TypeTag, class MyTypeTag>
struct VtkWriteGasDissolutionFactor { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteOilVaporizationFactor { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteOilFormationVolumeFactor { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteGasFormationVolumeFactor { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteWaterFormationVolumeFactor { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteOilSaturationPressure { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteGasSaturationPressure { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSaturationRatios { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSaturatedOilGasDissolutionFactor { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSaturatedGasOilVaporizationFactor { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePrimaryVarsMeaning { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteGasDissolutionFactor<TypeTag, Properties::TTag::VtkBlackOil>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteOilVaporizationFactor<TypeTag, Properties::TTag::VtkBlackOil>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteOilFormationVolumeFactor<TypeTag, Properties::TTag::VtkBlackOil>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteGasFormationVolumeFactor<TypeTag, Properties::TTag::VtkBlackOil>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteWaterFormationVolumeFactor<TypeTag, Properties::TTag::VtkBlackOil>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteOilSaturationPressure<TypeTag, Properties::TTag::VtkBlackOil>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteGasSaturationPressure<TypeTag, Properties::TTag::VtkBlackOil>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteSaturationRatios<TypeTag, Properties::TTag::VtkBlackOil>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteSaturatedOilGasDissolutionFactor<TypeTag, Properties::TTag::VtkBlackOil>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteSaturatedGasOilVaporizationFactor<TypeTag, Properties::TTag::VtkBlackOil>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWritePrimaryVarsMeaning<TypeTag, Properties::TTag::VtkBlackOil>
{ static constexpr bool value = false; };
struct VtkWriteGasDissolutionFactor { static constexpr bool value = false; };
struct VtkWriteOilVaporizationFactor { static constexpr bool value = false; };
struct VtkWriteOilFormationVolumeFactor { static constexpr bool value = false; };
struct VtkWriteGasFormationVolumeFactor { static constexpr bool value = false; };
struct VtkWriteWaterFormationVolumeFactor { static constexpr bool value = false; };
struct VtkWriteOilSaturationPressure { static constexpr bool value = false; };
struct VtkWriteGasSaturationPressure { static constexpr bool value = false; };
struct VtkWriteSaturationRatios { static constexpr bool value = false; };
struct VtkWriteSaturatedOilGasDissolutionFactor { static constexpr bool value = false; };
struct VtkWriteSaturatedGasOilVaporizationFactor { static constexpr bool value = false; };
struct VtkWritePrimaryVarsMeaning { static constexpr bool value = false; };
} // namespace Opm::Parameters
@ -174,36 +101,36 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::VtkWriteGasDissolutionFactor>
Parameters::Register<Parameters::VtkWriteGasDissolutionFactor>
("Include the gas dissolution factor (R_s) of the observed oil "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteOilVaporizationFactor>
Parameters::Register<Parameters::VtkWriteOilVaporizationFactor>
("Include the oil vaporization factor (R_v) of the observed gas "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteOilFormationVolumeFactor>
Parameters::Register<Parameters::VtkWriteOilFormationVolumeFactor>
("Include the oil formation volume factor (B_o) in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteGasFormationVolumeFactor>
Parameters::Register<Parameters::VtkWriteGasFormationVolumeFactor>
("Include the gas formation volume factor (B_g) in the "
"VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteWaterFormationVolumeFactor>
Parameters::Register<Parameters::VtkWriteWaterFormationVolumeFactor>
("Include the water formation volume factor (B_w) in the "
"VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteOilSaturationPressure>
Parameters::Register<Parameters::VtkWriteOilSaturationPressure>
("Include the saturation pressure of oil (p_o,sat) in the "
"VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteGasSaturationPressure>
Parameters::Register<Parameters::VtkWriteGasSaturationPressure>
("Include the saturation pressure of gas (p_g,sat) in the "
"VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteSaturatedOilGasDissolutionFactor>
Parameters::Register<Parameters::VtkWriteSaturatedOilGasDissolutionFactor>
("Include the gas dissolution factor (R_s,sat) of gas saturated "
"oil in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteSaturatedGasOilVaporizationFactor>
Parameters::Register<Parameters::VtkWriteSaturatedGasOilVaporizationFactor>
("Include the oil vaporization factor (R_v,sat) of oil saturated "
"gas in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteSaturationRatios>
Parameters::Register<Parameters::VtkWriteSaturationRatios>
("Write the ratio of the actually and maximum dissolved component of "
"the mixtures");
Parameters::registerParam<TypeTag, Parameters::VtkWritePrimaryVarsMeaning>
Parameters::Register<Parameters::VtkWritePrimaryVarsMeaning>
("Include how the primary variables should be interpreted to the "
"VTK output files");
}
@ -378,67 +305,67 @@ public:
private:
static bool gasDissolutionFactorOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteGasDissolutionFactor>();
static bool val = Parameters::Get<Parameters::VtkWriteGasDissolutionFactor>();
return val;
}
static bool oilVaporizationFactorOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteOilVaporizationFactor>();
static bool val = Parameters::Get<Parameters::VtkWriteOilVaporizationFactor>();
return val;
}
static bool oilFormationVolumeFactorOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteOilFormationVolumeFactor>();
static bool val = Parameters::Get<Parameters::VtkWriteOilFormationVolumeFactor>();
return val;
}
static bool gasFormationVolumeFactorOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteGasFormationVolumeFactor>();
static bool val = Parameters::Get<Parameters::VtkWriteGasFormationVolumeFactor>();
return val;
}
static bool waterFormationVolumeFactorOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteWaterFormationVolumeFactor>();
static bool val = Parameters::Get<Parameters::VtkWriteWaterFormationVolumeFactor>();
return val;
}
static bool oilSaturationPressureOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteOilSaturationPressure>();
static bool val = Parameters::Get<Parameters::VtkWriteOilSaturationPressure>();
return val;
}
static bool gasSaturationPressureOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteGasSaturationPressure>();
static bool val = Parameters::Get<Parameters::VtkWriteGasSaturationPressure>();
return val;
}
static bool saturatedOilGasDissolutionFactorOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSaturatedOilGasDissolutionFactor>();
static bool val = Parameters::Get<Parameters::VtkWriteSaturatedOilGasDissolutionFactor>();
return val;
}
static bool saturatedGasOilVaporizationFactorOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSaturatedGasOilVaporizationFactor>();
static bool val = Parameters::Get<Parameters::VtkWriteSaturatedGasOilVaporizationFactor>();
return val;
}
static bool saturationRatiosOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSaturationRatios>();
static bool val = Parameters::Get<Parameters::VtkWriteSaturationRatios>();
return val;
}
static bool primaryVarsMeaningOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePrimaryVarsMeaning>();
static bool val = Parameters::Get<Parameters::VtkWritePrimaryVarsMeaning>();
return val;
}

72
opm/models/io/vtkblackoilpolymermodule.hh
View File

@ -50,49 +50,13 @@ struct VtkBlackOilPolymer {};
namespace Opm::Parameters {
// create the property tags needed for the polymer output module
template<class TypeTag, class MyTypeTag>
struct VtkWritePolymerConcentration { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePolymerDeadPoreVolume { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePolymerAdsorption { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePolymerRockDensity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePolymerViscosityCorrection { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteWaterViscosityCorrection { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWritePolymerConcentration<TypeTag, Properties::TTag::VtkBlackOilPolymer>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWritePolymerDeadPoreVolume<TypeTag, Properties::TTag::VtkBlackOilPolymer>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWritePolymerViscosityCorrection<TypeTag, Properties::TTag::VtkBlackOilPolymer>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteWaterViscosityCorrection<TypeTag, Properties::TTag::VtkBlackOilPolymer>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWritePolymerRockDensity<TypeTag, Properties::TTag::VtkBlackOilPolymer>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWritePolymerAdsorption<TypeTag, Properties::TTag::VtkBlackOilPolymer>
{ static constexpr bool value = true; };
struct VtkWritePolymerConcentration { static constexpr bool value = true; };
struct VtkWritePolymerDeadPoreVolume { static constexpr bool value = true; };
struct VtkWritePolymerViscosityCorrection { static constexpr bool value = true; };
struct VtkWriteWaterViscosityCorrection { static constexpr bool value = true; };
struct VtkWritePolymerRockDensity { static constexpr bool value = true; };
struct VtkWritePolymerAdsorption { static constexpr bool value = true; };
} // namespace Opm::Parameters
@ -134,22 +98,22 @@ public:
if (!enablePolymer)
return;
Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerConcentration>
Parameters::Register<Parameters::VtkWritePolymerConcentration>
("Include the concentration of the polymer component in the water phase "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerDeadPoreVolume>
Parameters::Register<Parameters::VtkWritePolymerDeadPoreVolume>
("Include the fraction of the \"dead\" pore volume "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerRockDensity>
Parameters::Register<Parameters::VtkWritePolymerRockDensity>
("Include the amount of already adsorbed polymer component"
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerAdsorption>
Parameters::Register<Parameters::VtkWritePolymerAdsorption>
("Include the adsorption rate of the polymer component"
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerViscosityCorrection>
Parameters::Register<Parameters::VtkWritePolymerViscosityCorrection>
("Include the viscosity correction of the polymer component "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteWaterViscosityCorrection>
Parameters::Register<Parameters::VtkWriteWaterViscosityCorrection>
("Include the viscosity correction of the water component "
"due to polymers in the VTK output files");
}
@ -258,37 +222,37 @@ public:
private:
static bool polymerConcentrationOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerConcentration>();
static bool val = Parameters::Get<Parameters::VtkWritePolymerConcentration>();
return val;
}
static bool polymerDeadPoreVolumeOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerDeadPoreVolume>();
static bool val = Parameters::Get<Parameters::VtkWritePolymerDeadPoreVolume>();
return val;
}
static bool polymerRockDensityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerRockDensity>();
static bool val = Parameters::Get<Parameters::VtkWritePolymerRockDensity>();
return val;
}
static bool polymerAdsorptionOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerAdsorption>();
static bool val = Parameters::Get<Parameters::VtkWritePolymerAdsorption>();
return val;
}
static bool polymerViscosityCorrectionOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerViscosityCorrection>();
static bool val = Parameters::Get<Parameters::VtkWritePolymerViscosityCorrection>();
return val;
}
static bool waterViscosityCorrectionOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerViscosityCorrection>();
static bool val = Parameters::Get<Parameters::VtkWritePolymerViscosityCorrection>();
return val;
}

67
opm/models/io/vtkblackoilsolventmodule.hh
View File

@ -41,51 +41,14 @@
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Properties::TTag {
// create new type tag for the VTK multi-phase output
struct VtkBlackOilSolvent {};
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the solvent output module
template<class TypeTag, class MyTypeTag>
struct VtkWriteSolventSaturation { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSolventRsw { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSolventDensity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSolventViscosity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSolventMobility { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteSolventSaturation<TypeTag, Properties::TTag::VtkBlackOilSolvent>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteSolventRsw<TypeTag, Properties::TTag::VtkBlackOilSolvent>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteSolventDensity<TypeTag, Properties::TTag::VtkBlackOilSolvent>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteSolventViscosity<TypeTag, Properties::TTag::VtkBlackOilSolvent>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteSolventMobility<TypeTag, Properties::TTag::VtkBlackOilSolvent>
{ static constexpr bool value = true; };
struct VtkWriteSolventSaturation { static constexpr bool value = true; };
struct VtkWriteSolventRsw { static constexpr bool value = true; };
struct VtkWriteSolventDensity { static constexpr bool value = true; };
struct VtkWriteSolventViscosity { static constexpr bool value = true; };
struct VtkWriteSolventMobility { static constexpr bool value = true; };
} // namespace Opm::Properties
@ -127,19 +90,19 @@ public:
if (!enableSolvent)
return;
Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventSaturation>
Parameters::Register<Parameters::VtkWriteSolventSaturation>
("Include the \"saturation\" of the solvent component "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventRsw>
Parameters::Register<Parameters::VtkWriteSolventRsw>
("Include the \"dissolved volume in water\" of the solvent component "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventDensity>
Parameters::Register<Parameters::VtkWriteSolventDensity>
("Include the \"density\" of the solvent component "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventViscosity>
Parameters::Register<Parameters::VtkWriteSolventViscosity>
("Include the \"viscosity\" of the solvent component "
"in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventMobility>
Parameters::Register<Parameters::VtkWriteSolventMobility>
("Include the \"mobility\" of the solvent component "
"in the VTK output files");
}
@ -240,31 +203,31 @@ public:
private:
static bool solventSaturationOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventSaturation>();
static bool val = Parameters::Get<Parameters::VtkWriteSolventSaturation>();
return val;
}
static bool solventRswOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventRsw>();
static bool val = Parameters::Get<Parameters::VtkWriteSolventRsw>();
return val;
}
static bool solventDensityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventDensity>();
static bool val = Parameters::Get<Parameters::VtkWriteSolventDensity>();
return val;
}
static bool solventViscosityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventViscosity>();
static bool val = Parameters::Get<Parameters::VtkWriteSolventViscosity>();
return val;
}
static bool solventMobilityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventMobility>();
static bool val = Parameters::Get<Parameters::VtkWriteSolventMobility>();
return val;
}

91
opm/models/io/vtkcompositionmodule.hh
View File

@ -37,65 +37,16 @@
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Properties::TTag {
// create new type tag for the VTK composition output
struct VtkComposition {};
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the composition module
template<class TypeTag, class MyTypeTag>
struct VtkWriteMassFractions { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteMoleFractions { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteTotalMassFractions { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteTotalMoleFractions { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteMolarities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFugacities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFugacityCoeffs { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteMassFractions<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteMoleFractions<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteTotalMassFractions<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteTotalMoleFractions<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteMolarities<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteFugacities<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteFugacityCoeffs<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = false; };
struct VtkWriteMassFractions { static constexpr bool value = false; };
struct VtkWriteMoleFractions { static constexpr bool value = true; };
struct VtkWriteTotalMassFractions { static constexpr bool value = false; };
struct VtkWriteTotalMoleFractions { static constexpr bool value = false; };
struct VtkWriteMolarities { static constexpr bool value = false; };
struct VtkWriteFugacities { static constexpr bool value = false; };
struct VtkWriteFugacityCoeffs { static constexpr bool value = false; };
} // namespace Opm::Properties
@ -144,19 +95,19 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::VtkWriteMassFractions>
Parameters::Register<Parameters::VtkWriteMassFractions>
("Include mass fractions in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteMoleFractions>
Parameters::Register<Parameters::VtkWriteMoleFractions>
("Include mole fractions in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteTotalMassFractions>
Parameters::Register<Parameters::VtkWriteTotalMassFractions>
("Include total mass fractions in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteTotalMoleFractions>
Parameters::Register<Parameters::VtkWriteTotalMoleFractions>
("Include total mole fractions in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteMolarities>
Parameters::Register<Parameters::VtkWriteMolarities>
("Include component molarities in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteFugacities>
Parameters::Register<Parameters::VtkWriteFugacities>
("Include component fugacities in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteFugacityCoeffs>
Parameters::Register<Parameters::VtkWriteFugacityCoeffs>
("Include component fugacity coefficients in the VTK output files");
}
@ -278,43 +229,43 @@ public:
private:
static bool massFracOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMassFractions>();
static bool val = Parameters::Get<Parameters::VtkWriteMassFractions>();
return val;
}
static bool moleFracOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMoleFractions>();
static bool val = Parameters::Get<Parameters::VtkWriteMoleFractions>();
return val;
}
static bool totalMassFracOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTotalMassFractions>();
static bool val = Parameters::Get<Parameters::VtkWriteTotalMassFractions>();
return val;
}
static bool totalMoleFracOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTotalMoleFractions>();
static bool val = Parameters::Get<Parameters::VtkWriteTotalMoleFractions>();
return val;
}
static bool molarityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMolarities>();
static bool val = Parameters::Get<Parameters::VtkWriteMolarities>();
return val;
}
static bool fugacityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFugacities>();
static bool val = Parameters::Get<Parameters::VtkWriteFugacities>();
return val;
}
static bool fugacityCoeffOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFugacityCoeffs>();
static bool val = Parameters::Get<Parameters::VtkWriteFugacityCoeffs>();
return val;
}

50
opm/models/io/vtkdiffusionmodule.hh
View File

@ -28,49 +28,23 @@
#ifndef EWOMS_VTK_DIFFUSION_MODULE_HH
#define EWOMS_VTK_DIFFUSION_MODULE_HH
#include "vtkmultiwriter.hh"
#include "baseoutputmodule.hh"
#include <opm/material/densead/Evaluation.hpp>
#include <opm/material/densead/Math.hpp>
#include <opm/models/discretization/common/fvbaseparameters.hh>
#include <opm/models/io/baseoutputmodule.hh>
#include <opm/models/io/vtkmultiwriter.hh>
#include <opm/models/utils/propertysystem.hh>
#include <opm/models/utils/parametersystem.hh>
namespace Opm::Properties::TTag {
// create new type tag for the VTK output of the quantities for molecular
// diffusion
struct VtkDiffusion {};
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the diffusion module
template<class TypeTag, class MyTypeTag>
struct VtkWriteTortuosities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteDiffusionCoefficients { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteEffectiveDiffusionCoefficients { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteTortuosities<TypeTag, Properties::TTag::VtkDiffusion>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteDiffusionCoefficients<TypeTag, Properties::TTag::VtkDiffusion>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteEffectiveDiffusionCoefficients<TypeTag, Properties::TTag::VtkDiffusion>
{ static constexpr bool value = false; };
struct VtkWriteTortuosities { static constexpr bool value = false; };
struct VtkWriteDiffusionCoefficients { static constexpr bool value = false; };
struct VtkWriteEffectiveDiffusionCoefficients { static constexpr bool value = false; };
} // namespace Opm::Parameters
@ -117,12 +91,12 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::VtkWriteTortuosities>
Parameters::Register<Parameters::VtkWriteTortuosities>
("Include the tortuosity for each phase in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteDiffusionCoefficients>
Parameters::Register<Parameters::VtkWriteDiffusionCoefficients>
("Include the molecular diffusion coefficients in "
"the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteEffectiveDiffusionCoefficients>
Parameters::Register<Parameters::VtkWriteEffectiveDiffusionCoefficients>
("Include the effective molecular diffusion "
"coefficients the medium in the VTK output files");
}
@ -194,19 +168,19 @@ public:
private:
static bool tortuosityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTortuosities>();
static bool val = Parameters::Get<Parameters::VtkWriteTortuosities>();
return val;
}
static bool diffusionCoefficientOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteDiffusionCoefficients>();
static bool val = Parameters::Get<Parameters::VtkWriteDiffusionCoefficients>();
return val;
}
static bool effectiveDiffusionCoefficientOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteEffectiveDiffusionCoefficients>();
static bool val = Parameters::Get<Parameters::VtkWriteEffectiveDiffusionCoefficients>();
return val;
}

91
opm/models/io/vtkdiscretefracturemodule.hh
View File

@ -41,65 +41,16 @@
#include <cstdio>
namespace Opm::Properties::TTag {
// create new type tag for the VTK multi-phase output
struct VtkDiscreteFracture {};
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the multi phase module
template<class TypeTag, class MyTypeTag>
struct VtkWriteFractureSaturations { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFractureMobilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFractureRelativePermeabilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFracturePorosity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFractureIntrinsicPermeabilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFractureFilterVelocities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFractureVolumeFraction { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteFractureSaturations<TypeTag, Properties::TTag::VtkDiscreteFracture>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteFractureMobilities<TypeTag, Properties::TTag::VtkDiscreteFracture>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteFractureRelativePermeabilities<TypeTag, Properties::TTag::VtkDiscreteFracture>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteFracturePorosity<TypeTag, Properties::TTag::VtkDiscreteFracture>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteFractureIntrinsicPermeabilities<TypeTag, Properties::TTag::VtkDiscreteFracture>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteFractureFilterVelocities<TypeTag, Properties::TTag::VtkDiscreteFracture>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteFractureVolumeFraction<TypeTag, Properties::TTag::VtkDiscreteFracture>
{ static constexpr bool value = true; };
struct VtkWriteFractureSaturations { static constexpr bool value = true; };
struct VtkWriteFractureMobilities { static constexpr bool value = false; };
struct VtkWriteFractureRelativePermeabilities { static constexpr bool value = true; };
struct VtkWriteFracturePorosity { static constexpr bool value = true; };
struct VtkWriteFractureIntrinsicPermeabilities { static constexpr bool value = false; };
struct VtkWriteFractureFilterVelocities { static constexpr bool value = false; };
struct VtkWriteFractureVolumeFraction { static constexpr bool value = true; };
} // namespace Opm::Parameters
@ -153,20 +104,20 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureSaturations>
Parameters::Register<Parameters::VtkWriteFractureSaturations>
("Include the phase saturations in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureMobilities>
Parameters::Register<Parameters::VtkWriteFractureMobilities>
("Include the phase mobilities in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureRelativePermeabilities>
Parameters::Register<Parameters::VtkWriteFractureRelativePermeabilities>
("Include the phase relative permeabilities in the "
"VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteFracturePorosity>
Parameters::Register<Parameters::VtkWriteFracturePorosity>
("Include the porosity in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureIntrinsicPermeabilities>
Parameters::Register<Parameters::VtkWriteFractureIntrinsicPermeabilities>
("Include the intrinsic permeability in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureFilterVelocities>
Parameters::Register<Parameters::VtkWriteFractureFilterVelocities>
("Include in the filter velocities of the phases in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureVolumeFraction>
Parameters::Register<Parameters::VtkWriteFractureVolumeFraction>
("Add the fraction of the total volume which is "
"occupied by fractures in the VTK output");
}
@ -339,43 +290,43 @@ public:
private:
static bool saturationOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureSaturations>();
static bool val = Parameters::Get<Parameters::VtkWriteFractureSaturations>();
return val;
}
static bool mobilityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureMobilities>();
static bool val = Parameters::Get<Parameters::VtkWriteFractureMobilities>();
return val;
}
static bool relativePermeabilityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureRelativePermeabilities>();
static bool val = Parameters::Get<Parameters::VtkWriteFractureRelativePermeabilities>();
return val;
}
static bool porosityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFracturePorosity>();
static bool val = Parameters::Get<Parameters::VtkWriteFracturePorosity>();
return val;
}
static bool intrinsicPermeabilityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureIntrinsicPermeabilities>();
static bool val = Parameters::Get<Parameters::VtkWriteFractureIntrinsicPermeabilities>();
return val;
}
static bool volumeFractionOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureVolumeFraction>();
static bool val = Parameters::Get<Parameters::VtkWriteFractureVolumeFraction>();
return val;
}
static bool velocityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureFilterVelocities>();
static bool val = Parameters::Get<Parameters::VtkWriteFractureFilterVelocities>();
return val;
}

61
opm/models/io/vtkenergymodule.hh
View File

@ -34,51 +34,18 @@
#include <opm/models/discretization/common/fvbaseparameters.hh>
#include <opm/models/utils/propertysystem.hh>
#include <opm/models/utils/parametersystem.hh>
namespace Opm::Properties::TTag {
// create new type tag for the VTK energy output
struct VtkEnergy {};
} // namespace Opm::Properties::TTag
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Parameters {
// create the property tags needed for the energy module
template<class TypeTag, class MyTypeTag>
struct VtkWriteInternalEnergies { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteEnthalpies { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSolidInternalEnergy { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteThermalConductivity { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteSolidInternalEnergy<TypeTag, Properties::TTag::VtkEnergy>
{ static constexpr bool value = false; };
struct VtkWriteSolidInternalEnergy { static constexpr bool value = false; };
struct VtkWriteThermalConductivity { static constexpr bool value = false; };
struct VtkWriteInternalEnergies { static constexpr bool value = false; };
struct VtkWriteEnthalpies { static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteThermalConductivity<TypeTag, Properties::TTag::VtkEnergy>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteInternalEnergies<TypeTag, Properties::TTag::VtkEnergy>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteEnthalpies<TypeTag, Properties::TTag::VtkEnergy>
{ static constexpr bool value = false; };
} // namespace Opm::Properties
} // namespace Opm::Parameters
namespace Opm {
/*!
@ -125,16 +92,16 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::VtkWriteSolidInternalEnergy>
Parameters::Register<Parameters::VtkWriteSolidInternalEnergy>
("Include the volumetric internal energy of solid"
"matrix in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteThermalConductivity>
Parameters::Register<Parameters::VtkWriteThermalConductivity>
("Include the total thermal conductivity of the"
"medium in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteEnthalpies>
Parameters::Register<Parameters::VtkWriteEnthalpies>
("Include the specific enthalpy of the phases in "
"the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteInternalEnergies>
Parameters::Register<Parameters::VtkWriteInternalEnergies>
("Include the specific internal energy of the "
"phases in the VTK output files");
}
@ -209,25 +176,25 @@ public:
private:
static bool solidInternalEnergyOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolidInternalEnergy>();
static bool val = Parameters::Get<Parameters::VtkWriteSolidInternalEnergy>();
return val;
}
static bool thermalConductivityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteThermalConductivity>();
static bool val = Parameters::Get<Parameters::VtkWriteThermalConductivity>();
return val;
}
static bool enthalpyOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteEnthalpies>();
static bool val = Parameters::Get<Parameters::VtkWriteEnthalpies>();
return val;
}
static bool internalEnergyOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteInternalEnergies>();
static bool val = Parameters::Get<Parameters::VtkWriteInternalEnergies>();
return val;
}

163
opm/models/io/vtkmultiphasemodule.hh
View File

@ -27,117 +27,38 @@
#ifndef EWOMS_VTK_MULTI_PHASE_MODULE_HH
#define EWOMS_VTK_MULTI_PHASE_MODULE_HH
#include "vtkmultiwriter.hh"
#include "baseoutputmodule.hh"
#include <dune/common/fvector.hh>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/models/discretization/common/fvbaseparameters.hh>
#include <opm/models/utils/propertysystem.hh>
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/io/baseoutputmodule.hh>
#include <opm/models/io/vtkmultiwriter.hh>
#include <dune/common/fvector.hh>
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
#include <cstdio>
namespace Opm::Properties::TTag {
// create new type tag for the VTK multi-phase output
struct VtkMultiPhase {};
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the multi phase module
template<class TypeTag, class MyTypeTag>
struct VtkWriteExtrusionFactor { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePressures { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteDensities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSaturations { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteMobilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteRelativePermeabilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteViscosities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteAverageMolarMasses { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePorosity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteIntrinsicPermeabilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePotentialGradients { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFilterVelocities { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteExtrusionFactor<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
struct VtkWriteExtrusionFactor { static constexpr bool value = false; };
struct VtkWritePressures { static constexpr bool value = true; };
struct VtkWriteDensities { static constexpr bool value = true; };
struct VtkWriteSaturations { static constexpr bool value = true; };
struct VtkWriteMobilities { static constexpr bool value = false; };
struct VtkWriteRelativePermeabilities { static constexpr bool value = true; };
struct VtkWriteViscosities { static constexpr bool value = false; };
struct VtkWriteAverageMolarMasses { static constexpr bool value = false; };
struct VtkWritePorosity { static constexpr bool value = true; };
struct VtkWriteIntrinsicPermeabilities { static constexpr bool value = false; };
struct VtkWritePotentialGradients { static constexpr bool value = false; };
struct VtkWriteFilterVelocities { static constexpr bool value = false; };
template<class TypeTag>
struct VtkWritePressures<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteDensities<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteSaturations<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteMobilities<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteRelativePermeabilities<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteViscosities<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteAverageMolarMasses<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWritePorosity<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteIntrinsicPermeabilities<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWritePotentialGradients<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteFilterVelocities<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
} // namespace Opm::Properties
} // namespace Opm::Parameters
namespace Opm {
@ -197,29 +118,29 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::VtkWriteExtrusionFactor>
Parameters::Register<Parameters::VtkWriteExtrusionFactor>
("Include the extrusion factor of the degrees of freedom into the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWritePressures>
Parameters::Register<Parameters::VtkWritePressures>
("Include the phase pressures in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteDensities>
Parameters::Register<Parameters::VtkWriteDensities>
("Include the phase densities in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteSaturations>
Parameters::Register<Parameters::VtkWriteSaturations>
("Include the phase saturations in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteMobilities>
Parameters::Register<Parameters::VtkWriteMobilities>
("Include the phase mobilities in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteRelativePermeabilities>
Parameters::Register<Parameters::VtkWriteRelativePermeabilities>
("Include the phase relative permeabilities in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteViscosities>
Parameters::Register<Parameters::VtkWriteViscosities>
("Include component phase viscosities in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteAverageMolarMasses>
Parameters::Register<Parameters::VtkWriteAverageMolarMasses>
("Include the average phase mass in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWritePorosity>
Parameters::Register<Parameters::VtkWritePorosity>
("Include the porosity in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteIntrinsicPermeabilities>
Parameters::Register<Parameters::VtkWriteIntrinsicPermeabilities>
("Include the intrinsic permeability in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteFilterVelocities>
Parameters::Register<Parameters::VtkWriteFilterVelocities>
("Include in the filter velocities of the phases the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWritePotentialGradients>
Parameters::Register<Parameters::VtkWritePotentialGradients>
("Include the phase pressure potential gradients in the VTK output files");
}
@ -454,73 +375,73 @@ public:
private:
static bool extrusionFactorOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteExtrusionFactor>();
static bool val = Parameters::Get<Parameters::VtkWriteExtrusionFactor>();
return val;
}
static bool pressureOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePressures>();
static bool val = Parameters::Get<Parameters::VtkWritePressures>();
return val;
}
static bool densityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteDensities>();
static bool val = Parameters::Get<Parameters::VtkWriteDensities>();
return val;
}
static bool saturationOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSaturations>();
static bool val = Parameters::Get<Parameters::VtkWriteSaturations>();
return val;
}
static bool mobilityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMobilities>();
static bool val = Parameters::Get<Parameters::VtkWriteMobilities>();
return val;
}
static bool relativePermeabilityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteRelativePermeabilities>();
static bool val = Parameters::Get<Parameters::VtkWriteRelativePermeabilities>();
return val;
}
static bool viscosityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteViscosities>();
static bool val = Parameters::Get<Parameters::VtkWriteViscosities>();
return val;
}
static bool averageMolarMassOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteAverageMolarMasses>();
static bool val = Parameters::Get<Parameters::VtkWriteAverageMolarMasses>();
return val;
}
static bool porosityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePorosity>();
static bool val = Parameters::Get<Parameters::VtkWritePorosity>();
return val;
}
static bool intrinsicPermeabilityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteIntrinsicPermeabilities>();
static bool val = Parameters::Get<Parameters::VtkWriteIntrinsicPermeabilities>();
return val;
}
static bool velocityOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFilterVelocities>();
static bool val = Parameters::Get<Parameters::VtkWriteFilterVelocities>();
return val;
}
static bool potentialGradientOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePotentialGradients>();
static bool val = Parameters::Get<Parameters::VtkWritePotentialGradients>();
return val;
}

19
opm/models/io/vtkphasepresencemodule.hh
View File

@ -35,22 +35,9 @@
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Properties::TTag {
// create new type tag for the VTK primary variables output
struct VtkPhasePresence {};
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the primary variables module
template<class TypeTag, class MyTypeTag>
struct VtkWritePhasePresence { using type = Properties::UndefinedProperty; };
template<class TypeTag>
struct VtkWritePhasePresence<TypeTag, Properties::TTag::VtkPhasePresence>
{ static constexpr bool value = false; };
struct VtkWritePhasePresence { static constexpr bool value = false; };
} // namespace Opm::Parameters
@ -86,7 +73,7 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::VtkWritePhasePresence>
Parameters::Register<Parameters::VtkWritePhasePresence>
("Include the phase presence pseudo primary "
"variable in the VTK output files");
}
@ -137,7 +124,7 @@ public:
private:
static bool phasePresenceOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePhasePresence>();
static bool val = Parameters::Get<Parameters::VtkWritePhasePresence>();
return val;
}

43
opm/models/io/vtkprimaryvarsmodule.hh
View File

@ -35,36 +35,11 @@
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Properties::TTag {
// create new type tag for the VTK primary variables output
struct VtkPrimaryVars {};
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the primary variables module
template<class TypeTag, class MyTypeTag>
struct VtkWritePrimaryVars { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteProcessRank { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteDofIndex { using type = Properties::UndefinedProperty; };
template<class TypeTag>
struct VtkWritePrimaryVars<TypeTag, Properties::TTag::VtkPrimaryVars>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteProcessRank<TypeTag, Properties::TTag::VtkPrimaryVars>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteDofIndex<TypeTag, Properties::TTag::VtkPrimaryVars>
{ static constexpr bool value = false; };
struct VtkWritePrimaryVars { static constexpr bool value = false; };
struct VtkWriteProcessRank { static constexpr bool value = false; };
struct VtkWriteDofIndex { static constexpr bool value = false; };
} // namespace Opm::Properties
@ -102,11 +77,11 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::VtkWritePrimaryVars>
Parameters::Register<Parameters::VtkWritePrimaryVars>
("Include the primary variables into the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteProcessRank>
Parameters::Register<Parameters::VtkWriteProcessRank>
("Include the MPI process rank into the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteDofIndex>
Parameters::Register<Parameters::VtkWriteDofIndex>
("Include the index of the degrees of freedom into the VTK output files");
}
@ -178,17 +153,17 @@ public:
private:
static bool primaryVarsOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePrimaryVars>();
static bool val = Parameters::Get<Parameters::VtkWritePrimaryVars>();
return val;
}
static bool processRankOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteProcessRank>();
static bool val = Parameters::Get<Parameters::VtkWriteProcessRank>();
return val;
}
static bool dofIndexOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteDofIndex>();
static bool val = Parameters::Get<Parameters::VtkWriteDofIndex>();
return val;
}

39
opm/models/io/vtkptflashmodule.hh
View File

@ -27,40 +27,21 @@
#ifndef OPM_VTK_PTFLASH_MODULE_HH
#define OPM_VTK_PTFLASH_MODULE_HH
#include "vtkmultiwriter.hh"
#include "baseoutputmodule.hh"
#include <opm/material/common/MathToolbox.hpp>
#include <opm/models/discretization/common/fvbaseparameters.hh>
#include <opm/models/utils/propertysystem.hh>
#include <opm/models/io/baseoutputmodule.hh>
#include <opm/models/io/vtkmultiwriter.hh>
#include <opm/models/utils/parametersystem.hh>
namespace Opm::Properties::TTag {
// create new type tag for the VTK PTFlash output
struct VtkPTFlash {};
} // namespace Opm::Properties::TTag
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Parameters {
// create the property tags needed for the composition module
template<class TypeTag, class MyTypeTag>
struct VtkWriteLiquidMoleFractions { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteEquilibriumConstants { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteLiquidMoleFractions<TypeTag, Properties::TTag::VtkPTFlash>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteEquilibriumConstants<TypeTag, Properties::TTag::VtkPTFlash>
{ static constexpr bool value = false; };
struct VtkWriteLiquidMoleFractions { static constexpr bool value = false; };
struct VtkWriteEquilibriumConstants { static constexpr bool value = false; };
} // namespace Opm::Parameters
@ -105,9 +86,9 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::VtkWriteLiquidMoleFractions>
Parameters::Register<Parameters::VtkWriteLiquidMoleFractions>
("Include liquid mole fractions (L) in the VTK output files");
Parameters::registerParam<TypeTag, Parameters::VtkWriteEquilibriumConstants>
Parameters::Register<Parameters::VtkWriteEquilibriumConstants>
("Include equilibrium constants (K) in the VTK output files");
}
@ -169,13 +150,13 @@ public:
private:
static bool LOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteLiquidMoleFractions>();
static bool val = Parameters::Get<Parameters::VtkWriteLiquidMoleFractions>();
return val;
}
static bool equilConstOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteEquilibriumConstants>();
static bool val = Parameters::Get<Parameters::VtkWriteEquilibriumConstants>();
return val;
}

19
opm/models/io/vtktemperaturemodule.hh
View File

@ -37,23 +37,10 @@
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Properties::TTag {
// create new type tag for the VTK temperature output
struct VtkTemperature {};
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the temperature module
template<class TypeTag, class MyTypeTag>
struct VtkWriteTemperature { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteTemperature<TypeTag, Properties::TTag::VtkTemperature>
{ static constexpr bool value = true; };
struct VtkWriteTemperature { static constexpr bool value = true; };
} // namespace Opm::Parameters
@ -91,7 +78,7 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::VtkWriteTemperature>
Parameters::Register<Parameters::VtkWriteTemperature>
("Include the temperature in the VTK output files");
}
@ -143,7 +130,7 @@ public:
private:
static bool temperatureOutput_()
{
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTemperature>();
static bool val = Parameters::Get<Parameters::VtkWriteTemperature>();
return val;
}

5
opm/models/ncp/ncpmodel.hh
View File

@ -69,10 +69,7 @@ namespace TTag {
/*!
* \brief Define the type tag for the compositional NCP model.
*/
struct NcpModel { using InheritsFrom = std::tuple<VtkDiffusion,
VtkEnergy,
VtkComposition,
MultiPhaseBaseModel>; };
struct NcpModel { using InheritsFrom = std::tuple<MultiPhaseBaseModel>; };
} // namespace TTag
//! Use the Ncp local jacobian operator for the compositional NCP model

4
opm/models/ncp/ncpnewtonmethod.hh
View File

@ -117,10 +117,10 @@ protected:
// make sure that the error never grows beyond the maximum
// allowed one
if (this->error_ > Parameters::get<TypeTag, Parameters::NewtonMaxError>())
if (this->error_ > Parameters::Get<Parameters::NewtonMaxError<Scalar>>())
throw Opm::NumericalProblem("Newton: Error "+std::to_string(double(this->error_))+
+ " is larger than maximum allowed error of "
+ std::to_string(Parameters::get<TypeTag, Parameters::NewtonMaxError>()));
+ std::to_string(Parameters::Get<Parameters::NewtonMaxError<Scalar>>()));
}
/*!

66
opm/models/nonlinear/newtonmethod.hh
View File

@ -79,42 +79,6 @@ struct NewtonConvergenceWriter<TypeTag, TTag::NewtonMethod> { using type = NullC
} // namespace Opm::Properties
namespace Opm::Parameters {
template<class TypeTag>
struct NewtonVerbose<TypeTag, Properties::TTag::NewtonMethod>
{ static constexpr bool value = true; };
template<class TypeTag>
struct NewtonWriteConvergence<TypeTag, Properties::TTag::NewtonMethod>
{ static constexpr bool value = false; };
template<class TypeTag>
struct NewtonTolerance<TypeTag, Properties::TTag::NewtonMethod>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e-8;
};
// set the abortion tolerance to some very large value. if not
// overwritten at run-time this basically disables abortions
template<class TypeTag>
struct NewtonMaxError<TypeTag, Properties::TTag::NewtonMethod>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e100;
};
template<class TypeTag>
struct NewtonTargetIterations<TypeTag, Properties::TTag::NewtonMethod>
{ static constexpr int value = 10; };
template<class TypeTag>
struct NewtonMaxIterations<TypeTag, Properties::TTag::NewtonMethod>
{ static constexpr int value = 20; };
} // namespace Opm::Parameters
namespace Opm {
/*!
* \ingroup Newton
@ -154,7 +118,7 @@ public:
{
lastError_ = 1e100;
error_ = 1e100;
tolerance_ = Parameters::get<TypeTag, Parameters::NewtonTolerance>();
tolerance_ = Parameters::Get<Parameters::NewtonTolerance<Scalar>>();
numIterations_ = 0;
}
@ -166,20 +130,20 @@ public:
{
LinearSolverBackend::registerParameters();
Parameters::registerParam<TypeTag, Parameters::NewtonVerbose>
Parameters::Register<Parameters::NewtonVerbose>
("Specify whether the Newton method should inform "
"the user about its progress or not");
Parameters::registerParam<TypeTag, Parameters::NewtonWriteConvergence>
Parameters::Register<Parameters::NewtonWriteConvergence>
("Write the convergence behaviour of the Newton "
"method to a VTK file");
Parameters::registerParam<TypeTag, Parameters::NewtonTargetIterations>
Parameters::Register<Parameters::NewtonTargetIterations>
("The 'optimum' number of Newton iterations per time step");
Parameters::registerParam<TypeTag, Parameters::NewtonMaxIterations>
Parameters::Register<Parameters::NewtonMaxIterations>
("The maximum number of Newton iterations per time step");
Parameters::registerParam<TypeTag, Parameters::NewtonTolerance>
Parameters::Register<Parameters::NewtonTolerance<Scalar>>
("The maximum raw error tolerated by the Newton"
"method for considering a solution to be converged");
Parameters::registerParam<TypeTag, Parameters::NewtonMaxError>
Parameters::Register<Parameters::NewtonMaxError<Scalar>>
("The maximum error tolerated by the Newton "
"method to which does not cause an abort");
}
@ -544,7 +508,7 @@ protected:
*/
bool verbose_() const
{
return Parameters::get<TypeTag, Parameters::NewtonVerbose>() && (comm_.rank() == 0);
return Parameters::Get<Parameters::NewtonVerbose>() && (comm_.rank() == 0);
}
/*!
@ -557,8 +521,9 @@ protected:
{
numIterations_ = 0;
if (Parameters::get<TypeTag, Parameters::NewtonWriteConvergence>())
if (Parameters::Get<Parameters::NewtonWriteConvergence>()) {
convergenceWriter_.beginTimeStep();
}
}
/*!
@ -609,7 +574,7 @@ protected:
{
const auto& constraintsMap = model().linearizer().constraintsMap();
lastError_ = error_;
Scalar newtonMaxError = Parameters::get<TypeTag, Parameters::NewtonMaxError>();
Scalar newtonMaxError = Parameters::Get<Parameters::NewtonMaxError<Scalar>>();
// calculate the error as the maximum weighted tolerance of
// the solution's residual
@ -774,7 +739,7 @@ protected:
void writeConvergence_(const SolutionVector& currentSolution,
const GlobalEqVector& solutionUpdate)
{
if (Parameters::get<TypeTag, Parameters::NewtonWriteConvergence>()) {
if (Parameters::Get<Parameters::NewtonWriteConvergence>()) {
convergenceWriter_.beginIteration();
convergenceWriter_.writeFields(currentSolution, solutionUpdate);
convergenceWriter_.endIteration();
@ -846,8 +811,9 @@ protected:
*/
void end_()
{
if (Parameters::get<TypeTag, Parameters::NewtonWriteConvergence>())
if (Parameters::Get<Parameters::NewtonWriteConvergence>()) {
convergenceWriter_.endTimeStep();
}
}
/*!
@ -868,10 +834,10 @@ protected:
// optimal number of iterations we want to achieve
int targetIterations_() const
{ return Parameters::get<TypeTag, Parameters::NewtonTargetIterations>(); }
{ return Parameters::Get<Parameters::NewtonTargetIterations>(); }
// maximum number of iterations we do before giving up
int maxIterations_() const
{ return Parameters::get<TypeTag, Parameters::NewtonMaxIterations>(); }
{ return Parameters::Get<Parameters::NewtonMaxIterations>(); }
static bool enableConstraints_()
{ return getPropValue<TypeTag, Properties::EnableConstraints>(); }

48
opm/models/nonlinear/newtonmethodparameters.hh
View File

@ -23,32 +23,15 @@
#ifndef EWOMS_NEWTON_METHOD_PARAMETERS_HH
#define EWOMS_NEWTON_METHOD_PARAMETERS_HH
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Parameters {
//! Specifies whether the Newton method should print messages or not
template<class TypeTag, class MyTypeTag>
struct NewtonVerbose { using type = Properties::UndefinedProperty; };
//! Specifies whether the convergence rate and the global residual
//! gets written out to disk for every Newton iteration
template<class TypeTag, class MyTypeTag>
struct NewtonWriteConvergence { using type = Properties::UndefinedProperty; };
/*!
* \brief The value for the error below which convergence is declared
*
* This value can (and for the porous media models will) be changed to account for grid
* scaling and other effects.
*/
template<class TypeTag, class MyTypeTag>
struct NewtonTolerance { using type = Properties::UndefinedProperty; };
//! The maximum error which may occur in a simulation before the
//! Newton method for the time step is aborted
template<class TypeTag, class MyTypeTag>
struct NewtonMaxError { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct NewtonMaxError { static constexpr Scalar value = 1e100; };
//! Number of maximum iterations for the Newton method.
struct NewtonMaxIterations { static constexpr int value = 20; };
/*!
* \brief The number of iterations at which the Newton method
@ -58,12 +41,23 @@ struct NewtonMaxError { using type = Properties::UndefinedProperty; };
* is to scale the last time-step size by the deviation of the
* number of iterations used from the target steps.
*/
template<class TypeTag, class MyTypeTag>
struct NewtonTargetIterations { using type = Properties::UndefinedProperty; };
struct NewtonTargetIterations { static constexpr int value = 10; };
//! Number of maximum iterations for the Newton method.
template<class TypeTag, class MyTypeTag>
struct NewtonMaxIterations { using type = Properties::UndefinedProperty; };
/*!
* \brief The value for the error below which convergence is declared
*
* This value can (and for the porous media models will) be changed to account for grid
* scaling and other effects.
*/
template<class Scalar>
struct NewtonTolerance { static constexpr Scalar value = 1e-8; };
//! Specifies whether the Newton method should print messages or not
struct NewtonVerbose { static constexpr bool value = true; };
//! Specifies whether the convergence rate and the global residual
//! gets written out to disk for every Newton iteration
struct NewtonWriteConvergence { static constexpr bool value = false; };
} // end namespace Opm::Parameters

10
opm/models/ptflash/flashmodel.hh
View File

@ -35,13 +35,13 @@
#include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
#include <opm/material/fluidmatrixinteractions/NullMaterial.hpp>
#include <opm/models/common/multiphasebasemodel.hh>
#include <opm/models/common/energymodule.hh>
#include <opm/models/common/multiphasebasemodel.hh>
#include <opm/models/flash/flashratevector.hh>
#include <opm/models/flash/flashboundaryratevector.hh>
#include <opm/models/flash/flashextensivequantities.hh>
#include <opm/models/flash/flashproperties.hh>
#include <opm/models/flash/flashratevector.hh>
#include <opm/models/io/vtkcompositionmodule.hh>
#include <opm/models/io/vtkdiffusionmodule.hh>
@ -69,11 +69,7 @@ namespace Opm::Properties {
namespace TTag {
//! The type tag for the isothermal single phase problems
struct FlashModel { using InheritsFrom = std::tuple<VtkDiffusion,
VtkEnergy,
VtkComposition,
VtkPTFlash,
MultiPhaseBaseModel>; };
struct FlashModel { using InheritsFrom = std::tuple<MultiPhaseBaseModel>; };
} // namespace TTag
//! Use the FlashLocalResidual function for the flash model

6
opm/models/pvs/pvsmodel.hh
View File

@ -69,11 +69,7 @@ namespace TTag {
//! The type tag for the isothermal single phase problems
struct PvsModel
{
using InheritsFrom = std::tuple<VtkDiffusion,
VtkEnergy,
VtkComposition,
VtkPhasePresence,
MultiPhaseBaseModel>; };
using InheritsFrom = std::tuple<MultiPhaseBaseModel>; };
} // namespace TTag
//! Use the PVS local jacobian operator for the PVS model

20
opm/simulators/linalg/istlpreconditionerwrappers.hh
View File

@ -75,16 +75,16 @@ namespace Linear {
\
static void registerParameters() \
{ \
Parameters::registerParam<TypeTag, Parameters::PreconditionerOrder> \
Parameters::Register<Parameters::PreconditionerOrder> \
("The order of the preconditioner"); \
Parameters::registerParam<TypeTag, Parameters::PreconditionerRelaxation> \
Parameters::Register<Parameters::PreconditionerRelaxation<Scalar>> \
("The relaxation factor of the preconditioner"); \
} \
\
void prepare(IstlMatrix& matrix) \
{ \
int order = Parameters::get<TypeTag, Parameters::PreconditionerOrder>(); \
Scalar relaxationFactor = Parameters::get<TypeTag, Parameters::PreconditionerRelaxation>(); \
int order = Parameters::Get<Parameters::PreconditionerOrder>(); \
Scalar relaxationFactor = Parameters::Get<Parameters::PreconditionerRelaxation<Scalar>>(); \
seqPreCond_ = new SequentialPreconditioner(matrix, order, \
relaxationFactor); \
} \
@ -118,14 +118,14 @@ namespace Linear {
\
static void registerParameters() \
{ \
Parameters::registerParam<TypeTag, Parameters::PreconditionerRelaxation> \
Parameters::Register<Parameters::PreconditionerRelaxation<Scalar>> \
("The relaxation factor of the preconditioner"); \
} \
\
void prepare(OverlappingMatrix& matrix) \
{ \
Scalar relaxationFactor = \
Parameters::get<TypeTag, Parameters::PreconditionerRelaxation>(); \
Parameters::Get<Parameters::PreconditionerRelaxation<Scalar>>();\
seqPreCond_ = new SequentialPreconditioner(matrix, \
relaxationFactor); \
} \
@ -155,7 +155,7 @@ class PreconditionerWrapperILU
using OverlappingMatrix = GetPropType<TypeTag, Properties::OverlappingMatrix>;
using OverlappingVector = GetPropType<TypeTag, Properties::OverlappingVector>;
static constexpr int order = getPropValue<TypeTag, Parameters::PreconditionerOrder>();
static constexpr int order = 0;
public:
using SequentialPreconditioner = Dune::SeqILU<OverlappingMatrix, OverlappingVector, OverlappingVector, order>;
@ -165,13 +165,15 @@ public:
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::PreconditionerRelaxation>
Parameters::Register<Parameters::PreconditionerRelaxation<Scalar>>
("The relaxation factor of the preconditioner");
Parameters::Register<Parameters::PreconditionerOrder>
("The order of the preconditioner");
}
void prepare(OverlappingMatrix& matrix)
{
Scalar relaxationFactor = Parameters::get<TypeTag, Parameters::PreconditionerRelaxation>();
Scalar relaxationFactor = Parameters::Get<Parameters::PreconditionerRelaxation<Scalar>>();
// create the sequential preconditioner.
seqPreCond_ = new SequentialPreconditioner(matrix, relaxationFactor);

16
opm/simulators/linalg/istlsolverwrappers.hh
View File

@ -79,12 +79,12 @@ namespace Opm::Linear {
ScalarProduct& parScalarProduct, \
Preconditioner& parPreCond) \
{ \
Scalar tolerance = Parameters::get<TypeTag, Parameters::LinearSolverTolerance>(); \
int maxIter = Parameters::get<TypeTag, Parameters::LinearSolverMaxIterations>(); \
Scalar tolerance = Parameters::Get<Parameters::LinearSolverTolerance<Scalar>>(); \
int maxIter = Parameters::Get<Parameters::LinearSolverMaxIterations>();\
\
int verbosity = 0; \
if (parOperator.overlap().myRank() == 0) \
verbosity = Parameters::get<TypeTag, Parameters::LinearSolverVerbosity>(); \
verbosity = Parameters::Get<Parameters::LinearSolverVerbosity>(); \
solver_ = std::make_shared<RawSolver>(parOperator, parScalarProduct, \
parPreCond, tolerance, maxIter, \
verbosity); \
@ -125,7 +125,7 @@ public:
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::GMResRestart>
Parameters::Register<Parameters::GMResRestart>
("Number of iterations after which the GMRES linear solver is restarted");
}
@ -134,13 +134,13 @@ public:
ScalarProduct& parScalarProduct,
Preconditioner& parPreCond)
{
Scalar tolerance = Parameters::get<TypeTag, Parameters::LinearSolverTolerance>();
int maxIter = Parameters::get<TypeTag, Parameters::LinearSolverMaxIterations>();
Scalar tolerance = Parameters::Get<Parameters::LinearSolverTolerance<Scalar>>();
int maxIter = Parameters::Get<Parameters::LinearSolverMaxIterations>();
int verbosity = 0;
if (parOperator.overlap().myRank() == 0)
verbosity = Parameters::get<TypeTag, Parameters::LinearSolverVerbosity>();
int restartAfter = Parameters::get<TypeTag, Parameters::GMResRestart>();
verbosity = Parameters::Get<Parameters::LinearSolverVerbosity>();
int restartAfter = Parameters::Get<Parameters::GMResRestart>();
solver_ = std::make_shared<RawSolver>(parOperator,
parScalarProduct,
parPreCond,

36
opm/simulators/linalg/linalgparameters.hh
View File

@ -29,29 +29,22 @@
#ifndef EWOMS_LINALG_PARAMETERS_HH
#define EWOMS_LINALG_PARAMETERS_HH
#include <opm/models/utils/parametersystem.hh>
namespace Opm::Parameters {
template<class TypeTag, class MyTypeTag>
struct AmgCoarsenTarget { using type = Properties::UndefinedProperty; };
//! number of iterations between solver restarts for the GMRES solver
template<class TypeTag, class MyTypeTag>
struct GMResRestart { using type = Properties::UndefinedProperty; };
struct GMResRestart { static constexpr int value = 10; };
/*!
* \brief Maximum accepted error of the norm of the residual.
*/
template<class TypeTag, class MyTypeTag>
struct LinearSolverAbsTolerance { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct LinearSolverAbsTolerance { static constexpr Scalar value = -1.0; };
template<class TypeTag, class MyTypeTag>
struct LinearSolverMaxError { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct LinearSolverMaxError { static constexpr Scalar value = 1e7; };
//! Maximum number of iterations eyecuted by the linear solver
template<class TypeTag, class MyTypeTag>
struct LinearSolverMaxIterations { using type = Properties::UndefinedProperty; };
struct LinearSolverMaxIterations { static constexpr int value = 1000; };
/*!
* \brief The size of the algebraic overlap of the linear solver.
@ -60,14 +53,13 @@ struct LinearSolverMaxIterations { using type = Properties::UndefinedProperty; }
* of a grid, but it is only existant for the linear system of
* equations.
*/
template<class TypeTag, class MyTypeTag>
struct LinearSolverOverlapSize { using type = Properties::UndefinedProperty; };
struct LinearSolverOverlapSize { static constexpr unsigned value = 2; };
/*!
* \brief Maximum accepted error of the solution of the linear solver.
*/
template<class TypeTag, class MyTypeTag>
struct LinearSolverTolerance { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct LinearSolverTolerance { static constexpr Scalar value = 1e-3; };
/*!
* \brief Specifies the verbosity of the linear solver
@ -76,16 +68,14 @@ struct LinearSolverTolerance { using type = Properties::UndefinedProperty; };
* property to 1 prints aggregated convergence rates, 2 prints the
* convergence rate of every iteration of the scheme.
*/
template<class TypeTag, class MyTypeTag>
struct LinearSolverVerbosity { using type = Properties::UndefinedProperty; };
struct LinearSolverVerbosity { static constexpr int value = 0; };
//! The order of the sequential preconditioner
template<class TypeTag, class MyTypeTag>
struct PreconditionerOrder { using type = Properties::UndefinedProperty; };
struct PreconditionerOrder { static constexpr int value = 0; };
//! The relaxation factor of the preconditioner
template<class TypeTag, class MyTypeTag>
struct PreconditionerRelaxation { using type = Properties::UndefinedProperty; };
template<class Scalar>
struct PreconditionerRelaxation { static constexpr Scalar value = 1.0; };
} // namespace Opm::Parameters

32
opm/simulators/linalg/parallelamgbackend.hh
View File

@ -69,16 +69,7 @@ namespace Opm::Parameters {
//! The target number of DOFs per processor for the parallel algebraic
//! multi-grid solver
template<class TypeTag>
struct AmgCoarsenTarget<TypeTag, Properties::TTag::ParallelAmgLinearSolver>
{ static constexpr int value = 5000; };
template<class TypeTag>
struct LinearSolverMaxError<TypeTag, Properties::TTag::ParallelAmgLinearSolver>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e7;
};
struct AmgCoarsenTarget { static constexpr int value = 5000; };
}
@ -160,10 +151,10 @@ public:
{
ParentType::registerParameters();
Parameters::registerParam<TypeTag, Parameters::LinearSolverMaxError>
Parameters::Register<Parameters::LinearSolverMaxError<Scalar>>
("The maximum residual error which the linear solver tolerates "
"without giving up");
Parameters::registerParam<TypeTag, Parameters::AmgCoarsenTarget>
Parameters::Register<Parameters::AmgCoarsenTarget>
("The coarsening target for the agglomerations of "
"the AMG preconditioner");
}
@ -203,24 +194,25 @@ protected:
const auto& gridView = this->simulator_.gridView();
using CCC = CombinedCriterion<OverlappingVector, decltype(gridView.comm())>;
Scalar linearSolverTolerance = Parameters::get<TypeTag, Parameters::LinearSolverTolerance>();
Scalar linearSolverAbsTolerance = Parameters::get<TypeTag, Parameters::LinearSolverAbsTolerance>();
if(linearSolverAbsTolerance < 0.0)
Scalar linearSolverTolerance = Parameters::Get<Parameters::LinearSolverTolerance<Scalar>>();
Scalar linearSolverAbsTolerance = Parameters::Get<Parameters::LinearSolverAbsTolerance<Scalar>>();
if (linearSolverAbsTolerance < 0.0) {
linearSolverAbsTolerance = this->simulator_.model().newtonMethod().tolerance()/100.0;
}
convCrit_.reset(new CCC(gridView.comm(),
/*residualReductionTolerance=*/linearSolverTolerance,
/*absoluteResidualTolerance=*/linearSolverAbsTolerance,
Parameters::get<TypeTag, Parameters::LinearSolverMaxError>()));
Parameters::Get<Parameters::LinearSolverMaxError<Scalar>>()));
auto bicgstabSolver =
std::make_shared<RawLinearSolver>(parPreCond, *convCrit_, parScalarProduct);
int verbosity = 0;
if (parOperator.overlap().myRank() == 0)
verbosity = Parameters::get<TypeTag, Parameters::LinearSolverVerbosity>();
verbosity = Parameters::Get<Parameters::LinearSolverVerbosity>();
bicgstabSolver->setVerbosity(verbosity);
bicgstabSolver->setMaxIterations(Parameters::get<TypeTag, Parameters::LinearSolverMaxIterations>());
bicgstabSolver->setMaxIterations(Parameters::Get<Parameters::LinearSolverMaxIterations>());
bicgstabSolver->setLinearOperator(&parOperator);
bicgstabSolver->setRhs(this->overlappingb_);
@ -284,7 +276,7 @@ protected:
int verbosity = 0;
if (this->simulator_.vanguard().gridView().comm().rank() == 0)
verbosity = Parameters::get<TypeTag, Parameters::LinearSolverVerbosity>();
verbosity = Parameters::Get<Parameters::LinearSolverVerbosity>();
using SmootherArgs = typename Dune::Amg::SmootherTraits<ParallelSmoother>::Arguments;
@ -299,7 +291,7 @@ protected:
// Dune::Amg::FirstDiagonal>>
using CoarsenCriterion = Dune::Amg::
CoarsenCriterion<Dune::Amg::SymmetricCriterion<IstlMatrix, Dune::Amg::FrobeniusNorm> >;
int coarsenTarget = Parameters::get<TypeTag, Parameters::AmgCoarsenTarget>();
int coarsenTarget = Parameters::Get<Parameters::AmgCoarsenTarget>();
CoarsenCriterion coarsenCriterion(/*maxLevel=*/15, coarsenTarget);
coarsenCriterion.setDefaultValuesAnisotropic(GridView::dimension,
/*aggregateSizePerDim=*/3);

44
opm/simulators/linalg/parallelbasebackend.hh
View File

@ -152,15 +152,15 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::LinearSolverTolerance>
Parameters::Register<Parameters::LinearSolverTolerance<Scalar>>
("The maximum allowed error between of the linear solver");
Parameters::registerParam<TypeTag, Parameters::LinearSolverAbsTolerance>
Parameters::Register<Parameters::LinearSolverAbsTolerance<Scalar>>
("The maximum accepted error of the norm of the residual");
Parameters::registerParam<TypeTag, Parameters::LinearSolverOverlapSize>
Parameters::Register<Parameters::LinearSolverOverlapSize>
("The size of the algebraic overlap for the linear solver");
Parameters::registerParam<TypeTag, Parameters::LinearSolverMaxIterations>
Parameters::Register<Parameters::LinearSolverMaxIterations>
("The maximum number of iterations of the linear solver");
Parameters::registerParam<TypeTag, Parameters::LinearSolverVerbosity>
Parameters::Register<Parameters::LinearSolverVerbosity>
("The verbosity level of the linear solver");
PreconditionerWrapper::registerParameters();
@ -195,7 +195,7 @@ public:
simulator_.model().dofMapper());
// create the overlapping Jacobian matrix
unsigned overlapSize = Parameters::get<TypeTag, Parameters::LinearSolverOverlapSize>();
unsigned overlapSize = Parameters::Get<Parameters::LinearSolverOverlapSize>();
overlappingMatrix_ = new OverlappingMatrix(M.istlMatrix(),
borderListCreator.borderList(),
borderListCreator.blackList(),
@ -444,36 +444,4 @@ struct PreconditionerWrapper<TypeTag, TTag::ParallelBaseLinearSolver>
} // namespace Opm::Properties
namespace Opm::Parameters {
//! set the default number of maximum iterations for the linear solver
template<class TypeTag>
struct LinearSolverMaxIterations<TypeTag, Properties::TTag::ParallelBaseLinearSolver>
{ static constexpr int value = 1000; };
//! set the default overlap size to 2
template<class TypeTag>
struct LinearSolverOverlapSize<TypeTag, Properties::TTag::ParallelBaseLinearSolver>
{ static constexpr unsigned value = 2; };
//! make the linear solver shut up by default
template<class TypeTag>
struct LinearSolverVerbosity<TypeTag, Properties::TTag::ParallelBaseLinearSolver>
{ static constexpr int value = 0; };
//! set the preconditioner order to 0 by default
template<class TypeTag>
struct PreconditionerOrder<TypeTag, Properties::TTag::ParallelBaseLinearSolver>
{ static constexpr int value = 0; };
//! set the preconditioner relaxation parameter to 1.0 by default
template<class TypeTag>
struct PreconditionerRelaxation<TypeTag, Properties::TTag::ParallelBaseLinearSolver>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1.0;
};
} // namespace Opm::Parameters
#endif

23
opm/simulators/linalg/parallelbicgstabbackend.hh
View File

@ -59,17 +59,6 @@ struct LinearSolverBackend<TypeTag, TTag::ParallelBiCGStabLinearSolver>
} // namespace Opm::Properties
namespace Opm::Parameters {
template<class TypeTag>
struct LinearSolverMaxError<TypeTag, Properties::TTag::ParallelBiCGStabLinearSolver>
{
using type = GetPropType<TypeTag, Properties::Scalar>;
static constexpr type value = 1e7;
};
}
namespace Opm::Linear {
/*!
@ -131,7 +120,7 @@ public:
{
ParentType::registerParameters();
Parameters::registerParam<TypeTag, Parameters::LinearSolverMaxError>
Parameters::Register<Parameters::LinearSolverMaxError<Scalar>>
("The maximum residual error which the linear solver tolerates"
" without giving up");
}
@ -146,24 +135,24 @@ protected:
const auto& gridView = this->simulator_.gridView();
using CCC = CombinedCriterion<OverlappingVector, decltype(gridView.comm())>;
Scalar linearSolverTolerance = Parameters::get<TypeTag, Parameters::LinearSolverTolerance>();
Scalar linearSolverAbsTolerance = Parameters::get<TypeTag, Parameters::LinearSolverAbsTolerance>();
Scalar linearSolverTolerance = Parameters::Get<Parameters::LinearSolverTolerance<Scalar>>();
Scalar linearSolverAbsTolerance = Parameters::Get<Parameters::LinearSolverAbsTolerance<Scalar>>();
if(linearSolverAbsTolerance < 0.0)
linearSolverAbsTolerance = this->simulator_.model().newtonMethod().tolerance() / 100.0;
convCrit_.reset(new CCC(gridView.comm(),
/*residualReductionTolerance=*/linearSolverTolerance,
/*absoluteResidualTolerance=*/linearSolverAbsTolerance,
Parameters::get<TypeTag, Parameters::LinearSolverMaxError>()));
Parameters::Get<Parameters::LinearSolverMaxError<Scalar>>()));
auto bicgstabSolver =
std::make_shared<RawLinearSolver>(parPreCond, *convCrit_, parScalarProduct);
int verbosity = 0;
if (parOperator.overlap().myRank() == 0)
verbosity = Parameters::get<TypeTag, Parameters::LinearSolverVerbosity>();
verbosity = Parameters::Get<Parameters::LinearSolverVerbosity>();
bicgstabSolver->setVerbosity(verbosity);
bicgstabSolver->setMaxIterations(Parameters::get<TypeTag, Parameters::LinearSolverMaxIterations>());
bicgstabSolver->setMaxIterations(Parameters::Get<Parameters::LinearSolverMaxIterations>());
bicgstabSolver->setLinearOperator(&parOperator);
bicgstabSolver->setRhs(this->overlappingb_);

9
opm/simulators/linalg/parallelistlbackend.hh
View File

@ -158,13 +158,4 @@ struct PreconditionerWrapper<TypeTag, TTag::ParallelIstlLinearSolver>
} // namespace Opm::Properties
namespace Opm::Parameters {
//! set the GMRes restart parameter to 10 by default
template<class TypeTag>
struct GMResRestart<TypeTag, Properties::TTag::ParallelIstlLinearSolver>
{ static constexpr int value = 10; };
}
#endif

4
opm/simulators/linalg/superlubackend.hh
View File

@ -73,7 +73,7 @@ public:
static void registerParameters()
{
Parameters::registerParam<TypeTag, Parameters::LinearSolverVerbosity>
Parameters::Register<Parameters::LinearSolverVerbosity>
("The verbosity level of the linear solver");
}
@ -114,7 +114,7 @@ public:
{
Vector bTmp(b);
int verbosity = Parameters::get<TypeTag, Parameters::LinearSolverVerbosity>();
int verbosity = Parameters::Get<Parameters::LinearSolverVerbosity>();
Dune::InverseOperatorResult result;
Dune::SuperLU<Matrix> solver(A, verbosity > 0);
solver.apply(x, bTmp, result);