18#ifndef DUMUX_NONEQUILIBRIUM_VOLUME_VARIABLES_HH 
   19#define DUMUX_NONEQUILIBRIUM_VOLUME_VARIABLES_HH 
   35template<
class Traits, 
class EquilibriumVolumeVariables, 
bool enableChemicalNonEquilibrium,
 
   36         bool enableThermalNonEquilibrium, 
int numEnergyEqFluid>
 
   39template<
class Traits, 
class EquilibriumVolumeVariables>
 
   42                                                  EquilibriumVolumeVariables,
 
   43                                                  Traits::ModelTraits::enableChemicalNonEquilibrium(),
 
   44                                                  Traits::ModelTraits::enableThermalNonEquilibrium(),
 
   45                                                  Traits::ModelTraits::numEnergyEqFluid()>;
 
   50template<
class Traits, 
class EquilibriumVolumeVariables>
 
   52                                                  EquilibriumVolumeVariables,
 
   56: 
public EquilibriumVolumeVariables
 
   58    using ParentType = EquilibriumVolumeVariables;
 
   59    using ParameterCache = 
typename Traits::FluidSystem::ParameterCache;
 
   60    using Scalar = 
typename Traits::PrimaryVariables::value_type;
 
   62    using ModelTraits = 
typename Traits::ModelTraits;
 
   64    using FS = 
typename Traits::FluidSystem;
 
   65    static constexpr auto numEnergyEqFluid = ModelTraits::numEnergyEqFluid();
 
   66    static constexpr auto numEnergyEqSolid = ModelTraits::numEnergyEqSolid();
 
   68    static constexpr auto phase0Idx = FS::phase0Idx;
 
   69    static constexpr auto phase1Idx = FS::phase1Idx;
 
   70    static constexpr auto sPhaseIdx = FS::numPhases;
 
   74    using NumFluidPhasesArray = std::array<Scalar, ModelTraits::numFluidPhases()>;
 
   75    using InterfacialAreasArray =  std::array<std::array<Scalar, ModelTraits::numFluidPhases()+numEnergyEqSolid>,
 
   76                                              ModelTraits::numFluidPhases()+numEnergyEqSolid>;
 
   80     using Indices = 
typename ModelTraits::Indices;
 
   89    template<
class ElemSol, 
class Problem, 
class Element, 
class Scv>
 
   91                const Problem &problem,
 
   92                const Element &element,
 
   96        ParentType::update(elemSol, problem, element, scv);
 
   98        ParameterCache paramCache;
 
   99        paramCache.updateAll(this->fluidState());
 
 
  114    template<
class ElemSol, 
class Problem, 
class Element, 
class Scv>
 
  117                              const ParameterCache& paramCache,
 
  118                              const Problem& problem,
 
  119                              const Element& element,
 
  122        const auto& spatialParams = problem.spatialParams();
 
  123        factorEnergyTransfer_ = spatialParams.factorEnergyTransfer(element, scv, elemSol);
 
  124        characteristicLength_ = spatialParams.characteristicLength(element, scv, elemSol);
 
  127        const unsigned int vIdxGlobal = scv.dofIndex();
 
  128        for (
int phaseIdx = 0; phaseIdx < ModelTraits::numFluidPhases(); ++phaseIdx)
 
  130            const auto darcyMagVelocity = problem.gridVariables().volumeDarcyMagVelocity(phaseIdx, vIdxGlobal);
 
  131            const auto dynamicViscosity = fluidState.viscosity(phaseIdx);
 
  132            const auto density = fluidState.density(phaseIdx);
 
  133            const auto kinematicViscosity = dynamicViscosity/density;
 
  135            using FluidSystem = 
typename Traits::FluidSystem;
 
  136            const auto heatCapacity = FluidSystem::heatCapacity(fluidState, paramCache, phaseIdx);
 
  137            const auto thermalConductivity = FluidSystem::thermalConductivity(fluidState, paramCache, phaseIdx);
 
  138            const auto porosity = this->porosity();
 
  143                                                                       prandtlNumber_[phaseIdx],
 
  145                                                                       ModelTraits::nusseltFormulation());
 
 
  160    template<
