freeflow/navierstokes/mass/1pnc/model.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:
//
// SPDX-FileCopyrightInfo: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#ifndef DUMUX_NAVIERSTOKES_1PNC_MODEL_HH
#define DUMUX_NAVIERSTOKES_1PNC_MODEL_HH
 
#include <dumux/common/properties.hh>
#include <dumux/common/properties/model.hh>
 
#include <dumux/freeflow/spatialparams.hh>
#include <dumux/freeflow/turbulencemodel.hh>
#include "dumux/freeflow/navierstokes/iofields.hh"
#include <dumux/freeflow/navierstokes/energy/model.hh>
#include <dumux/freeflow/navierstokes/scalarfluxvariablescachefiller.hh>
#include <dumux/material/fluidstates/compositional.hh>
 
#include <dumux/flux/fickslaw.hh>
#include <dumux/flux/fourierslaw.hh>
 
#include "localresidual.hh"
#include "volumevariables.hh"
#include "fluxvariables.hh"
#include "indices.hh"
#include "iofields.hh"
 
namespace Dumux {
 
template<int nComp, bool useM, int repCompEqIdx = nComp>
struct NavierStokesMassOnePNCModelTraits
{
    static constexpr int numEq() { return nComp; }
 
    static constexpr int numFluidPhases() { return 1; }
 
    static constexpr int numFluidComponents() { return nComp; }
 
    static constexpr bool useMoles() { return useM; }
 
    // Enable advection
    static constexpr bool enableAdvection() { return true; }
 
    static constexpr bool enableEnergyBalance() { return false; }
 
    static constexpr bool enableMolecularDiffusion() { return true; }
 
    static constexpr int replaceCompEqIdx() { return repCompEqIdx; }
 
    static constexpr bool usesTurbulenceModel() { return false; }
 
    static constexpr auto turbulenceModel()
    { return TurbulenceModel::none; }
 
    using Indices = NavierStokesMassOnePNCIndices;
};
 
template<class PV,
         class FSY,
         class FST,
         class MT>
struct NavierStokesMassOnePNCVolumeVariablesTraits
{
    using PrimaryVariables = PV;
    using FluidSystem = FSY;
    using FluidState = FST;
    using ModelTraits = MT;
};
 
// \{
// properties for the single-phase Navier-Stokes model
namespace Properties {
 
// Type tags
 
// Create new type tags
namespace TTag {
struct NavierStokesMassOnePNC{ using InheritsFrom = std::tuple<ModelProperties>; };
struct NavierStokesMassOnePNCNI{ using InheritsFrom = std::tuple<NavierStokesMassOnePNC>; };
 
}
 
template<class TypeTag>
struct BaseModelTraits<TypeTag, TTag::NavierStokesMassOnePNC>
{
private:
    using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
public:
    using type = NavierStokesMassOnePNCModelTraits<FluidSystem::numComponents, getPropValue<TypeTag, Properties::UseMoles>(), getPropValue<TypeTag, Properties::ReplaceCompEqIdx>()>;
};
 
 
template<class TypeTag>
struct ModelTraits<TypeTag, TTag::NavierStokesMassOnePNC>
{ using type = GetPropType<TypeTag, Properties::BaseModelTraits>; };
 
 template<class TypeTag>
 struct FluidState<TypeTag, TTag::NavierStokesMassOnePNC>
 {
 private:
     using Scalar = GetPropType<TypeTag, Properties::Scalar>;
     using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
     using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
 public:
     using type = CompositionalFluidState<Scalar, FluidSystem>;
 };
 
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::NavierStokesMassOnePNC>
{ using type = NavierStokesMassOnePNCLocalResidual<TypeTag>; };
 
template<class TypeTag>
struct VolumeVariables<TypeTag, TTag::NavierStokesMassOnePNC>
{
private:
    using PV = GetPropType<TypeTag, Properties::PrimaryVariables>;
    using FSY = GetPropType<TypeTag, Properties::FluidSystem>;
    using FST = GetPropType<TypeTag, Properties::FluidState>;
    using MT = GetPropType<TypeTag, Properties::ModelTraits>;
 
    static_assert(FSY::numPhases == MT::numFluidPhases(), "Number of phases mismatch between model and fluid system");
    static_assert(FST::numPhases == MT::numFluidPhases(), "Number of phases mismatch between model and fluid state");
    // static_assert(!FSY::isMiscible(), "The Navier-Stokes model only works with immiscible fluid systems.");
 
