zhyang-dev/OpenFOAM-12
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

multiphaseEulerFoam: New phaseInterface system to replace phasePair

Browse Source 
A new class, phaseInterface, has been added to represent interfacial
configurations between pairs of phases. This class and its derivations
explicitly represent different configurations (e.g., dispersal,
segregation, displacement) by type and provide a run-time selection
mechanism so that these configurations can be uniquely named and
intuitively selected for sub-models to apply to.

For example, drag models can be selected for an air-water system with
full phase inversion with the following syntax in
constant/phaseProperties:

    drag
    {
        air_dispersedIn_water
        {
            type            IshiiZuber;
        }

        air_segregatedWith_water
        {
            type            segregated;
            m               0.5;
            n               8;
        }

        steam_dispersedIn_water
        {
            type            SchillerNaumann;
            residualRe      1e-3;
        }
    }

As well as the entries now being underscore separated, note also that
the sub model sections are now dictionaries ("{ ... }"), rather than
lists ("( ... );"). If a list is provided instead, then the input will
be considered to be in the old syntax, and will be read in a backwards
compatibility mode.

The new dictionary syntax permits substitution and therefore reuse of
settings, reducing the workload associated with setting up a large case
with many model combinations. In future it may be possible to introduce
wildcards to further reduce the verbosity of the input.

The new phase-interface classes and keywords and the phase-pairs and
keywords that they replace are listed below:

    Default/General:            phaseInterface "<phase>_<phase>"
                            replaces phasePair "(<phase> and <phase>)"

          Dispersed:   dispersedPhaseInterface "<phase>_dispersedIn_<phase>"
                     replaces orderedPhasePair "(<phase> in <phase>)"

         Segregated:  segregatedPhaseInterface "<phase>_segregatedWith_<phase>"
                            replaces phasePair "(<phase> and <phase>)"

              Sided:       sidedPhaseInterface "<phase>_<phase>_inThe_<phase>"
                     replaces orderedPhasePair "(<phase> in <phase>)"

          Displaced:   displacedPhaseInterface "<phase>_<phase>_displacedBy_<phase>"
                                        is new

Interface combinations are also possible. There can be, for example, an
interface which is both dispersed and sided. This class is the
dispersedSidedPhaseInterface and can be selected with the keyword
"<phase>_dispersedIn_<phase>_inThe_<phase>". This is needed, for
example, in two-resistance heat transfer modelling, where a different
model can be selected to represent heat transfer within the fluids on
either side of an interface.

A full list of all available phase interface relationships can be
generated by specifying an incorrect name, and viewing the output of the
error message that results.

The "displaced" interface is not currently used, but will shortly be
utilised to allowing the user to control how models between phases
change as the fraction of a third phase becomes significant and
displaces the phases associated with the interface in question.

Notes for developers:

There is no centralised storage of phase interface relationships in the
phase system any more; the table of phasePairs has been removed, and
there is no correcponding table of phaseInterfaces. Models now locally
store their own phaseInterface objects, or a derivation thereof, rather
than a reference to a centrally stored object. These phaseInterface
classes hold only references so there is no cost associated with their
duplication in multiple sub models.

If a model requires an interface of a specific type, it has to down-cast
the interface provided to it. There is a `phaseSystem::modelCast` method
for this purpose which also provides meaningful error messages in the
event that an inappropriate interface was specified and the cast fails.

Model generation is now hierarchical. Wrapper models (blended and sided)
are constructed with the same interface as non-wrapper models (drag,
virtual mass, etc...). The wrapper model constructors call the
constructors of their sub-models directly, rather than requiring model
pointers to be passed in.

Sub-model lookup has been significantly generalised and simplified.
There is now just one `phaseSystem::lookupInterfacialModel` method which
takes a phaseInterface as its argument. Looking up a model for a
specific configuration just requires providing the appropriate
phaseInterface. E.g., this call will return the virtual mass model for
gas bubbles in liquid:

    lookupSubModel<virtualMassModel>(dispersedPhaseInterface(gas, liquid))

Whilst this call will return the drag model for the segregated regime:

    lookupSubModel<dragModel>(segregatedPhaseInterface(phase1, phase2))

And this call will return the complete blended heat transfer model:

    lookupSubModel<blendedHeatTransferModel>(phaseInterface(phase1, phase2))
This commit is contained in:
Will Bainbridge
2022-01-12 16:46:18 +00:00
parent 27d2ec6d43
commit 6bd200d0b5
274 changed files with 8653 additions and 4402 deletions
Download Patch File Download Diff File Expand all files Collapse all files

302
applications/solvers/multiphase/multiphaseEulerFoam/functionObjects/phaseForces/phaseForces.C
View File

@ -25,7 +25,6 @@ License
#include "phaseForces.H"
#include "addToRunTimeSelectionTable.H"
#include "BlendedInterfacialModel.H"
#include "fvcGrad.H"
#include "dragModel.H"
#include "virtualMassModel.H"
@ -45,26 +44,6 @@ namespace functionObjects
}
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * * //
template<class modelType>
Foam::tmp<Foam::volVectorField>
Foam::functionObjects::phaseForces::nonDragForce(const phasePair& pair) const
{
const BlendedInterfacialModel<modelType>& model =
fluid_.lookupBlendedSubModel<modelType>(pair);
if (&pair.phase1() == &phase_)
{
return -model.template F<vector>();
}
else
{
return model.template F<vector>();
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::functionObjects::phaseForces::phaseForces
@ -86,123 +65,127 @@ Foam::functionObjects::phaseForces::phaseForces
{
read(dict);
forAllConstIter
(
phaseSystem::phasePairTable,
fluid_.phasePairs(),
pairIter
)
forAll(fluid_.phases(), phasei)
{
const phasePair& pair = pairIter();
const phaseModel& otherPhase = fluid_.phases()[phasei];
if (pair.contains(phase_) && !pair.ordered())
if (&otherPhase == &phase_) continue;
const phaseInterface interface(phase_, otherPhase);
if (fluid_.foundInterfacialModel<blendedDragModel>(interface))
{
if (fluid_.foundBlendedSubModel<dragModel>(pair))
{
forceFields_.insert
forceFields_.insert
(
dragModel::typeName,
new volVectorField
(
dragModel::typeName,
new volVectorField
IOobject
(
IOobject
(
IOobject::groupName("dragForce", phase_.name()),
mesh_.time().timeName(),
mesh_
),
mesh_,
dimensionedVector(dimForce/dimVolume, Zero)
)
);
}
IOobject::groupName("dragForce", phase_.name()),
mesh_.time().timeName(),
mesh_
),
mesh_,
dimensionedVector(dimForce/dimVolume, Zero)
)
);
}
if (fluid_.foundBlendedSubModel<virtualMassModel>(pair))
{
forceFields_.insert
if (fluid_.foundInterfacialModel<blendedVirtualMassModel>(interface))
{
forceFields_.insert
(
virtualMassModel::typeName,
new volVectorField
(
virtualMassModel::typeName,
new volVectorField
IOobject
(
IOobject
IOobject::groupName
(
IOobject::groupName
(
"virtualMassForce",
phase_.name()
),
mesh_.time().timeName(),
mesh_
"virtualMassForce",
phase_.name()
),
mesh_,
dimensionedVector(dimForce/dimVolume, Zero)
)
);
}
mesh_.time().timeName(),
mesh_
),
mesh_,
dimensionedVector(dimForce/dimVolume, Zero)
)
);
}
if (fluid_.foundBlendedSubModel<liftModel>(pair))
{
forceFields_.insert
if (fluid_.foundInterfacialModel<blendedLiftModel>(interface))
{
forceFields_.insert
(
liftModel::typeName,
new volVectorField
(
liftModel::typeName,
new volVectorField
IOobject
(
IOobject
(
IOobject::groupName("liftForce", phase_.name()),
mesh_.time().timeName(),
mesh_
),
mesh_,
dimensionedVector(dimForce/dimVolume, Zero)
)
);
}
IOobject::groupName("liftForce", phase_.name()),
mesh_.time().timeName(),
mesh_
),
mesh_,
dimensionedVector(dimForce/dimVolume, Zero)
)
);
}
if (fluid_.foundBlendedSubModel<wallLubricationModel>(pair))
{
forceFields_.insert
if
(
fluid_.foundInterfacialModel
<blendedWallLubricationModel>(interface)
)
{
forceFields_.insert
(
wallLubricationModel::typeName,
new volVectorField
(
wallLubricationModel::typeName,
new volVectorField
IOobject
(
IOobject
IOobject::groupName
(
IOobject::groupName
(
"wallLubricationForce",
phase_.name()
),
mesh_.time().timeName(),
mesh_
"wallLubricationForce",
phase_.name()
),
mesh_,
dimensionedVector(dimForce/dimVolume, Zero)
)
);
}
mesh_.time().timeName(),
mesh_
),
mesh_,
dimensionedVector(dimForce/dimVolume, Zero)
)
);
}
if (fluid_.foundBlendedSubModel<turbulentDispersionModel>(pair))
{
forceFields_.insert
if
(
fluid_.foundInterfacialModel
<blendedTurbulentDispersionModel>(interface)
)
{
forceFields_.insert
(
turbulentDispersionModel::typeName,
new volVectorField
(
turbulentDispersionModel::typeName,
new volVectorField
IOobject
(
IOobject
IOobject::groupName
(
IOobject::groupName
(
"turbulentDispersionForce",
phase_.name()
),
mesh_.time().timeName(),
mesh_
"turbulentDispersionForce",
phase_.name()
),
mesh_,
dimensionedVector(dimForce/dimVolume, Zero)
)
);
}
mesh_.time().timeName(),
mesh_
),
mesh_,
dimensionedVector(dimForce/dimVolume, Zero)
)
);
}
}
}
@ -238,53 +221,62 @@ bool Foam::functionObjects::phaseForces::execute()
}
// Add the forces from all the interfaces which contain this phase
forAllConstIter
(
phaseSystem::phasePairTable,
fluid_.phasePairs(),
pairIter
)
forAll(fluid_.phases(), phasei)
{
const phasePair& pair = pairIter();
const phaseModel& otherPhase = fluid_.phases()[phasei];
if (pair.contains(phase_) && !pair.ordered())
if (&otherPhase == &phase_) continue;
const phaseInterface interface(phase_, otherPhase);
if (fluid_.foundInterfacialModel<blendedDragModel>(interface))
{
if (fluid_.foundBlendedSubModel<dragModel>(pair))
{
*forceFields_[dragModel::typeName] +=
fluid_.lookupBlendedSubModel<dragModel>(pair).K()
*(pair.otherPhase(phase_).U() - phase_.U());
}
*forceFields_[dragModel::typeName] +=
fluid_.lookupInterfacialModel<blendedDragModel>(interface).K()
*(otherPhase.U() - phase_.U());
}
if (fluid_.foundBlendedSubModel<virtualMassModel>(pair))
{
*forceFields_[virtualMassModel::typeName] +=
fluid_.lookupBlendedSubModel<virtualMassModel>(pair).K()
*(pair.otherPhase(phase_).DUDt() - phase_.DUDt());
}
if (fluid_.foundInterfacialModel<blendedVirtualMassModel>(interface))
{
*forceFields_[virtualMassModel::typeName] +=
fluid_.lookupInterfacialModel
<blendedVirtualMassModel>(interface).K()
*(otherPhase.DUDt() - phase_.DUDt());
}
if (fluid_.foundBlendedSubModel<liftModel>(pair))
{
*forceFields_[liftModel::typeName] +=
nonDragForce<liftModel>(pair);
}
if (fluid_.foundInterfacialModel<blendedLiftModel>(interface))
{
*forceFields_[liftModel::typeName] +=
(&interface.phase1() == &phase_ ? -1 : +1)
*fluid_.lookupInterfacialModel<blendedLiftModel>(interface).F();
}
if (fluid_.foundBlendedSubModel<wallLubricationModel>(pair))
{
*forceFields_[wallLubricationModel::typeName] +=
nonDragForce<wallLubricationModel>(pair);
}
if
(
fluid_.foundInterfacialModel
<blendedWallLubricationModel>(interface)
)
{
*forceFields_[wallLubricationModel::typeName] +=
(&interface.phase1() == &phase_ ? -1 : +1)
*fluid_.lookupInterfacialModel
<blendedWallLubricationModel>(interface).F();
}
if (fluid_.foundBlendedSubModel<turbulentDispersionModel>(pair))
{
*forceFields_[turbulentDispersionModel::typeName] +=
fluid_.lookupBlendedSubModel<turbulentDispersionModel>
(
pair
).D()
*(&pair.phase1() == &phase_ ? -1 : +1)
*fvc::grad(pair.phase1()/(pair.phase1() + pair.phase2()));
}
if
(
fluid_.foundInterfacialModel
<blendedTurbulentDispersionModel>(interface)
)
{
*forceFields_[turbulentDispersionModel::typeName] +=
fluid_.lookupInterfacialModel
<blendedTurbulentDispersionModel>(interface).D()
*fvc::grad
(
otherPhase
/max(phase_ + otherPhase, otherPhase.residualAlpha())
);
}
}

