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 #911 from akva2/move_vtk_params_to_params

Browse Source 
Move vtk parameters to Opm::Parameters namespace
This commit is contained in:
Atgeirr Flø Rasmussen 2024-08-01 13:01:57 +02:00 committed by GitHub
commit ff07e7f04c
20 changed files with 682 additions and 485 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
examples/problems/co2ptflashproblem.hh
View File

@ -174,42 +174,6 @@ struct LinearSolverAbsTolerance<TypeTag, TTag::CO2PTBaseProblem> {
static constexpr type value = 0.;
};
// output
template <class TypeTag>
struct VtkWriteFilterVelocities<TypeTag, TTag::CO2PTBaseProblem> {
static constexpr bool value = true;
};
template <class TypeTag>
struct VtkWritePotentialGradients<TypeTag, TTag::CO2PTBaseProblem> {
static constexpr bool value = true;
};
template <class TypeTag>
struct VtkWriteTotalMassFractions<TypeTag, TTag::CO2PTBaseProblem> {
static constexpr bool value = true;
};
template <class TypeTag>
struct VtkWriteTotalMoleFractions<TypeTag, TTag::CO2PTBaseProblem> {
static constexpr bool value = true;
};
template <class TypeTag>
struct VtkWriteFugacityCoeffs<TypeTag, TTag::CO2PTBaseProblem> {
static constexpr bool value = true;
};
template <class TypeTag>
struct VtkWriteLiquidMoleFractions<TypeTag, TTag::CO2PTBaseProblem> {
static constexpr bool value = true;
};
template <class TypeTag>
struct VtkWriteEquilibriumConstants<TypeTag, TTag::CO2PTBaseProblem> {
static constexpr bool value = true;
};
// this is kinds of telling the report step length
template <class TypeTag>
struct EpisodeLength<TypeTag, TTag::CO2PTBaseProblem> {
@ -309,6 +273,34 @@ template <class TypeTag>
struct NewtonMaxIterations<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr int value = 30; };
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; };
} // namespace Opm::Parameters
namespace Opm {

9
examples/problems/lensproblem.hh
View File

@ -175,10 +175,6 @@ struct LensUpperRightZ<TypeTag, TTag::LensBaseProblem>
static constexpr type value = 1.0;
};
// By default, include the intrinsic permeability tensor to the VTK output files
template<class TypeTag>
struct VtkWriteIntrinsicPermeabilities<TypeTag, TTag::LensBaseProblem> { static constexpr bool value = true; };
} // namespace Opm::Properties
namespace Opm::Parameters {
@ -247,6 +243,11 @@ template<class TypeTag>
struct NewtonWriteConvergence<TypeTag, Properties::TTag::LensBaseProblem>
{ static constexpr bool value = false; };
// By default, include the intrinsic permeability tensor to the VTK output files
template<class TypeTag>
struct VtkWriteIntrinsicPermeabilities<TypeTag, Properties::TTag::LensBaseProblem>
{ static constexpr bool value = true; };
} // namespace Opm::Parameters
namespace Opm {

9
examples/problems/outflowproblem.hh
View File

@ -76,10 +76,6 @@ public:
template<class TypeTag>
struct EnableGravity<TypeTag, TTag::OutflowBaseProblem> { static constexpr bool value = false; };
// Also write mass fractions to the output
template<class TypeTag>
struct VtkWriteMassFractions<TypeTag, TTag::OutflowBaseProblem> { static constexpr bool value = true; };
} // namespace Opm::Properties
namespace Opm::Parameters {
@ -105,6 +101,11 @@ struct InitialTimeStepSize<TypeTag, Properties::TTag::OutflowBaseProblem>
static constexpr type value = 1;
};
// 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 {

9
examples/problems/powerinjectionproblem.hh
View File

@ -119,10 +119,6 @@ public:
using type = Opm::EffToAbsLaw<EffectiveLaw>;
};
// Write out the filter velocities for this problem
template<class TypeTag>
struct VtkWriteFilterVelocities<TypeTag, TTag::PowerInjectionBaseProblem> { static constexpr bool value = true; };
// Disable gravity
template<class TypeTag>
struct EnableGravity<TypeTag, TTag::PowerInjectionBaseProblem> { static constexpr bool value = false; };
@ -181,6 +177,11 @@ struct InitialTimeStepSize<TypeTag, Properties::TTag::PowerInjectionBaseProblem>
static constexpr type value = 1e-3;
};
// 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 {

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