class ElemSol, 
class Problem, 
class Element, 
class Scv>
 
  163                               const ParameterCache& paramCache,
 
  164                               const Problem& problem,
 
  165                               const Element& element,
 
  168        const Scalar pc = fluidState.pressure(phase1Idx) - fluidState.pressure(phase0Idx);
 
  169        const Scalar Sw = fluidState.saturation(phase0Idx);
 
  171        const auto fluidMatrixInteraction = problem.spatialParams().fluidMatrixInteraction(element, scv, elemSol);
 
  172        const auto areaWN = fluidMatrixInteraction.wettingNonwettingInterface().area(Sw, pc);
 
  173        const auto areaNS = fluidMatrixInteraction.nonwettingSolidInterface().area(Sw, pc);
 
  174        interfacialArea_[phase0Idx][phase1Idx] = areaWN;
 
  175        interfacialArea_[phase1Idx][phase0Idx] = interfacialArea_[phase0Idx][phase1Idx];
 
  176        interfacialArea_[phase0Idx][phase0Idx] = 0.0;
 
  180        static const bool computeAwsFromAnsAndPcMax = 
getParam<bool>(
"SpatialParams.ComputeAwsFromAnsAndPcMax", 
true);
 
  181        if (computeAwsFromAnsAndPcMax)
 
  184            const Scalar pcMax = fluidMatrixInteraction.wettingNonwettingInterface().basicParams().pcMax();
 
  185            const auto solidSurface = fluidMatrixInteraction.nonwettingSolidInterface().area(0., pcMax);
 
  186            interfacialArea_[phase0Idx][sPhaseIdx] = solidSurface - areaNS;
 
  189            interfacialArea_[phase0Idx][sPhaseIdx] = fluidMatrixInteraction.wettingSolidInterface().area(Sw, pc);
 
  191        interfacialArea_[sPhaseIdx][phase0Idx] = interfacialArea_[phase0Idx][sPhaseIdx];
 
  192        interfacialArea_[sPhaseIdx][sPhaseIdx] = 0.0;
 
  194        interfacialArea_[phase1Idx][sPhaseIdx] = areaNS;
 
  195        interfacialArea_[sPhaseIdx][phase1Idx] = interfacialArea_[phase1Idx][sPhaseIdx];
 
  196        interfacialArea_[phase1Idx][phase1Idx] = 0.0;
 
 
  203    const Scalar 
interfacialArea(
const unsigned int phaseIIdx, 
const unsigned int phaseJIdx)
 const 
  206        assert(phaseIIdx not_eq phaseJIdx);
 
  207        return interfacialArea_[phaseIIdx][phaseJIdx];
 
 
  212    { 
return reynoldsNumber_[phaseIdx]; }
 
 
  216    { 
return prandtlNumber_[phaseIdx]; }
 
 
  220    { 
return nusseltNumber_[phaseIdx]; }
 
 
  224    { 
return characteristicLength_; }
 
 
  228    { 
return factorEnergyTransfer_; }
 
 
  232    NumFluidPhasesArray reynoldsNumber_;
 
  233    NumFluidPhasesArray prandtlNumber_;
 
  234    NumFluidPhasesArray nusseltNumber_;
 
  236    Scalar characteristicLength_;
 
  237    Scalar factorEnergyTransfer_;
 
  238    InterfacialAreasArray interfacialArea_;
 
 
  244template<
class Traits, 
class EquilibriumVolumeVariables>
 
  246                                                  EquilibriumVolumeVariables,
 
  250: 
public EquilibriumVolumeVariables
 
  252    using ParentType = EquilibriumVolumeVariables;
 
  253    using ParameterCache = 
typename Traits::FluidSystem::ParameterCache;
 
  254    using Scalar = 
typename Traits::PrimaryVariables::value_type;
 
  256    using ModelTraits = 
typename Traits::ModelTraits;
 
  257    using FS = 
typename Traits::FluidSystem;
 
  258    static constexpr auto numEnergyEqFluid = ModelTraits::numEnergyEqFluid();
 
  259    static constexpr auto numEnergyEqSolid = ModelTraits::numEnergyEqSolid();
 
  263    using NumFluidPhasesArray = std::array<Scalar, ModelTraits::numFluidPhases()>;
 
  266    using Indices = 
typename ModelTraits::Indices;
 
  278    template<