12
applications/solvers/multiphase/multiphaseEulerFoam/functionObjects/phaseForces/phaseForces.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2018-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2018-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -31,7 +31,7 @@ Description
and in combination with the multiphaseEulerFoam solver.
For a simulation involving more than two phases, the accumulated force is
calculated by looping over all phasePairs involving that phase. The fields
calculated by looping over all interfaces involving that phase. The fields
are stored in the database so that they can be processed further, e.g. with
the fieldAveraging functionObject.
@ -89,6 +89,7 @@ protected:
// Protected data
//- Force fields
HashPtrTable<volVectorField> forceFields_;
//- Phase for which forces are evaluated
@ -98,13 +99,6 @@ protected:
const phaseSystem& fluid_;
// Protected Member Functions
//- Evaluate and return non-drag force
template<class modelType>
tmp<volVectorField> nonDragForce(const phasePair& key) const;
public:
//- Runtime type information

22
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/diffusiveMassTransferModels/Frossling/Frossling.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "Frossling.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -49,10 +48,18 @@ namespace diffusiveMassTransferModels
Foam::diffusiveMassTransferModels::Frossling::Frossling
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
diffusiveMassTransferModel(dict, pair),
diffusiveMassTransferModel(dict, interface),
interface_
(
interface.modelCast
<
diffusiveMassTransferModel,
dispersedPhaseInterface
>()
),
Le_("Le", dimless, dict)
{}
@ -68,9 +75,12 @@ Foam::diffusiveMassTransferModels::Frossling::~Frossling()
Foam::tmp<Foam::volScalarField>
Foam::diffusiveMassTransferModels::Frossling::K() const
{
volScalarField Sh(2 + 0.552*sqrt(pair_.Re())*cbrt(Le_*pair_.Pr()));
const volScalarField Sh
(
2 + 0.552*sqrt(interface_.Re())*cbrt(Le_*interface_.Pr())
);
return 6*pair_.dispersed()*Sh/sqr(pair_.dispersed().d());
return 6*interface_.dispersed()*Sh/sqr(interface_.dispersed().d());
}

