research/OpenFOAM-2.4.x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' of github.com:OpenFOAM/OpenFOAM-2.3.x

Browse source
This commit is contained in:
mattijs 2014-04-01 15:06:35 +01:00
commit 4d6f4a3115
21 changed files with 1356 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/Make/files
View file

@ -5,6 +5,7 @@ dragModels/Ergun/Ergun.C
dragModels/Gibilaro/Gibilaro.C
dragModels/GidaspowErgunWenYu/GidaspowErgunWenYu.C
dragModels/GidaspowSchillerNaumann/GidaspowSchillerNaumann.C
dragModels/Lain/Lain.C
dragModels/SchillerNaumann/SchillerNaumann.C
dragModels/SyamlalOBrien/SyamlalOBrien.C
dragModels/TomiyamaCorrelated/TomiyamaCorrelated.C
@ -20,6 +21,8 @@ liftModels/liftModel/liftModel.C
liftModels/liftModel/newLiftModel.C
liftModels/noLift/noLift.C
liftModels/constantLiftCoefficient/constantLiftCoefficient.C
liftModels/Moraga/Moraga.C
liftModels/LegendreMagnaudet/LegendreMagnaudet.C
liftModels/TomiyamaLift/TomiyamaLift.C
heatTransferModels/heatTransferModel/heatTransferModel.C
@ -36,16 +39,19 @@ wallLubricationModels/wallLubricationModel/wallLubricationModel.C
wallLubricationModels/wallLubricationModel/newWallLubricationModel.C
wallLubricationModels/noWallLubrication/noWallLubrication.C
wallLubricationModels/Antal/Antal.C
wallLubricationModels/Frank/Frank.C
turbulentDispersionModels/turbulentDispersionModel/turbulentDispersionModel.C
turbulentDispersionModels/turbulentDispersionModel/newTurbulentDispersionModel.C
turbulentDispersionModels/noTurbulentDispersion/noTurbulentDispersion.C
turbulentDispersionModels/constantTurbulentDispersionCoefficient/constantTurbulentDispersionCoefficient.C
turbulentDispersionModels/Burns/Burns.C
turbulentDispersionModels/Gosman/Gosman.C
aspectRatioModels/aspectRatioModel/aspectRatioModel.C
aspectRatioModels/aspectRatioModel/newAspectRatioModel.C
aspectRatioModels/constantAspectRatio/constantAspectRatio.C
aspectRatioModels/VakhrushevEfremov/VakhrushevEfremov.C
aspectRatioModels/Wellek/Wellek.C
LIB = $(FOAM_LIBBIN)/libcompressibleEulerianInterfacialModels

74
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/Wellek/Wellek.C Normal file
View file