class ElemSol, 
class Problem, 
class Element, 
class Scv>
 
  280                const Problem &problem,
 
  281                const Element &element,
 
  285        ParentType::update(elemSol, problem, element, scv);
 
  287        ParameterCache paramCache;
 
  288        paramCache.updateAll(this->fluidState());
 
 
  305    template<
class ElemSol, 
class Problem, 
class Element, 
class Scv>
 
  308                              const ParameterCache& paramCache,
 
  309                              const Problem& problem,
 
  310                              const Element& element,
 
  313        const auto& spatialParams = problem.spatialParams();
 
  314        factorEnergyTransfer_ = spatialParams.factorEnergyTransfer(element, scv, elemSol);
 
  315        characteristicLength_ = spatialParams.characteristicLength(element, scv, elemSol);
 
  318        const unsigned int vIdxGlobal = scv.dofIndex();
 
  319        for (
int phaseIdx = 0; phaseIdx < ModelTraits::numFluidPhases(); ++phaseIdx)
 
  321            const auto darcyMagVelocity = problem.gridVariables().volumeDarcyMagVelocity(phaseIdx, vIdxGlobal);
 
  322            const auto dynamicViscosity = fluidState.viscosity(phaseIdx);
 
  323            const auto density = fluidState.density(phaseIdx);
 
  324            const auto kinematicViscosity = dynamicViscosity/density;
 
  326            using FluidSystem = 
typename Traits::FluidSystem;
 
  327            const auto heatCapacity = FluidSystem::heatCapacity(fluidState, paramCache, phaseIdx);
 
  328            const auto thermalConductivity = FluidSystem::thermalConductivity(fluidState, paramCache, phaseIdx);
 
  329            const auto porosity = this->porosity();
 
  334                                                                       prandtlNumber_[phaseIdx],
 
  336                                                                       ModelTraits::nusseltFormulation());
 
 
  351    template<
class ElemSol, 
class Problem, 
class Element, 
class Scv>
 
  354                               const ParameterCache& paramCache,
 
  355                               const Problem& problem,
 
  356                               const Element& element,
 
  359       using FluidSolidInterfacialAreaFormulation = 
typename Problem::SpatialParams::FluidSolidInterfacialAreaFormulation;
 
  360       interfacialArea_ = FluidSolidInterfacialAreaFormulation::fluidSolidInterfacialArea(this->porosity(), 
characteristicLength());
 
 
  365    { 
return reynoldsNumber_[phaseIdx]; }
 
 
  369    { 
return prandtlNumber_[phaseIdx]; }
 
 
  373    { 
return nusseltNumber_[phaseIdx]; }
 
 
  377    { 
return characteristicLength_; }
 
 
  381    { 
return factorEnergyTransfer_; }
 
 
  384    {
return interfacialArea_;}
 
 
  388    NumFluidPhasesArray reynoldsNumber_;
 
  389    NumFluidPhasesArray prandtlNumber_;
 
  390    NumFluidPhasesArray nusseltNumber_;
 
  392    Scalar characteristicLength_;
 
  393    Scalar factorEnergyTransfer_;
 
  394    Scalar interfacialArea_ ;
 
 
  400template<
class Traits, 
class EquilibriumVolumeVariables>
 
  402                                                  EquilibriumVolumeVariables,
 
  406: 
public EquilibriumVolumeVariables
 
  408    using ParentType = EquilibriumVolumeVariables;
 
  409    using FluidState = 
typename Traits::FluidState;
 
  410    using FS = 
typename Traits::FluidSystem;
 
  411    using ParameterCache = 
typename Traits::FluidSystem::ParameterCache;
 
  412    using Scalar = 
typename Traits::PrimaryVariables::value_type;
 
  414    using ModelTraits = 
typename Traits::ModelTraits;
 
  416    static constexpr auto phase0Idx = FS::phase0Idx;
 
  417    static constexpr auto phase1Idx = FS::phase1Idx;
 
  418    static constexpr auto wCompIdx = FS::comp0Idx;
 
  419    static constexpr auto nCompIdx = FS::comp1Idx;
 
  423    using NumFluidPhasesArray = std::array<Scalar, ModelTraits::numFluidPhases()>;
 
  426    using Indices = 