11
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/diffusiveMassTransferModels/Frossling/Frossling.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,8 +43,6 @@ SourceFiles
namespace Foam
{
class phasePair;
namespace diffusiveMassTransferModels
{
@ -58,6 +56,9 @@ class Frossling
{
// Private Data
//- Interface
const dispersedPhaseInterface interface_;
//- Lewis number
const dimensionedScalar Le_;
@ -70,11 +71,11 @@ public:
// Constructors
//- Construct from components
//- Construct from a dictionary and an interface
Frossling
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

24
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/diffusiveMassTransferModels/diffusiveMassTransferModel/diffusiveMassTransferModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,8 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "diffusiveMassTransferModel.H"
#include "phasePair.H"
#include "BlendedInterfacialModel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -37,6 +35,11 @@ namespace Foam
diffusiveMassTransferModel,
0
);
defineSidedInterfacialModelTypeNameAndDebug
(
blendedDiffusiveMassTransferModel,
0
);
defineRunTimeSelectionTable(diffusiveMassTransferModel, dictionary);
}
@ -48,10 +51,8 @@ const Foam::dimensionSet Foam::diffusiveMassTransferModel::dimK(0, -2, 0, 0, 0);
Foam::diffusiveMassTransferModel::diffusiveMassTransferModel
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
pair_(pair)
{}
@ -61,4 +62,15 @@ Foam::diffusiveMassTransferModel::~diffusiveMassTransferModel()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::blendedDiffusiveMassTransferModel::K() const
{
tmp<volScalarField> (diffusiveMassTransferModel::*k)() const =
&diffusiveMassTransferModel::K;
return evaluate(k, "K", diffusiveMassTransferModel::dimK, false);
}
// ************************************************************************* //

91
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/diffusiveMassTransferModels/diffusiveMassTransferModel/diffusiveMassTransferModel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,6 +25,7 @@ Class
Foam::diffusiveMassTransferModel
Description
Model for diffusive mass transfer coefficients between two phases
SourceFiles
diffusiveMassTransferModel.C
@ -39,11 +40,13 @@ SourceFiles
#include "volFields.H"
#include "dictionary.H"
#include "runTimeSelectionTables.H"
#include "BlendedInterfacialModel.H"
#include "SidedInterfacialModel.H"
namespace Foam
{
class phasePair;
class phaseSystem;
/*---------------------------------------------------------------------------*\
Class diffusiveMassTransferModel Declaration
@ -51,14 +54,6 @@ class phasePair;
class diffusiveMassTransferModel
{
protected:
// Protected data
//- Phase pair
const phasePair& pair_;
public:
//- Runtime type information
@ -74,9 +69,9 @@ public:
dictionary,
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
),
(dict, pair)
(dict, interface)
);
@ -85,14 +80,17 @@ public:
//- Coefficient dimensions
static const dimensionSet dimK;
//- Does this model require correcting on fixed flux boundaries?
static const bool correctFixedFluxBCs = false;
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
diffusiveMassTransferModel
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);
@ -105,7 +103,7 @@ public:
static autoPtr<diffusiveMassTransferModel> New
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);
@ -117,6 +115,69 @@ public:
};
/*---------------------------------------------------------------------------*\
Class blendedDiffusiveMassTransferModel Declaration
\*---------------------------------------------------------------------------*/
class blendedDiffusiveMassTransferModel
:
public BlendedInterfacialModel<diffusiveMassTransferModel>
{
public:
// Constructors
//- Inherit base class constructors
using
BlendedInterfacialModel<diffusiveMassTransferModel>::
BlendedInterfacialModel;
// Selectors
static autoPtr<blendedDiffusiveMassTransferModel> New
(
const dictionary& dict,
const phaseInterface& interface
);
// Member Functions
//- Return the heatTransfer coefficient K
tmp<volScalarField> K() const;
};
/*---------------------------------------------------------------------------*\
Class sidedBlendedDiffusiveMassTransferModel Declaration
\*---------------------------------------------------------------------------*/
class sidedBlendedDiffusiveMassTransferModel
:
public SidedInterfacialModel<blendedDiffusiveMassTransferModel>
{
public:
// Constructors
//- Inherit base class constructors
using
SidedInterfacialModel<blendedDiffusiveMassTransferModel>::
SidedInterfacialModel;
// Selectors
static autoPtr<sidedBlendedDiffusiveMassTransferModel> New
(
const dictionary& dict,
const phaseInterface& interface
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

42
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/diffusiveMassTransferModels/diffusiveMassTransferModel/diffusiveMassTransferModelNew.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "diffusiveMassTransferModel.H"
#include "phasePair.H"
// * * * * * * * * * * * * * * * * Selector * * * * * * * * * * * * * * * * //
@ -32,13 +31,16 @@ Foam::autoPtr<Foam::diffusiveMassTransferModel>
Foam::diffusiveMassTransferModel::New
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
{
word diffusiveMassTransferModelType(dict.lookup("type"));
const dictionary& modelDict =
interface.fluid().modelSubDict<diffusiveMassTransferModel>(dict);
const word diffusiveMassTransferModelType(modelDict.lookup("type"));
Info<< "Selecting diffusiveMassTransferModel for "
<< pair << ": " << diffusiveMassTransferModelType << endl;
<< interface.name() << ": " << diffusiveMassTransferModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(diffusiveMassTransferModelType);
@ -53,7 +55,35 @@ Foam::diffusiveMassTransferModel::New
<< exit(FatalError);
}
return cstrIter()(dict, pair);
return cstrIter()(modelDict, interface);
}
Foam::autoPtr<Foam::blendedDiffusiveMassTransferModel>
Foam::blendedDiffusiveMassTransferModel::New
(
const dictionary& dict,
const phaseInterface& interface
)
{
return autoPtr<blendedDiffusiveMassTransferModel>
(
new blendedDiffusiveMassTransferModel(dict, interface)
);
}
Foam::autoPtr<Foam::sidedBlendedDiffusiveMassTransferModel>
Foam::sidedBlendedDiffusiveMassTransferModel::New
(
const dictionary& dict,
const phaseInterface& interface
)
{
return autoPtr<sidedBlendedDiffusiveMassTransferModel>
(
new sidedBlendedDiffusiveMassTransferModel(dict, interface)
);
}

17
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/diffusiveMassTransferModels/sphericalDiffusiveMassTransfer/sphericalDiffusiveMassTransfer.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "sphericalDiffusiveMassTransfer.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -50,10 +49,18 @@ Foam::diffusiveMassTransferModels::sphericalDiffusiveMassTransfer::
sphericalDiffusiveMassTransfer
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
diffusiveMassTransferModel(dict, pair),
diffusiveMassTransferModel(dict, interface),
interface_
(
interface.modelCast
<
diffusiveMassTransferModel,
dispersedPhaseInterface
>()
),
Le_("Le", dimless, dict)
{}
@ -70,7 +77,7 @@ Foam::diffusiveMassTransferModels::sphericalDiffusiveMassTransfer::
Foam::tmp<Foam::volScalarField>
Foam::diffusiveMassTransferModels::sphericalDiffusiveMassTransfer::K() const
{
return 60*pair_.dispersed()/sqr(pair_.dispersed().d());
return 60*interface_.dispersed()/sqr(interface_.dispersed().d());
}

12
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/diffusiveMassTransferModels/sphericalDiffusiveMassTransfer/sphericalDiffusiveMassTransfer.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -42,9 +42,6 @@ SourceFiles
namespace Foam
{
class phasePair;
namespace diffusiveMassTransferModels
{
@ -58,6 +55,9 @@ class sphericalDiffusiveMassTransfer
{
// Private Data
//- Interface
const dispersedPhaseInterface interface_;
//- Lewis number
const dimensionedScalar Le_;
@ -70,11 +70,11 @@ public:
// Constructors
//- Construct from components
//- Construct from a dictionary and an interface
sphericalDiffusiveMassTransfer
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

19
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/interfaceCompositionModels/Henry/Henry.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "Henry.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,20 +43,20 @@ namespace interfaceCompositionModels
Foam::interfaceCompositionModels::Henry::Henry
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
interfaceCompositionModel(dict, pair),
interfaceCompositionModel(dict, interface),
k_(dict.lookup("k")),
YSolvent_
(
IOobject
(
IOobject::groupName("YSolvent", pair.name()),
pair.phase1().mesh().time().timeName(),
pair.phase1().mesh()
IOobject::groupName("YSolvent", this->interface().name()),
interface.mesh().time().timeName(),
interface.mesh()
),
pair.phase1().mesh(),
interface.mesh(),
dimensionedScalar(dimless, 1)
)
{
@ -120,8 +119,8 @@ Foam::tmp<Foam::volScalarField> Foam::interfaceCompositionModels::Henry::YfPrime
{
return volScalarField::New
(
IOobject::groupName("YfPrime", pair().name()),
pair().phase1().mesh(),
IOobject::groupName("YfPrime", interface().name()),
interface().mesh(),
dimensionedScalar(dimless/dimTemperature, 0)
);
}

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/interfaceCompositionModels/Henry/Henry.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -46,9 +46,6 @@ SourceFiles
namespace Foam
{
class phasePair;
namespace interfaceCompositionModels
{
@ -74,13 +71,14 @@ public:
//- Runtime type information
TypeName("Henry");
// Constructors
//- Construct from components
//- Construct from a dictionary and an interface
Henry
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

25
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/interfaceCompositionModels/Raoult/Raoult.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "Raoult.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,30 +43,30 @@ namespace interfaceCompositionModels
Foam::interfaceCompositionModels::Raoult::Raoult
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
interfaceCompositionModel(dict, pair),
interfaceCompositionModel(dict, interface),
YNonVapour_
(
IOobject
(
IOobject::groupName("YNonVapour", pair.name()),
pair.phase1().mesh().time().timeName(),
pair.phase1().mesh()
IOobject::groupName("YNonVapour", this->interface().name()),
interface.mesh().time().timeName(),
interface.mesh()
),
pair.phase1().mesh(),
interface.mesh(),
dimensionedScalar(dimless, 1)
),
YNonVapourPrime_
(
IOobject
(
IOobject::groupName("YNonVapourPrime", pair.name()),
pair.phase1().mesh().time().timeName(),
pair.phase1().mesh()
IOobject::groupName("YNonVapourPrime", this->interface().name()),
interface.mesh().time().timeName(),
interface.mesh()
),
pair.phase1().mesh(),
interface.mesh(),
dimensionedScalar(dimless/dimTemperature, 0)
)
{
@ -81,7 +80,7 @@ Foam::interfaceCompositionModels::Raoult::Raoult
interfaceCompositionModel::New
(
dict.subDict(*iter),
pair
interface
)
)
);

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/interfaceCompositionModels/Raoult/Raoult.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,9 +43,6 @@ SourceFiles
namespace Foam
{
class phasePair;
namespace interfaceCompositionModels
{
@ -74,13 +71,14 @@ public:
//- Runtime type information
TypeName("Raoult");
// Constructors
//- Construct from components
//- Construct from a dictionary and an interface
Raoult
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

44
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/interfaceCompositionModels/interfaceCompositionModel/interfaceCompositionModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,7 +25,6 @@ License
#include "interfaceCompositionModel.H"
#include "phaseModel.H"
#include "phasePair.H"
#include "phaseSystem.H"
#include "rhoReactionThermo.H"
@ -34,6 +33,7 @@ License
namespace Foam
{
defineTypeNameAndDebug(interfaceCompositionModel, 0);
defineSidedInterfacialModelTypeNameAndDebug(interfaceCompositionModel, 0);
defineRunTimeSelectionTable(interfaceCompositionModel, dictionary);
}
@ -43,41 +43,17 @@ namespace Foam
Foam::interfaceCompositionModel::interfaceCompositionModel
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
pair_(pair),
interface_
(
interface.modelCast<interfaceCompositionModel, sidedPhaseInterface>()
),
species_(dict.lookup("species")),
Le_("Le", dimless, dict),
phase_
(
// !!! This is a hack, to let the models know which side of the
// interface it applies to. In general, we are going to need improve
// the phase-pair system to take into account model sidedness and other
// types of asymmetry from just dispersed/continuous.
pair.phase1().name() == IOobject::group(dict.dictName())
? pair.phase1()
: pair.phase2()
),
otherPhase_(pair.otherPhase(phase_)),
thermo_
(
phase_.mesh().lookupObject<rhoReactionThermo>
(
IOobject::groupName(physicalProperties::typeName, phase_.name())
)
),
otherThermo_
(
otherPhase_.mesh().lookupObject<rhoThermo>
(
IOobject::groupName
(
physicalProperties::typeName,
otherPhase_.name()
)
)
)
thermo_(refCast<const rhoReactionThermo>(interface_.phase().thermo())),
otherThermo_(interface_.otherPhase().thermo())
{}
@ -122,7 +98,7 @@ Foam::tmp<Foam::volScalarField> Foam::interfaceCompositionModel::D
return volScalarField::New
(
IOobject::groupName("D", pair_.name()),
IOobject::groupName("D" + speciesName, interface_.name()),
composition().kappa(speciei, p, T)
/composition().Cp(speciei, p, T)
/composition().rho(speciei, p, T)

60
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/interfaceCompositionModels/interfaceCompositionModel/interfaceCompositionModel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -44,13 +44,12 @@ SourceFiles
#include "hashedWordList.H"
#include "rhoReactionThermo.H"
#include "runTimeSelectionTables.H"
#include "sidedPhaseInterface.H"
#include "SidedInterfacialModel.H"
namespace Foam
{
class phaseModel;
class phasePair;
/*---------------------------------------------------------------------------*\
Class interfaceCompositionModel Declaration
\*---------------------------------------------------------------------------*/
@ -59,8 +58,8 @@ class interfaceCompositionModel
{
// Private data
//- Phase pair
const phasePair& pair_;
//- Interface
const sidedPhaseInterface interface_;
//- Names of the transferring species
const hashedWordList species_;
@ -68,12 +67,6 @@ class interfaceCompositionModel
//- Lewis number
const dimensionedScalar Le_;
//- Phase
const phaseModel& phase_;
//- Other phase
const phaseModel& otherPhase_;
//- Multi-component thermo model for this side of the interface
const rhoReactionThermo& thermo_;
@ -96,19 +89,19 @@ public:
dictionary,
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
),
(dict, pair)
(dict, interface)
);
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
interfaceCompositionModel
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);
@ -121,7 +114,8 @@ public:
static autoPtr<interfaceCompositionModel> New
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface,
const bool outer=true
);
@ -129,8 +123,8 @@ public:
// Access
//- Return the phase pair
inline const phasePair& pair() const;
//- Return the interface
inline const sidedPhaseInterface& interface() const;
//- Return the transferring species names
inline const hashedWordList& species() const;
@ -194,6 +188,34 @@ public:
};
/*---------------------------------------------------------------------------*\
Class sidedInterfaceCompositionModel Declaration
\*---------------------------------------------------------------------------*/
class sidedInterfaceCompositionModel
:
public SidedInterfacialModel<interfaceCompositionModel>
{
public:
// Constructors
//- Inherit base class constructors
using
SidedInterfacialModel<interfaceCompositionModel>::
SidedInterfacialModel;
// Selectors
static autoPtr<sidedInterfaceCompositionModel> New
(
const dictionary& dict,
const phaseInterface& interface
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

9
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/interfaceCompositionModels/interfaceCompositionModel/interfaceCompositionModelI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2019-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2019-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -23,11 +23,14 @@ License
\*---------------------------------------------------------------------------*/
#include "interfaceCompositionModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
const Foam::phasePair& Foam::interfaceCompositionModel::pair() const
const Foam::sidedPhaseInterface&
Foam::interfaceCompositionModel::interface() const
{
return pair_;
return interface_;
}

33
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/interfaceCompositionModels/interfaceCompositionModel/interfaceCompositionModelNew.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,8 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "interfaceCompositionModel.H"
#include "phasePair.H"
#include "rhoThermo.H"
#include "phaseSystem.H"
// * * * * * * * * * * * * * * * * Selector * * * * * * * * * * * * * * * * //
@ -33,13 +32,19 @@ Foam::autoPtr<Foam::interfaceCompositionModel>
Foam::interfaceCompositionModel::New
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface,
const bool outer
)
{
const word interfaceCompositionModelType = word(dict.lookup("type"));
const dictionary& modelDict =
outer
? interface.fluid().modelSubDict<interfaceCompositionModel>(dict)
: dict;
const word interfaceCompositionModelType(modelDict.lookup("type"));
Info<< "Selecting interfaceCompositionModel for "
<< pair << ": " << interfaceCompositionModelType << endl;
<< interface.name() << ": " << interfaceCompositionModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(interfaceCompositionModelType);
@ -54,7 +59,21 @@ Foam::interfaceCompositionModel::New
<< exit(FatalError);
}
return cstrIter()(dict, pair);
return cstrIter()(modelDict, interface);
}
Foam::autoPtr<Foam::sidedInterfaceCompositionModel>
Foam::sidedInterfaceCompositionModel::New
(
const dictionary& dict,
const phaseInterface& interface
)
{
return autoPtr<sidedInterfaceCompositionModel>
(
new sidedInterfaceCompositionModel(dict, interface)
);
}

35
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/interfaceCompositionModels/nonRandomTwoLiquid/nonRandomTwoLiquid.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "nonRandomTwoLiquid.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -49,30 +48,30 @@ namespace interfaceCompositionModels
Foam::interfaceCompositionModels::nonRandomTwoLiquid::nonRandomTwoLiquid
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
interfaceCompositionModel(dict, pair),
interfaceCompositionModel(dict, interface),
gamma1_
(
IOobject
(
IOobject::groupName("gamma1", pair.name()),
pair.phase1().mesh().time().timeName(),
pair.phase1().mesh()
IOobject::groupName("gamma1", this->interface().name()),
interface.mesh().time().timeName(),
interface.mesh()
),
pair.phase1().mesh(),
interface.mesh(),
dimensionedScalar(dimless, 1)
),
gamma2_
(
IOobject
(
IOobject::groupName("gamma2", pair.name()),
pair.phase1().mesh().time().timeName(),
pair.phase1().mesh()
IOobject::groupName("gamma2", this->interface().name()),
interface.mesh().time().timeName(),
interface.mesh()
),
pair.phase1().mesh(),
interface.mesh(),
dimensionedScalar(dimless, 1)
),
beta12_("", dimless/dimTemperature, 0),
@ -122,7 +121,8 @@ Foam::interfaceCompositionModels::nonRandomTwoLiquid::nonRandomTwoLiquid
saturationModel::New
(
dict.subDict(species1Name_).subDict("interaction"),
pair
interface,
false
).ptr()
);
saturationModel21_.reset
@ -130,7 +130,8 @@ Foam::interfaceCompositionModels::nonRandomTwoLiquid::nonRandomTwoLiquid
saturationModel::New
(
dict.subDict(species2Name_).subDict("interaction"),
pair
interface,
false
).ptr()
);
@ -139,7 +140,8 @@ Foam::interfaceCompositionModels::nonRandomTwoLiquid::nonRandomTwoLiquid
interfaceCompositionModel::New
(
dict.subDict(species1Name_),
pair
interface,
false
).ptr()
);
speciesModel2_.reset
@ -147,7 +149,8 @@ Foam::interfaceCompositionModels::nonRandomTwoLiquid::nonRandomTwoLiquid
interfaceCompositionModel::New
(
dict.subDict(species2Name_),
pair
interface,
false
).ptr()
);
}

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/interfaceCompositionModels/nonRandomTwoLiquid/nonRandomTwoLiquid.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -47,9 +47,6 @@ SourceFiles
namespace Foam
{
class phasePair;
namespace interfaceCompositionModels
{
@ -111,13 +108,14 @@ public:
//- Runtime type information
TypeName("nonRandomTwoLiquid");
// Constructors
//- Construct from components
//- Construct from a dictionary and an interface
nonRandomTwoLiquid
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/interfaceCompositionModels/saturated/saturated.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "saturated.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -65,10 +64,10 @@ Foam::interfaceCompositionModels::saturated::wRatioByP() const
Foam::interfaceCompositionModels::saturated::saturated
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
interfaceCompositionModel(dict, pair),
interfaceCompositionModel(dict, interface),
saturatedName_(species()[0]),
saturatedIndex_(composition().species()[saturatedName_]),
saturationModel_
@ -76,7 +75,8 @@ Foam::interfaceCompositionModels::saturated::saturated
saturationModel::New
(
dict.subDict("saturationPressure"),
pair
interface,
false
)
)
{

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/interfaceCompositionModels/saturated/saturated.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,9 +43,6 @@ SourceFiles
namespace Foam
{
class phasePair;
namespace interfaceCompositionModels
{
@ -83,13 +80,14 @@ public:
//- Runtime type information
TypeName("saturated");
// Constructors
//- Construct from components
//- Construct from a dictionary and an interface
saturated
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

6
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/Antoine/Antoine.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,10 +43,10 @@ namespace saturationModels
Foam::saturationModels::Antoine::Antoine
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
saturationModel(pair),
saturationModel(dict, interface),
A_("A", dimless, dict),
B_("B", dimTemperature, dict),
C_("C", dimTemperature, dict)

11
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/Antoine/Antoine.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -78,10 +78,15 @@ public:
//- Runtime type information
TypeName("Antoine");
// Constructors
//- Construct from a dictionary
Antoine(const dictionary& dict, const phasePair& pair);
//- Construct from a dictionary and an interface
Antoine
(
const dictionary& dict,
const phaseInterface& interface
);
//- Destructor

6
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/AntoineExtended/AntoineExtended.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -48,10 +48,10 @@ namespace saturationModels
Foam::saturationModels::AntoineExtended::AntoineExtended
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
Antoine(dict, pair),
Antoine(dict, interface),
D_("D", dimless, dict),
F_("F", dimless, dict),
E_("E", dimless/pow(dimTemperature, F_), dict)

11
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/AntoineExtended/AntoineExtended.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -78,10 +78,15 @@ public:
//- Runtime type information
TypeName("AntoineExtended");
// Constructors
//- Construct from a dictionary
AntoineExtended(const dictionary& dict, const phasePair& pair);
//- Construct from a dictionary and an interface
AntoineExtended
(
const dictionary& dict,
const phaseInterface& interface
);
//- Destructor

8
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/ArdenBuck/ArdenBuck.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -37,12 +37,14 @@ namespace saturationModels
}
}
static const Foam::dimensionedScalar zeroC("", Foam::dimTemperature, 273.15);
static const Foam::dimensionedScalar A("", Foam::dimPressure, 611.21);
static const Foam::dimensionedScalar B("", Foam::dimless, 18.678);
static const Foam::dimensionedScalar C("", Foam::dimTemperature, 234.5);
static const Foam::dimensionedScalar D("", Foam::dimTemperature, 257.14);
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
@ -60,10 +62,10 @@ Foam::saturationModels::ArdenBuck::xByTC
Foam::saturationModels::ArdenBuck::ArdenBuck
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
saturationModel(pair)
saturationModel(dict, interface)
{}

11
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/ArdenBuck/ArdenBuck.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -63,10 +63,15 @@ public:
//- Runtime type information
TypeName("ArdenBuck");
// Constructors
//- Construct from a dictionary
ArdenBuck(const dictionary& dict, const phasePair& pair);
//- Construct from a dictionary and an interface
ArdenBuck
(
const dictionary& dict,
const phaseInterface& interface
);
//- Destructor

6
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/constantSaturationConditions/constantSaturationConditions.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -49,10 +49,10 @@ Foam::saturationModels::constantSaturationConditions::
constantSaturationConditions
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
saturationModel(pair),
saturationModel(dict, interface),
pSat_("pSat", dimPressure, dict),
Tsat_("Tsat", dimTemperature, dict)
{}

7
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/constantSaturationConditions/constantSaturationConditions.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -68,13 +68,14 @@ public:
//- Runtime type information
TypeName("constant");
// Constructors
//- Construct from a dictionary
//- Construct from a dictionary and an interface
constantSaturationConditions
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

11
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/function1/function1.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2017-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,14 +43,11 @@ namespace saturationModels
Foam::saturationModels::function1::function1
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
saturationModel(pair),
function_
(
Function1<scalar>::New("function", dict)
)
saturationModel(dict, interface),
function_(Function1<scalar>::New("function", dict))
{}

11
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/function1/function1.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2017-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2017-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -104,10 +104,15 @@ public:
//- Runtime type information
TypeName("function1");
// Constructors
//- Construct from a dictionary
function1(const dictionary& dict, const phasePair& pair);
//- Construct from a dictionary and an interface
function1
(
const dictionary& dict,
const phaseInterface& interface
);
//- Destructor

6
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/polynomial/polynomial.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,10 +43,10 @@ namespace saturationModels
Foam::saturationModels::polynomial::polynomial
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
saturationModel(pair),
saturationModel(dict, interface),
C_(dict.lookup("C<8>"))
{}

11
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/polynomial/polynomial.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -74,10 +74,15 @@ public:
//- Runtime type information
TypeName("polynomial");
// Constructors
//- Construct from a dictionary
polynomial(const dictionary& dict, const phasePair& pair);
//- Construct from a dictionary and an interface
polynomial
(
const dictionary& dict,
const phaseInterface& interface
);
//- Destructor

33
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/saturationModel/saturationModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -36,17 +36,22 @@ namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::saturationModel::saturationModel(const phasePair& pair)
Foam::saturationModel::saturationModel
(
const dictionary& dict,
const phaseInterface& interface
)
:
IOdictionary
regIOobject
(
IOobject
(
IOobject::groupName("saturationModel", pair.name()),
pair.phase1().time().constant(),
pair.phase1().mesh()
IOobject::groupName("saturationModel", interface.name()),
interface.mesh().time().constant(),
interface.mesh()
)
)
),
interface_(interface)
{}
@ -56,4 +61,18 @@ Foam::saturationModel::~saturationModel()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const Foam::phaseInterface& Foam::saturationModel::interface() const
{
return interface_;
}
bool Foam::saturationModel::writeData(Ostream& os) const
{
return os.good();
}
// ************************************************************************* //

45
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/saturationModel/saturationModel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,6 +25,8 @@ Class
Foam::saturationModel
Description
Model to describe the dependence of saturation pressure on temperature, and
vice versa
SourceFiles
saturationModel.C
@ -35,11 +37,10 @@ SourceFiles
#ifndef saturationModel_H
#define saturationModel_H
#include "IOdictionary.H"
#include "volFields.H"
#include "dictionary.H"
#include "phaseInterface.H"
#include "runTimeSelectionTables.H"
#include "phasePair.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -52,8 +53,14 @@ namespace Foam
class saturationModel
:
public IOdictionary
public regIOobject
{
// Private Data
//- The interface
const phaseInterface interface_;
public:
//- Runtime type information
@ -67,28 +74,30 @@ public:
saturationModel,
dictionary,
(
const dictionary& dict, const phasePair& pair
const dictionary& dict,
const phaseInterface& interface
),
(dict, pair)
(dict, interface)
);
// Constructors
//- Construct null
saturationModel(const phasePair& pair);
//- Disallow default bitwise copy construction
saturationModel(const saturationModel&) = delete;
//- Construct from a dictionary and an interface
saturationModel
(
const dictionary& dict,
const phaseInterface& interface
);
// Selectors
//- Select null constructed
static autoPtr<saturationModel> New
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface,
const bool outer=true
);
@ -98,6 +107,9 @@ public:
// Member Functions
//- Access the interface
const phaseInterface& interface() const;
//- Saturation pressure
virtual tmp<volScalarField> pSat
(
@ -122,11 +134,8 @@ public:
const volScalarField& p
) const = 0;
// Member Operators
//- Disallow default bitwise assignment
void operator=(const saturationModel&) = delete;
//- Dummy write for regIOobject
bool writeData(Ostream& os) const;
};

17
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/saturationModels/saturationModel/saturationModelNew.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,19 +24,24 @@ License
\*---------------------------------------------------------------------------*/
#include "saturationModel.H"
#include "phaseSystem.H"
// * * * * * * * * * * * * * * * * Selector * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::saturationModel> Foam::saturationModel::New
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface,
const bool outer
)
{
word saturationModelType(dict.lookup("type"));
const dictionary& modelDict =
outer ? interface.fluid().modelSubDict<saturationModel>(dict) : dict;
Info<< "Selecting saturationModel: "
<< saturationModelType << endl;
const word saturationModelType(modelDict.lookup("type"));
Info<< "Selecting saturationModel for "
<< interface.name() << ": " << saturationModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(saturationModelType);
@ -51,7 +56,7 @@ Foam::autoPtr<Foam::saturationModel> Foam::saturationModel::New
<< exit(FatalError);
}
return cstrIter()(dict, pair);
return cstrIter()(modelDict, interface);
}