    using BaseTraits = NavierStokesMassOnePNCVolumeVariablesTraits<PV, FSY, FST, MT>;
    using DT = GetPropType<TypeTag, Properties::MolecularDiffusionType>;
    using EDM = GetPropType<TypeTag, Properties::EffectiveDiffusivityModel>;
 
    template<class BaseTraits, class DT, class EDM>
    struct NCTraits : public BaseTraits
    {
        using DiffusionType = DT;
        using EffectiveDiffusivityModel = EDM;
    };
 
public:
    using type = NavierStokesMassOnePNCVolumeVariables<NCTraits<BaseTraits, DT, EDM>>;
};
 
template<class TypeTag>
struct MolecularDiffusionType<TypeTag, TTag::NavierStokesMassOnePNC> { using type = FicksLaw<TypeTag>; };
 
template<class TypeTag>
struct EffectiveDiffusivityModel<TypeTag, TTag::NavierStokesMassOnePNC>
{
    struct type
    {
        template<class VolumeVariables>
        static auto effectiveDiffusionCoefficient(const VolumeVariables& volVars,
                                                    const int phaseIdx,
                                                    const int compIdxI,
                                                    const int compIdxJ)
        {
            return volVars.diffusionCoefficient(phaseIdx, compIdxI, compIdxJ);
        }
    };
};
 
template<class TypeTag>
struct FluxVariables<TypeTag, TTag::NavierStokesMassOnePNC>
{
    using Problem = GetPropType<TypeTag, Properties::Problem>;
    using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
 
    struct FluxTypes
    {
        using MolecularDiffusionType = GetPropType<TypeTag, Properties::MolecularDiffusionType>;
    };
 
    using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
    using ElementFluxVariablesCache = typename GetPropType<TypeTag, Properties::GridFluxVariablesCache>::LocalView;
 
    using type = NavierStokesMassOnePNCFluxVariables<Problem, ModelTraits, FluxTypes, ElementVolumeVariables, ElementFluxVariablesCache>;
};
 
template<class TypeTag>
struct SolutionDependentMolecularDiffusion<TypeTag, TTag::NavierStokesMassOnePNC> { static constexpr bool value = true; };
 
 
template<class TypeTag>
struct FluxVariablesCache<TypeTag, TTag::NavierStokesMassOnePNC>
{
    struct type : public GetPropType<TypeTag, Properties::MolecularDiffusionType>::Cache
    {};
};
 
template<class TypeTag>
struct FluxVariablesCacheFiller<TypeTag, TTag::NavierStokesMassOnePNC>
{
    using Problem = GetPropType<TypeTag, Properties::Problem>;
    using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
    static constexpr bool diffusionIsSolDependent = getPropValue<TypeTag, Properties::SolutionDependentMolecularDiffusion>();
    static constexpr bool heatConductionIsSolDependent = false; // no heat conduction
 
    using type = FreeFlowScalarFluxVariablesCacheFiller<Problem, ModelTraits, diffusionIsSolDependent, heatConductionIsSolDependent>;
};
 
// ! The specific I/O fields
template<class TypeTag>
struct IOFields<TypeTag, TTag::NavierStokesMassOnePNC> { using type = NavierStokesMassOnePNCIOFields<NavierStokesIOFields>; };
 
template<class TypeTag>
struct CouplingManager<TypeTag, TTag::NavierStokesMassOnePNC>
{
private:
    struct EmptyCouplingManager {};
public:
    using type = EmptyCouplingManager;
};
 
// Set the default spatial parameters
template<class TypeTag>
struct SpatialParams<TypeTag, TTag::NavierStokesMassOnePNC>
{
    using GridGeometry = GetPropType<TypeTag, Properties::GridGeometry>;
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
    using type = FreeFlowDefaultSpatialParams<GridGeometry, Scalar>;
};
// Properties for the non-isothermal single phase model
 
template<class TypeTag>
struct IOFields<TypeTag, TTag::NavierStokesMassOnePNCNI> { using type = NavierStokesEnergyIOFields<NavierStokesMassOnePNCIOFields<NavierStokesIOFields>>; };
 
template<class TypeTag>
struct ModelTraits<TypeTag, TTag::NavierStokesMassOnePNCNI> { using type = NavierStokesEnergyModelTraits<GetPropType<TypeTag, Properties::BaseModelTraits>>; };
 
template<class TypeTag>
struct VolumeVariables<TypeTag, TTag::NavierStokesMassOnePNCNI>
{
private:
    using PV = GetPropType<TypeTag, Properties::PrimaryVariables>;
    using FSY = GetPropType<TypeTag, Properties::FluidSystem>;
    using FST = GetPropType<TypeTag, Properties::FluidState>;
    using MT = GetPropType<TypeTag, Properties::ModelTraits>;
 