typename ModelTraits::Indices;
 
  436    template<
class ElemSol, 
class Problem, 
class Element, 
class Scv>
 
  438                const Problem &problem,
 
  439                const Element &element,
 
  443        ParentType::update(elemSol, problem, element, scv);
 
  445        ParameterCache paramCache;
 
  446        paramCache.updateAll(this->fluidState());
 
 
  461    template<
class ElemSol, 
class Problem, 
class Element, 
class Scv>
 
  463                              const FluidState& fluidState,
 
  464                              const ParameterCache& paramCache,
 
  465                              const Problem& problem,
 
  466                              const Element& element,
 
  469        const auto& spatialParams = problem.spatialParams();
 
  470        factorMassTransfer_ = spatialParams.factorMassTransfer(element, scv, elemSol);
 
  471        characteristicLength_ = spatialParams.characteristicLength(element, scv, elemSol);
 
  474        const unsigned int vIdxGlobal = scv.dofIndex();
 
  475        for (
int phaseIdx = 0; phaseIdx < ModelTraits::numFluidPhases(); ++phaseIdx)
 
  477            const auto darcyMagVelocity = problem.gridVariables().volumeDarcyMagVelocity(phaseIdx, vIdxGlobal);
 
  478            const auto dynamicViscosity = fluidState.viscosity(phaseIdx);
 
  479            const auto density = fluidState.density(phaseIdx);
 
  480            const auto kinematicViscosity = dynamicViscosity/density;
 
  483            using FluidSystem = 
typename Traits::FluidSystem;
 
  484            const auto diffCoeff = FluidSystem::binaryDiffusionCoefficient(fluidState,
 
  493                                                                   schmidtNumber_[phaseIdx],
 
  494                                                                   ModelTraits::sherwoodFormulation());
 
 
  508    template<
class ElemSol, 
class Problem, 
class Element, 
class Scv>
 
  510                               const FluidState& fluidState,
 
  511                               const ParameterCache& paramCache,
 
  512                               const Problem& problem,
 
  513                               const Element& element,
 
  516        const auto Sw = fluidState.saturation(phase0Idx) ;
 
  517        const auto pc = fluidState.pressure(phase1Idx) - fluidState.pressure(phase0Idx);
 
  521        const auto fluidMatrixInteraction = problem.spatialParams().fluidMatrixInteraction(element, scv, elemSol);
 
  522        interfacialArea_ = fluidMatrixInteraction.wettingNonwettingInterface().area(Sw, pc);
 
 
  528    const Scalar 
interfacialArea(
const unsigned int phaseIIdx, 
const unsigned int phaseJIdx)
 const 
  531        assert( (phaseIIdx == phase1Idx && phaseJIdx == phase0Idx)
 
  532                || (phaseIIdx == phase0Idx && phaseJIdx == phase1Idx) );
 
  533        return interfacialArea_;
 
 
  538    { 
return reynoldsNumber_[phaseIdx]; }
 
 
  542    { 
return schmidtNumber_[phaseIdx]; }
 
 
  546    { 
return sherwoodNumber_[phaseIdx]; }
 
 
  550    { 
return characteristicLength_; }
 
 
  554    { 
return factorMassTransfer_; }
 
 
  557    Scalar characteristicLength_;
 
  558    Scalar factorMassTransfer_;
 
  559    Scalar interfacialArea_ ;
 
  560    NumFluidPhasesArray sherwoodNumber_;
 
  561    NumFluidPhasesArray schmidtNumber_;
 
  562    NumFluidPhasesArray reynoldsNumber_;
 
 
  566template<
class Traits, 
class EquilibriumVolumeVariables>
 
  568                                                  EquilibriumVolumeVariables,
 
  572: 
public EquilibriumVolumeVariables
 
  574    using ParentType = EquilibriumVolumeVariables;
 
  575    using FluidState = 
typename Traits::FluidState;
 
  576    using FS = 
typename Traits::FluidSystem;
 
  577    using ParameterCache = 
typename Traits::FluidSystem::ParameterCache;
 
  578    using Scalar = 
typename Traits::PrimaryVariables::value_type;
 
  580    using ModelTraits = 
