fluidmatrixinteraction.hh

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
 *   See the file COPYING for full copying permissions.                      *
 *                                                                           *
 *   This program 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 3 of the License, or       *
 *   (at your option) any later version.                                     *
 *                                                                           *
 *   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.   *
 *****************************************************************************/
#ifndef DUMUX_MATERIAL_FLUIDMATRIX_INTERACTIONS_FLUIDMATRIX_INTERACTION_HH
#define DUMUX_MATERIAL_FLUIDMATRIX_INTERACTIONS_FLUIDMATRIX_INTERACTION_HH
 
#include <type_traits>
#include <utility>
 
namespace Dumux {
 
template<class... Laws>
struct FluidMatrixInteraction : public Laws...
{
   FluidMatrixInteraction(Laws&&... laws) : Laws(std::forward<Laws>(laws))... {}
};
 
template<class... Laws>
auto makeFluidMatrixInteraction(Laws&&... laws)
{
    return FluidMatrixInteraction(wrap(std::forward<Laws>(laws))...);
}
 
} // end namespace Dumux
 
namespace Dumux::FluidMatrix {
 
template<class A, template<class> class Wrapper>
struct Adapter
{
    template<class T, std::enable_if_t<std::is_same_v<A, std::decay_t<T>>, int> = 0>
    friend auto wrap(T&& t) { return Wrapper(std::forward<T>(t)); }
};
 
template<class T>
class PcKrSw
{
public:
    using Scalar = typename std::decay_t<T>::Scalar;
 
    using PcKrSwType = T;
 
    PcKrSw(T&& impl) : impl_(std::forward<T>(impl)) {}
 
    Scalar pc(const Scalar sw) const { return impl_.pc(sw); }
    Scalar dpc_dsw(const Scalar sw) const { return impl_.dpc_dsw(sw); }
    Scalar endPointPc() const { return impl_.endPointPc(); }
    Scalar sw(const Scalar pc) const { return impl_.sw(pc); }
    Scalar dsw_dpc(const Scalar pc) const { return impl_.dsw_dpc(pc); }
    Scalar krw(const Scalar sw) const { return impl_.krw(sw); }
    Scalar dkrw_dsw(const Scalar sw) const { return impl_.dkrw_dsw(sw); }
    Scalar krn(const Scalar sw) const { return impl_.krn(sw); }
    Scalar dkrn_dsw(const Scalar sw) const { return impl_.dkrn_dsw(sw); }
 
    const T& pcSwCurve() const { return impl_; }
    const T& krSwCurve()  const { return impl_; }
 
private:
    T impl_;
};
 
template<typename T>
PcKrSw(T&&) -> PcKrSw<T>;
 
template<class T>
class MultiPhasePcKrSw
{
public:
    using Scalar = typename std::decay_t<T>::Scalar;
 
    MultiPhasePcKrSw(T&& impl) : impl_(std::forward<T>(impl)) {}
 
    template<class FS>
    auto capillaryPressures(const FS& fs, int wp) const { return impl_.capillaryPressures(fs, wp); }
    template<class FS>
    auto relativePermeabilities(const FS& fs, int wp) const { return impl_.relativePermeabilities(fs, wp); }
 
    const T& multiPhasePcKrS() const { return impl_; }
 
private:
    T impl_;
};
 
template<typename T>
MultiPhasePcKrSw(T&&) -> MultiPhasePcKrSw<T>;
 
template<class T>
struct ThreePhasePcKrSw
{
    using Scalar = typename std::decay_t<T>::Scalar;
    using value_type = T;
 
    using PcKrSwType = T;
 
    ThreePhasePcKrSw(T&& impl) : impl_(std::forward<T>(impl)) {}
 
    Scalar pcgw(const Scalar sw, const Scalar sn) const { return impl_.pcgw(sw, sn); }
    Scalar pcnw(const Scalar sw, const Scalar sn) const { return impl_.pcnw(sw, sn); }
    Scalar pcgn(const Scalar sw, const Scalar sn) const { return impl_.pcgn(sw, sn); }
    Scalar pcAlpha(const Scalar sw, const Scalar sn) const { return impl_.pcAlpha(sw, sn); }
 
    Scalar krw(const Scalar sw, const Scalar sn) const { return impl_.krw(sw, sn); }
    Scalar krn(const Scalar sw, const Scalar sn) const { return impl_.krn(sw, sn); }
    Scalar krg(const Scalar sw, const Scalar sn) const { return impl_.krn(sw, sn); }
    Scalar kr(const int phaseIdx, const Scalar sw, const Scalar sn) const { return impl_.kr(phaseIdx, sw, sn); }
 
    const T& pcSwCurve() const { return impl_; }
    const T& krSwCurve()  const { return impl_; }
private:
    T impl_;
};
 
template<typename T>
ThreePhasePcKrSw(T&&) -> ThreePhasePcKrSw<T>;
 
template<class T>
class WettingNonwettingInterfacialAreaPcSw
{
public:
    WettingNonwettingInterfacialAreaPcSw(T&& impl) : impl_(std::forward<T>(impl)) {}
    const T& wettingNonwettingInterface() const { return impl_; }
private:
    T impl_;
};
 
template<typename T>
WettingNonwettingInterfacialAreaPcSw(T&&) -> WettingNonwettingInterfacialAreaPcSw<T>;
 
template<class T>
class WettingSolidInterfacialAreaPcSw
{
public:
    WettingSolidInterfacialAreaPcSw(T&& impl) : impl_(std::forward<T>(impl)) {}
    const T& wettingSolidInterface() const { return impl_; }
private:
    T impl_;
};
 
template<typename T>
WettingSolidInterfacialAreaPcSw(T&&) -> WettingSolidInterfacialAreaPcSw<T>;
 
template<class T>
class NonwettingSolidInterfacialAreaPcSw
{
public:
    NonwettingSolidInterfacialAreaPcSw(T&& impl) : impl_(std::forward<T>(impl)) {}
    const T& nonwettingSolidInterface() const { return impl_; }
private:
    T impl_;
};
 
template<typename T>
NonwettingSolidInterfacialAreaPcSw(T&&) -> NonwettingSolidInterfacialAreaPcSw<T>;
 
 
template<class T>
class Adsorption
{
public:
    using value_type = T;
 
    Adsorption(T&& impl) : impl_(std::forward<T>(impl)) {}
    const T& adsorptionModel() const { return impl_; }
private:
    T impl_;
};
 
template<typename T>
Adsorption(T&&) -> Adsorption<T>;
 
}  // end namespace Dumux::FluidMatrix
 
#endif