23
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/surfaceTensionModels/constantSurfaceTensionCoefficient/constantSurfaceTensionCoefficient.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "constantSurfaceTensionCoefficient.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -50,11 +49,10 @@ Foam::surfaceTensionModels::constantSurfaceTensionCoefficient::
constantSurfaceTensionCoefficient
(
const dictionary& dict,
const phasePair& pair,
const bool registerObject
const phaseInterface& interface
)
:
surfaceTensionModel(dict, pair, registerObject),
surfaceTensionModel(dict, interface),
sigma_("sigma", dimSigma, dict)
{}
@ -71,27 +69,28 @@ Foam::surfaceTensionModels::constantSurfaceTensionCoefficient::
Foam::tmp<Foam::volScalarField>
Foam::surfaceTensionModels::constantSurfaceTensionCoefficient::sigma() const
{
const fvMesh& mesh(this->pair_.phase1().mesh());
return volScalarField::New
(
"sigma",
mesh,
interface_.mesh(),
sigma_
);
}
Foam::tmp<Foam::scalarField>
Foam::surfaceTensionModels::constantSurfaceTensionCoefficient::sigma
(
label patchi
const label patchi
) const
{
const fvMesh& mesh(this->pair_.phase1().mesh());
return tmp<scalarField>
(
new scalarField(mesh.boundary()[patchi].size(), sigma_.value())
new scalarField
(
interface_.mesh().boundary()[patchi].size(),
sigma_.value()
)
);
}

9
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/surfaceTensionModels/constantSurfaceTensionCoefficient/constantSurfaceTensionCoefficient.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -66,12 +66,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
constantSurfaceTensionCoefficient
(
const dictionary& dict,
const phasePair& pair,
const bool registerObject
const phaseInterface& interface
);
@ -85,7 +84,7 @@ public:
virtual tmp<volScalarField> sigma() const;
//- Surface tension for a patch
virtual tmp<scalarField> sigma(label patchi) const;
virtual tmp<scalarField> sigma(const label patchi) const;
};

28
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/surfaceTensionModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "surfaceTensionModel.H"
#include "phasePair.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -42,23 +41,10 @@ const Foam::dimensionSet Foam::surfaceTensionModel::dimSigma(1, 0, -2, 0, 0);
Foam::surfaceTensionModel::surfaceTensionModel
(
const dictionary& dict,
const phasePair& pair,
const bool registerObject
const phaseInterface& interface
)
:
regIOobject
(
IOobject
(
IOobject::groupName(typeName, pair.name()),
pair.phase1().mesh().time().timeName(),
pair.phase1().mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE,
registerObject
)
),
pair_(pair)
interface_(interface)
{}
@ -68,12 +54,4 @@ Foam::surfaceTensionModel::~surfaceTensionModel()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool Foam::surfaceTensionModel::writeData(Ostream& os) const
{
return os.good();
}
// ************************************************************************* //

29
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/surfaceTensionModel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -40,26 +40,23 @@ SourceFiles
#include "volFields.H"
#include "dictionary.H"
#include "runTimeSelectionTables.H"
#include "phaseInterface.H"
namespace Foam
{
class phasePair;
/*---------------------------------------------------------------------------*\
Class surfaceTensionModel Declaration
\*---------------------------------------------------------------------------*/
class surfaceTensionModel
:
public regIOobject
{
protected:
// Protected data
//- Phase pair
const phasePair& pair_;
//- Interface
const phaseInterface interface_;
public:
@ -76,10 +73,9 @@ public:
dictionary,
(
const dictionary& dict,
const phasePair& pair,
const bool registerObject
const phaseInterface& interface
),
(dict, pair, registerObject)
(dict, interface)
);
@ -91,12 +87,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
surfaceTensionModel
(
const dictionary& dict,
const phasePair& pair,
const bool registerObject
const phaseInterface& interface
);
@ -109,7 +104,8 @@ public:
static autoPtr<surfaceTensionModel> New
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface,
const bool outer=true
);
@ -119,10 +115,7 @@ public:
virtual tmp<volScalarField> sigma() const = 0;
//- Surface tension for a patch
virtual tmp<scalarField> sigma(label patchi) const = 0;
//- Dummy write for regIOobject
bool writeData(Ostream& os) const;
virtual tmp<scalarField> sigma(const label patchi) const = 0;
};

18
applications/solvers/multiphase/multiphaseEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/surfaceTensionModelNew.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "surfaceTensionModel.H"
#include "phasePair.H"
#include "phaseSystem.H"
// * * * * * * * * * * * * * * * * Selector * * * * * * * * * * * * * * * * //
@ -32,13 +32,19 @@ Foam::autoPtr<Foam::surfaceTensionModel >
Foam::surfaceTensionModel::New
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface,
const bool outer
)
{
word surfaceTensionModelType(dict.lookup("type"));
const dictionary& modelDict =
outer
? interface.fluid().modelSubDict<surfaceTensionModel>(dict)
: dict;
const word surfaceTensionModelType(modelDict.lookup("type"));
Info<< "Selecting surfaceTensionModel for "
<< pair << ": " << surfaceTensionModelType << endl;
<< interface.name() << ": " << surfaceTensionModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(surfaceTensionModelType);
@ -53,7 +59,7 @@ Foam::surfaceTensionModel::New
<< exit(FatalError);
}
return cstrIter()(dict, pair, true);
return cstrIter()(modelDict, interface);
}

5
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/Make/files
View File

@ -1,5 +1,6 @@
dragModels/dragModel/dragModel.C
dragModels/dragModel/dragModelNew.C
dragModels/dispersedDragModel/dispersedDragModel.C
dragModels/Beetstra/Beetstra.C
dragModels/segregated/segregated.C
dragModels/Ergun/Ergun.C
@ -26,6 +27,7 @@ swarmCorrections/TomiyamaSwarm/TomiyamaSwarm.C
liftModels/liftModel/liftModel.C
liftModels/liftModel/liftModelNew.C
liftModels/dispersedLiftModel/dispersedLiftModel.C
liftModels/noLift/noLift.C
liftModels/constantLiftCoefficient/constantLiftCoefficient.C
liftModels/Moraga/Moraga.C
@ -43,12 +45,14 @@ heatTransferModels/timeScaleFilteredHeatTransfer/timeScaleFilteredHeatTransfer.C
virtualMassModels/virtualMassModel/virtualMassModel.C
virtualMassModels/virtualMassModel/virtualMassModelNew.C
virtualMassModels/dispersedVirtualMassModel/dispersedVirtualMassModel.C
virtualMassModels/noVirtualMass/noVirtualMass.C
virtualMassModels/constantVirtualMassCoefficient/constantVirtualMassCoefficient.C
virtualMassModels/Lamb/Lamb.C
wallLubricationModels/wallLubricationModel/wallLubricationModel.C
wallLubricationModels/wallLubricationModel/wallLubricationModelNew.C
wallLubricationModels/dispersedWallLubricationModel/dispersedWallLubricationModel.C
wallLubricationModels/noWallLubrication/noWallLubrication.C
wallLubricationModels/Antal/Antal.C
wallLubricationModels/Frank/Frank.C
@ -56,6 +60,7 @@ wallLubricationModels/TomiyamaWallLubrication/TomiyamaWallLubrication.C
turbulentDispersionModels/turbulentDispersionModel/turbulentDispersionModel.C
turbulentDispersionModels/turbulentDispersionModel/turbulentDispersionModelNew.C
turbulentDispersionModels/dispersedTurbulentDispersionModel/dispersedTurbulentDispersionModel.C
turbulentDispersionModels/noTurbulentDispersion/noTurbulentDispersion.C
turbulentDispersionModels/constantTurbulentDispersionCoefficient/constantTurbulentDispersionCoefficient.C
turbulentDispersionModels/Burns/Burns.C

11
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/aspectRatioModels/TomiyamaAspectRatio/TomiyamaAspectRatio.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "TomiyamaAspectRatio.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -49,11 +48,11 @@ namespace aspectRatioModels
Foam::aspectRatioModels::TomiyamaAspectRatio::TomiyamaAspectRatio
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
VakhrushevEfremov(dict, pair),
wallDependentModel(pair.phase1().mesh())
VakhrushevEfremov(dict, interface),
wallDependentModel(interface_.mesh())
{}
@ -70,7 +69,7 @@ Foam::aspectRatioModels::TomiyamaAspectRatio::E() const
{
return
VakhrushevEfremov::E()
*max(1 - 0.35*yWall()/pair_.dispersed().d(), scalar(0.65));
*max(1 - 0.35*yWall()/interface_.dispersed().d(), scalar(0.65));
}