@ -0,0 +1,74 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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 "Wellek.H"
#include "orderedPhasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace aspectRatioModels
{
defineTypeNameAndDebug(Wellek, 0);
addToRunTimeSelectionTable
(
aspectRatioModel,
Wellek,
dictionary
);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::aspectRatioModels::Wellek::Wellek
(
const dictionary& dict,
const orderedPhasePair& pair
)
:
aspectRatioModel(dict, pair)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::aspectRatioModels::Wellek::~Wellek()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::aspectRatioModels::Wellek::E() const
{
return scalar(1)/(scalar(1) + 0.163*pow(pair_.Eo(), 0.757));
}
// ************************************************************************* //

107
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/Wellek/Wellek.H Normal file
View file

@ -0,0 +1,107 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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::aspectRatioModels::Wellek
Description
Aspect ratio model of Wellek et al.
References:
\verbatim
"Implementation and Comparison of Correlations for interfacial Forces
in a Gas-Liquid System within an Euler-Euler Framework"
M Otromke
PhD Thesis
April 2013
\endverbatim
\verbatim
"Shape of liquid drops moving in liquid media"
R M Wellek, A K Agrawal, A H P Skelland
International Journal of Multiphase Flow
Volume 12, Issue 5, Pages 854-862, September 1966
\endverbatim
SourceFiles
Wellek.C
\*---------------------------------------------------------------------------*/
#ifndef Wellek_H
#define Wellek_H
#include "aspectRatioModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace aspectRatioModels
{
/*---------------------------------------------------------------------------*\
Class Wellek Declaration
\*---------------------------------------------------------------------------*/
class Wellek
:
public aspectRatioModel
{
public:
//- Runtime type information
TypeName("Wellek");
// Constructors
//- Construct from a dictionary and an ordered phase pair
Wellek
(
const dictionary& dict,
const orderedPhasePair& pair
);
//- Destructor
virtual ~Wellek();
// Member Functions
//- Aspect ratio
virtual tmp<volScalarField> E() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace aspectRatioModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

75
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/Lain/Lain.C Normal file
View file

@ -0,0 +1,75 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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 "Lain.H"
#include "phasePair.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace dragModels
{
defineTypeNameAndDebug(Lain, 0);
addToRunTimeSelectionTable(dragModel, Lain, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::dragModels::Lain::Lain
(
const dictionary& dict,
const phasePair& pair,
const bool registerObject
)
:
dragModel(dict, pair, registerObject)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::dragModels::Lain::~Lain()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField> Foam::dragModels::Lain::CdRe() const
{
volScalarField Re(pair_.Re());
return
neg(Re - 1.5)*16.0
+ pos(Re - 1.5)*neg(Re - 80.0)*14.9*pow(Re, 0.22)
+ pos(Re - 80.0)*neg(Re - 1500.0)*48*(1.0 - 2.21/sqrt(max(Re, SMALL)))
+ pos(Re - 1500.0)*2.61*Re;
}
// ************************************************************************* //

112
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/Lain/Lain.H Normal file
View file

@ -0,0 +1,112 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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::dragModels::Lain
Description
Drag model of Lain et al.
References:
\verbatim
"Implementation and Comparison of Correlations for interfacial Forces
in a Gas-Liquid System within an Euler-Euler Framework"
M Otromke
PhD Thesis
April 2013
\endverbatim
\verbatim
"Modelling hydrodynamics and turbulence in a bubble column using the
Euler-Lagrange procedure"
S Lain, D Brodera, M Sommerfelda, M F Goza
International Journal of Multiphase Flow
Volume 28, Issue 8, Pages 1381-1407, August 2002
\endverbatim
SourceFiles
Lain.C
\*---------------------------------------------------------------------------*/
#ifndef Lain_H
#define Lain_H
#include "dragModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class phasePair;
namespace dragModels
{
/*---------------------------------------------------------------------------*\
Class Lain Declaration
\*---------------------------------------------------------------------------*/
class Lain
:
public dragModel
{
public:
//- Runtime type information
TypeName("Lain");
// Constructors
//- Construct from a dictionary and a phase pair
Lain
(
const dictionary& dict,
const phasePair& pair,
const bool registerObject
);
//- Destructor
virtual ~Lain();
// Member Functions
//- Drag coefficient
virtual tmp<volScalarField> CdRe() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace dragModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

98
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/liftModels/LegendreMagnaudet/LegendreMagnaudet.C Normal file
View file

@ -0,0 +1,98 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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 "LegendreMagnaudet.H"
#include "phasePair.H"
#include "fvc.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace liftModels
{
defineTypeNameAndDebug(LegendreMagnaudet, 0);
addToRunTimeSelectionTable(liftModel, LegendreMagnaudet, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::liftModels::LegendreMagnaudet::LegendreMagnaudet
(
const dictionary& dict,
const phasePair& pair
)
:
liftModel(dict, pair),
residualRe_("residualRe", dimless, dict.lookup("residualRe"))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::liftModels::LegendreMagnaudet::~LegendreMagnaudet()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField> Foam::liftModels::LegendreMagnaudet::Cl() const
{
volScalarField Re(max(pair_.Re(), residualRe_));
volScalarField Sr
(
sqr(pair_.dispersed().d())
/(
Re
*pair_.continuous().nu()
)
*mag(fvc::grad(pair_.continuous().U()))
);
volScalarField ClLowSqr
(
sqr(6.0*2.255)
*sqr(Sr)
/(
pow4(constant::mathematical::pi)
*Re
*pow3(Sr + 0.2*Re)
)
);
volScalarField ClHighSqr
(
sqr(0.5*(Re + 16.0)/(Re + 29.0))
);
return sqrt(ClLowSqr + ClHighSqr);
}
// ************************************************************************* //

118
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/liftModels/LegendreMagnaudet/LegendreMagnaudet.H Normal file
View file

@ -0,0 +1,118 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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::liftModels::LegendreMagnaudet
Description
Lift model of Legendre and Magnaudet.
References:
\verbatim
"Implementation and Comparison of Correlations for interfacial Forces
in a Gas-Liquid System within an Euler-Euler Framework"
M Otromke
PhD Thesis
April 2013
\endverbatim
\verbatim
"The lift force on a spherical bubble in a viscous linear shear flow"
D Legendre, J Magnaudet
Journal of Fluid Mechanics
Volume 368, pp 81-126, August 1998
\endverbatim
SourceFiles
LegendreMagnaudet.C
\*---------------------------------------------------------------------------*/
#ifndef LegendreMagnaudet_H
#define LegendreMagnaudet_H
#include "liftModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class phasePair;
namespace liftModels
{
/*---------------------------------------------------------------------------*\
Class LegendreMagnaudet Declaration
\*---------------------------------------------------------------------------*/
class LegendreMagnaudet
:
public liftModel
{
private:
// Private data
//- Residual Reynold's number
const dimensionedScalar residualRe_;
public:
//- Runtime type information
TypeName("LegendreMagnaudet");
// Constructors
//- Construct from a dictionary and a phase pair
LegendreMagnaudet
(
const dictionary& dict,
const phasePair& pair
);
//- Destructor
virtual ~LegendreMagnaudet();
// Member Functions
//- Lift coefficient
virtual tmp<volScalarField> Cl() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace liftModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

77
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/liftModels/Moraga/Moraga.C Normal file
View file

@ -0,0 +1,77 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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 "Moraga.H"
#include "phasePair.H"
#include "fvc.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace liftModels
{
defineTypeNameAndDebug(Moraga, 0);
addToRunTimeSelectionTable(liftModel, Moraga, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::liftModels::Moraga::Moraga
(
const dictionary& dict,
const phasePair& pair
)
:
liftModel(dict, pair)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::liftModels::Moraga::~Moraga()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField> Foam::liftModels::Moraga::Cl() const
{
volScalarField ReSqrSr
(
pair_.Re()
*sqr(pair_.dispersed().d())
/pair_.continuous().nu()
*mag(fvc::grad(pair_.continuous().U()))
);
return 0.2*exp(- ReSqrSr/3.6e5 - 0.12)*exp(ReSqrSr/3.0e7);
}
// ************************************************************************* //

110
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/liftModels/Moraga/Moraga.H Normal file
View file

@ -0,0 +1,110 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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::liftModels::Moraga
Description
Lift model of Moraga et al.
References:
\verbatim
"Implementation and Comparison of Correlations for interfacial Forces
in a Gas-Liquid System within an Euler-Euler Framework"
M Otromke
PhD Thesis
April 2013
\endverbatim
\verbatim
"Lateral forces on spheres in turbulent uniform shear flow"
F J Moraga, F J Bonetto, R T Lahey
International Journal of Multiphase Flow
Volume 25, Issues 6-7, Pages 1321-1372, September 1999
\endverbatim
SourceFiles
Moraga.C
\*---------------------------------------------------------------------------*/
#ifndef Moraga_H
#define Moraga_H
#include "liftModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class phasePair;
namespace liftModels
{
/*---------------------------------------------------------------------------*\
Class Moraga Declaration
\*---------------------------------------------------------------------------*/
class Moraga
:
public liftModel
{
public:
//- Runtime type information
TypeName("Moraga");
// Constructors
//- Construct from a dictionary and a phase pair
Moraga
(
const dictionary& dict,
const phasePair& pair
);
//- Destructor
virtual ~Moraga();
// Member Functions
//- Lift coefficient
virtual tmp<volScalarField> Cl() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace liftModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

102
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/turbulentDispersionModels/Burns/Burns.C Normal file
View file

@ -0,0 +1,102 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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 "Burns.H"
#include "phasePair.H"
#include "fvc.H"
#include "PhaseIncompressibleTurbulenceModel.H"
#include "addToRunTimeSelectionTable.H"
#include "dragModel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace turbulentDispersionModels
{
defineTypeNameAndDebug(Burns, 0);
addToRunTimeSelectionTable
(
turbulentDispersionModel,
Burns,
dictionary
);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::turbulentDispersionModels::Burns::Burns
(
const dictionary& dict,
const phasePair& pair
)
:
turbulentDispersionModel(dict, pair),
sigma_("sigma", dimless, dict.lookup("sigma")),
residualAlpha_("residualAlpha", dimless, dict.lookup("residualAlpha"))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::turbulentDispersionModels::Burns::~Burns()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volVectorField>
Foam::turbulentDispersionModels::Burns::F() const
{
const fvMesh& mesh(pair_.phase1().mesh());
const dragModel&
drag
(
mesh.lookupObject<dragModel>
(
IOobject::groupName(dragModel::typeName, pair_.name())
)
);
return
- 0.75
*drag.CdRe()
*pair_.dispersed()
*pair_.continuous().nu()
*pair_.continuous().turbulence().nut()
/(
sigma_
*sqr(pair_.dispersed().d())
)
*pair_.continuous().rho()
*fvc::grad(pair_.continuous())
*(1.0 + pair_.dispersed()/max(pair_.continuous(), residualAlpha_));
}
// ************************************************************************* //

120
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/turbulentDispersionModels/Burns/Burns.H Normal file
View file

@ -0,0 +1,120 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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::turbulentDispersionModels::Burns
Description
Turbulent dispersion model of Burns et al.
References:
\verbatim
"Implementation and Comparison of Correlations for interfacial Forces
in a Gas-Liquid System within an Euler-Euler Framework"
M Otromke
PhD Thesis
April 2013
\endverbatim
\verbatim
"The Favre averaged drag model for turbulent dispersion in Eulerian
multi-phase flows"
A D Burns, T Frank, I Hamill, J M Shi
5th international conference on multiphase flow
Volume 4, Paper 392, May 2004
\endverbatim
SourceFiles
Burns.C
\*---------------------------------------------------------------------------*/
#ifndef Burns_H
#define Burns_H
#include "turbulentDispersionModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class phasePair;
namespace turbulentDispersionModels
{
/*---------------------------------------------------------------------------*\
Class Burns Declaration
\*---------------------------------------------------------------------------*/
class Burns
:
public turbulentDispersionModel
{
// Private data
//- Schmidt number
const dimensionedScalar sigma_;
//- Residual phase fraction
const dimensionedScalar residualAlpha_;
public:
//- Runtime type information
TypeName("Burns");
// Constructors
//- Construct from a dictionary and a phase pair
Burns
(
const dictionary& dict,
const phasePair& pair
);
//- Destructor
virtual ~Burns();
// Member Functions
//- Turbulent dispersion force
virtual tmp<volVectorField> F() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace turbulentDispersionModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

98
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/wallLubricationModels/Frank/Frank.C Normal file
View file

@ -0,0 +1,98 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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 "Frank.H"
#include "phasePair.H"
#include "fvc.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace wallLubricationModels
{
defineTypeNameAndDebug(Frank, 0);
addToRunTimeSelectionTable
(
wallLubricationModel,
Frank,
dictionary
);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::wallLubricationModels::Frank::Frank
(
const dictionary& dict,
const phasePair& pair
)
:
wallLubricationModel(dict, pair),
Cwd_("Cwd", dimless, dict.lookup("Cwd")),
Cwc_("Cwc", dimless, dict.lookup("Cwc")),
p_(readScalar(dict.lookup("p")))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::wallLubricationModels::Frank::~Frank()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volVectorField> Foam::wallLubricationModels::Frank::F() const
{
volVectorField Ur(pair_.Ur());
volVectorField nWall(- fvc::grad(yWall_));
nWall /= mag(nWall) + SMALL;
volScalarField Eo(pair_.Eo());
volScalarField yTilde(yWall_/(Cwc_*pair_.dispersed().d()));
return
(
pos(Eo - 1.0)*neg(Eo - 5.0)*exp(-0.933*Eo + 0.179)
+ pos(Eo - 5.0)*neg(Eo - 33.0)*(0.00599*Eo - 0.0187)
+ pos(Eo - 33.0)*0.179
)
*max
(
dimensionedScalar("zero", dimless/dimLength, 0.0),
(1.0 - yTilde)/(Cwd_*yWall_*pow(yTilde, p_ - 1.0))
)
*pair_.dispersed()
*pair_.continuous().rho()
*magSqr(Ur - (Ur & nWall)*nWall)
*nWall;
}
// ************************************************************************* //

125
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/wallLubricationModels/Frank/Frank.H Normal file
View file

@ -0,0 +1,125 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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::wallLubricationModels::Frank
Description
Wall lubrication model of Frank.
References:
\verbatim
"Implementation and Comparison of Correlations for interfacial Forces
in a Gas-Liquid System within an Euler-Euler Framework"
M Otromke
PhD Thesis
April 2013
\endverbatim
\verbatim
"Advances in Computational Fluid Dynamics (CFD) of 3-dimensional Gas-
Liquid Multiphase Flows"
T Frank
NAFEMS Seminar : Simulation of Complex Flows (CFD)
Pages 1-18, April 2005
\endverbatim
SourceFiles
Frank.C
\*---------------------------------------------------------------------------*/
#ifndef Frank_H
#define Frank_H
#include "wallLubricationModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class phasePair;
namespace wallLubricationModels
{
/*---------------------------------------------------------------------------*\
Class Frank Declaration
\*---------------------------------------------------------------------------*/
class Frank
:
public wallLubricationModel
{
private:
// Private data
//- Coefficient d
const dimensionedScalar Cwd_;
//- Coefficient c
const dimensionedScalar Cwc_;
//- Power p
const scalar p_;
public:
//- Runtime type information
TypeName("Frank");
// Constructors
//- Construct from components
Frank
(
const dictionary& dict,
const phasePair& pair
);
//- Destructor
virtual ~Frank();
// Member Functions
//- Wall lubrication force
tmp<volVectorField> F() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace wallLubricationModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

11
applications/solvers/multiphase/twoPhaseEulerFoam/phaseIncompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
View file

@ -422,19 +422,12 @@ void Foam::RASModels::kineticTheoryModel::correct()
*gs0_*(1.0/da)*ThetaSqrt/sqrtPi
);
// NB, drag = K*alpha*alpha2,
// (the alpha and alpha2 has been extracted from the drag function for
// numerical reasons)
// Drag
volScalarField magUr(mag(U - Uc_));
volScalarField alpha2Prim
(
max
(
alpha*(1.0 - alpha),
residualAlpha_
)
*phase_.fluid().drag(phase_).K()/rho
phase_.fluid().drag(phase_).K()/rho
);
// Eq. 3.25, p. 50 Js = J1 - J2

2
applications/utilities/preProcessing/mapFields/mapFields.C
View file

@ -184,7 +184,7 @@ int main(int argc, char *argv[])
(
"mapMethod",
"word",
"specify the mapping method"
"specify the mapping method (direct|mapNearest|cellVolumeWeight)"
);
argList::addBoolOption
(

52
src/finiteVolume/fields/fvPatchFields/derived/uniformTotalPressure/uniformTotalPressureFvPatchScalarField.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -88,46 +88,60 @@ uniformTotalPressureFvPatchScalarField
const fvPatchFieldMapper& mapper
)
:
fixedValueFvPatchScalarField(ptf, p, iF, mapper),
fixedValueFvPatchScalarField(p, iF), // bypass mapper
UName_(ptf.UName_),
phiName_(ptf.phiName_),
rhoName_(ptf.rhoName_),
psiName_(ptf.psiName_),
gamma_(ptf.gamma_),
pressure_(ptf.pressure_().clone().ptr())
{}
{
// Evaluate since value not mapped
const scalar t = this->db().time().timeOutputValue();
fvPatchScalarField::operator==(pressure_->value(t));
}
Foam::uniformTotalPressureFvPatchScalarField::
uniformTotalPressureFvPatchScalarField
(
const uniformTotalPressureFvPatchScalarField& tppsf
const uniformTotalPressureFvPatchScalarField& ptf
)
:
fixedValueFvPatchScalarField(tppsf),
UName_(tppsf.UName_),
phiName_(tppsf.phiName_),
rhoName_(tppsf.rhoName_),
psiName_(tppsf.psiName_),
gamma_(tppsf.gamma_),
pressure_(tppsf.pressure_().clone().ptr())
fixedValueFvPatchScalarField(ptf),
UName_(ptf.UName_),
phiName_(ptf.phiName_),
rhoName_(ptf.rhoName_),
psiName_(ptf.psiName_),
gamma_(ptf.gamma_),
pressure_
(
ptf.pressure_.valid()
? ptf.pressure_().clone().ptr()
: NULL
)
{}
Foam::uniformTotalPressureFvPatchScalarField::
uniformTotalPressureFvPatchScalarField
(
const uniformTotalPressureFvPatchScalarField& tppsf,
const uniformTotalPressureFvPatchScalarField& ptf,
const DimensionedField<scalar, volMesh>& iF
)
:
fixedValueFvPatchScalarField(tppsf, iF),
UName_(tppsf.UName_),
phiName_(tppsf.phiName_),
rhoName_(tppsf.rhoName_),
psiName_(tppsf.psiName_),
gamma_(tppsf.gamma_),
pressure_(tppsf.pressure_().clone().ptr())
fixedValueFvPatchScalarField(ptf, iF),
UName_(ptf.UName_),
phiName_(ptf.phiName_),
rhoName_(ptf.rhoName_),
psiName_(ptf.psiName_),
gamma_(ptf.gamma_),
pressure_
(
ptf.pressure_.valid()
? ptf.pressure_().clone().ptr()
: NULL
)
{}

14
src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/thixotropicViscosity/thixotropicViscosity.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2013-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -64,19 +64,19 @@ void thixotropicViscosity::updateMu()
const dimensionedScalar mSMALL("SMALL", dimMass, ROOTVSMALL);
const volScalarField deltaMass("deltaMass", max(m0, film.deltaMass()));
const volScalarField filmMass("filmMass", film.netMass() + mSMALL);
const volScalarField mask(pos(film.delta() - film.deltaSmall()));
// weighting field to blend new and existing mass contributions
const volScalarField w
(
"w",
max(scalar(0.0), min(scalar(1.0), deltaMass/filmMass))
max(scalar(0.0), min(scalar(1.0), deltaMass/(deltaMass + filmMass)))
);
// evaluate thixotropic viscosity
volScalarField muThx("muThx", muInf_/(sqr(1.0 - K_*lambda_) + ROOTVSMALL));
// set new viscosity based on weight field
mu_ = w*muInf_ + (1.0 - w)*muThx;
// set new viscosity
mu_ =
mask*muInf_/(sqr(1.0 - K_*(1.0 - w)*lambda_) + ROOTVSMALL)
+ (1 - mask)*muInf_;
mu_.correctBoundaryConditions();
}

10
src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -260,10 +260,12 @@ tmp<fvScalarMatrix> thermoSingleLayer::q(volScalarField& hs) const
volScalarField htcst(htcs_->h());
volScalarField htcwt(htcw_->h());
forAll(alpha_, i)
const volScalarField mask(pos(delta_ - deltaSmall_));
forAll(mask, i)
{
htcst[i] *= max(alpha_[i], ROOTVSMALL);
htcwt[i] *= max(alpha_[i], ROOTVSMALL);
htcst[i] *= max(mask[i], ROOTVSMALL);
htcwt[i] *= max(mask[i], ROOTVSMALL);
}
htcst.correctBoundaryConditions();

90
src/sampling/meshToMeshInterpolation/meshToMesh/meshToMeshTemplates.C
View file

@ -386,7 +386,7 @@ Foam::meshToMesh::mapSrcToTgt
const typename fieldType::GeometricBoundaryField& srcBfld =
field.boundaryField();
wordList patchTypes(tgtBm.size(), calculatedFvPatchField<Type>::typeName);
PtrList<fvPatchField<Type> > tgtPatchFields(tgtBm.size());
// constuct tgt boundary patch types as copy of 'field' boundary types
// note: this will provide place holders for fields with additional
@ -396,7 +396,43 @@ Foam::meshToMesh::mapSrcToTgt
label srcPatchI = srcPatchID_[i];
label tgtPatchI = tgtPatchID_[i];
patchTypes[tgtPatchI] = srcBfld[srcPatchI].type();
if (!tgtPatchFields.set(tgtPatchI))
{
tgtPatchFields.set
(
tgtPatchI,
fvPatchField<Type>::New
(
srcBfld[srcPatchI],
tgtMesh.boundary()[tgtPatchI],
DimensionedField<Type, volMesh>::null(),
directFvPatchFieldMapper
(
labelList(tgtMesh.boundary()[tgtPatchI].size(), -1)
)
)
);
}
}
// Any unset tgtPatchFields become calculated
forAll(tgtPatchFields, tgtPatchI)
{
if (!tgtPatchFields.set(tgtPatchI))
{
// Note: use factory New method instead of direct generation of
// calculated so we keep constraints
tgtPatchFields.set
(
tgtPatchI,
fvPatchField<Type>::New
(
calculatedFvPatchField<Type>::typeName,
tgtMesh.boundary()[tgtPatchI],
DimensionedField<Type, volMesh>::null()
)
);
}
}
tmp<fieldType> tresult
@ -412,8 +448,9 @@ Foam::meshToMesh::mapSrcToTgt
IOobject::NO_WRITE
),
tgtMesh,
dimensioned<Type>("0", field.dimensions(), pTraits<Type>::zero),
patchTypes
field.dimensions(),
Field<Type>(tgtMesh.nCells(), pTraits<Type>::zero),
tgtPatchFields
)
);
@ -512,7 +549,7 @@ Foam::meshToMesh::mapTgtToSrc
const typename fieldType::GeometricBoundaryField& tgtBfld =
field.boundaryField();
wordList patchTypes(srcBm.size(), calculatedFvPatchField<Type>::typeName);
PtrList<fvPatchField<Type> > srcPatchFields(srcBm.size());
// constuct src boundary patch types as copy of 'field' boundary types
// note: this will provide place holders for fields with additional
@ -522,7 +559,43 @@ Foam::meshToMesh::mapTgtToSrc
label srcPatchI = srcPatchID_[i];
label tgtPatchI = tgtPatchID_[i];
patchTypes[srcPatchI] = tgtBfld[tgtPatchI].type();
if (!srcPatchFields.set(tgtPatchI))
{
srcPatchFields.set
(
srcPatchI,
fvPatchField<Type>::New
(
tgtBfld[srcPatchI],
srcMesh.boundary()[tgtPatchI],
DimensionedField<Type, volMesh>::null(),
directFvPatchFieldMapper
(
labelList(srcMesh.boundary()[srcPatchI].size(), -1)
)
)
);
}
}
// Any unset srcPatchFields become calculated
forAll(srcPatchFields, srcPatchI)
{
if (!srcPatchFields.set(srcPatchI))
{
// Note: use factory New method instead of direct generation of
// calculated so we keep constraints
srcPatchFields.set
(
srcPatchI,
fvPatchField<Type>::New
(
calculatedFvPatchField<Type>::typeName,
srcMesh.boundary()[srcPatchI],
DimensionedField<Type, volMesh>::null()
)
);
}
}
tmp<fieldType> tresult
@ -538,8 +611,9 @@ Foam::meshToMesh::mapTgtToSrc
IOobject::NO_WRITE
),
srcMesh,
dimensioned<Type>("0", field.dimensions(), pTraits<Type>::zero),
patchTypes
field.dimensions(),
Field<Type>(srcMesh.nCells(), pTraits<Type>::zero),
srcPatchFields
)
);

2
tutorials/lagrangian/reactingParcelFilmFoam/cylinder/0.org/U
View file

@ -23,7 +23,7 @@ boundaryField
{
"(sides|frontAndBack)"
{
type pressureInletOutletVelocity;
type fixedValue;
value uniform (0 0 0);
}
region0_to_wallFilmRegion_wallFilmFaces

2
tutorials/lagrangian/reactingParcelFilmFoam/cylinder/system/fvSolution
View file

@ -96,6 +96,8 @@ PIMPLE
nCorrectors 2;
nNonOrthogonalCorrectors 0;
momentumPredictor yes;
pRefCell 0;
pRefValue 1e5;
}