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.; 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 // this is kinds of telling the report step length
template <class TypeTag> template <class TypeTag>
struct EpisodeLength<TypeTag, TTag::CO2PTBaseProblem> { struct EpisodeLength<TypeTag, TTag::CO2PTBaseProblem> {
@ -309,6 +273,34 @@ template <class TypeTag>
struct NewtonMaxIterations<TypeTag, Properties::TTag::CO2PTBaseProblem> struct NewtonMaxIterations<TypeTag, Properties::TTag::CO2PTBaseProblem>
{ static constexpr int value = 30; }; { 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::Parameters
namespace Opm { namespace Opm {

9
examples/problems/lensproblem.hh
View File

@ -175,10 +175,6 @@ struct LensUpperRightZ<TypeTag, TTag::LensBaseProblem>
static constexpr type value = 1.0; 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::Properties
namespace Opm::Parameters { namespace Opm::Parameters {
@ -247,6 +243,11 @@ template<class TypeTag>
struct NewtonWriteConvergence<TypeTag, Properties::TTag::LensBaseProblem> struct NewtonWriteConvergence<TypeTag, Properties::TTag::LensBaseProblem>
{ static constexpr bool value = false; }; { 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::Parameters
namespace Opm { namespace Opm {

9
examples/problems/outflowproblem.hh
View File

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

9
examples/problems/powerinjectionproblem.hh
View File

@ -119,10 +119,6 @@ public:
using type = Opm::EffToAbsLaw<EffectiveLaw>; 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 // Disable gravity
template<class TypeTag> template<class TypeTag>
struct EnableGravity<TypeTag, TTag::PowerInjectionBaseProblem> { static constexpr bool value = false; }; 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; 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::Parameters
namespace Opm { namespace Opm {

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

@ -129,15 +129,6 @@ public:
using type = Opm::LiquidPhase<Scalar, Opm::NullComponent<Scalar> >; 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 // set slightly different properties for the two-phase case
///////////////////// /////////////////////
@ -173,9 +164,26 @@ public:
using type = Opm::TwoPhaseImmiscibleFluidSystem<Scalar, WettingPhase, NonwettingPhase>; using type = Opm::TwoPhaseImmiscibleFluidSystem<Scalar, WettingPhase, NonwettingPhase>;
}; };
} // namespace Opm::Properties } // 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 { namespace Opm {
/*! /*!

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

@ -27,24 +27,24 @@
#ifndef EWOMS_BASE_OUTPUT_MODULE_HH #ifndef EWOMS_BASE_OUTPUT_MODULE_HH
#define 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/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 <array>
#include <cstdio>
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <string_view>
#include <vector>
#include <cstdio>
namespace Opm::Properties { namespace Opm::Properties {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -42,66 +42,100 @@
#include <cstdio> #include <cstdio>
namespace Opm::Properties { namespace Opm::Properties::TTag {
namespace TTag {
// create new type tag for the VTK multi-phase output // create new type tag for the VTK multi-phase output
struct VtkMultiPhase {}; struct VtkMultiPhase {};
} // namespace TTag } // namespace Opm::Properties::TTag
namespace Opm::Parameters {
// create the property tags needed for the multi phase module // create the property tags needed for the multi phase module
template<class TypeTag, class MyTypeTag> template<class TypeTag, class MyTypeTag>
struct VtkWriteExtrusionFactor { using type = UndefinedProperty; }; struct VtkWriteExtrusionFactor { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag> template<class TypeTag, class MyTypeTag>
struct VtkWritePressures { using type = UndefinedProperty; }; struct VtkWritePressures { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag> template<class TypeTag, class MyTypeTag>
struct VtkWriteDensities { using type = UndefinedProperty; }; struct VtkWriteDensities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag> template<class TypeTag, class MyTypeTag>
struct VtkWriteSaturations { using type = UndefinedProperty; }; struct VtkWriteSaturations { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag> template<class TypeTag, class MyTypeTag>
struct VtkWriteMobilities { using type = UndefinedProperty; }; struct VtkWriteMobilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag> template<class TypeTag, class MyTypeTag>
struct VtkWriteRelativePermeabilities { using type = UndefinedProperty; }; struct VtkWriteRelativePermeabilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag> template<class TypeTag, class MyTypeTag>
struct VtkWriteViscosities { using type = UndefinedProperty; }; struct VtkWriteViscosities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag> template<class TypeTag, class MyTypeTag>
struct VtkWriteAverageMolarMasses { using type = UndefinedProperty; }; struct VtkWriteAverageMolarMasses { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag> template<class TypeTag, class MyTypeTag>
struct VtkWritePorosity { using type = UndefinedProperty; }; struct VtkWritePorosity { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag> template<class TypeTag, class MyTypeTag>
struct VtkWriteIntrinsicPermeabilities { using type = UndefinedProperty; }; struct VtkWriteIntrinsicPermeabilities { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag> template<class TypeTag, class MyTypeTag>
struct VtkWritePotentialGradients { using type = UndefinedProperty; }; struct VtkWritePotentialGradients { using type = Properties::UndefinedProperty; };
template<class TypeTag, class MyTypeTag> template<class TypeTag, class MyTypeTag>
struct VtkWriteFilterVelocities { using type = UndefinedProperty; }; struct VtkWriteFilterVelocities { using type = Properties::UndefinedProperty; };
// set default values for what quantities to output // set default values for what quantities to output
template<class TypeTag> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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 } // namespace Opm::Properties
@ -163,29 +197,29 @@ public:
*/ */
static void registerParameters() 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"); ("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"); ("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"); ("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"); ("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"); ("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"); ("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"); ("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"); ("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"); ("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"); ("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"); ("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"); ("Include the phase pressure potential gradients in the VTK output files");
} }
@ -419,73 +453,73 @@ public:
private: private:
static bool extrusionFactorOutput_() static bool extrusionFactorOutput_()
{ {
static bool val = Parameters::get<TypeTag, Properties::VtkWriteExtrusionFactor>(); static bool val = Parameters::get<TypeTag, Parameters::VtkWriteExtrusionFactor>();
return val; return val;
} }
static bool pressureOutput_() static bool pressureOutput_()
{ {
static bool val = Parameters::get<TypeTag, Properties::VtkWritePressures>(); static bool val = Parameters::get<TypeTag, Parameters::VtkWritePressures>();
return val; return val;
} }
static bool densityOutput_() static bool densityOutput_()
{ {
static bool val = Parameters::get<TypeTag, Properties::VtkWriteDensities>(); static bool val = Parameters::get<TypeTag, Parameters::VtkWriteDensities>();
return val; return val;
} }
static bool saturationOutput_() static bool saturationOutput_()
{ {
static bool val = Parameters::get<TypeTag, Properties::VtkWriteSaturations>(); static bool val = Parameters::get<TypeTag, Parameters::VtkWriteSaturations>();
return val; return val;
} }
static bool mobilityOutput_() static bool mobilityOutput_()
{ {
static bool val = Parameters::get<TypeTag, Properties::VtkWriteMobilities>(); static bool val = Parameters::get<TypeTag, Parameters::VtkWriteMobilities>();
return val; return val;
} }
static bool relativePermeabilityOutput_() static bool relativePermeabilityOutput_()
{ {
static bool val = Parameters::get<TypeTag, Properties::VtkWriteRelativePermeabilities>(); static bool val = Parameters::get<TypeTag, Parameters::VtkWriteRelativePermeabilities>();
return val; return val;
} }
static bool viscosityOutput_() static bool viscosityOutput_()
{ {
static bool val = Parameters::get<TypeTag, Properties::VtkWriteViscosities>(); static bool val = Parameters::get<TypeTag, Parameters::VtkWriteViscosities>();
return val; return val;
} }
static bool averageMolarMassOutput_() static bool averageMolarMassOutput_()
{ {
static bool val = Parameters::get<TypeTag, Properties::VtkWriteAverageMolarMasses>(); static bool val = Parameters::get<TypeTag, Parameters::VtkWriteAverageMolarMasses>();
return val; return val;
} }
static bool porosityOutput_() static bool porosityOutput_()
{ {
static bool val = Parameters::get<TypeTag, Properties::VtkWritePorosity>(); static bool val = Parameters::get<TypeTag, Parameters::VtkWritePorosity>();
return val; return val;
} }
static bool intrinsicPermeabilityOutput_() static bool intrinsicPermeabilityOutput_()
{ {
static bool val = Parameters::get<TypeTag, Properties::VtkWriteIntrinsicPermeabilities>(); static bool val = Parameters::get<TypeTag, Parameters::VtkWriteIntrinsicPermeabilities>();
return val; return val;
} }
static bool velocityOutput_() static bool velocityOutput_()
{ {
static bool val = Parameters::get<TypeTag, Properties::VtkWriteFilterVelocities>(); static bool val = Parameters::get<TypeTag, Parameters::VtkWriteFilterVelocities>();
return val; return val;
} }
static bool potentialGradientOutput_() static bool potentialGradientOutput_()
{ {
static bool val = Parameters::get<TypeTag, Properties::VtkWritePotentialGradients>(); static bool val = Parameters::get<TypeTag, Parameters::VtkWritePotentialGradients>();
return val; return val;
} }

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

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

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

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

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

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

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

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