6
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/aspectRatioModels/TomiyamaAspectRatio/TomiyamaAspectRatio.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -70,11 +70,11 @@ public:
// Constructors
//- Construct from a dictionary and an ordered phase pair
//- Construct from a dictionary and an interface
TomiyamaAspectRatio
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

9
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/aspectRatioModels/VakhrushevEfremov/VakhrushevEfremov.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "VakhrushevEfremov.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -49,10 +48,10 @@ namespace aspectRatioModels
Foam::aspectRatioModels::VakhrushevEfremov::VakhrushevEfremov
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
aspectRatioModel(dict, pair)
aspectRatioModel(dict, interface)
{}
@ -67,7 +66,7 @@ Foam::aspectRatioModels::VakhrushevEfremov::~VakhrushevEfremov()
Foam::tmp<Foam::volScalarField>
Foam::aspectRatioModels::VakhrushevEfremov::E() const
{
const volScalarField Ta(pair_.Ta());
const volScalarField Ta(interface_.Ta());
return
neg(Ta - 1)

6
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/aspectRatioModels/VakhrushevEfremov/VakhrushevEfremov.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -68,11 +68,11 @@ public:
// Constructors
//- Construct from a dictionary and an ordered phase pair
//- Construct from a dictionary and an interface
VakhrushevEfremov
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

9
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/aspectRatioModels/Wellek/Wellek.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "Wellek.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -49,10 +48,10 @@ namespace aspectRatioModels
Foam::aspectRatioModels::Wellek::Wellek
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
aspectRatioModel(dict, pair)
aspectRatioModel(dict, interface)
{}
@ -67,7 +66,7 @@ Foam::aspectRatioModels::Wellek::~Wellek()
Foam::tmp<Foam::volScalarField>
Foam::aspectRatioModels::Wellek::E() const
{
return scalar(1)/(1 + 0.163*pow(pair_.Eo(), 0.757));
return scalar(1)/(1 + 0.163*pow(interface_.Eo(), 0.757));
}

6
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/aspectRatioModels/Wellek/Wellek.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -74,11 +74,11 @@ public:
// Constructors
//- Construct from a dictionary and an ordered phase pair
//- Construct from a dictionary and an interface
Wellek
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

7
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/aspectRatioModels/aspectRatioModel/aspectRatioModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "aspectRatioModel.H"
#include "phasePair.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -40,10 +39,10 @@ namespace Foam
Foam::aspectRatioModel::aspectRatioModel
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
pair_(pair)
interface_(interface.modelCast<aspectRatioModel, dispersedPhaseInterface>())
{}

22
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/aspectRatioModels/aspectRatioModel/aspectRatioModel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,6 +25,9 @@ Class
Foam::aspectRatioModel
Description
Model for deviations in the shape of the dispersed phase from spherical.
Just a sub-model modifier, typically for the drag model. Not a proper part
of the diameter/shape modelling in the phase models.
SourceFiles
aspectRatioModel.C
@ -40,12 +43,11 @@ SourceFiles
#include "volFields.H"
#include "dictionary.H"
#include "runTimeSelectionTables.H"
#include "dispersedPhaseInterface.H"
namespace Foam
{
class phasePair;
/*---------------------------------------------------------------------------*\
Class aspectRatioModel Declaration
\*---------------------------------------------------------------------------*/
@ -56,8 +58,8 @@ protected:
// Protected data
//- Phase pair
const phasePair& pair_;
//- Interface
const dispersedPhaseInterface interface_;
public:
@ -74,19 +76,19 @@ public:
dictionary,
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
),
(dict, pair)
(dict, interface)
);
// Constructors
//- Construct from a dictionary and an ordered phase pair
//- Construct from a dictionary and an interface
aspectRatioModel
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);
@ -99,7 +101,7 @@ public:
static autoPtr<aspectRatioModel> New
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

12
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/aspectRatioModels/aspectRatioModel/aspectRatioModelNew.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "aspectRatioModel.H"
#include "phasePair.H"
#include "phaseSystem.H"
// * * * * * * * * * * * * * * * * Selector * * * * * * * * * * * * * * * * //
@ -32,13 +32,13 @@ Foam::autoPtr<Foam::aspectRatioModel>
Foam::aspectRatioModel::New
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
{
word aspectRatioModelType(dict.lookup("type"));
const word aspectRatioModelType(dict.lookup("type"));
Info<< "Selecting aspectRatioModel for "
<< pair << ": " << aspectRatioModelType << endl;
<< interface.name() << ": " << aspectRatioModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(aspectRatioModelType);
@ -53,7 +53,7 @@ Foam::aspectRatioModel::New
<< exit(FatalError);
}
return cstrIter()(dict, pair);
return cstrIter()(dict, interface);
}

11
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/aspectRatioModels/constantAspectRatio/constantAspectRatio.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "constantAspectRatio.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -49,10 +48,10 @@ namespace aspectRatioModels
Foam::aspectRatioModels::constantAspectRatio::constantAspectRatio
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
aspectRatioModel(dict, pair),
aspectRatioModel(dict, interface),
E0_("E0", dimless, dict)
{}
@ -68,12 +67,10 @@ Foam::aspectRatioModels::constantAspectRatio::~constantAspectRatio()
Foam::tmp<Foam::volScalarField>
Foam::aspectRatioModels::constantAspectRatio::E() const
{
const fvMesh& mesh(this->pair_.phase1().mesh());
return volScalarField::New
(
aspectRatioModel::typeName + ":E",
mesh,
interface_.mesh(),
E0_
);
}

6
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/aspectRatioModels/constantAspectRatio/constantAspectRatio.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -66,11 +66,11 @@ public:
// Constructors
//- Construct from a dictionary and an ordered phase pair
//- Construct from a dictionary and an interface
constantAspectRatio
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