    static_assert(FSY::numPhases == MT::numFluidPhases(), "Number of phases mismatch between model and fluid system");
    static_assert(FST::numPhases == MT::numFluidPhases(), "Number of phases mismatch between model and fluid state");
    static_assert(!FSY::isMiscible(), "The Navier-Stokes model only works with immiscible fluid systems.");
 
    using BaseTraits = NavierStokesMassOnePNCVolumeVariablesTraits<PV, FSY, FST, MT>;
 
    using DT = GetPropType<TypeTag, Properties::MolecularDiffusionType>;
    using EDM = GetPropType<TypeTag, Properties::EffectiveDiffusivityModel>;
    using ETCM = GetPropType<TypeTag, Properties::ThermalConductivityModel>;
    using HCT = GetPropType<TypeTag, Properties::HeatConductionType>;
 
    struct NCNITraits : public BaseTraits
    {
        using DiffusionType = DT;
        using EffectiveDiffusivityModel = EDM;
        using EffectiveThermalConductivityModel = ETCM;
        using HeatConductionType = HCT;
    };
 
public:
    using type = NavierStokesMassOnePNCVolumeVariables<NCNITraits>;
};
 
template<class TypeTag>
struct ThermalConductivityModel<TypeTag, TTag::NavierStokesMassOnePNCNI>
{
    struct type
    {
        template<class VolVars>
        static auto effectiveThermalConductivity(const VolVars& volVars)
        {
            return volVars.fluidThermalConductivity();
        }
    };
};
 
template<class TypeTag>
struct HeatConductionType<TypeTag, TTag::NavierStokesMassOnePNCNI>
{ using type = FouriersLaw<TypeTag>; };
 
template<class TypeTag>
struct FluxVariables<TypeTag, TTag::NavierStokesMassOnePNCNI>
{
    using Problem = GetPropType<TypeTag, Properties::Problem>;
    using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
 
    struct FluxTypes
    {
        using MolecularDiffusionType = GetPropType<TypeTag, Properties::MolecularDiffusionType>;
        using HeatConductionType = GetPropType<TypeTag, Properties::HeatConductionType>;
    };
 
    using ElementVolumeVariables = typename GetPropType<TypeTag, Properties::GridVolumeVariables>::LocalView;
    using ElementFluxVariablesCache = typename GetPropType<TypeTag, Properties::GridFluxVariablesCache>::LocalView;
 
    using type = NavierStokesMassOnePNCFluxVariables<Problem, ModelTraits, FluxTypes, ElementVolumeVariables, ElementFluxVariablesCache>;
};
 
template<class TypeTag>
struct FluxVariablesCache<TypeTag, TTag::NavierStokesMassOnePNCNI>
{
    struct type
    : public GetPropType<TypeTag, Properties::MolecularDiffusionType>::Cache
    , public GetPropType<TypeTag, Properties::HeatConductionType>::Cache
    {};
};
 
template<class TypeTag>
struct FluxVariablesCacheFiller<TypeTag, TTag::NavierStokesMassOnePNCNI>
{
    using Problem = GetPropType<TypeTag, Properties::Problem>;
    using ModelTraits = GetPropType<TypeTag, Properties::ModelTraits>;
    static constexpr bool diffusionIsSolDependent = getPropValue<TypeTag, Properties::SolutionDependentMolecularDiffusion>();
    static constexpr bool heatConductionIsSolDependent = getPropValue<TypeTag, Properties::SolutionDependentHeatConduction>();
 
    using type = FreeFlowScalarFluxVariablesCacheFiller<Problem, ModelTraits, diffusionIsSolDependent, heatConductionIsSolDependent>;
};
 
template<class TypeTag>
struct SolutionDependentHeatConduction<TypeTag, TTag::NavierStokesMassOnePNCNI> { static constexpr bool value = true; };
 
} // end namespace Properties
 
} // end namespace Dumux
 
#endif // DUMUX_NAVIERSTOKES_MODEL_HH