typename Traits::ModelTraits;
 
  581    static constexpr auto numEnergyEqFluid = ModelTraits::numEnergyEqFluid();
 
  582    static constexpr auto numEnergyEqSolid = ModelTraits::numEnergyEqSolid();
 
  584    static constexpr auto phase0Idx = FS::phase0Idx;
 
  585    static constexpr auto phase1Idx = FS::phase1Idx;
 
  586    static constexpr auto sPhaseIdx = FS::numPhases;
 
  587    static constexpr auto wCompIdx = FS::comp0Idx;
 
  588    static constexpr auto nCompIdx = FS::comp1Idx;
 
  591    static_assert((numEnergyEqFluid > 1), 
"This model only deals with energy transfer between two fluids and one solid phase");
 
  593    using NumFluidPhasesArray = std::array<Scalar, ModelTraits::numFluidPhases()>;
 
  594    using InterfacialAreasArray =  std::array<std::array<Scalar, ModelTraits::numFluidPhases()+numEnergyEqSolid>,
 
  595                                              ModelTraits::numFluidPhases()+numEnergyEqSolid>;
 
  598    using Indices = 
typename ModelTraits::Indices;
 
  609    template<
class ElemSol, 
class Problem, 
class Element, 
class Scv>
 
  611                const Problem &problem,
 
  612                const Element &element,
 
  616        ParentType::update(elemSol, problem, element, scv);
 
  618        ParameterCache paramCache;
 
  619        paramCache.updateAll(this->fluidState());
 
 
  634    template<
class ElemSol, 
class Problem, 
class Element, 
class Scv>
 
  636                              const FluidState& fluidState,
 
  637                              const ParameterCache& paramCache,
 
  638                              const Problem& problem,
 
  639                              const Element& element,
 
  642        const auto& spatialParams = problem.spatialParams();
 
  643        factorMassTransfer_ = spatialParams.factorMassTransfer(element, scv, elemSol);
 
  644        factorEnergyTransfer_ = spatialParams.factorEnergyTransfer(element, scv, elemSol);
 
  645        characteristicLength_ = spatialParams.characteristicLength(element, scv, elemSol);
 
  647        const auto vIdxGlobal = scv.dofIndex();
 
  648        using FluidSystem = 
typename Traits::FluidSystem;
 
  649        for (
int phaseIdx = 0; phaseIdx < ModelTraits::numFluidPhases(); ++phaseIdx)
 
  651            const auto darcyMagVelocity = problem.gridVariables().volumeDarcyMagVelocity(phaseIdx, vIdxGlobal);
 
  652            const auto dynamicViscosity = fluidState.viscosity(phaseIdx);
 
  653            const auto density = fluidState.density(phaseIdx);
 
  654            const auto kinematicViscosity = dynamicViscosity/density;
 
  655            const auto heatCapacity = FluidSystem::heatCapacity(fluidState, paramCache, phaseIdx);
 
  656            const auto thermalConductivity = FluidSystem::thermalConductivity(fluidState, paramCache, phaseIdx);
 
  659            const auto porosity = this->porosity();
 
  660            const auto diffCoeff = FluidSystem::binaryDiffusionCoefficient(fluidState,
 
  670                                                                       prandtlNumber_[phaseIdx],
 
  672                                                                       ModelTraits::nusseltFormulation());
 
  675                                                                   schmidtNumber_[phaseIdx],
 
  676                                                                   ModelTraits::sherwoodFormulation());
 
 
  690    template<
class ElemSol, 
class Problem, 
class Element, 
class Scv>
 
  692                               const FluidState& fluidState,
 
  693                               const ParameterCache& paramCache,
 
  694                               const Problem& problem,
 
  695                               const Element& element,
 
  698        const Scalar pc = fluidState.pressure(phase1Idx) - fluidState.pressure(phase0Idx);
 
  699        const Scalar Sw = fluidState.saturation(phase0Idx);
 
  701        const auto fluidMatrixInteraction = problem.spatialParams().fluidMatrixInteraction(element, scv, elemSol);
 
  703        const auto awn = fluidMatrixInteraction.wettingNonwettingInterface().area(Sw, pc);
 
  704        interfacialArea_[phase0Idx][phase1Idx] = awn;
 
  705        interfacialArea_[phase1Idx][phase0Idx] = interfacialArea_[phase0Idx][phase1Idx];
 
  706        interfacialArea_[phase0Idx][phase0Idx] = 0.;
 
  708        const auto areaNS = fluidMatrixInteraction.nonwettingSolidInterface().area(Sw, pc);
 
  712        static const bool computeAwsFromAnsAndPcMax = 