53
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/AttouFerschneider/AttouFerschneider.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2018-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2018-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "AttouFerschneider.H"
#include "phasePair.H"
#include "phaseSystem.H"
#include "addToRunTimeSelectionTable.H"
@ -107,11 +106,12 @@ Foam::dragModels::AttouFerschneider::KLiquidSolid
Foam::dragModels::AttouFerschneider::AttouFerschneider
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject),
dragModel(dict, interface, registerObject),
interface_(interface),
gasName_(dict.lookup("gas")),
liquidName_(dict.lookup("liquid")),
solidName_(dict.lookup("solid")),
@ -128,48 +128,29 @@ Foam::dragModels::AttouFerschneider::~AttouFerschneider()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::dragModels::AttouFerschneider::CdRe() const
{
FatalErrorInFunction
<< "Not implemented."
<< "Drag coefficient is not defined for the AttouFerschneider model."
<< exit(FatalError);
return tmp<volScalarField>(nullptr);
}
Foam::tmp<Foam::volScalarField>
Foam::dragModels::AttouFerschneider::K() const
{
switch (Pair<word>::compare(pair_, phasePairKey(gasName_, liquidName_)))
{
case 1:
return KGasLiquid(pair_.phase1(), pair_.phase2());
case -1:
return KGasLiquid(pair_.phase2(), pair_.phase1());
}
const phaseModel& gas = interface_.fluid().phases()[gasName_];
const phaseModel& liquid = interface_.fluid().phases()[liquidName_];
const phaseModel& solid = interface_.fluid().phases()[solidName_];
switch (Pair<word>::compare(pair_, phasePairKey(gasName_, solidName_)))
if (interface_.contains(gas) && interface_.contains(liquid))
{
case 1:
return KGasSolid(pair_.phase1(), pair_.phase2());
case -1:
return KGasSolid(pair_.phase2(), pair_.phase1());
return KGasLiquid(gas, liquid);
}
switch (Pair<word>::compare(pair_, phasePairKey(liquidName_, solidName_)))
if (interface_.contains(gas) && interface_.contains(solid))
{
case 1:
return KLiquidSolid(pair_.phase1(), pair_.phase2());
case -1:
return KLiquidSolid(pair_.phase2(), pair_.phase1());
return KGasSolid(gas, solid);
}
if (interface_.contains(liquid) && interface_.contains(solid))
{
return KLiquidSolid(liquid, solid);
}
FatalErrorInFunction
<< "The pair does not contain two of out of the gas, liquid and solid "
<< "phase models."
<< "The interface " << interface_.name() << " does not contain two "
<< "out of the gas, liquid and solid phase models."
<< exit(FatalError);
return tmp<volScalarField>(nullptr);

15
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/AttouFerschneider/AttouFerschneider.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2018-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2018-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -51,9 +51,6 @@ SourceFiles
namespace Foam
{
class phaseModel;
namespace dragModels
{
@ -67,6 +64,9 @@ class AttouFerschneider
{
// Private Data
//- Interface
const phaseInterface interface_;
//- Name of the gaseous phase
const word gasName_;
@ -115,11 +115,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
AttouFerschneider
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);
@ -130,9 +130,6 @@ public:
// Member Functions
//- Drag coefficient
virtual tmp<volScalarField> CdRe() const;
//- The drag coefficient used in the momentum equation
virtual tmp<volScalarField> K() const;

13
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/Beetstra/Beetstra.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2016-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "Beetstra.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,11 +43,11 @@ namespace dragModels
Foam::dragModels::Beetstra::Beetstra
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject),
dispersedDragModel(dict, interface, registerObject),
residualRe_("residualRe", dimless, dict.lookup("residualRe"))
{}
@ -65,15 +64,15 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::Beetstra::CdRe() const
{
const volScalarField alpha1
(
max(pair_.dispersed(), pair_.continuous().residualAlpha())
max(interface_.dispersed(), interface_.continuous().residualAlpha())
);
const volScalarField alpha2
(
max(1 - pair_.dispersed(), pair_.continuous().residualAlpha())
max(1 - interface_.dispersed(), interface_.continuous().residualAlpha())
);
const volScalarField Res(alpha2*pair_.Re());
const volScalarField Res(alpha2*interface_.Re());
const volScalarField ResLim
(

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/Beetstra/Beetstra.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2016-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -45,7 +45,7 @@ SourceFiles
#ifndef Beetstra_H
#define Beetstra_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -60,7 +60,7 @@ namespace dragModels
class Beetstra
:
public dragModel
public dispersedDragModel
{
// Private Data
@ -76,11 +76,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
Beetstra
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

16
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/Ergun/Ergun.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "Ergun.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,11 +43,11 @@ namespace dragModels
Foam::dragModels::Ergun::Ergun
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject)
dispersedDragModel(dict, interface, registerObject)
{}
@ -62,14 +61,17 @@ Foam::dragModels::Ergun::~Ergun()
Foam::tmp<Foam::volScalarField> Foam::dragModels::Ergun::CdRe() const
{
const phaseModel& dispersed = interface_.dispersed();
const phaseModel& continuous = interface_.continuous();
return
(4.0/3.0)
*(
150
*max(1 - pair_.continuous(), pair_.dispersed().residualAlpha())
/max(pair_.continuous(), pair_.continuous().residualAlpha())
*max(1 - continuous, dispersed.residualAlpha())
/max(continuous, continuous.residualAlpha())
+ 1.75
*pair_.Re()
*interface_.Re()
);
}

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/Ergun/Ergun.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -41,7 +41,7 @@ SourceFiles
#ifndef Ergun_H
#define Ergun_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -56,7 +56,7 @@ namespace dragModels
class Ergun
:
public dragModel
public dispersedDragModel
{
public:
@ -66,11 +66,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
Ergun
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

13
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/Gibilaro/Gibilaro.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "Gibilaro.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,11 +43,11 @@ namespace dragModels
Foam::dragModels::Gibilaro::Gibilaro
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject)
dispersedDragModel(dict, interface, registerObject)
{}
@ -64,13 +63,13 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::Gibilaro::CdRe() const
{
const volScalarField alpha2
(
max(1 - pair_.dispersed(), pair_.continuous().residualAlpha())
max(1 - interface_.dispersed(), interface_.continuous().residualAlpha())
);
return
(4.0/3.0)
*(17.3/alpha2 + 0.336*pair_.Re())
*max(pair_.continuous(), pair_.continuous().residualAlpha())
*(17.3/alpha2 + 0.336*interface_.Re())
*max(interface_.continuous(), interface_.continuous().residualAlpha())
*pow(alpha2, -2.8);
}

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/Gibilaro/Gibilaro.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -42,7 +42,7 @@ SourceFiles
#ifndef Gibilaro_H
#define Gibilaro_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -57,7 +57,7 @@ namespace dragModels
class Gibilaro
:
public dragModel
public dispersedDragModel
{
public:
@ -67,11 +67,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
Gibilaro
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

31
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/GidaspowErgunWenYu/GidaspowErgunWenYu.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "GidaspowErgunWenYu.H"
#include "phasePair.H"
#include "Ergun.H"
#include "WenYu.H"
#include "addToRunTimeSelectionTable.H"
@ -46,29 +45,13 @@ namespace dragModels
Foam::dragModels::GidaspowErgunWenYu::GidaspowErgunWenYu
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject),
Ergun_
(
new Ergun
(
dict,
pair,
false
)
),
WenYu_
(
new WenYu
(
dict,
pair,
false
)
)
dispersedDragModel(dict, interface, registerObject),
Ergun_(dict, interface, false),
WenYu_(dict, interface, false)
{}
@ -84,8 +67,8 @@ Foam::tmp<Foam::volScalarField>
Foam::dragModels::GidaspowErgunWenYu::CdRe() const
{
return
pos0(pair_.continuous() - 0.8)*WenYu_->CdRe()
+ neg(pair_.continuous() - 0.8)*Ergun_->CdRe();
pos0(interface_.continuous() - 0.8)*WenYu_.CdRe()
+ neg(interface_.continuous() - 0.8)*Ergun_.CdRe();
}

21
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/GidaspowErgunWenYu/GidaspowErgunWenYu.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,7 +43,9 @@ SourceFiles
#ifndef GidaspowErgunWenYu_H
#define GidaspowErgunWenYu_H
#include "dragModel.H"
#include "dispersedDragModel.H"
#include "Ergun.H"
#include "WenYu.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -52,24 +54,21 @@ namespace Foam
namespace dragModels
{
class Ergun;
class WenYu;
/*---------------------------------------------------------------------------*\
Class GidaspowErgunWenYu Declaration
\*---------------------------------------------------------------------------*/
class GidaspowErgunWenYu
:
public dragModel
public dispersedDragModel
{
// Private Data
//- Ergun drag model
autoPtr<Ergun> Ergun_;
Ergun Ergun_;
//- Wen Yu drag model
autoPtr<WenYu> WenYu_;
WenYu WenYu_;
public:
@ -80,11 +79,11 @@ public:
// Constructors
//- Construct from a dictionary and an ordered phase pair
//- Construct from a dictionary and an interface
GidaspowErgunWenYu
(
const dictionary& interfaceDict,
const phasePair& pair,
const dictionary& dict,
const phaseInterface& interface,
const bool registerObject
);

13
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/GidaspowSchillerNaumann/GidaspowSchillerNaumann.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "GidaspowSchillerNaumann.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,11 +43,11 @@ namespace dragModels
Foam::dragModels::GidaspowSchillerNaumann::GidaspowSchillerNaumann
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject),
dispersedDragModel(dict, interface, registerObject),
residualRe_("residualRe", dimless, dict)
{}
@ -66,10 +65,10 @@ Foam::dragModels::GidaspowSchillerNaumann::CdRe() const
{
const volScalarField alpha2
(
max(1 - pair_.dispersed(), pair_.continuous().residualAlpha())
max(1 - interface_.dispersed(), interface_.continuous().residualAlpha())
);
const volScalarField Re(alpha2*pair_.Re());
const volScalarField Re(alpha2*interface_.Re());
const volScalarField CdsRe
(
@ -80,7 +79,7 @@ Foam::dragModels::GidaspowSchillerNaumann::CdRe() const
return
CdsRe
*pow(alpha2, -2.65)
*max(pair_.continuous(), pair_.continuous().residualAlpha());
*max(interface_.continuous(), interface_.continuous().residualAlpha());
}

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/GidaspowSchillerNaumann/GidaspowSchillerNaumann.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -48,7 +48,7 @@ SourceFiles
#ifndef GidaspowSchillerNaumann_H
#define GidaspowSchillerNaumann_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -63,7 +63,7 @@ namespace dragModels
class GidaspowSchillerNaumann
:
public dragModel
public dispersedDragModel
{
// Private Data
@ -79,11 +79,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
GidaspowSchillerNaumann
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

21
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/IshiiZuber/IshiiZuber.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "IshiiZuber.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,11 +43,11 @@ namespace dragModels
Foam::dragModels::IshiiZuber::IshiiZuber
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject)
dispersedDragModel(dict, interface, registerObject)
{}
@ -63,17 +62,17 @@ Foam::dragModels::IshiiZuber::~IshiiZuber()
Foam::tmp<Foam::volScalarField>
Foam::dragModels::IshiiZuber::CdRe() const
{
const volScalarField Re(pair_.Re());
const volScalarField Eo(pair_.Eo());
const volScalarField Re(interface_.Re());
const volScalarField Eo(interface_.Eo());
const volScalarField mud(pair_.dispersed().thermo().mu());
const volScalarField muc(pair_.continuous().thermo().mu());
const volScalarField mud(interface_.dispersed().thermo().mu());
const volScalarField muc(interface_.continuous().thermo().mu());
const volScalarField muStar((mud + 0.4*muc)/(mud + muc));
const volScalarField muMix
(
muc*pow(max(1 - pair_.dispersed(), scalar(1e-3)), -2.5*muStar)
muc*pow(max(1 - interface_.dispersed(), scalar(1e-3)), -2.5*muStar)
);
const volScalarField ReM(Re*muc/muMix);
@ -83,7 +82,7 @@ Foam::dragModels::IshiiZuber::CdRe() const
+ neg(1000 - ReM)*0.44*ReM
);
volScalarField F((muc/muMix)*sqrt(1 - pair_.dispersed()));
volScalarField F((muc/muMix)*sqrt(1 - interface_.dispersed()));
F.max(1e-3);
const volScalarField Ealpha((1 + 17.67*pow(F, 0.8571428))/(18.67*F));
@ -92,7 +91,7 @@ Foam::dragModels::IshiiZuber::CdRe() const
return
pos0(CdReEllipse - CdRe)
*min(CdReEllipse, Re*sqr(1 - pair_.dispersed())*2.66667)
*min(CdReEllipse, Re*sqr(1 - interface_.dispersed())*2.66667)
+ neg(CdReEllipse - CdRe)*CdRe;
}

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/IshiiZuber/IshiiZuber.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,7 +43,7 @@ SourceFiles
#ifndef IshiiZuber_H
#define IshiiZuber_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -58,7 +58,7 @@ namespace dragModels
class IshiiZuber
:
public dragModel
public dispersedDragModel
{
public:
@ -69,11 +69,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
IshiiZuber
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

9
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/Lain/Lain.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "Lain.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,11 +43,11 @@ namespace dragModels
Foam::dragModels::Lain::Lain
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject)
dispersedDragModel(dict, interface, registerObject)
{}
@ -62,7 +61,7 @@ Foam::dragModels::Lain::~Lain()
Foam::tmp<Foam::volScalarField> Foam::dragModels::Lain::CdRe() const
{
volScalarField Re(pair_.Re());
volScalarField Re(interface_.Re());
return
neg(Re - 1.5)*16.0

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/Lain/Lain.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -50,7 +50,7 @@ SourceFiles
#ifndef Lain_H
#define Lain_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -65,7 +65,7 @@ namespace dragModels
class Lain
:
public dragModel
public dispersedDragModel
{
public:
@ -75,11 +75,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
Lain
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

9
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/SchillerNaumann/SchillerNaumann.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "SchillerNaumann.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,11 +43,11 @@ namespace dragModels
Foam::dragModels::SchillerNaumann::SchillerNaumann
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject),
dispersedDragModel(dict, interface, registerObject),
residualRe_("residualRe", dimless, dict)
{}
@ -63,7 +62,7 @@ Foam::dragModels::SchillerNaumann::~SchillerNaumann()
Foam::tmp<Foam::volScalarField> Foam::dragModels::SchillerNaumann::CdRe() const
{
volScalarField Re(pair_.Re());
volScalarField Re(interface_.Re());
return
neg(Re - 1000)*24*(1.0 + 0.15*pow(Re, 0.687))

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/SchillerNaumann/SchillerNaumann.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -35,7 +35,7 @@ SourceFiles
#ifndef SchillerNaumann_H
#define SchillerNaumann_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -50,7 +50,7 @@ namespace dragModels
class SchillerNaumann
:
public dragModel
public dispersedDragModel
{
// Private Data
@ -66,11 +66,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
SchillerNaumann
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

13
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/SyamlalOBrien/SyamlalOBrien.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "SyamlalOBrien.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,11 +43,11 @@ namespace dragModels
Foam::dragModels::SyamlalOBrien::SyamlalOBrien
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject)
dispersedDragModel(dict, interface, registerObject)
{}
@ -64,7 +63,7 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::SyamlalOBrien::CdRe() const
{
const volScalarField alpha2
(
max(1 - pair_.dispersed(), pair_.continuous().residualAlpha())
max(1 - interface_.dispersed(), interface_.continuous().residualAlpha())
);
const volScalarField A(pow(alpha2, 4.14));
@ -73,7 +72,7 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::SyamlalOBrien::CdRe() const
neg(alpha2 - 0.85)*(0.8*pow(alpha2, 1.28))
+ pos0(alpha2 - 0.85)*(pow(alpha2, 2.65))
);
const volScalarField Re(pair_.Re());
const volScalarField Re(interface_.Re());
const volScalarField Vr
(
0.5
@ -85,7 +84,7 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::SyamlalOBrien::CdRe() const
return
CdsRe
*max(pair_.continuous(), pair_.continuous().residualAlpha())
*max(interface_.continuous(), interface_.continuous().residualAlpha())
/sqr(Vr);
}

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/SyamlalOBrien/SyamlalOBrien.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -42,7 +42,7 @@ SourceFiles
#ifndef SyamlalOBrien_H
#define SyamlalOBrien_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -57,7 +57,7 @@ namespace dragModels
class SyamlalOBrien
:
public dragModel
public dispersedDragModel
{
public:
@ -67,11 +67,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
SyamlalOBrien
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

13
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/Tenneti/Tenneti.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2016-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "Tenneti.H"
#include "phasePair.H"
#include "SchillerNaumann.H"
#include "addToRunTimeSelectionTable.H"
@ -45,11 +44,11 @@ namespace dragModels
Foam::dragModels::Tenneti::Tenneti
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject),
dispersedDragModel(dict, interface, registerObject),
residualRe_("residualRe", dimless, dict.lookup("residualRe"))
{}
@ -66,15 +65,15 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::Tenneti::CdRe() const
{
const volScalarField alpha1
(
max(pair_.dispersed(), pair_.continuous().residualAlpha())
max(interface_.dispersed(), interface_.continuous().residualAlpha())
);
const volScalarField alpha2
(
max(1 - pair_.dispersed(), pair_.continuous().residualAlpha())
max(1 - interface_.dispersed(), interface_.continuous().residualAlpha())
);
const volScalarField Res(alpha2*pair_.Re());
const volScalarField Res(alpha2*interface_.Re());
const volScalarField CdReIsolated
(

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/Tenneti/Tenneti.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2016-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -45,7 +45,7 @@ SourceFiles
#ifndef Tenneti_H
#define Tenneti_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -62,7 +62,7 @@ class SchillerNaumann;
class Tenneti
:
public dragModel
public dispersedDragModel
{
// Private Data
@ -78,11 +78,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
Tenneti
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

13
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/TomiyamaAnalytic/TomiyamaAnalytic.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "TomiyamaAnalytic.H"
#include "phasePair.H"
#include "aspectRatioModel.H"
#include "addToRunTimeSelectionTable.H"
@ -45,15 +44,15 @@ namespace dragModels
Foam::dragModels::TomiyamaAnalytic::TomiyamaAnalytic
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject),
dispersedDragModel(dict, interface, registerObject),
residualRe_("residualRe", dimless, dict),
residualEo_("residualEo", dimless, dict),
residualE_("residualE", dimless, dict),
aspectRatio_(aspectRatioModel::New(dict.subDict("aspectRatio"), pair))
aspectRatio_(aspectRatioModel::New(dict.subDict("aspectRatio"), interface))
{}
@ -68,7 +67,7 @@ Foam::dragModels::TomiyamaAnalytic::~TomiyamaAnalytic()
Foam::tmp<Foam::volScalarField>
Foam::dragModels::TomiyamaAnalytic::CdRe() const
{
const volScalarField Eo(max(pair_.Eo(), residualEo_));
const volScalarField Eo(max(interface_.Eo(), residualEo_));
const volScalarField E(max(aspectRatio_->E(), residualE_));
const volScalarField OmEsq(max(1 - sqr(E), sqr(residualE_)));
@ -84,7 +83,7 @@ Foam::dragModels::TomiyamaAnalytic::CdRe() const
+ 16*pow(E, 4.0/3.0)
)
/sqr(F)
*max(pair_.Re(), residualRe_);
*max(interface_.Re(), residualRe_);
}

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/TomiyamaAnalytic/TomiyamaAnalytic.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,7 +43,7 @@ SourceFiles
#ifndef TomiyamaAnalytic_H
#define TomiyamaAnalytic_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -61,7 +61,7 @@ namespace dragModels
class TomiyamaAnalytic
:
public dragModel
public dispersedDragModel
{
// Private Data
@ -86,11 +86,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
TomiyamaAnalytic
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

11
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/TomiyamaCorrelated/TomiyamaCorrelated.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "TomiyamaCorrelated.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,11 +43,11 @@ namespace dragModels
Foam::dragModels::TomiyamaCorrelated::TomiyamaCorrelated
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject),
dispersedDragModel(dict, interface, registerObject),
A_("A", dimless, dict)
{}
@ -64,8 +63,8 @@ Foam::dragModels::TomiyamaCorrelated::~TomiyamaCorrelated()
Foam::tmp<Foam::volScalarField>
Foam::dragModels::TomiyamaCorrelated::CdRe() const
{
const volScalarField Re(pair_.Re());
const volScalarField Eo(pair_.Eo());
const volScalarField Re(interface_.Re());
const volScalarField Eo(interface_.Eo());
return
max

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/TomiyamaCorrelated/TomiyamaCorrelated.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,7 +43,7 @@ SourceFiles
#ifndef TomiyamaCorrelated_H
#define TomiyamaCorrelated_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -58,7 +58,7 @@ namespace dragModels
class TomiyamaCorrelated
:
public dragModel
public dispersedDragModel
{
// Private Data
@ -74,11 +74,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
TomiyamaCorrelated
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

13
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/TomiyamaKataokaZunSakaguchi/TomiyamaKataokaZunSakaguchi.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "TomiyamaKataokaZunSakaguchi.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -49,11 +48,11 @@ namespace dragModels
Foam::dragModels::TomiyamaKataokaZunSakaguchi::TomiyamaKataokaZunSakaguchi
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject),
dispersedDragModel(dict, interface, registerObject),
residualRe_("residualRe", dimless, dict),
residualEo_("residualEo", dimless, dict)
{}
@ -70,8 +69,8 @@ Foam::dragModels::TomiyamaKataokaZunSakaguchi::~TomiyamaKataokaZunSakaguchi()
Foam::tmp<Foam::volScalarField>
Foam::dragModels::TomiyamaKataokaZunSakaguchi::CdRe() const
{
volScalarField Re(pair_.Re());
volScalarField Eo(max(pair_.Eo(), residualEo_));
volScalarField Re(interface_.Re());
volScalarField Eo(max(interface_.Eo(), residualEo_));
return
max
@ -79,7 +78,7 @@ Foam::dragModels::TomiyamaKataokaZunSakaguchi::CdRe() const
24*(1 + 0.15*pow(Re, 0.687))/max(Re, residualRe_),
8*Eo/(3*(Eo + 4.0))
)
*max(pair_.Re(), residualRe_);
*max(interface_.Re(), residualRe_);
}

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/TomiyamaKataokaZunSakaguchi/TomiyamaKataokaZunSakaguchi.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -44,7 +44,7 @@ SourceFiles
#ifndef TomiyamaKataokaZunSakaguchi_H
#define TomiyamaKataokaZunSakaguchi_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -59,7 +59,7 @@ namespace dragModels
class TomiyamaKataokaZunSakaguchi
:
public dragModel
public dispersedDragModel
{
// Private Data
@ -78,11 +78,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
TomiyamaKataokaZunSakaguchi
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

13
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/WenYu/WenYu.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "WenYu.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,11 +43,11 @@ namespace dragModels
Foam::dragModels::WenYu::WenYu
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject),
dispersedDragModel(dict, interface, registerObject),
residualRe_("residualRe", dimless, dict)
{}
@ -65,10 +64,10 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::WenYu::CdRe() const
{
const volScalarField alpha2
(
max(1 - pair_.dispersed(), pair_.continuous().residualAlpha())
max(1 - interface_.dispersed(), interface_.continuous().residualAlpha())
);
const volScalarField Res(alpha2*pair_.Re());
const volScalarField Res(alpha2*interface_.Re());
const volScalarField CdsRes
(
neg(Res - 1000)*24*(1.0 + 0.15*pow(Res, 0.687))
@ -78,7 +77,7 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::WenYu::CdRe() const
return
CdsRes
*pow(alpha2, -3.65)
*max(pair_.continuous(), pair_.continuous().residualAlpha());
*max(interface_.continuous(), interface_.continuous().residualAlpha());
}

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/WenYu/WenYu.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,7 +43,7 @@ SourceFiles
#ifndef WenYu_H
#define WenYu_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -58,7 +58,7 @@ namespace dragModels
class WenYu
:
public dragModel
public dispersedDragModel
{
// Private Data
@ -74,11 +74,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
WenYu
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

13
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/aerosolDrag/aerosolDrag.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2019-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2019-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "aerosolDrag.H"
#include "phasePair.H"
#include "swarmCorrection.H"
#include "addToRunTimeSelectionTable.H"
#include "constants.H"
@ -49,11 +48,11 @@ using Foam::constant::mathematical::pi;
Foam::dragModels::aerosolDrag::aerosolDrag
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject),
dispersedDragModel(dict, interface, registerObject),
A1_(dict.lookupOrDefault<scalar>("A1", 2.514)),
A2_(dict.lookupOrDefault<scalar>("A2", 0.8)),
A3_(dict.lookupOrDefault<scalar>("A3", 0.55)),
@ -71,9 +70,9 @@ Foam::dragModels::aerosolDrag::~aerosolDrag()
Foam::tmp<Foam::volScalarField> Foam::dragModels::aerosolDrag::CdRe() const
{
const volScalarField& T = pair_.continuous().thermo().T();
const volScalarField& p = pair_.continuous().thermo().p();
tmp<volScalarField> td(pair_.dispersed().d());
const volScalarField& T = interface_.continuous().thermo().T();
const volScalarField& p = interface_.continuous().thermo().p();
tmp<volScalarField> td(interface_.dispersed().d());
const volScalarField& d = td();
const volScalarField lambda(k*T/(sqrt(2.0)*pi*p*sqr(sigma_)));

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/aerosolDrag/aerosolDrag.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2019-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2019-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -70,7 +70,7 @@ SourceFiles
#ifndef aerosolDrag_H
#define aerosolDrag_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -85,7 +85,7 @@ namespace dragModels
class aerosolDrag
:
public dragModel
public dispersedDragModel
{
// Private Data
@ -110,11 +110,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
aerosolDrag
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

93
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/dispersedDragModel/dispersedDragModel.C Normal file
View File

@ -0,0 +1,93 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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.
OpenFOAM 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 OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "dispersedDragModel.H"
#include "phaseSystem.H"
#include "noSwarm.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::dragModels::dispersedDragModel::dispersedDragModel
(
const dictionary& dict,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, interface, registerObject),
interface_(interface.modelCast<dragModel, dispersedPhaseInterface>()),
swarmCorrection_
(
dict.found("swarmCorrection")
? swarmCorrection::New(dict.subDict("swarmCorrection"), interface).ptr()
: new swarmCorrections::noSwarm(dict, interface)
)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::dragModels::dispersedDragModel::~dispersedDragModel()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField> Foam::dragModels::dispersedDragModel::Ki() const
{
return
0.75
*CdRe()
*swarmCorrection_->Cs()
*interface_.continuous().rho()
*interface_.continuous().thermo().nu()
/sqr(interface_.dispersed().d());
}
Foam::tmp<Foam::volScalarField> Foam::dragModels::dispersedDragModel::K() const
{
return
max
(
interface_.dispersed(),
interface_.dispersed().residualAlpha()
)*Ki();
}
Foam::tmp<Foam::surfaceScalarField>
Foam::dragModels::dispersedDragModel::Kf() const
{
return
max
(
fvc::interpolate(interface_.dispersed()),
interface_.dispersed().residualAlpha()
)*fvc::interpolate(Ki());
}
// ************************************************************************* //

118
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/dispersedDragModel/dispersedDragModel.H Normal file
View File

@ -0,0 +1,118 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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.
OpenFOAM 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 OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::dispersedDragModel
Description
Model for drag between two phases where one phase can be considered
dispersed in the other and the drag therefore characterised by a drag
coefficient
SourceFiles
dispersedDragModel.C
\*---------------------------------------------------------------------------*/
#ifndef dispersedDragModel_H
#define dispersedDragModel_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "dragModel.H"
#include "dispersedPhaseInterface.H"
namespace Foam
{
namespace dragModels
{
/*---------------------------------------------------------------------------*\
Class dispersedDragModel Declaration
\*---------------------------------------------------------------------------*/
class dispersedDragModel
:
public dragModel
{
protected:
// Protected data
//- Interface
const dispersedPhaseInterface interface_;
//- Swarm correction
autoPtr<swarmCorrection> swarmCorrection_;
public:
// Constructors
// Construct from a dictionary and an interface
dispersedDragModel
(
const dictionary& dict,
const phaseInterface& interface,
const bool registerObject
);
//- Destructor
virtual ~dispersedDragModel();
// Member Functions
//- Drag coefficient
virtual tmp<volScalarField> CdRe() const = 0;
//- Return the phase-intensive drag coefficient Ki
// used in the momentum equations
// ddt(alpha1*rho1*U1) + ... = ... alphad*K*(U1-U2)
// ddt(alpha2*rho2*U2) + ... = ... alphad*K*(U2-U1)
virtual tmp<volScalarField> Ki() const;
//- Return the drag coefficient K
// used in the momentum equations
// ddt(alpha1*rho1*U1) + ... = ... K*(U1-U2)
// ddt(alpha2*rho2*U2) + ... = ... K*(U2-U1)
virtual tmp<volScalarField> K() const;
//- Return the drag coefficient Kf
// used in the face-momentum equations
virtual tmp<surfaceScalarField> Kf() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace dragModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

67
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/dragModel/dragModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,10 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "dragModel.H"
#include "phasePair.H"
#include "noSwarm.H"
#include "surfaceInterpolate.H"
#include "BlendedInterfacialModel.H"
#include "phaseSystem.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -46,7 +43,7 @@ const Foam::dimensionSet Foam::dragModel::dimK(1, -3, -1, 0, 0);
Foam::dragModel::dragModel
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
@ -54,24 +51,13 @@ Foam::dragModel::dragModel
(
IOobject
(
IOobject::groupName(typeName, pair.name()),
pair.phase1().mesh().time().timeName(),
pair.phase1().mesh(),
IOobject::groupName(typeName, interface.name()),
interface.mesh().time().timeName(),
interface.mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE,
registerObject
)
),
pair_(pair),
swarmCorrection_
(
dict.found("swarmCorrection")
? swarmCorrection::New
(
dict.subDict("swarmCorrection"),
pair
)
: autoPtr<swarmCorrection>(new swarmCorrections::noSwarm(dict, pair))
)
{}
@ -84,39 +70,22 @@ Foam::dragModel::~dragModel()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField> Foam::dragModel::Ki() const
{
return
0.75
*CdRe()
*swarmCorrection_->Cs()
*pair_.continuous().rho()
*pair_.continuous().thermo().nu()
/sqr(pair_.dispersed().d());
}
Foam::tmp<Foam::volScalarField> Foam::dragModel::K() const
{
return max(pair_.dispersed(), pair_.dispersed().residualAlpha())*Ki();
}
Foam::tmp<Foam::surfaceScalarField> Foam::dragModel::Kf() const
{
return
max
(
fvc::interpolate(pair_.dispersed()),
pair_.dispersed().residualAlpha()
)*fvc::interpolate(Ki());
}
bool Foam::dragModel::writeData(Ostream& os) const
{
return os.good();
}
Foam::tmp<Foam::volScalarField> Foam::blendedDragModel::K() const
{
return evaluate(&dragModel::K, "K", dragModel::dimK, false);
}
Foam::tmp<Foam::surfaceScalarField> Foam::blendedDragModel::Kf() const
{
return evaluate(&dragModel::Kf, "Kf", dragModel::dimK, false);
}
// ************************************************************************* //

79
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/dragModel/dragModel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,6 +25,7 @@ Class
Foam::dragModel
Description
Model for drag between phases
SourceFiles
dragModel.C
@ -40,11 +41,11 @@ SourceFiles
#include "volFields.H"
#include "dictionary.H"
#include "runTimeSelectionTables.H"
#include "BlendedInterfacialModel.H"
namespace Foam
{
class phasePair;
class swarmCorrection;
/*---------------------------------------------------------------------------*\
@ -55,17 +56,6 @@ class dragModel
:
public regIOobject
{
protected:
// Protected data
//- Phase pair
const phasePair& pair_;
//- Swarm correction
autoPtr<swarmCorrection> swarmCorrection_;
public:
//- Runtime type information
@ -81,10 +71,10 @@ public:
dictionary,
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
),
(dict, pair, registerObject)
(dict, interface, registerObject)
);
@ -93,14 +83,17 @@ public:
//- Coefficient dimensions
static const dimensionSet dimK;
//- Does this model require correcting on fixed flux boundaries?
static const bool correctFixedFluxBCs = true;
// Constructors
// Construct with residual constants
// Construct from a dictionary and an interface
dragModel
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);
@ -114,36 +107,64 @@ public:
static autoPtr<dragModel> New
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface,
const bool outer=true,
const bool registerObject=true
);
// Member Functions
//- Drag coefficient
virtual tmp<volScalarField> CdRe() const = 0;
//- Return the phase-intensive drag coefficient Ki
// used in the momentum equations
// ddt(alpha1*rho1*U1) + ... = ... alphad*K*(U1-U2)
// ddt(alpha2*rho2*U2) + ... = ... alphad*K*(U2-U1)
virtual tmp<volScalarField> Ki() const;
//- Return the drag coefficient K
// used in the momentum equations
// ddt(alpha1*rho1*U1) + ... = ... K*(U1-U2)
// ddt(alpha2*rho2*U2) + ... = ... K*(U2-U1)
virtual tmp<volScalarField> K() const;
virtual tmp<volScalarField> K() const = 0;
//- Return the drag coefficient Kf
// used in the face-momentum equations
virtual tmp<surfaceScalarField> Kf() const;
virtual tmp<surfaceScalarField> Kf() const = 0;
//- Dummy write for regIOobject
bool writeData(Ostream& os) const;
};
/*---------------------------------------------------------------------------*\
Class blendedDragModel Declaration
\*---------------------------------------------------------------------------*/
class blendedDragModel
:
public BlendedInterfacialModel<dragModel>
{
public:
// Constructors
//- Inherit base class constructors
using BlendedInterfacialModel<dragModel>::BlendedInterfacialModel;
// Selectors
static autoPtr<blendedDragModel> New
(
const dictionary& dict,
const phaseInterface& interface
);
// Member Functions
//- Return the drag coefficient K
tmp<volScalarField> K() const;
//- Return the drag coefficient Kf
tmp<surfaceScalarField> Kf() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

27
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/dragModel/dragModelNew.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,20 +24,25 @@ License
\*---------------------------------------------------------------------------*/
#include "dragModel.H"
#include "phasePair.H"
#include "phaseSystem.H"
// * * * * * * * * * * * * * * * * Selector * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::dragModel> Foam::dragModel::New
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface,
const bool outer,
const bool registerObject
)
{
word dragModelType(dict.lookup("type"));
const dictionary& modelDict =
outer ? interface.fluid().modelSubDict<dragModel>(dict) : dict;
const word dragModelType(modelDict.lookup("type"));
Info<< "Selecting dragModel for "
<< pair << ": " << dragModelType << endl;
<< interface.name() << ": " << dragModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(dragModelType);
@ -52,7 +57,17 @@ Foam::autoPtr<Foam::dragModel> Foam::dragModel::New
<< exit(FatalError);
}
return cstrIter()(dict, pair, true);
return cstrIter()(modelDict, interface, registerObject);
}
Foam::autoPtr<Foam::blendedDragModel> Foam::blendedDragModel::New
(
const dictionary& dict,
const phaseInterface& interface
)
{
return autoPtr<blendedDragModel>(new blendedDragModel(dict, interface));
}

42
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/segregated/segregated.C
View File

@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "segregated.H"
#include "phasePair.H"
#include "fvcGrad.H"
#include "surfaceInterpolate.H"
#include "zeroGradientFvPatchFields.H"
@ -47,11 +46,12 @@ namespace dragModels
Foam::dragModels::segregated::segregated
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict, pair, registerObject),
dragModel(dict, interface, registerObject),
interface_(interface.modelCast<dragModel, segregatedPhaseInterface>()),
m_("m", dimless, dict),
n_("n", dimless, dict)
{}
@ -65,29 +65,18 @@ Foam::dragModels::segregated::~segregated()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField> Foam::dragModels::segregated::CdRe() const
{
FatalErrorInFunction
<< "Not implemented."
<< "Drag coefficient not defined for the segregated model."
<< exit(FatalError);
return pair_.phase1();
}
Foam::tmp<Foam::volScalarField> Foam::dragModels::segregated::K() const
{
const fvMesh& mesh(pair_.phase1().mesh());
const fvMesh& mesh(interface_.phase1().mesh());
const volScalarField& alpha1(pair_.phase1());
const volScalarField& alpha2(pair_.phase2());
const volScalarField& alpha1(interface_.phase1());
const volScalarField& alpha2(interface_.phase2());
const volScalarField& rho1(pair_.phase1().rho());
const volScalarField& rho2(pair_.phase2().rho());
const volScalarField& rho1(interface_.phase1().rho());
const volScalarField& rho2(interface_.phase2().rho());
tmp<volScalarField> tnu1(pair_.phase1().thermo().nu());
tmp<volScalarField> tnu2(pair_.phase2().thermo().nu());
tmp<volScalarField> tnu1(interface_.phase1().thermo().nu());
tmp<volScalarField> tnu2(interface_.phase2().thermo().nu());
const volScalarField& nu1(tnu1());
const volScalarField& nu2(tnu2());
@ -109,7 +98,10 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::segregated::K() const
const dimensionedScalar residualAlpha
(
(pair_.phase1().residualAlpha() + pair_.phase2().residualAlpha())/2
(
interface_.phase1().residualAlpha()
+ interface_.phase2().residualAlpha()
)/2
);
const volScalarField I1(alpha1/max(alpha1 + alpha2, residualAlpha));
@ -127,12 +119,12 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::segregated::K() const
const volScalarField limitedAlpha1
(
max(alpha1, pair_.phase1().residualAlpha())
max(alpha1, interface_.phase1().residualAlpha())
);
const volScalarField limitedAlpha2
(
max(alpha2, pair_.phase2().residualAlpha())
max(alpha2, interface_.phase2().residualAlpha())
);
const volScalarField muAlphaI
@ -143,7 +135,7 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::segregated::K() const
const volScalarField ReI
(
pair_.rho()*pair_.magUr()
interface_.rho()*interface_.magUr()
/(magGradI*limitedAlpha1*limitedAlpha2*muI)
);

13
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/segregated/segregated.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2014-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,6 +43,7 @@ SourceFiles
#define segregated_H
#include "dragModel.H"
#include "segregatedPhaseInterface.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -61,6 +62,9 @@ class segregated
{
// Private Data
//- Interface
const segregatedPhaseInterface interface_;
//- M coefficient
const dimensionedScalar m_;
@ -76,11 +80,11 @@ public:
// Constructors
//- Construct from components
//- Construct from a dictionary and an interface
segregated
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);
@ -91,9 +95,6 @@ public:
// Member Functions
//- Drag coefficient
virtual tmp<volScalarField> CdRe() const;
//- The drag function used in the momentum equation
virtual tmp<volScalarField> K() const;

29
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/timeScaleFilteredDrag/timeScaleFilteredDrag.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2019-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2019-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "timeScaleFilteredDrag.H"
#include "phasePair.H"
#include "swarmCorrection.H"
#include "addToRunTimeSelectionTable.H"
@ -45,17 +44,25 @@ namespace dragModels
Foam::dragModels::timeScaleFilteredDrag::timeScaleFilteredDrag
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
)
:
dragModel(dict.subDict("dragModel"), pair, registerObject),
dispersedDragModel(dict.subDict("dragModel"), interface, registerObject),
dragModel_
(
dragModel::New(dict.subDict("dragModel"), pair)
dragModel::New(dict.subDict("dragModel"), interface, false, false)
),
minRelaxTime_("minRelaxTime", dimTime, dict)
{}
{
if (!isA<dispersedDragModel>(dragModel_()))
{
FatalErrorInFunction
<< "The sub-drag-model of a " << type()
<< " drag model must be for a dispersed configuration"
<< exit(FatalError);
}
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
@ -71,16 +78,16 @@ Foam::dragModels::timeScaleFilteredDrag::CdRe() const
{
const volScalarField limit
(
sqr(pair_.dispersed().d())
*pair_.dispersed().rho()
sqr(interface_.dispersed().d())
*interface_.dispersed().rho()
/0.75
/swarmCorrection_->Cs()
/pair_.continuous().rho()
/pair_.continuous().thermo().nu()
/interface_.continuous().rho()
/interface_.continuous().thermo().nu()
/minRelaxTime_
);
return min(dragModel_->CdRe(), limit);
return min(refCast<const dispersedDragModel>(dragModel_()).CdRe(), limit);
}

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/timeScaleFilteredDrag/timeScaleFilteredDrag.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2019-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2019-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -37,7 +37,7 @@ SourceFiles
#ifndef timeScaleFilteredDrag_H
#define timeScaleFilteredDrag_H
#include "dragModel.H"
#include "dispersedDragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -52,7 +52,7 @@ namespace dragModels
class timeScaleFilteredDrag
:
public dragModel
public dispersedDragModel
{
// Private Data
@ -71,11 +71,11 @@ public:
// Constructors
//- Construct from a dictionary and a phase pair
//- Construct from a dictionary and an interface
timeScaleFilteredDrag
(
const dictionary& dict,
const phasePair& pair,
const phaseInterface& interface,
const bool registerObject
);

23
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/heatTransferModels/Gunn/Gunn.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2019-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2019-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "Gunn.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,10 +43,14 @@ namespace heatTransferModels
Foam::heatTransferModels::Gunn::Gunn
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
heatTransferModel(dict, pair)
heatTransferModel(dict, interface),
interface_
(
interface.modelCast<heatTransferModel, dispersedPhaseInterface>()
)
{}
@ -64,7 +67,7 @@ Foam::heatTransferModels::Gunn::K(const scalar residualAlpha) const
{
const volScalarField alpha2
(
max(1 - pair_.dispersed(), pair_.continuous().residualAlpha())
max(1 - interface_.dispersed(), interface_.continuous().residualAlpha())
);
const volScalarField sqrAlpha2(sqr(alpha2));
@ -72,15 +75,15 @@ Foam::heatTransferModels::Gunn::K(const scalar residualAlpha) const
const volScalarField Nu
(
(7 - 10*alpha2 + 5*sqrAlpha2)
*(1 + 0.7*pow(pair_.Re(), 0.2)*cbrt(pair_.Pr()))
*(1 + 0.7*pow(interface_.Re(), 0.2)*cbrt(interface_.Pr()))
+ (1.33 - 2.4*alpha2 + 1.2*sqrAlpha2)
*pow(pair_.Re(), 0.7)*cbrt(pair_.Pr())
*pow(interface_.Re(), 0.7)*cbrt(interface_.Pr())
);
return
6*max(pair_.dispersed(), residualAlpha)
*pair_.continuous().thermo().kappa()
*Nu/sqr(pair_.dispersed().d());
6*max(interface_.dispersed(), residualAlpha)
*interface_.continuous().thermo().kappa()
*Nu/sqr(interface_.dispersed().d());
}

12
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/heatTransferModels/Gunn/Gunn.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2019-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2019-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -60,6 +60,12 @@ class Gunn
:
public heatTransferModel
{
// Private Data
//- Interface
const dispersedPhaseInterface interface_;
public:
//- Runtime type information
@ -68,11 +74,11 @@ public:
// Constructors
//- Construct from components
//- Construct from a dictionary and an interface
Gunn
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

19
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/heatTransferModels/RanzMarshall/RanzMarshall.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "RanzMarshall.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -44,10 +43,14 @@ namespace heatTransferModels
Foam::heatTransferModels::RanzMarshall::RanzMarshall
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
heatTransferModel(dict, pair)
heatTransferModel(dict, interface),
interface_
(
interface.modelCast<heatTransferModel, dispersedPhaseInterface>()
)
{}
@ -62,14 +65,14 @@ Foam::heatTransferModels::RanzMarshall::~RanzMarshall()
Foam::tmp<Foam::volScalarField>
Foam::heatTransferModels::RanzMarshall::K(const scalar residualAlpha) const
{
volScalarField Nu(2 + 0.6*sqrt(pair_.Re())*cbrt(pair_.Pr()));
volScalarField Nu(2 + 0.6*sqrt(interface_.Re())*cbrt(interface_.Pr()));
return
6
*max(pair_.dispersed(), residualAlpha)
*pair_.continuous().thermo().kappa()
*max(interface_.dispersed(), residualAlpha)
*interface_.continuous().thermo().kappa()
*Nu
/sqr(pair_.dispersed().d());
/sqr(interface_.dispersed().d());
}

12
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/heatTransferModels/RanzMarshall/RanzMarshall.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -53,6 +53,12 @@ class RanzMarshall
:
public heatTransferModel
{
// Private Data
//- Interface
const dispersedPhaseInterface interface_;
public:
//- Runtime type information
@ -61,11 +67,11 @@ public:
// Constructors
//- Construct from components
//- Construct from a dictionary and an interface
RanzMarshall
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

17
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/heatTransferModels/constantNu/constantNuHeatTransfer.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2019-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2019-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "constantNuHeatTransfer.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -49,10 +48,14 @@ namespace heatTransferModels
Foam::heatTransferModels::constantNuHeatTransfer::constantNuHeatTransfer
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
)
:
heatTransferModel(dict, pair),
heatTransferModel(dict, interface),
interface_
(
interface.modelCast<heatTransferModel, dispersedPhaseInterface>()
),
Nu_("Nu", dimless, dict)
{}
@ -73,10 +76,10 @@ Foam::heatTransferModels::constantNuHeatTransfer::K
{
return
6.0
*max(pair_.dispersed(), residualAlpha)
*pair_.continuous().thermo().kappa()
*max(interface_.dispersed(), residualAlpha)
*interface_.continuous().thermo().kappa()
*Nu_
/sqr(pair_.dispersed().d());
/sqr(interface_.dispersed().d());
}

10
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/heatTransferModels/constantNu/constantNuHeatTransfer.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2019-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2019-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -55,9 +55,13 @@ class constantNuHeatTransfer
{
// Private Data
//- Interface
const dispersedPhaseInterface interface_;
//- Nusselt number
dimensionedScalar Nu_;
public:
//- Runtime type information
@ -66,11 +70,11 @@ public:
// Constructors
//- Construct from components
//- Construct from a dictionary and an interface
constantNuHeatTransfer
(
const dictionary& dict,
const phasePair& pair
const phaseInterface& interface
);

Some files were not shown because too many files have changed in this diff Show More