implement a multiplexer three-phase fluid-matrixinteraction for ECL problems
this allows to switch between the Default three-phase implementation, Stone1 and Stone2 at runtime.
This commit is contained in:
Andreas Lauser
parent
11ccc40e44
commit
a25cee980b
325
opm/material/fluidmatrixinteractions/EclMultiplexerMaterial.hpp
Normal file
325
opm/material/fluidmatrixinteractions/EclMultiplexerMaterial.hpp
Normal file
@ -0,0 +1,325 @@
|
||||
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
// vi: set et ts=4 sw=4 sts=4:
|
||||
/*
|
||||
Copyright (C) 2015 by Andreas Lauser
|
||||
|
||||
This file is part of the Open Porous Media project (OPM).
|
||||
|
||||
OPM is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OPM is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OPM. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
/*!
|
||||
* \file
|
||||
* \copydoc Opm::EclMultiplexerMaterial
|
||||
*/
|
||||
#ifndef OPM_ECL_MULTIPLEXER_MATERIAL_HPP
|
||||
#define OPM_ECL_MULTIPLEXER_MATERIAL_HPP
|
||||
|
||||
#include "EclMultiplexerMaterialParams.hpp"
|
||||
|
||||
#include <opm/material/common/Valgrind.hpp>
|
||||
#include <opm/material/common/MathToolbox.hpp>
|
||||
|
||||
#include <opm/material/common/Exceptions.hpp>
|
||||
#include <opm/material/common/ErrorMacros.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
namespace Opm {
|
||||
|
||||
/*!
|
||||
* \ingroup FluidMatrixInteractions
|
||||
*
|
||||
* \brief Implements a multiplexer class that provides all three phase capillary pressure
|
||||
* laws used by the ECLipse simulator.
|
||||
*/
|
||||
template <class TraitsT,
|
||||
class GasOilMaterialLawT,
|
||||
class OilWaterMaterialLawT,
|
||||
class ParamsT = EclMultiplexerMaterialParams<TraitsT,
|
||||
GasOilMaterialLawT,
|
||||
OilWaterMaterialLawT> >
|
||||
class EclMultiplexerMaterial : public TraitsT
|
||||
{
|
||||
public:
|
||||
typedef GasOilMaterialLawT GasOilMaterialLaw;
|
||||
typedef OilWaterMaterialLawT OilWaterMaterialLaw;
|
||||
|
||||
typedef Opm::EclStone1Material<TraitsT, GasOilMaterialLaw, OilWaterMaterialLaw> Stone1Material;
|
||||
typedef Opm::EclStone2Material<TraitsT, GasOilMaterialLaw, OilWaterMaterialLaw> Stone2Material;
|
||||
typedef Opm::EclDefaultMaterial<TraitsT, GasOilMaterialLaw, OilWaterMaterialLaw> DefaultMaterial;
|
||||
|
||||
// some safety checks
|
||||
static_assert(TraitsT::numPhases == 3,
|
||||
"The number of phases considered by this capillary pressure "
|
||||
"law is always three!");
|
||||
static_assert(GasOilMaterialLaw::numPhases == 2,
|
||||
"The number of phases considered by the gas-oil capillary "
|
||||
"pressure law must be two!");
|
||||
static_assert(OilWaterMaterialLaw::numPhases == 2,
|
||||
"The number of phases considered by the oil-water capillary "
|
||||
"pressure law must be two!");
|
||||
static_assert(std::is_same<typename GasOilMaterialLaw::Scalar,
|
||||
typename OilWaterMaterialLaw::Scalar>::value,
|
||||
"The two two-phase capillary pressure laws must use the same "
|
||||
"type of floating point values.");
|
||||
|
||||
typedef TraitsT Traits;
|
||||
typedef ParamsT Params;
|
||||
typedef typename Traits::Scalar Scalar;
|
||||
|
||||
static const int numPhases = 3;
|
||||
static const int waterPhaseIdx = Traits::wettingPhaseIdx;
|
||||
static const int oilPhaseIdx = Traits::nonWettingPhaseIdx;
|
||||
static const int gasPhaseIdx = Traits::gasPhaseIdx;
|
||||
|
||||
//! Specify whether this material law implements the two-phase
|
||||
//! convenience API
|
||||
static const bool implementsTwoPhaseApi = false;
|
||||
|
||||
//! Specify whether this material law implements the two-phase
|
||||
//! convenience API which only depends on the phase saturations
|
||||
static const bool implementsTwoPhaseSatApi = false;
|
||||
|
||||
//! Specify whether the quantities defined by this material law
|
||||
//! are saturation dependent
|
||||
static const bool isSaturationDependent = true;
|
||||
|
||||
//! Specify whether the quantities defined by this material law
|
||||
//! are dependent on the absolute pressure
|
||||
static const bool isPressureDependent = false;
|
||||
|
||||
//! Specify whether the quantities defined by this material law
|
||||
//! are temperature dependent
|
||||
static const bool isTemperatureDependent = false;
|
||||
|
||||
//! Specify whether the quantities defined by this material law
|
||||
//! are dependent on the phase composition
|
||||
static const bool isCompositionDependent = false;
|
||||
|
||||
/*!
|
||||
* \brief Implements the multiplexer three phase capillary pressure law
|
||||
* used by the ECLipse simulator.
|
||||
*
|
||||
* This material law is valid for three fluid phases and only
|
||||
* depends on the saturations.
|
||||
*
|
||||
* The required two-phase relations are supplied by means of template
|
||||
* arguments and can be an arbitrary other material laws.
|
||||
*
|
||||
* \param values Container for the return values
|
||||
* \param params Parameters
|
||||
* \param state The fluid state
|
||||
*/
|
||||
template <class ContainerT, class FluidState>
|
||||
static void capillaryPressures(ContainerT &values,
|
||||
const Params ¶ms,
|
||||
const FluidState &fluidState)
|
||||
{
|
||||
switch (params.approach()) {
|
||||
case EclStone1Approach:
|
||||
Stone1Material::capillaryPressures(values,
|
||||
params.template getRealParams<EclStone1Approach>(),
|
||||
fluidState);
|
||||
break;
|
||||
|
||||
case EclStone2Approach:
|
||||
Stone2Material::capillaryPressures(values,
|
||||
params.template getRealParams<EclStone2Approach>(),
|
||||
fluidState);
|
||||
break;
|
||||
|
||||
case EclDefaultApproach:
|
||||
DefaultMaterial::capillaryPressures(values,
|
||||
params.template getRealParams<EclDefaultApproach>(),
|
||||
fluidState);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief Capillary pressure between the gas and the non-wetting
|
||||
* liquid (i.e., oil) phase.
|
||||
*
|
||||
* This is defined as
|
||||
* \f[
|
||||
* p_{c,gn} = p_g - p_n
|
||||
* \f]
|
||||
*/
|
||||
template <class FluidState, class Evaluation = typename FluidState::Scalar>
|
||||
static Evaluation pcgn(const Params ¶ms,
|
||||
const FluidState &fs)
|
||||
{
|
||||
OPM_THROW(std::logic_error, "Not implemented: pcgn()");
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief Capillary pressure between the non-wetting liquid (i.e.,
|
||||
* oil) and the wetting liquid (i.e., water) phase.
|
||||
*
|
||||
* This is defined as
|
||||
* \f[
|
||||
* p_{c,nw} = p_n - p_w
|
||||
* \f]
|
||||
*/
|
||||
template <class FluidState, class Evaluation = typename FluidState::Scalar>
|
||||
static Evaluation pcnw(const Params ¶ms,
|
||||
const FluidState &fs)
|
||||
{
|
||||
OPM_THROW(std::logic_error, "Not implemented: pcnw()");
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief The inverse of the capillary pressure
|
||||
*/
|
||||
template <class ContainerT, class FluidState>
|
||||
static void saturations(ContainerT &values,
|
||||
const Params ¶ms,
|
||||
const FluidState &fs)
|
||||
{
|
||||
OPM_THROW(std::logic_error, "Not implemented: saturations()");
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief The saturation of the gas phase.
|
||||
*/
|
||||
template <class FluidState, class Evaluation = typename FluidState::Scalar>
|
||||
static Evaluation Sg(const Params ¶ms,
|
||||
const FluidState &fluidState)
|
||||
{
|
||||
OPM_THROW(std::logic_error, "Not implemented: Sg()");
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief The saturation of the non-wetting (i.e., oil) phase.
|
||||
*/
|
||||
template <class FluidState, class Evaluation = typename FluidState::Scalar>
|
||||
static Evaluation Sn(const Params ¶ms,
|
||||
const FluidState &fluidState)
|
||||
{
|
||||
OPM_THROW(std::logic_error, "Not implemented: Sn()");
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief The saturation of the wetting (i.e., water) phase.
|
||||
*/
|
||||
template <class FluidState, class Evaluation = typename FluidState::Scalar>
|
||||
static Evaluation Sw(const Params ¶ms,
|
||||
const FluidState &fluidState)
|
||||
{
|
||||
OPM_THROW(std::logic_error, "Not implemented: Sw()");
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief The relative permeability of all phases.
|
||||
*
|
||||
* The relative permeability of the water phase it uses the same
|
||||
* value as the relative permeability for water in the water-oil
|
||||
* law with \f$S_o = 1 - S_w\f$. The gas relative permebility is
|
||||
* taken from the gas-oil material law, but with \f$S_o = 1 -
|
||||
* S_g\f$. The relative permeability of the oil phase is
|
||||
* calculated using the relative permeabilities of the oil phase
|
||||
* in the two two-phase systems.
|
||||
*
|
||||
* A more detailed description can be found in the "Three phase
|
||||
* oil relative permeability models" section of the ECLipse
|
||||
* technical description.
|
||||
*/
|
||||
template <class ContainerT, class FluidState>
|
||||
static void relativePermeabilities(ContainerT &values,
|
||||
const Params ¶ms,
|
||||
const FluidState &fluidState)
|
||||
{
|
||||
switch (params.approach()) {
|
||||
case EclStone1Approach:
|
||||
Stone1Material::relativePermeabilities(values,
|
||||
params.template getRealParams<EclStone1Approach>(),
|
||||
fluidState);
|
||||
break;
|
||||
|
||||
case EclStone2Approach:
|
||||
Stone2Material::relativePermeabilities(values,
|
||||
params.template getRealParams<EclStone2Approach>(),
|
||||
fluidState);
|
||||
break;
|
||||
|
||||
case EclDefaultApproach:
|
||||
DefaultMaterial::relativePermeabilities(values,
|
||||
params.template getRealParams<EclDefaultApproach>(),
|
||||
fluidState);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief The relative permeability of the gas phase.
|
||||
*/
|
||||
template <class FluidState, class Evaluation = typename FluidState::Scalar>
|
||||
static Evaluation krg(const Params ¶ms,
|
||||
const FluidState &fluidState)
|
||||
{
|
||||
OPM_THROW(std::logic_error, "Not implemented: krg()");
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief The relative permeability of the wetting phase.
|
||||
*/
|
||||
template <class FluidState, class Evaluation = typename FluidState::Scalar>
|
||||
static Evaluation krw(const Params ¶ms,
|
||||
const FluidState &fluidState)
|
||||
{
|
||||
OPM_THROW(std::logic_error, "Not implemented: krw()");
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief The relative permeability of the non-wetting (i.e., oil) phase.
|
||||
*/
|
||||
template <class FluidState, class Evaluation = typename FluidState::Scalar>
|
||||
static Evaluation krn(const Params ¶ms,
|
||||
const FluidState &fluidState)
|
||||
{
|
||||
OPM_THROW(std::logic_error, "Not implemented: krn()");
|
||||
}
|
||||
|
||||
|
||||
/*!
|
||||
* \brief Update the hysteresis parameters after a time step.
|
||||
*
|
||||
* This assumes that the nested two-phase material laws are parameters for
|
||||
* EclHysteresisLaw. If they are not, calling this methid will cause a compiler
|
||||
* error. (But not calling it will still work.)
|
||||
*/
|
||||
template <class FluidState>
|
||||
static void updateHysteresis(Params ¶ms, const FluidState &fluidState)
|
||||
{
|
||||
switch (params.approach()) {
|
||||
case EclStone1Approach:
|
||||
Stone1Material::updateHysteresis(params.template getRealParams<EclStone1Approach>(),
|
||||
fluidState);
|
||||
break;
|
||||
|
||||
case EclStone2Approach:
|
||||
Stone2Material::updateHysteresis(params.template getRealParams<EclStone2Approach>(),
|
||||
fluidState);
|
||||
break;
|
||||
|
||||
case EclDefaultApproach:
|
||||
DefaultMaterial::updateHysteresis(params.template getRealParams<EclDefaultApproach>(),
|
||||
fluidState);
|
||||
break;
|
||||
}
|
||||
}
|
||||
};
|
||||
} // namespace Opm
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,227 @@
|
||||
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
// vi: set et ts=4 sw=4 sts=4:
|
||||
/*
|
||||
Copyright (C) 2013 by Andreas Lauser
|
||||
|
||||
This file is part of the Open Porous Media project (OPM).
|
||||
|
||||
OPM is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OPM is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OPM. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
/*!
|
||||
* \file
|
||||
* \copydoc Opm::EclMultiplexerMaterialParams
|
||||
*/
|
||||
#ifndef OPM_ECL_MULTIPLEXER_MATERIAL_PARAMS_HPP
|
||||
#define OPM_ECL_MULTIPLEXER_MATERIAL_PARAMS_HPP
|
||||
|
||||
#include "EclStone1Material.hpp"
|
||||
#include "EclStone2Material.hpp"
|
||||
#include "EclDefaultMaterial.hpp"
|
||||
|
||||
#include <type_traits>
|
||||
#include <cassert>
|
||||
#include <memory>
|
||||
|
||||
namespace Opm {
|
||||
|
||||
enum EclMultiplexerApproach {
|
||||
EclDefaultApproach,
|
||||
EclStone1Approach,
|
||||
EclStone2Approach
|
||||
};
|
||||
|
||||
/*!
|
||||
* \brief Multiplexer implementation for the parameters required by the
|
||||
* multiplexed three-phase material law.
|
||||
*
|
||||
* Essentially, this class just stores parameter object for the "nested" material law and
|
||||
* provides some methods to convert to it.
|
||||
*/
|
||||
template<class Traits, class GasOilMaterialLawT, class OilWaterMaterialLawT>
|
||||
class EclMultiplexerMaterialParams : public Traits
|
||||
{
|
||||
typedef typename Traits::Scalar Scalar;
|
||||
enum { numPhases = 3 };
|
||||
|
||||
typedef Opm::EclStone1Material<Traits, GasOilMaterialLawT, OilWaterMaterialLawT> Stone1Material;
|
||||
typedef Opm::EclStone2Material<Traits, GasOilMaterialLawT, OilWaterMaterialLawT> Stone2Material;
|
||||
typedef Opm::EclDefaultMaterial<Traits, GasOilMaterialLawT, OilWaterMaterialLawT> DefaultMaterial;
|
||||
|
||||
typedef typename Stone1Material::Params Stone1Params;
|
||||
typedef typename Stone2Material::Params Stone2Params;
|
||||
typedef typename DefaultMaterial::Params DefaultParams;
|
||||
|
||||
public:
|
||||
typedef typename GasOilMaterialLawT::Params GasOilParams;
|
||||
typedef typename OilWaterMaterialLawT::Params OilWaterParams;
|
||||
|
||||
|
||||
/*!
|
||||
* \brief The multiplexer constructor.
|
||||
*/
|
||||
EclMultiplexerMaterialParams()
|
||||
{
|
||||
realParams_ = 0;
|
||||
|
||||
#ifndef NDEBUG
|
||||
finalized_ = false;
|
||||
#endif
|
||||
}
|
||||
|
||||
~EclMultiplexerMaterialParams()
|
||||
{
|
||||
switch (approach()) {
|
||||
case EclStone1Approach:
|
||||
delete static_cast<Stone1Material*>(realParams_);
|
||||
break;
|
||||
|
||||
case EclStone2Approach:
|
||||
delete static_cast<Stone2Material*>(realParams_);
|
||||
break;
|
||||
|
||||
case EclDefaultApproach:
|
||||
delete static_cast<DefaultMaterial*>(realParams_);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief Finish the initialization of the parameter object.
|
||||
*/
|
||||
void finalize()
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
finalized_ = true;
|
||||
#endif
|
||||
}
|
||||
|
||||
OilWaterParams& oilWaterParams()
|
||||
{
|
||||
switch (approach()) {
|
||||
case EclStone1Approach:
|
||||
return getRealParams<EclStone1Approach>().oilWaterParams();
|
||||
|
||||
case EclStone2Approach:
|
||||
return getRealParams<EclStone2Approach>().oilWaterParams();
|
||||
|
||||
case EclDefaultApproach:
|
||||
return getRealParams<EclDefaultApproach>().oilWaterParams();
|
||||
}
|
||||
}
|
||||
|
||||
GasOilParams& gasOilParams()
|
||||
{
|
||||
switch (approach()) {
|
||||
case EclStone1Approach:
|
||||
return getRealParams<EclStone1Approach>().gasOilParams();
|
||||
|
||||
case EclStone2Approach:
|
||||
return getRealParams<EclStone2Approach>().gasOilParams();
|
||||
|
||||
case EclDefaultApproach:
|
||||
return getRealParams<EclDefaultApproach>().gasOilParams();
|
||||
}
|
||||
}
|
||||
|
||||
void setApproach(EclMultiplexerApproach newApproach)
|
||||
{
|
||||
assert(realParams_ == 0);
|
||||
approach_ = newApproach;
|
||||
|
||||
switch (approach()) {
|
||||
case EclStone1Approach:
|
||||
realParams_ = new Stone1Params;
|
||||
break;
|
||||
|
||||
case EclStone2Approach:
|
||||
realParams_ = new Stone2Params;
|
||||
break;
|
||||
|
||||
case EclDefaultApproach:
|
||||
realParams_ = new DefaultParams;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
EclMultiplexerApproach approach() const
|
||||
{ return approach_; }
|
||||
|
||||
// get the parameter object for the Stone1 case
|
||||
template <EclMultiplexerApproach approachV>
|
||||
typename std::enable_if<approachV == EclStone1Approach, Stone1Params>::type&
|
||||
getRealParams()
|
||||
{
|
||||
assert(approach() == approachV);
|
||||
return *static_cast<Stone1Params*>(realParams_);
|
||||
}
|
||||
|
||||
template <EclMultiplexerApproach approachV>
|
||||
typename std::enable_if<approachV == EclStone1Approach, const Stone1Params>::type&
|
||||
getRealParams() const
|
||||
{
|
||||
assert(approach() == approachV);
|
||||
return *static_cast<const Stone1Params*>(realParams_);
|
||||
}
|
||||
|
||||
// get the parameter object for the Stone2 case
|
||||
template <EclMultiplexerApproach approachV>
|
||||
typename std::enable_if<approachV == EclStone2Approach, Stone2Params>::type&
|
||||
getRealParams()
|
||||
{
|
||||
assert(approach() == approachV);
|
||||
return *static_cast<Stone2Params*>(realParams_);
|
||||
}
|
||||
|
||||
template <EclMultiplexerApproach approachV>
|
||||
typename std::enable_if<approachV == EclStone2Approach, const Stone2Params>::type&
|
||||
getRealParams() const
|
||||
{
|
||||
assert(approach() == approachV);
|
||||
return *static_cast<const Stone2Params*>(realParams_);
|
||||
}
|
||||
|
||||
// get the parameter object for the Default case
|
||||
template <EclMultiplexerApproach approachV>
|
||||
typename std::enable_if<approachV == EclDefaultApproach, DefaultParams>::type&
|
||||
getRealParams()
|
||||
{
|
||||
assert(approach() == approachV);
|
||||
return *static_cast<DefaultParams*>(realParams_);
|
||||
}
|
||||
|
||||
template <EclMultiplexerApproach approachV>
|
||||
typename std::enable_if<approachV == EclDefaultApproach, const DefaultParams>::type&
|
||||
getRealParams() const
|
||||
{
|
||||
assert(approach() == approachV);
|
||||
return *static_cast<const DefaultParams*>(realParams_);
|
||||
}
|
||||
|
||||
private:
|
||||
#ifndef NDEBUG
|
||||
void assertFinalized_() const
|
||||
{ assert(finalized_); }
|
||||
|
||||
bool finalized_;
|
||||
#else
|
||||
void assertFinalized_() const
|
||||
{ }
|
||||
#endif
|
||||
|
||||
EclMultiplexerApproach approach_;
|
||||
void* realParams_;
|
||||
};
|
||||
} // namespace Opm
|
||||
|
||||
#endif
|
||||
@ -47,6 +47,7 @@
|
||||
#include <opm/material/fluidmatrixinteractions/EclDefaultMaterial.hpp>
|
||||
#include <opm/material/fluidmatrixinteractions/EclStone1Material.hpp>
|
||||
#include <opm/material/fluidmatrixinteractions/EclStone2Material.hpp>
|
||||
#include <opm/material/fluidmatrixinteractions/EclMultiplexerMaterial.hpp>
|
||||
|
||||
// include the helper classes to construct traits
|
||||
#include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
|
||||
@ -343,6 +344,15 @@ int main(int argc, char **argv)
|
||||
testThreePhaseApi<MaterialLaw, ThreePhaseFluidState>();
|
||||
//testThreePhaseSatApi<MaterialLaw, ThreePhaseFluidState>();
|
||||
}
|
||||
{
|
||||
typedef Opm::BrooksCorey<TwoPhaseTraits> TwoPhaseMaterial;
|
||||
typedef Opm::EclMultiplexerMaterial<ThreePhaseTraits,
|
||||
/*GasOilMaterial=*/TwoPhaseMaterial,
|
||||
/*OilWaterMaterial=*/TwoPhaseMaterial> MaterialLaw;
|
||||
testGenericApi<MaterialLaw, ThreePhaseFluidState>();
|
||||
testThreePhaseApi<MaterialLaw, ThreePhaseFluidState>();
|
||||
//testThreePhaseSatApi<MaterialLaw, ThreePhaseFluidState>();
|
||||
}
|
||||
{
|
||||
typedef Opm::ThreePhaseParkerVanGenuchten<ThreePhaseTraits> MaterialLaw;
|
||||
testGenericApi<MaterialLaw, ThreePhaseFluidState>();
|
||||
|
||||
Loading…
Reference in New Issue
Block a user