getParam<bool>(
"SpatialParams.ComputeAwsFromAnsAndPcMax", 
true);
 
  713        if (computeAwsFromAnsAndPcMax)
 
  716            const Scalar pcMax = fluidMatrixInteraction.wettingNonwettingInterface().basicParams().pcMax();
 
  717            const auto solidSurface = fluidMatrixInteraction.nonwettingSolidInterface().area(0., pcMax);
 
  718            interfacialArea_[phase0Idx][sPhaseIdx] = solidSurface - areaNS;
 
  721            interfacialArea_[phase0Idx][sPhaseIdx] = fluidMatrixInteraction.wettingSolidInterface().area(Sw, pc);
 
  723        interfacialArea_[sPhaseIdx][phase0Idx] = interfacialArea_[phase0Idx][sPhaseIdx];
 
  724        interfacialArea_[sPhaseIdx][sPhaseIdx] = 0.;
 
  726        interfacialArea_[phase1Idx][sPhaseIdx] = areaNS;
 
  727        interfacialArea_[sPhaseIdx][phase1Idx] = interfacialArea_[phase1Idx][sPhaseIdx];
 
  728        interfacialArea_[phase1Idx][phase1Idx] = 0.;
 
 
  735    const Scalar 
interfacialArea(
const unsigned int phaseIIdx, 
const unsigned int phaseJIdx)
 const 
  738        assert(phaseIIdx not_eq phaseJIdx);
 
  739        return interfacialArea_[phaseIIdx][phaseJIdx];
 
 
  744    { 
return reynoldsNumber_[phaseIdx]; }
 
 
  748    { 
return prandtlNumber_[phaseIdx]; }
 
 
  752    { 
return nusseltNumber_[phaseIdx]; }
 
 
  756    { 
return schmidtNumber_[phaseIdx]; }
 
 
  760    { 
return sherwoodNumber_[phaseIdx]; }
 
 
  764    { 
return characteristicLength_; }
 
 
  768    { 
return factorEnergyTransfer_; }
 
 
  772    { 
return factorMassTransfer_; }
 
 
  776    NumFluidPhasesArray reynoldsNumber_;
 
  777    NumFluidPhasesArray prandtlNumber_;
 
  778    NumFluidPhasesArray nusseltNumber_;
 
  779    NumFluidPhasesArray schmidtNumber_;
 
  780    NumFluidPhasesArray sherwoodNumber_;
 
  781    Scalar characteristicLength_;
 
  782    Scalar factorEnergyTransfer_;
 
  783    Scalar factorMassTransfer_;
 
  784    InterfacialAreasArray interfacialArea_;
 
 