@ -129,15 +129,6 @@ public:
using type = Opm::LiquidPhase<Scalar, Opm::NullComponent<Scalar> >;
};
// 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, TTag::ImmiscibleSinglePhaseModel> { static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteMobilities<TypeTag, TTag::ImmiscibleSinglePhaseModel> { static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteRelativePermeabilities<TypeTag, TTag::ImmiscibleSinglePhaseModel> { static constexpr bool value = false; };
/////////////////////
// set slightly different properties for the two-phase case
/////////////////////
@ -173,9 +164,26 @@ public:
using type = Opm::TwoPhaseImmiscibleFluidSystem<Scalar, WettingPhase, NonwettingPhase>;
};
} // 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 {
/*!

26
opm/models/io/baseoutputmodule.hh
View File

@ -27,24 +27,24 @@
#ifndef EWOMS_BASE_OUTPUT_MODULE_HH
#define EWOMS_BASE_OUTPUT_MODULE_HH
#include "baseoutputwriter.hh"
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
#include <opm/models/utils/basicproperties.hh>
#include <opm/models/common/multiphasebaseproperties.hh>
#include <opm/models/discretization/common/fvbaseproperties.hh>
#include <dune/istl/bvector.hh>
#include <dune/common/fvector.hh>
#include <dune/istl/bvector.hh>
#include <opm/models/common/multiphasebaseproperties.hh>
#include <opm/models/discretization/common/fvbaseproperties.hh>
#include <opm/models/io/baseoutputwriter.hh>
#include <opm/models/utils/basicproperties.hh>
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
#include <array>
#include <cstdio>
#include <sstream>
#include <string>
#include <string_view>
#include <vector>
#include <cstdio>
namespace Opm::Properties {

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

@ -27,49 +27,60 @@
#ifndef EWOMS_VTK_BLACK_OIL_ENERGY_MODULE_HH
#define EWOMS_VTK_BLACK_OIL_ENERGY_MODULE_HH
#include "vtkmultiwriter.hh"
#include "baseoutputmodule.hh"
#include <dune/common/fvector.hh>
#include <opm/material/densead/Math.hpp>
#include <opm/models/discretization/common/fvbaseparameters.hh>
#include <opm/models/utils/propertysystem.hh>
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/blackoil/blackoilproperties.hh>
namespace Opm::Properties {
#include <opm/models/discretization/common/fvbaseparameters.hh>
namespace TTag {
#include <opm/models/io/baseoutputmodule.hh>
#include <opm/models/io/vtkmultiwriter.hh>
#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 TTag
} // 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 = UndefinedProperty; };
struct VtkWriteRockInternalEnergy { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteTotalThermalConductivity { using type = UndefinedProperty; };
struct VtkWriteTotalThermalConductivity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFluidInternalEnergies { using type = UndefinedProperty; };
struct VtkWriteFluidInternalEnergies { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFluidEnthalpies { using type = UndefinedProperty; };
struct VtkWriteFluidEnthalpies { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteRockInternalEnergy<TypeTag, TTag::VtkBlackOilEnergy> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteTotalThermalConductivity<TypeTag, TTag::VtkBlackOilEnergy> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteFluidInternalEnergies<TypeTag, TTag::VtkBlackOilEnergy> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteFluidEnthalpies<TypeTag, TTag::VtkBlackOilEnergy> { static constexpr bool value = true; };
struct VtkWriteRockInternalEnergy<TypeTag, Properties::TTag::VtkBlackOilEnergy>
{ static constexpr bool value = true; };
} // namespace Opm::Properties
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; };
} // namespace Opm::Parameters
namespace Opm {
/*!
@ -112,15 +123,15 @@ public:
if (!enableEnergy)
return;
Parameters::registerParam<TypeTag, Properties::VtkWriteRockInternalEnergy>
Parameters::registerParam<TypeTag, Parameters::VtkWriteRockInternalEnergy>
("Include the volumetric internal energy of rock "
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteTotalThermalConductivity>
Parameters::registerParam<TypeTag, Parameters::VtkWriteTotalThermalConductivity>
("Include the total thermal conductivity of the medium and the fluids "
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteFluidInternalEnergies>
Parameters::registerParam<TypeTag, Parameters::VtkWriteFluidInternalEnergies>
("Include the internal energies of the fluids in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteFluidEnthalpies>
Parameters::registerParam<TypeTag, Parameters::VtkWriteFluidEnthalpies>
("Include the enthalpies of the fluids in the VTK output files");
}
@ -212,25 +223,25 @@ public:
private:
static bool rockInternalEnergyOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteRockInternalEnergy>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteRockInternalEnergy>();
return val;
}
static bool totalThermalConductivityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteTotalThermalConductivity>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTotalThermalConductivity>();
return val;
}
static bool fluidInternalEnergiesOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFluidInternalEnergies>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFluidInternalEnergies>();
return val;
}
static bool fluidEnthalpiesOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFluidEnthalpies>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFluidEnthalpies>();
return val;
}

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

@ -27,53 +27,67 @@
#ifndef EWOMS_VTK_BLACK_OIL_MICP_MODULE_HH
#define EWOMS_VTK_BLACK_OIL_MICP_MODULE_HH
#include "vtkmultiwriter.hh"
#include "baseoutputmodule.hh"
#include <dune/common/fvector.hh>
#include <opm/material/densead/Math.hpp>
#include <opm/models/discretization/common/fvbaseparameters.hh>
#include <opm/models/utils/propertysystem.hh>
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/blackoil/blackoilproperties.hh>
namespace Opm::Properties {
#include <opm/models/discretization/common/fvbaseparameters.hh>
namespace TTag {
#include <opm/models/io/baseoutputmodule.hh>
#include <opm/models/io/vtkmultiwriter.hh>
#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 TTag
} // 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 = UndefinedProperty; };
struct VtkWriteMicrobialConcentration { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteOxygenConcentration { using type = UndefinedProperty; };
struct VtkWriteOxygenConcentration { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteUreaConcentration { using type = UndefinedProperty; };
struct VtkWriteUreaConcentration { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteBiofilmConcentration { using type = UndefinedProperty; };
struct VtkWriteBiofilmConcentration { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteCalciteConcentration { using type = UndefinedProperty; };
struct VtkWriteCalciteConcentration { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteMicrobialConcentration<TypeTag, TTag::VtkBlackOilMICP> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteOxygenConcentration<TypeTag, TTag::VtkBlackOilMICP> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteUreaConcentration<TypeTag, TTag::VtkBlackOilMICP> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteBiofilmConcentration<TypeTag, TTag::VtkBlackOilMICP> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteCalciteConcentration<TypeTag, TTag::VtkBlackOilMICP> { static constexpr bool value = true; };
struct VtkWriteMicrobialConcentration<TypeTag, Properties::TTag::VtkBlackOilMICP>
{ static constexpr bool value = true; };
} // namespace Opm::Properties
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; };
} // namespace Opm::Parameters
namespace Opm {
/*!
@ -113,18 +127,18 @@ public:
if (!enableMICP)
return;
Parameters::registerParam<TypeTag, Properties::VtkWriteMicrobialConcentration>
Parameters::registerParam<TypeTag, Parameters::VtkWriteMicrobialConcentration>
("Include the concentration of the microbial component in the water phase "
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteOxygenConcentration>
Parameters::registerParam<TypeTag, Parameters::VtkWriteOxygenConcentration>
("Include the concentration of the oxygen component in the water phase "
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteUreaConcentration>
Parameters::registerParam<TypeTag, Parameters::VtkWriteUreaConcentration>
("Include the concentration of the urea component in the water phase "
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteBiofilmConcentration>
Parameters::registerParam<TypeTag, Parameters::VtkWriteBiofilmConcentration>
("Include the biofilm volume fraction in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteCalciteConcentration>
Parameters::registerParam<TypeTag, Parameters::VtkWriteCalciteConcentration>
("Include the calcite volume fraction in the VTK output files");
}
@ -223,31 +237,31 @@ public:
private:
static bool microbialConcentrationOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteMicrobialConcentration>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMicrobialConcentration>();
return val;
}
static bool oxygenConcentrationOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteOxygenConcentration>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteOxygenConcentration>();
return val;
}
static bool ureaConcentrationOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteUreaConcentration>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteUreaConcentration>();
return val;
}
static bool biofilmConcentrationOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteBiofilmConcentration>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteBiofilmConcentration>();
return val;
}
static bool calciteConcentrationOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteCalciteConcentration>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteCalciteConcentration>();
return val;
}
@ -257,6 +271,7 @@ private:
ScalarBuffer biofilmConcentration_;
ScalarBuffer calciteConcentration_;
};
} // namespace Opm
#endif

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

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

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

@ -27,57 +27,74 @@
#ifndef EWOMS_VTK_BLACK_OIL_POLYMER_MODULE_HH
#define EWOMS_VTK_BLACK_OIL_POLYMER_MODULE_HH
#include "vtkmultiwriter.hh"
#include "baseoutputmodule.hh"
#include <dune/common/fvector.hh>
#include <opm/material/densead/Math.hpp>
#include <opm/models/discretization/common/fvbaseparameters.hh>
#include <opm/models/utils/propertysystem.hh>
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/blackoil/blackoilproperties.hh>
namespace Opm::Properties {
#include <opm/models/discretization/common/fvbaseparameters.hh>
namespace TTag {
#include <opm/models/io/baseoutputmodule.hh>
#include <opm/models/io/vtkmultiwriter.hh>
#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 VtkBlackOilPolymer {};
} // namespace TTag
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the polymer output module
template<class TypeTag, class MyTypeTag>
struct VtkWritePolymerConcentration { using type = UndefinedProperty; };
struct VtkWritePolymerConcentration { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePolymerDeadPoreVolume { using type = UndefinedProperty; };
struct VtkWritePolymerDeadPoreVolume { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePolymerAdsorption { using type = UndefinedProperty; };
struct VtkWritePolymerAdsorption { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePolymerRockDensity { using type = UndefinedProperty; };
struct VtkWritePolymerRockDensity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePolymerViscosityCorrection { using type = UndefinedProperty; };
struct VtkWritePolymerViscosityCorrection { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteWaterViscosityCorrection { using type = UndefinedProperty; };
struct VtkWriteWaterViscosityCorrection { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWritePolymerConcentration<TypeTag, TTag::VtkBlackOilPolymer> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWritePolymerDeadPoreVolume<TypeTag, TTag::VtkBlackOilPolymer> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWritePolymerViscosityCorrection<TypeTag, TTag::VtkBlackOilPolymer> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteWaterViscosityCorrection<TypeTag, TTag::VtkBlackOilPolymer> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWritePolymerRockDensity<TypeTag, TTag::VtkBlackOilPolymer> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWritePolymerAdsorption<TypeTag, TTag::VtkBlackOilPolymer> { static constexpr bool value = true; };
struct VtkWritePolymerConcentration<TypeTag, Properties::TTag::VtkBlackOilPolymer>
{ static constexpr bool value = true; };
} // namespace Opm::Properties
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; };
} // namespace Opm::Parameters
namespace Opm {
/*!
@ -117,22 +134,22 @@ public:
if (!enablePolymer)
return;
Parameters::registerParam<TypeTag, Properties::VtkWritePolymerConcentration>
Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerConcentration>
("Include the concentration of the polymer component in the water phase "
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWritePolymerDeadPoreVolume>
Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerDeadPoreVolume>
("Include the fraction of the \"dead\" pore volume "
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWritePolymerRockDensity>
Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerRockDensity>
("Include the amount of already adsorbed polymer component"
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWritePolymerAdsorption>
Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerAdsorption>
("Include the adsorption rate of the polymer component"
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWritePolymerViscosityCorrection>
Parameters::registerParam<TypeTag, Parameters::VtkWritePolymerViscosityCorrection>
("Include the viscosity correction of the polymer component "
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteWaterViscosityCorrection>
Parameters::registerParam<TypeTag, Parameters::VtkWriteWaterViscosityCorrection>
("Include the viscosity correction of the water component "
"due to polymers in the VTK output files");
}
@ -239,37 +256,37 @@ public:
private:
static bool polymerConcentrationOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWritePolymerConcentration>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerConcentration>();
return val;
}
static bool polymerDeadPoreVolumeOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWritePolymerDeadPoreVolume>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerDeadPoreVolume>();
return val;
}
static bool polymerRockDensityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWritePolymerRockDensity>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerRockDensity>();
return val;
}
static bool polymerAdsorptionOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWritePolymerAdsorption>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerAdsorption>();
return val;
}
static bool polymerViscosityCorrectionOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWritePolymerViscosityCorrection>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerViscosityCorrection>();
return val;
}
static bool waterViscosityCorrectionOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWritePolymerViscosityCorrection>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePolymerViscosityCorrection>();
return val;
}

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

@ -27,51 +27,65 @@
#ifndef EWOMS_VTK_BLACK_OIL_SOLVENT_MODULE_HH
#define EWOMS_VTK_BLACK_OIL_SOLVENT_MODULE_HH
#include "vtkmultiwriter.hh"
#include "baseoutputmodule.hh"
#include <dune/common/fvector.hh>
#include <opm/material/densead/Math.hpp>
#include <opm/models/discretization/common/fvbaseparameters.hh>
#include <opm/models/utils/propertysystem.hh>
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/blackoil/blackoilproperties.hh>
namespace Opm::Properties {
#include <opm/models/discretization/common/fvbaseparameters.hh>
namespace TTag {
#include <opm/models/io/baseoutputmodule.hh>
#include <opm/models/io/vtkmultiwriter.hh>
#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 TTag
} // 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 = UndefinedProperty; };
struct VtkWriteSolventSaturation { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSolventRsw { using type = UndefinedProperty; };
struct VtkWriteSolventRsw { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSolventDensity { using type = UndefinedProperty; };
struct VtkWriteSolventDensity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSolventViscosity { using type = UndefinedProperty; };
struct VtkWriteSolventViscosity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSolventMobility { using type = UndefinedProperty; };
struct VtkWriteSolventMobility { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteSolventSaturation<TypeTag, TTag::VtkBlackOilSolvent> { static constexpr bool value = true; };
struct VtkWriteSolventSaturation<TypeTag, Properties::TTag::VtkBlackOilSolvent>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteSolventRsw<TypeTag, TTag::VtkBlackOilSolvent> { static constexpr bool value = true; };
struct VtkWriteSolventRsw<TypeTag, Properties::TTag::VtkBlackOilSolvent>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteSolventDensity<TypeTag, TTag::VtkBlackOilSolvent> { static constexpr bool value = true; };
struct VtkWriteSolventDensity<TypeTag, Properties::TTag::VtkBlackOilSolvent>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteSolventViscosity<TypeTag, TTag::VtkBlackOilSolvent> { static constexpr bool value = true; };
struct VtkWriteSolventViscosity<TypeTag, Properties::TTag::VtkBlackOilSolvent>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteSolventMobility<TypeTag, TTag::VtkBlackOilSolvent> { static constexpr bool value = true; };
struct VtkWriteSolventMobility<TypeTag, Properties::TTag::VtkBlackOilSolvent>
{ static constexpr bool value = true; };
} // namespace Opm::Properties
@ -113,19 +127,19 @@ public:
if (!enableSolvent)
return;
Parameters::registerParam<TypeTag, Properties::VtkWriteSolventSaturation>
Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventSaturation>
("Include the \"saturation\" of the solvent component "
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteSolventRsw>
Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventRsw>
("Include the \"dissolved volume in water\" of the solvent component "
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteSolventDensity>
Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventDensity>
("Include the \"density\" of the solvent component "
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteSolventViscosity>
Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventViscosity>
("Include the \"viscosity\" of the solvent component "
"in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteSolventMobility>
Parameters::registerParam<TypeTag, Parameters::VtkWriteSolventMobility>
("Include the \"mobility\" of the solvent component "
"in the VTK output files");
}
@ -224,31 +238,31 @@ public:
private:
static bool solventSaturationOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteSolventSaturation>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventSaturation>();
return val;
}
static bool solventRswOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteSolventRsw>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventRsw>();
return val;
}
static bool solventDensityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteSolventDensity>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventDensity>();
return val;
}
static bool solventViscosityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteSolventViscosity>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventViscosity>();
return val;
}
static bool solventMobilityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteSolventMobility>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSolventMobility>();
return val;
}
@ -258,6 +272,7 @@ private:
ScalarBuffer solventViscosity_;
ScalarBuffer solventMobility_;
};
} // namespace Opm
#endif

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

@ -27,56 +27,75 @@
#ifndef EWOMS_VTK_COMPOSITION_MODULE_HH
#define EWOMS_VTK_COMPOSITION_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>
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Properties {
namespace TTag {
namespace Opm::Properties::TTag {
// create new type tag for the VTK composition output
struct VtkComposition {};
} // namespace TTag
} // 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 = UndefinedProperty; };
struct VtkWriteMassFractions { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteMoleFractions { using type = UndefinedProperty; };
struct VtkWriteMoleFractions { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteTotalMassFractions { using type = UndefinedProperty; };
struct VtkWriteTotalMassFractions { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteTotalMoleFractions { using type = UndefinedProperty; };
struct VtkWriteTotalMoleFractions { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteMolarities { using type = UndefinedProperty; };
struct VtkWriteMolarities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFugacities { using type = UndefinedProperty; };
struct VtkWriteFugacities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFugacityCoeffs { using type = UndefinedProperty; };
struct VtkWriteFugacityCoeffs { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteMassFractions<TypeTag, TTag::VtkComposition> { static constexpr bool value = false; };
struct VtkWriteMassFractions<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteMoleFractions<TypeTag, TTag::VtkComposition> { static constexpr bool value = true; };
struct VtkWriteMoleFractions<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteTotalMassFractions<TypeTag, TTag::VtkComposition> { static constexpr bool value = false; };
struct VtkWriteTotalMassFractions<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteTotalMoleFractions<TypeTag, TTag::VtkComposition> { static constexpr bool value = false; };
struct VtkWriteTotalMoleFractions<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteMolarities<TypeTag, TTag::VtkComposition> { static constexpr bool value = false; };
struct VtkWriteMolarities<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteFugacities<TypeTag, TTag::VtkComposition> { static constexpr bool value = false; };
struct VtkWriteFugacities<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteFugacityCoeffs<TypeTag, TTag::VtkComposition> { static constexpr bool value = false; };
struct VtkWriteFugacityCoeffs<TypeTag, Properties::TTag::VtkComposition>
{ static constexpr bool value = false; };
} // namespace Opm::Properties
@ -125,19 +144,19 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Properties::VtkWriteMassFractions>
Parameters::registerParam<TypeTag, Parameters::VtkWriteMassFractions>
("Include mass fractions in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteMoleFractions>
Parameters::registerParam<TypeTag, Parameters::VtkWriteMoleFractions>
("Include mole fractions in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteTotalMassFractions>
Parameters::registerParam<TypeTag, Parameters::VtkWriteTotalMassFractions>
("Include total mass fractions in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteTotalMoleFractions>
Parameters::registerParam<TypeTag, Parameters::VtkWriteTotalMoleFractions>
("Include total mole fractions in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteMolarities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteMolarities>
("Include component molarities in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteFugacities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteFugacities>
("Include component fugacities in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteFugacityCoeffs>
Parameters::registerParam<TypeTag, Parameters::VtkWriteFugacityCoeffs>
("Include component fugacity coefficients in the VTK output files");
}
@ -258,43 +277,43 @@ public:
private:
static bool massFracOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteMassFractions>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMassFractions>();
return val;
}
static bool moleFracOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteMoleFractions>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMoleFractions>();
return val;
}
static bool totalMassFracOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteTotalMassFractions>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTotalMassFractions>();
return val;
}
static bool totalMoleFracOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteTotalMoleFractions>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTotalMoleFractions>();
return val;
}
static bool molarityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteMolarities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMolarities>();
return val;
}
static bool fugacityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFugacities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFugacities>();
return val;
}
static bool fugacityCoeffOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFugacityCoeffs>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFugacityCoeffs>();
return val;
}

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

@ -39,33 +39,40 @@
#include <opm/models/utils/propertysystem.hh>
#include <opm/models/utils/parametersystem.hh>
namespace Opm::Properties {
namespace TTag {
namespace Opm::Properties::TTag {
// create new type tag for the VTK output of the quantities for molecular
// diffusion
struct VtkDiffusion {};
} // namespace TTag
} // 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 = UndefinedProperty; };
struct VtkWriteTortuosities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteDiffusionCoefficients { using type = UndefinedProperty; };
struct VtkWriteDiffusionCoefficients { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteEffectiveDiffusionCoefficients { using type = UndefinedProperty; };
struct VtkWriteEffectiveDiffusionCoefficients { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteTortuosities<TypeTag, TTag::VtkDiffusion> { static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteDiffusionCoefficients<TypeTag, TTag::VtkDiffusion> { static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteEffectiveDiffusionCoefficients<TypeTag, TTag::VtkDiffusion> { static constexpr bool value = false; };
struct VtkWriteTortuosities<TypeTag, Properties::TTag::VtkDiffusion>
{ static constexpr bool value = false; };
} // namespace Opm::Properties
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; };
} // namespace Opm::Parameters
namespace Opm {
/*!
@ -110,12 +117,12 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Properties::VtkWriteTortuosities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteTortuosities>
("Include the tortuosity for each phase in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteDiffusionCoefficients>
Parameters::registerParam<TypeTag, Parameters::VtkWriteDiffusionCoefficients>
("Include the molecular diffusion coefficients in "
"the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteEffectiveDiffusionCoefficients>
Parameters::registerParam<TypeTag, Parameters::VtkWriteEffectiveDiffusionCoefficients>
("Include the effective molecular diffusion "
"coefficients the medium in the VTK output files");
}
@ -186,19 +193,19 @@ public:
private:
static bool tortuosityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteTortuosities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTortuosities>();
return val;
}
static bool diffusionCoefficientOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteDiffusionCoefficients>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteDiffusionCoefficients>();
return val;
}
static bool effectiveDiffusionCoefficientOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteEffectiveDiffusionCoefficients>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteEffectiveDiffusionCoefficients>();
return val;
}

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

@ -27,62 +27,81 @@
#ifndef EWOMS_VTK_DISCRETE_FRACTURE_MODULE_HH
#define EWOMS_VTK_DISCRETE_FRACTURE_MODULE_HH
#include "vtkmultiwriter.hh"
#include "baseoutputmodule.hh"
#include <dune/common/fvector.hh>
#include <opm/material/common/Valgrind.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>
#include <opm/material/common/Valgrind.hpp>
#include <cstdio>
namespace Opm::Properties {
namespace TTag {
namespace Opm::Properties::TTag {
// create new type tag for the VTK multi-phase output
struct VtkDiscreteFracture {};
} // namespace TTag
} // 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 = UndefinedProperty; };
struct VtkWriteFractureSaturations { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFractureMobilities { using type = UndefinedProperty; };
struct VtkWriteFractureMobilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFractureRelativePermeabilities { using type = UndefinedProperty; };
struct VtkWriteFractureRelativePermeabilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFracturePorosity { using type = UndefinedProperty; };
struct VtkWriteFracturePorosity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFractureIntrinsicPermeabilities { using type = UndefinedProperty; };
struct VtkWriteFractureIntrinsicPermeabilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFractureFilterVelocities { using type = UndefinedProperty; };
struct VtkWriteFractureFilterVelocities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFractureVolumeFraction { using type = UndefinedProperty; };
struct VtkWriteFractureVolumeFraction { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteFractureSaturations<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteFractureMobilities<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteFractureRelativePermeabilities<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteFracturePorosity<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteFractureIntrinsicPermeabilities<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteFractureFilterVelocities<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteFractureVolumeFraction<TypeTag, TTag::VtkDiscreteFracture> { static constexpr bool value = true; };
struct VtkWriteFractureSaturations<TypeTag, Properties::TTag::VtkDiscreteFracture>
{ static constexpr bool value = true; };
} // namespace Opm::Properties
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; };
} // namespace Opm::Parameters
namespace Opm {
/*!
@ -134,20 +153,20 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Properties::VtkWriteFractureSaturations>
Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureSaturations>
("Include the phase saturations in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteFractureMobilities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureMobilities>
("Include the phase mobilities in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteFractureRelativePermeabilities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureRelativePermeabilities>
("Include the phase relative permeabilities in the "
"VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteFracturePorosity>
Parameters::registerParam<TypeTag, Parameters::VtkWriteFracturePorosity>
("Include the porosity in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteFractureIntrinsicPermeabilities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureIntrinsicPermeabilities>
("Include the intrinsic permeability in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteFractureFilterVelocities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureFilterVelocities>
("Include in the filter velocities of the phases in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteFractureVolumeFraction>
Parameters::registerParam<TypeTag, Parameters::VtkWriteFractureVolumeFraction>
("Add the fraction of the total volume which is "
"occupied by fractures in the VTK output");
}
@ -319,43 +338,43 @@ public:
private:
static bool saturationOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFractureSaturations>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureSaturations>();
return val;
}
static bool mobilityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFractureMobilities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureMobilities>();
return val;
}
static bool relativePermeabilityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFractureRelativePermeabilities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureRelativePermeabilities>();
return val;
}
static bool porosityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFracturePorosity>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFracturePorosity>();
return val;
}
static bool intrinsicPermeabilityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFractureIntrinsicPermeabilities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureIntrinsicPermeabilities>();
return val;
}
static bool volumeFractionOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFractureVolumeFraction>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureVolumeFraction>();
return val;
}
static bool velocityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFractureFilterVelocities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFractureFilterVelocities>();
return val;
}

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

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

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

@ -42,66 +42,100 @@
#include <cstdio>
namespace Opm::Properties {
namespace TTag {
namespace Opm::Properties::TTag {
// create new type tag for the VTK multi-phase output
struct VtkMultiPhase {};
} // namespace TTag
} // 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 = UndefinedProperty; };
struct VtkWriteExtrusionFactor { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePressures { using type = UndefinedProperty; };
struct VtkWritePressures { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteDensities { using type = UndefinedProperty; };
struct VtkWriteDensities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteSaturations { using type = UndefinedProperty; };
struct VtkWriteSaturations { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteMobilities { using type = UndefinedProperty; };
struct VtkWriteMobilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteRelativePermeabilities { using type = UndefinedProperty; };
struct VtkWriteRelativePermeabilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteViscosities { using type = UndefinedProperty; };
struct VtkWriteViscosities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteAverageMolarMasses { using type = UndefinedProperty; };
struct VtkWriteAverageMolarMasses { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePorosity { using type = UndefinedProperty; };
struct VtkWritePorosity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteIntrinsicPermeabilities { using type = UndefinedProperty; };
struct VtkWriteIntrinsicPermeabilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWritePotentialGradients { using type = UndefinedProperty; };
struct VtkWritePotentialGradients { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteFilterVelocities { using type = UndefinedProperty; };
struct VtkWriteFilterVelocities { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteExtrusionFactor<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
struct VtkWriteExtrusionFactor<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWritePressures<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = true; };
struct VtkWritePressures<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteDensities<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = true; };
struct VtkWriteDensities<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteSaturations<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = true; };
struct VtkWriteSaturations<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteMobilities<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
struct VtkWriteMobilities<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteRelativePermeabilities<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = true; };
struct VtkWriteRelativePermeabilities<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteViscosities<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
struct VtkWriteViscosities<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteAverageMolarMasses<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
struct VtkWriteAverageMolarMasses<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWritePorosity<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = true; };
struct VtkWritePorosity<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = true; };
template<class TypeTag>
struct VtkWriteIntrinsicPermeabilities<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
struct VtkWriteIntrinsicPermeabilities<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWritePotentialGradients<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
struct VtkWritePotentialGradients<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteFilterVelocities<TypeTag, TTag::VtkMultiPhase> { static constexpr bool value = false; };
struct VtkWriteFilterVelocities<TypeTag, Properties::TTag::VtkMultiPhase>
{ static constexpr bool value = false; };
} // namespace Opm::Properties
@ -163,29 +197,29 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Properties::VtkWriteExtrusionFactor>
Parameters::registerParam<TypeTag, Parameters::VtkWriteExtrusionFactor>
("Include the extrusion factor of the degrees of freedom into the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWritePressures>
Parameters::registerParam<TypeTag, Parameters::VtkWritePressures>
("Include the phase pressures in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteDensities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteDensities>
("Include the phase densities in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteSaturations>
Parameters::registerParam<TypeTag, Parameters::VtkWriteSaturations>
("Include the phase saturations in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteMobilities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteMobilities>
("Include the phase mobilities in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteRelativePermeabilities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteRelativePermeabilities>
("Include the phase relative permeabilities in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteViscosities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteViscosities>
("Include component phase viscosities in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteAverageMolarMasses>
Parameters::registerParam<TypeTag, Parameters::VtkWriteAverageMolarMasses>
("Include the average phase mass in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWritePorosity>
Parameters::registerParam<TypeTag, Parameters::VtkWritePorosity>
("Include the porosity in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteIntrinsicPermeabilities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteIntrinsicPermeabilities>
("Include the intrinsic permeability in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteFilterVelocities>
Parameters::registerParam<TypeTag, Parameters::VtkWriteFilterVelocities>
("Include in the filter velocities of the phases the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWritePotentialGradients>
Parameters::registerParam<TypeTag, Parameters::VtkWritePotentialGradients>
("Include the phase pressure potential gradients in the VTK output files");
}
@ -419,73 +453,73 @@ public:
private:
static bool extrusionFactorOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteExtrusionFactor>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteExtrusionFactor>();
return val;
}
static bool pressureOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWritePressures>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePressures>();
return val;
}
static bool densityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteDensities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteDensities>();
return val;
}
static bool saturationOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteSaturations>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSaturations>();
return val;
}
static bool mobilityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteMobilities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMobilities>();
return val;
}
static bool relativePermeabilityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteRelativePermeabilities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteRelativePermeabilities>();
return val;
}
static bool viscosityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteViscosities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteViscosities>();
return val;
}
static bool averageMolarMassOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteAverageMolarMasses>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteAverageMolarMasses>();
return val;
}
static bool porosityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWritePorosity>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePorosity>();
return val;
}
static bool intrinsicPermeabilityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteIntrinsicPermeabilities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteIntrinsicPermeabilities>();
return val;
}
static bool velocityOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFilterVelocities>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFilterVelocities>();
return val;
}
static bool potentialGradientOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWritePotentialGradients>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePotentialGradients>();
return val;
}

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

@ -27,31 +27,32 @@
#ifndef EWOMS_VTK_PHASE_PRESENCE_MODULE_HH
#define EWOMS_VTK_PHASE_PRESENCE_MODULE_HH
#include "vtkmultiwriter.hh"
#include "baseoutputmodule.hh"
#include <opm/models/discretization/common/fvbaseparameters.hh>
#include <opm/models/io/baseoutputmodule.hh>
#include <opm/models/io/vtkmultiwriter.hh>
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
namespace Opm::Properties {
namespace TTag {
namespace Opm::Properties::TTag {
// create new type tag for the VTK primary variables output
struct VtkPhasePresence {};
} // namespace TTag
} // 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 = UndefinedProperty; };
struct VtkWritePhasePresence { using type = Properties::UndefinedProperty; };
template<class TypeTag>
struct VtkWritePhasePresence<TypeTag, TTag::VtkPhasePresence> { static constexpr bool value = false; };
struct VtkWritePhasePresence<TypeTag, Properties::TTag::VtkPhasePresence>
{ static constexpr bool value = false; };
} // namespace Opm::Properties
} // namespace Opm::Parameters
namespace Opm {
/*!
@ -85,7 +86,7 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Properties::VtkWritePhasePresence>
Parameters::registerParam<TypeTag, Parameters::VtkWritePhasePresence>
("Include the phase presence pseudo primary "
"variable in the VTK output files");
}
@ -135,7 +136,7 @@ public:
private:
static bool phasePresenceOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWritePhasePresence>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWritePhasePresence>();
return val;
}

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

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

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

@ -37,28 +37,32 @@
#include <opm/models/utils/propertysystem.hh>
#include <opm/models/utils/parametersystem.hh>
namespace Opm::Properties {
namespace TTag {
namespace Opm::Properties::TTag {
// create new type tag for the VTK PTFlash output
struct VtkPTFlash {};
} // namespace TTag
} // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the composition module
template<class TypeTag, class MyTypeTag>
struct VtkWriteLiquidMoleFractions { using type = UndefinedProperty; };
struct VtkWriteLiquidMoleFractions { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag>
struct VtkWriteEquilibriumConstants { using type = UndefinedProperty; };
struct VtkWriteEquilibriumConstants { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteLiquidMoleFractions<TypeTag, TTag::VtkPTFlash> { static constexpr bool value = false; };
template<class TypeTag>
struct VtkWriteEquilibriumConstants<TypeTag, TTag::VtkPTFlash> { static constexpr bool value = false; };
struct VtkWriteLiquidMoleFractions<TypeTag, Properties::TTag::VtkPTFlash>
{ static constexpr bool value = false; };
} // namespace Opm::Properties
template<class TypeTag>
struct VtkWriteEquilibriumConstants<TypeTag, Properties::TTag::VtkPTFlash>
{ static constexpr bool value = false; };
} // namespace Opm::Parameters
namespace Opm {
@ -101,9 +105,9 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Properties::VtkWriteLiquidMoleFractions>
Parameters::registerParam<TypeTag, Parameters::VtkWriteLiquidMoleFractions>
("Include liquid mole fractions (L) in the VTK output files");
Parameters::registerParam<TypeTag, Properties::VtkWriteEquilibriumConstants>
Parameters::registerParam<TypeTag, Parameters::VtkWriteEquilibriumConstants>
("Include equilibrium constants (K) in the VTK output files");
}
@ -164,13 +168,13 @@ public:
private:
static bool LOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteLiquidMoleFractions>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteLiquidMoleFractions>();
return val;
}
static bool equilConstOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteEquilibriumConstants>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteEquilibriumConstants>();
return val;
}

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

@ -27,34 +27,35 @@
#ifndef EWOMS_VTK_TEMPERATURE_MODULE_HH
#define EWOMS_VTK_TEMPERATURE_MODULE_HH
#include "vtkmultiwriter.hh"
#include "baseoutputmodule.hh"
#include <opm/material/common/MathToolbox.hpp>
#include <opm/models/discretization/common/fvbaseparameters.hh>
#include <opm/models/io/baseoutputmodule.hh>
#include <opm/models/io/vtkmultiwriter.hh>
#include <opm/models/utils/parametersystem.hh>
#include <opm/models/utils/propertysystem.hh>
#include <opm/material/common/MathToolbox.hpp>
namespace Opm::Properties {
namespace TTag {
namespace Opm::Properties::TTag {
// create new type tag for the VTK temperature output
struct VtkTemperature {};
} // namespace TTag
} // 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 = UndefinedProperty; };
struct VtkWriteTemperature { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output
template<class TypeTag>
struct VtkWriteTemperature<TypeTag, TTag::VtkTemperature> { static constexpr bool value = true; };
struct VtkWriteTemperature<TypeTag, Properties::TTag::VtkTemperature>
{ static constexpr bool value = true; };
} // namespace Opm::Properties
} // namespace Opm::Parameters
namespace Opm {
@ -90,7 +91,7 @@ public:
*/
static void registerParameters()
{
Parameters::registerParam<TypeTag, Properties::VtkWriteTemperature>
Parameters::registerParam<TypeTag, Parameters::VtkWriteTemperature>
("Include the temperature in the VTK output files");
}
@ -141,7 +142,7 @@ public:
private:
static bool temperatureOutput_()
{
static bool val = Parameters::get<TypeTag, Properties::VtkWriteTemperature>();
static bool val = Parameters::get<TypeTag, Parameters::VtkWriteTemperature>();
return val;
}