Collection of functions which calculate dimensionless numbers. Each number has it's own function....
Definition dimensionlessnumbers.hh:53
static Scalar nusseltNumberForced(const Scalar reynoldsNumber, const Scalar prandtlNumber, const Scalar porosity, NusseltFormulation formulation)
Calculate the Nusselt Number [-] (Nu).
Definition dimensionlessnumbers.hh:139
static Scalar reynoldsNumber(const Scalar darcyMagVelocity, const Scalar charcteristicLength, const Scalar kinematicViscosity)
Calculate the Reynolds Number [-] (Re).
Definition dimensionlessnumbers.hh:76
static Scalar prandtlNumber(const Scalar dynamicViscosity, const Scalar heatCapacity, const Scalar thermalConductivity)
Calculate the Prandtl Number [-] (Pr).
Definition dimensionlessnumbers.hh:106
static Scalar schmidtNumber(const Scalar dynamicViscosity, const Scalar massDensity, const Scalar diffusionCoefficient)
Calculate the Schmidt Number [-] (Sc).
Definition dimensionlessnumbers.hh:212
static Scalar sherwoodNumber(const Scalar reynoldsNumber, const Scalar schmidtNumber, SherwoodFormulation formulation)
Calculate the Sherwood Number [-] (Sh).
Definition dimensionlessnumbers.hh:248
void updateInterfacialArea(const ElemSol &elemSol, const FluidState &fluidState, const ParameterCache ¶mCache, const Problem &problem, const Element &element, const Scv &scv)
Updates the volume specific interfacial area [m^2 / m^3] between the phases.
Definition porousmediumflow/nonequilibrium/volumevariables.hh:161
const Scalar factorEnergyTransfer() const
access function pre factor energy transfer
Definition porousmediumflow/nonequilibrium/volumevariables.hh:227
const Scalar prandtlNumber(const unsigned int phaseIdx) const
access function Prandtl Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:215
const Scalar interfacialArea(const unsigned int phaseIIdx, const unsigned int phaseJIdx) const
The specific interfacial area between two fluid phases [m^2 / m^3].
Definition porousmediumflow/nonequilibrium/volumevariables.hh:203
typename ModelTraits::Indices Indices
Definition porousmediumflow/nonequilibrium/volumevariables.hh:80
void update(const ElemSol &elemSol, const Problem &problem, const Element &element, const Scv &scv)
Update all quantities for a given control volume.
Definition porousmediumflow/nonequilibrium/volumevariables.hh:90
const Scalar reynoldsNumber(const unsigned int phaseIdx) const
access function Reynolds Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:211
void updateDimLessNumbers(const ElemSol &elemSol, const FluidState &fluidState, const ParameterCache ¶mCache, const Problem &problem, const Element &element, const Scv &scv)
Updates dimensionless numbers.
Definition porousmediumflow/nonequilibrium/volumevariables.hh:115
const Scalar nusseltNumber(const unsigned int phaseIdx) const
access function Nusselt Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:219
const Scalar characteristicLength() const
access function characteristic length
Definition porousmediumflow/nonequilibrium/volumevariables.hh:223
typename Traits::FluidState FluidState
Definition porousmediumflow/nonequilibrium/volumevariables.hh:79
const Scalar characteristicLength() const
access function characteristic length
Definition porousmediumflow/nonequilibrium/volumevariables.hh:763
const Scalar sherwoodNumber(const unsigned int phaseIdx) const
access function Sherwood Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:759
typename ModelTraits::Indices Indices
Definition porousmediumflow/nonequilibrium/volumevariables.hh:598
void update(const ElemSol &elemSol, const Problem &problem, const Element &element, const Scv &scv)
Update all quantities for a given control volume.
Definition porousmediumflow/nonequilibrium/volumevariables.hh:610
const Scalar factorMassTransfer() const
access function pre factor mass transfer
Definition porousmediumflow/nonequilibrium/volumevariables.hh:771
const Scalar factorEnergyTransfer() const
access function pre factor energy transfer
Definition porousmediumflow/nonequilibrium/volumevariables.hh:767
const Scalar schmidtNumber(const unsigned int phaseIdx) const
access function Schmidt Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:755
const Scalar nusseltNumber(const unsigned int phaseIdx) const
access function Nusselt Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:751
const Scalar interfacialArea(const unsigned int phaseIIdx, const unsigned int phaseJIdx) const
The specific interfacial area between two fluid phases [m^2 / m^3].
Definition porousmediumflow/nonequilibrium/volumevariables.hh:735
const Scalar prandtlNumber(const unsigned int phaseIdx) const
access function Prandtl Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:747
void updateDimLessNumbers(const ElemSol &elemSol, const FluidState &fluidState, const ParameterCache ¶mCache, const Problem &problem, const Element &element, const Scv &scv)
Updates the volume specific interfacial area [m^2 / m^3] between the phases.
Definition porousmediumflow/nonequilibrium/volumevariables.hh:635
const Scalar reynoldsNumber(const unsigned int phaseIdx) const
access function Reynolds Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:743
void updateInterfacialArea(const ElemSol &elemSol, const FluidState &fluidState, const ParameterCache ¶mCache, const Problem &problem, const Element &element, const Scv &scv)
Updates the volume specific interfacial area [m^2 / m^3] between the phases.
Definition porousmediumflow/nonequilibrium/volumevariables.hh:691
void update(const ElemSol &elemSol, const Problem &problem, const Element &element, const Scv &scv)
Update all quantities for a given control volume.
Definition porousmediumflow/nonequilibrium/volumevariables.hh:437
const Scalar reynoldsNumber(const unsigned int phaseIdx) const
access function Reynolds Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:537
void updateDimLessNumbers(const ElemSol &elemSol, const FluidState &fluidState, const ParameterCache ¶mCache, const Problem &problem, const Element &element, const Scv &scv)
Updates the volume specific interfacial area [m^2 / m^3] between the phases.
Definition porousmediumflow/nonequilibrium/volumevariables.hh:462
typename ModelTraits::Indices Indices
Definition porousmediumflow/nonequilibrium/volumevariables.hh:426
const Scalar characteristicLength() const
access function characteristic length
Definition porousmediumflow/nonequilibrium/volumevariables.hh:549
const Scalar sherwoodNumber(const unsigned int phaseIdx) const
access function Sherwood Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:545
const Scalar factorMassTransfer() const
access function pre factor mass transfer
Definition porousmediumflow/nonequilibrium/volumevariables.hh:553
const Scalar interfacialArea(const unsigned int phaseIIdx, const unsigned int phaseJIdx) const
The specific interfacial area between two fluid phases [m^2 / m^3].
Definition porousmediumflow/nonequilibrium/volumevariables.hh:528
void updateInterfacialArea(const ElemSol &elemSol, const FluidState &fluidState, const ParameterCache ¶mCache, const Problem &problem, const Element &element, const Scv &scv)
Updates the volume specific interfacial area [m^2 / m^3] between the phases.
Definition porousmediumflow/nonequilibrium/volumevariables.hh:509
const Scalar schmidtNumber(const unsigned int phaseIdx) const
access function Schmidt Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:541
typename ModelTraits::Indices Indices
Definition porousmediumflow/nonequilibrium/volumevariables.hh:266
const Scalar fluidSolidInterfacialArea() const
Definition porousmediumflow/nonequilibrium/volumevariables.hh:383
const Scalar characteristicLength() const
access function characteristic length
Definition porousmediumflow/nonequilibrium/volumevariables.hh:376
const Scalar reynoldsNumber(const unsigned int phaseIdx) const
access function Reynolds Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:364
void updateDimLessNumbers(const ElemSol &elemSol, const FluidState &fluidState, const ParameterCache ¶mCache, const Problem &problem, const Element &element, const Scv &scv)
Updates dimensionless numbers.
Definition porousmediumflow/nonequilibrium/volumevariables.hh:306
void updateInterfacialArea(const ElemSol &elemSol, const FluidState &fluidState, const ParameterCache ¶mCache, const Problem &problem, const Element &element, const Scv &scv)
Updates the volume specific interfacial area [m^2 / m^3] between the solid and the fluid phase.
Definition porousmediumflow/nonequilibrium/volumevariables.hh:352
const Scalar nusseltNumber(const unsigned int phaseIdx) const
access function Nusselt Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:372
const Scalar prandtlNumber(const unsigned int phaseIdx) const
access function Prandtl Number
Definition porousmediumflow/nonequilibrium/volumevariables.hh:368
typename Traits::FluidState FluidState
Definition porousmediumflow/nonequilibrium/volumevariables.hh:267
const Scalar factorEnergyTransfer() const
access function pre factor energy transfer
Definition porousmediumflow/nonequilibrium/volumevariables.hh:380
void update(const ElemSol &elemSol, const Problem &problem, const Element &element, const Scv &scv)
Update all quantities for a given control volume.
Definition porousmediumflow/nonequilibrium/volumevariables.hh:279
This class contains the volume variables required for the modules which require the specific interfac...
Definition porousmediumflow/nonequilibrium/volumevariables.hh:37
Collection of functions, calculating dimensionless numbers.
T getParam(Args &&... args)
A free function to get a parameter from the parameter tree singleton.
Definition parameters.hh:139
NonEquilibriumVolumeVariablesImplementation< Traits, EquilibriumVolumeVariables, Traits::ModelTraits::enableChemicalNonEquilibrium(), Traits::ModelTraits::enableThermalNonEquilibrium(), Traits::ModelTraits::numEnergyEqFluid()> NonEquilibriumVolumeVariables
Definition porousmediumflow/nonequilibrium/volumevariables.hh:40
The infrastructure to retrieve run-time parameters from Dune::ParameterTrees.