PLIC,MPLIC: New piecewise-linear interface compression schemes
A new family of interface compression interpolation schemes based on
piecewise-linear interface calculation (PLIC). PLIC represents an interface by
surface-cuts which split each cell to match the volume fraction of the phase in
that cell. The surface-cuts are oriented according to the point field of the
local phase fraction. The phase fraction on each cell face — the interpolated
value — is then calculated from the amount submerged below the surface-cut.
The basic PLIC method generates a single cut so cannot handle cells in which
there are multiple interfaces or where the interface is not fully resolved. In
those cells, the interpolation reverts to an alternative scheme, typically
standard interface compression. PLIC, with a fallback to interface compression,
produces robust solutions for real engineering cases. It can run with large time
steps so can solve problems like hydrodynamics of a planing hull, with rigid
body motion of the hull (above). The user selects PLIC by the following setting
in fvSchemes:
div(phi,alpha) Gauss PLIC interfaceCompression vanLeer 1;
The multicut PLIC (MPLIC) scheme extends PLIC to handle multiple
surface-cuts. Where a single cut is insufficient, MPLIC performs a topological
face-edge-face walk to produce multiple splits of a cell. If that is still
insufficient, MPLIC decomposes the cell into tetrahedrons on which the cuts are
applied. The extra cutting carries an additional computational cost but requires
no fallback. The user selects MPLIC by the following setting in the fvSchemes
file:
div(phi,alpha) Gauss MPLIC;
Variants of the PLIC and MPLIC schemes are also available which use velocities
at the face points to calculate the face flux. These PLICU and MPLICU schemes
are likely to be more accurate in regions of interface under high shear.
More details can be found here:
https://cfd.direct/openfoam/free-software/multiphase-interface-capturing
Jakub Knir
CFD Direct Ltd.
This commit is contained in:
Jakub Knir
255
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLIC.C
Normal file
255
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLIC.C
Normal file
@ -0,0 +1,255 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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 "MPLIC.H"
|
||||
#include "MPLICcell.H"
|
||||
#include "volPointInterpolation.H"
|
||||
#include "syncTools.H"
|
||||
#include "slicedSurfaceFields.H"
|
||||
#include "upwind.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
defineTypeNameAndDebug(MPLIC, 0);
|
||||
|
||||
surfaceInterpolationScheme<scalar>::addMeshFluxConstructorToTable<MPLIC>
|
||||
addMPLICScalarMeshFluxConstructorToTable_;
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Private Functions * * * * * * * * * * * * * //
|
||||
|
||||
void Foam::MPLIC::setCellAlphaf
|
||||
(
|
||||
const label celli,
|
||||
const scalarField& phi,
|
||||
scalarField& alphaf,
|
||||
boolList& correctedFaces,
|
||||
const DynamicList<scalar>& cellAlphaf,
|
||||
const fvMesh& mesh
|
||||
) const
|
||||
{
|
||||
// Face owners reference
|
||||
const labelList& own = mesh.faceOwner();
|
||||
|
||||
// The cell face labels
|
||||
const labelList& cFaces = mesh.cells()[celli];
|
||||
|
||||
// Fill the alphaf with surface interpolation in direction of the flow
|
||||
forAll(cFaces, i)
|
||||
{
|
||||
const label facei = cFaces[i];
|
||||
const scalar phiSigni = sign(phi[facei]);
|
||||
|
||||
if
|
||||
(
|
||||
(own[facei] == celli && phiSigni == 1)
|
||||
|| (own[facei] != celli && phiSigni == -1)
|
||||
)
|
||||
{
|
||||
alphaf[facei] = cellAlphaf[i];
|
||||
correctedFaces[facei] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Foam::tmp<Foam::surfaceScalarField> Foam::MPLIC::surfaceAlpha
|
||||
(
|
||||
const volScalarField& alpha,
|
||||
const surfaceScalarField& phi,
|
||||
scalarField& initAlphaf,
|
||||
const bool unweighted,
|
||||
const scalar tol,
|
||||
const bool isMPLIC
|
||||
) const
|
||||
{
|
||||
// Finite volume mesh reference
|
||||
const fvMesh& mesh = alpha.mesh();
|
||||
|
||||
// Reference to primitive mesh
|
||||
const primitiveMesh& primMesh = mesh;
|
||||
|
||||
// Velocity field reference
|
||||
const volVectorField& U
|
||||
(
|
||||
mesh.lookupObject<const volVectorField>
|
||||
(
|
||||
IOobject::groupName("U", phi.group())
|
||||
)
|
||||
);
|
||||
|
||||
// Interpolate alpha from volume to the points of the mesh
|
||||
const scalarField alphap
|
||||
(
|
||||
volPointInterpolation::New(mesh).interpolate(alpha)
|
||||
);
|
||||
|
||||
// Interpolate U from cell centres to the points of the mesh
|
||||
vectorField Up;
|
||||
|
||||
if (!unweighted)
|
||||
{
|
||||
Up = volPointInterpolation::New(mesh).interpolate(U);
|
||||
}
|
||||
|
||||
// Flatten down phi flux field
|
||||
const scalarField spicedPhi
|
||||
(
|
||||
slicedSurfaceScalarField
|
||||
(
|
||||
IOobject
|
||||
(
|
||||
"splicedPhi",
|
||||
mesh.time().timeName(),
|
||||
mesh
|
||||
),
|
||||
phi,
|
||||
false
|
||||
).splice()
|
||||
);
|
||||
|
||||
scalarField alphaf(mesh.nFaces(), 0);
|
||||
|
||||
// Mark which faces are corrected by MPLIC
|
||||
boolList correctedFaces(mesh.nFaces(), false);
|
||||
|
||||
// Construct class for cell cut
|
||||
MPLICcell cutCell(unweighted, isMPLIC);
|
||||
|
||||
// Loop through all the cells
|
||||
forAll(mesh.cells(), celli)
|
||||
{
|
||||
if (alpha[celli] < (1 - tol) && alpha[celli] > tol)
|
||||
{
|
||||
// Store cell information
|
||||
const MPLICcellStorage cellInfo
|
||||
(
|
||||
primMesh,
|
||||
alphap,
|
||||
Up,
|
||||
alpha[celli],
|
||||
U[celli],
|
||||
celli
|
||||
);
|
||||
|
||||
// Volume ratio matching algorithm
|
||||
if (cutCell.matchAlpha(cellInfo))
|
||||
{
|
||||
// Fill cutCell.alphaf() with face values from this cell
|
||||
setCellAlphaf
|
||||
(
|
||||
celli,
|
||||
spicedPhi,
|
||||
alphaf,
|
||||
correctedFaces,
|
||||
cutCell.alphaf(),
|
||||
mesh
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Synchronise across the processor and cyclic patches
|
||||
syncTools::syncFaceList(mesh, alphaf, plusEqOp<scalar>());
|
||||
syncTools::syncFaceList(mesh, correctedFaces, plusEqOp<bool>());
|
||||
|
||||
// Correct selected faces
|
||||
forAll(correctedFaces, facei)
|
||||
{
|
||||
if (correctedFaces[facei])
|
||||
{
|
||||
initAlphaf[facei] = alphaf[facei];
|
||||
}
|
||||
}
|
||||
|
||||
// Convert the alphaPhi spliced field into a surfaceScalarField
|
||||
tmp<surfaceScalarField> tslicedAlpha
|
||||
(
|
||||
surfaceScalarField::New
|
||||
(
|
||||
"alphaf",
|
||||
slicedSurfaceScalarField
|
||||
(
|
||||
IOobject
|
||||
(
|
||||
"alphaf",
|
||||
mesh.time().timeName(),
|
||||
mesh
|
||||
),
|
||||
mesh,
|
||||
dimless,
|
||||
initAlphaf,
|
||||
false
|
||||
),
|
||||
fvsPatchField<scalar>::calculatedType()
|
||||
)
|
||||
);
|
||||
surfaceScalarField& slicedAlpha = tslicedAlpha.ref();
|
||||
|
||||
forAll(mesh.boundary(), patchi)
|
||||
{
|
||||
if (alpha.boundaryField()[patchi].fixesValue())
|
||||
{
|
||||
slicedAlpha.boundaryFieldRef()[patchi] =
|
||||
alpha.boundaryField()[patchi];
|
||||
}
|
||||
}
|
||||
|
||||
return tslicedAlpha;
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
Foam::tmp<Foam::surfaceScalarField> Foam::MPLIC::interpolate
|
||||
(
|
||||
const GeometricField<scalar, fvPatchField, volMesh>& vf
|
||||
) const
|
||||
{
|
||||
tmp<surfaceScalarField> tvff(upwind<scalar>(mesh(), phi_).interpolate(vf));
|
||||
|
||||
scalarField spicedTvff
|
||||
(
|
||||
slicedSurfaceScalarField
|
||||
(
|
||||
IOobject
|
||||
(
|
||||
"spicedTvff",
|
||||
mesh().time().timeName(),
|
||||
mesh()
|
||||
),
|
||||
tvff,
|
||||
false
|
||||
).splice()
|
||||
);
|
||||
|
||||
return surfaceAlpha(vf, phi_, spicedTvff, true, 1e-6);
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
176
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLIC.H
Normal file
176
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLIC.H
Normal file
@ -0,0 +1,176 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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::MPLIC
|
||||
|
||||
Description
|
||||
Multicut Piecewise-Linear Interface Calculation (MPLIC) corrected scheme is
|
||||
a surface interpolation scheme for flux calculation in advection of a
|
||||
bounded variable, e.g. phase fraction and for interface capturing in the
|
||||
volume of fluid (VoF) method.
|
||||
|
||||
The interface is represented by multiple cuts which split each cell to match
|
||||
the volume fraction of the phase in the cell. The cut planes are oriented
|
||||
according to the point field of the local phase fraction. The phase
|
||||
fraction at each cell face - the interpolated value - is then calculated
|
||||
from the face area on either side of the cuts.
|
||||
|
||||
Three progressively more complex algorithms are used to ensure the cell
|
||||
volume fraction is accurately reproduced:
|
||||
-# single cut: cuts all the cell faces regardless the order
|
||||
-# multi cut: topological face-edge-face walk which can split cell into
|
||||
multiple sub-volumes
|
||||
-# tetrahedron cut: decomposes cell into tetrahedrons which are cut
|
||||
|
||||
Example:
|
||||
\verbatim
|
||||
divSchemes
|
||||
{
|
||||
.
|
||||
.
|
||||
div(phi,alpha) Gauss MPLIC;
|
||||
.
|
||||
.
|
||||
}
|
||||
\endverbatim
|
||||
|
||||
See also
|
||||
Foam::MPLICU
|
||||
Foam::PLIC
|
||||
Foam::PLICU
|
||||
Foam::interfaceCompression
|
||||
|
||||
SourceFiles
|
||||
MPLIC.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef MPLIC_H
|
||||
#define MPLIC_H
|
||||
|
||||
#include "surfaceInterpolationScheme.H"
|
||||
#include "DynamicList.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class MPLIC Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
class MPLIC
|
||||
:
|
||||
public surfaceInterpolationScheme<scalar>
|
||||
{
|
||||
protected:
|
||||
|
||||
// Private member data
|
||||
|
||||
const surfaceScalarField& phi_;
|
||||
|
||||
|
||||
// Protected member functions
|
||||
|
||||
//- Set alphaPhi for the faces of the given cell
|
||||
void setCellAlphaf
|
||||
(
|
||||
const label celli,
|
||||
const scalarField& phi,
|
||||
scalarField& alphaf,
|
||||
boolList& correctedFaces,
|
||||
const DynamicList<scalar>& cellAlphaf,
|
||||
const fvMesh& mesh
|
||||
) const;
|
||||
|
||||
//- Return alpha interpolation
|
||||
tmp<surfaceScalarField> surfaceAlpha
|
||||
(
|
||||
const volScalarField& alpha,
|
||||
const surfaceScalarField& phi,
|
||||
scalarField& spicedTvff,
|
||||
const bool unweighted,
|
||||
const scalar tol,
|
||||
const bool isMPLIC = true
|
||||
) const;
|
||||
|
||||
|
||||
public:
|
||||
|
||||
//- Runtime type information
|
||||
TypeName("MPLIC");
|
||||
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct from faceFlux and Istream
|
||||
MPLIC
|
||||
(
|
||||
const fvMesh& mesh,
|
||||
const surfaceScalarField& faceFlux,
|
||||
Istream& is
|
||||
)
|
||||
:
|
||||
surfaceInterpolationScheme<scalar>(mesh),
|
||||
phi_(faceFlux)
|
||||
{}
|
||||
|
||||
|
||||
// Member Functions
|
||||
|
||||
//- Return the interpolation weighting factors
|
||||
virtual tmp<surfaceScalarField> weights
|
||||
(
|
||||
const GeometricField<scalar, fvPatchField, volMesh>&
|
||||
) const
|
||||
{
|
||||
NotImplemented;
|
||||
|
||||
return tmp<surfaceScalarField>(nullptr);
|
||||
}
|
||||
|
||||
//- Return the face-interpolate of the given cell field
|
||||
virtual tmp<surfaceScalarField> interpolate
|
||||
(
|
||||
const GeometricField<scalar, fvPatchField, volMesh>& vf
|
||||
) const;
|
||||
|
||||
|
||||
// Member Operators
|
||||
|
||||
//- Disallow default bitwise assignment
|
||||
void operator=(const MPLIC&) = delete;
|
||||
};
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
68
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICU.C
Normal file
68
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICU.C
Normal file
@ -0,0 +1,68 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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 "MPLICU.H"
|
||||
#include "slicedSurfaceFields.H"
|
||||
#include "upwind.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
defineTypeNameAndDebug(MPLICU, 0);
|
||||
|
||||
surfaceInterpolationScheme<scalar>::addMeshFluxConstructorToTable<MPLICU>
|
||||
addMPLICUScalarMeshFluxConstructorToTable_;
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
Foam::tmp<Foam::surfaceScalarField> Foam::MPLICU::interpolate
|
||||
(
|
||||
const GeometricField<scalar, fvPatchField, volMesh>& vf
|
||||
) const
|
||||
{
|
||||
tmp<surfaceScalarField> tvff(upwind<scalar>(mesh(), phi_).interpolate(vf));
|
||||
|
||||
scalarField spicedTvff
|
||||
(
|
||||
slicedSurfaceScalarField
|
||||
(
|
||||
IOobject
|
||||
(
|
||||
"spicedTvff",
|
||||
mesh().time().timeName(),
|
||||
mesh()
|
||||
),
|
||||
tvff,
|
||||
false
|
||||
).splice()
|
||||
);
|
||||
|
||||
return surfaceAlpha(vf, phi_, spicedTvff, false, 1e-6);
|
||||
}
|
||||
|
||||
// ************************************************************************* //
|
||||
146
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICU.H
Normal file
146
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICU.H
Normal file
@ -0,0 +1,146 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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::MPLICU
|
||||
|
||||
Description
|
||||
Velocity-weighted Multicut Piecewise-Linear Interface Calculation (MPLICU)
|
||||
corrected scheme is a surface interpolation scheme for flux calculation in
|
||||
advection of a bounded variable, e.g. phase fraction and for interface
|
||||
capturing in the volume of fluid (VoF) method.
|
||||
|
||||
The interface is represented by multiple cuts which split each cell to match
|
||||
the volume fraction of the phase in the cell. The cut planes are oriented
|
||||
according to the point field of the local phase fraction. The phase
|
||||
fraction at each cell face - the interpolated value - is then calculated
|
||||
from the face area on either side of the cuts.
|
||||
|
||||
Three progressively more complex algorithms are used to ensure the cell
|
||||
volume fraction is accurately reproduced:
|
||||
-# single cut: cuts all the cell faces regardless the order
|
||||
-# multi cut: topological face-edge-face walk which can split cell into
|
||||
multiple sub-volumes
|
||||
-# tetrahedron cut: decomposes cell into tetrahedrons which are cut
|
||||
|
||||
Additionally the face point velocity values are used to calculate the face
|
||||
flux which is likely to be more accurate in the presence of high shear.
|
||||
|
||||
Example:
|
||||
\verbatim
|
||||
divSchemes
|
||||
{
|
||||
.
|
||||
.
|
||||
div(phi,alpha1) Gauss MPLICU;
|
||||
.
|
||||
.
|
||||
}
|
||||
\endverbatim
|
||||
|
||||
See also
|
||||
Foam::MPLIC
|
||||
Foam::PLIC
|
||||
Foam::PLICU
|
||||
Foam::interfaceCompression
|
||||
|
||||
SourceFiles
|
||||
MPLICU.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef MPLICU_H
|
||||
#define MPLICU_H
|
||||
|
||||
#include "MPLIC.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class MPLICU Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
class MPLICU
|
||||
:
|
||||
public MPLIC
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
//- Runtime type information
|
||||
TypeName("MPLICU");
|
||||
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct from faceFlux and Istream
|
||||
MPLICU
|
||||
(
|
||||
const fvMesh& mesh,
|
||||
const surfaceScalarField& faceFlux,
|
||||
Istream& is
|
||||
)
|
||||
:
|
||||
MPLIC(mesh, faceFlux, is)
|
||||
{}
|
||||
|
||||
|
||||
// Member Functions
|
||||
|
||||
//- Return the interpolation weighting factors
|
||||
virtual tmp<surfaceScalarField> weights
|
||||
(
|
||||
const GeometricField<scalar, fvPatchField, volMesh>& vf
|
||||
) const
|
||||
{
|
||||
NotImplemented;
|
||||
|
||||
return tmp<surfaceScalarField>(nullptr);
|
||||
}
|
||||
|
||||
//- Return the face-interpolate of the given cell field
|
||||
virtual tmp<surfaceScalarField> interpolate
|
||||
(
|
||||
const GeometricField<scalar, fvPatchField, volMesh>& vf
|
||||
) const;
|
||||
|
||||
|
||||
// Member Operators
|
||||
|
||||
//- Disallow default bitwise assignment
|
||||
void operator=(const MPLICU&) = delete;
|
||||
};
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
1054
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICcell.C
Normal file
1054
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICcell.C
Normal file
File diff suppressed because it is too large
Load Diff
399
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICcell.H
Normal file
399
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICcell.H
Normal file
@ -0,0 +1,399 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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::MPLICcell
|
||||
|
||||
Description
|
||||
Class performs geometric matching of volume fraction and calculates surface
|
||||
interpolation of volume fraction field.
|
||||
|
||||
Cut algorithms:
|
||||
- Single cell cut
|
||||
- Face-edge walk multiple cell cuts
|
||||
- Tet decomposition cell cuts
|
||||
|
||||
SourceFiles
|
||||
MPLICcell.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef MPLICcell_H
|
||||
#define MPLICcell_H
|
||||
|
||||
#include "MPLICface.H"
|
||||
#include "MPLICcellStorage.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class MPLICcell Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
class MPLICcell
|
||||
{
|
||||
// Private member data
|
||||
|
||||
// Face related objects
|
||||
|
||||
//- Select unweighted interpolation if true
|
||||
// velocity flux corrected if false
|
||||
const bool unweighted_;
|
||||
|
||||
//- Select multi-cut if true or single-cut if false
|
||||
const bool multiCut_;
|
||||
|
||||
//- Surface interpolated alpha
|
||||
DynamicList<scalar> alphaf_;
|
||||
|
||||
//- Flux of alpha from point interpolated U
|
||||
DynamicList<scalar> alphaPhiU_;
|
||||
|
||||
//- Face flux from point interpolated U
|
||||
DynamicList<scalar> phiU_;
|
||||
|
||||
|
||||
// Geometry related objects
|
||||
|
||||
//- Calculated volume fraction corresponding to the cut
|
||||
scalar cutAlpha_;
|
||||
|
||||
//- Cut surface area vector
|
||||
vector cutSf_;
|
||||
|
||||
//- Cut normal
|
||||
vector cutNormal_;
|
||||
|
||||
//- Face cutter
|
||||
MPLICface faceCutter_;
|
||||
|
||||
//- Sub cell volume
|
||||
scalar subCellVolume_;
|
||||
|
||||
//- Cut points for single cut
|
||||
DynamicList<point> cutPoints_;
|
||||
|
||||
//- Cut edge labels for single cut
|
||||
DynamicList<label> cutEdges_;
|
||||
|
||||
//- Submerged face areas
|
||||
DynamicList<vector> subFaceAreas_;
|
||||
|
||||
//- Submerged face areas
|
||||
DynamicList<scalar> subFaceMagSf_;
|
||||
|
||||
//- Submerged face centers
|
||||
DynamicList<vector> subFaceCentres_;
|
||||
|
||||
template<class Type>
|
||||
class Vector4
|
||||
:
|
||||
public VectorSpace<Vector4<Type>, Type, 4>
|
||||
{
|
||||
public:
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct null
|
||||
inline Vector4()
|
||||
{}
|
||||
|
||||
inline Type a() const
|
||||
{
|
||||
return this->v_[0];
|
||||
}
|
||||
|
||||
inline Type b() const
|
||||
{
|
||||
return this->v_[1];
|
||||
}
|
||||
|
||||
inline Type c() const
|
||||
{
|
||||
return this->v_[2];
|
||||
}
|
||||
|
||||
inline Type d() const
|
||||
{
|
||||
return this->v_[3];
|
||||
}
|
||||
|
||||
|
||||
inline Type& a()
|
||||
{
|
||||
return this->v_[0];
|
||||
}
|
||||
|
||||
inline Type& b()
|
||||
{
|
||||
return this->v_[1];
|
||||
}
|
||||
|
||||
inline Type& c()
|
||||
{
|
||||
return this->v_[2];
|
||||
}
|
||||
|
||||
inline Type& d()
|
||||
{
|
||||
return this->v_[3];
|
||||
}
|
||||
};
|
||||
|
||||
typedef Vector4<scalar> vector4;
|
||||
|
||||
//- Four point alpha values for cubic polynomial fit
|
||||
vector4 pCubicAlphas_;
|
||||
|
||||
//- Four cell alpha values for cubic polynomial fit
|
||||
vector4 cCubicAlphas_;
|
||||
|
||||
|
||||
// Tetrahedron storage objects
|
||||
|
||||
//- Tetrahedron alpha point values
|
||||
scalarField tetPointsAlpha_;
|
||||
|
||||
//- Tetrahedron velocity point values
|
||||
vectorField tetPointsU_;
|
||||
|
||||
//- Tetrahedron points
|
||||
pointField tetPoints_;
|
||||
|
||||
//- Tetrahedron surface area vectors
|
||||
Vector4<vector> tetSf_;
|
||||
|
||||
//- Tetrahedron face centres
|
||||
Vector4<vector> tetCf_;
|
||||
|
||||
//- Tetrahedron triangular faces addressing
|
||||
const FixedList<face, 4> tetFaces_;
|
||||
|
||||
|
||||
// Multicut addressing
|
||||
|
||||
//- Is addressnig computed?
|
||||
bool addressingCalculated_;
|
||||
|
||||
//- Local edge faces
|
||||
DynamicList<DynamicList<label>> localEdgeFaces_;
|
||||
|
||||
//- Local face edges
|
||||
DynamicList<DynamicList<label>> localFaceEdges_;
|
||||
|
||||
|
||||
// Cell-point work arrays
|
||||
|
||||
DynamicList<scalar> cellPointsAlpha_;
|
||||
|
||||
DynamicList<scalar> pointsAlpha_;
|
||||
|
||||
|
||||
// Private Member Functions
|
||||
|
||||
//- Match cell volume ratio to phase fraction
|
||||
// Returns:
|
||||
// - +1: success
|
||||
// - 0: fail
|
||||
// - -1: base scheme
|
||||
label calcMatchAlphaCutCell
|
||||
(
|
||||
const MPLICcellStorage& cellInfo,
|
||||
const bool tetDecom = false
|
||||
);
|
||||
|
||||
//- Find in between which two point alpha values
|
||||
// the target volume fraction lies
|
||||
void findPointAlphaBounds
|
||||
(
|
||||
const MPLICcellStorage& cellInfo,
|
||||
const bool tetDecom
|
||||
);
|
||||
|
||||
//- Calculate the two interior point alpha values for the cubic fit
|
||||
void calcPointAlphaInterior
|
||||
(
|
||||
const MPLICcellStorage& cellInfo,
|
||||
const bool tetDecom
|
||||
);
|
||||
|
||||
//- Solve the cubic fit
|
||||
FixedList<scalar, 4> solveVanderMatrix() const;
|
||||
|
||||
//- Identifying roots of cubic equation matching target volume fraction
|
||||
void findRoots
|
||||
(
|
||||
const MPLICcellStorage& cellInfo,
|
||||
const FixedList<scalar, 4>& coeffs,
|
||||
const bool tetDecom
|
||||
);
|
||||
|
||||
//- Select simple cut or tet decomposition
|
||||
scalar calcAlpha
|
||||
(
|
||||
const MPLICcellStorage& cellInfo,
|
||||
const scalar target,
|
||||
const bool tetDecom
|
||||
);
|
||||
|
||||
//- Calculate current sub-cell volume
|
||||
void calcSubCellVolume();
|
||||
|
||||
//- Calculate cell cut, volume and alpha
|
||||
scalar calcCutCellVolumeAlpha
|
||||
(
|
||||
const MPLICcellStorage& cellInfo,
|
||||
const scalar target
|
||||
);
|
||||
|
||||
//- Calculate cell cut, volume and alpha by tet decomposition
|
||||
scalar calcTetCutCellVolumeAlpha
|
||||
(
|
||||
const MPLICcellStorage& cellInfo,
|
||||
const scalar target
|
||||
);
|
||||
|
||||
//- Attempt single cut through the cell
|
||||
// Returns:
|
||||
// - 1: success
|
||||
// - 0: fail
|
||||
bool singleCutCell
|
||||
(
|
||||
const MPLICcellStorage& cellInfo,
|
||||
const scalar target
|
||||
);
|
||||
|
||||
//- Attempt multiple cuts through the cell
|
||||
bool multiCutCell
|
||||
(
|
||||
const MPLICcellStorage& cellInfo,
|
||||
const scalar target
|
||||
);
|
||||
|
||||
//- Single cut through tet
|
||||
bool cutTetCell
|
||||
(
|
||||
const scalar target,
|
||||
const label faceOrig,
|
||||
const bool ow
|
||||
);
|
||||
|
||||
//- Calculate local addressing for multi-cut
|
||||
inline void calcAddressing
|
||||
(
|
||||
const MPLICcellStorage& cellInfo
|
||||
);
|
||||
|
||||
//- Append face area vectors and centers to cache
|
||||
inline void appendSfCf
|
||||
(
|
||||
const vector& Sf,
|
||||
const vector& Cf,
|
||||
const scalar magSf,
|
||||
const bool own = true
|
||||
);
|
||||
|
||||
//- Calculating surface vector of unordered edges
|
||||
inline bool cutStatusCalcSf();
|
||||
|
||||
//- Calculate cut surface area vector
|
||||
inline vector calcCutSf() const;
|
||||
|
||||
//- Calculating surface center of unordered edges
|
||||
inline vector calcCutCf(const vector& cutSf) const;
|
||||
|
||||
//- Calculate phiU
|
||||
inline void phiU
|
||||
(
|
||||
const pointField& points,
|
||||
const faceList& faces,
|
||||
const labelList& cFaces,
|
||||
const vectorField& pointsU
|
||||
);
|
||||
|
||||
//- Resize and set all the cell face fields to 0
|
||||
inline void resetFaceFields(const label nFaces);
|
||||
|
||||
//- Compute surface interpolation from area ratio
|
||||
inline void calcAlphaf(const UIndirectList<scalar>& magSfs);
|
||||
|
||||
//- Compute surface interpolation from flux ratio
|
||||
inline void calcAlphaUf();
|
||||
|
||||
//- Clear storage
|
||||
inline void clear();
|
||||
|
||||
//- Clear single cut storage
|
||||
inline void clearOneCut();
|
||||
|
||||
|
||||
public:
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct for given interpolation and PLIC type
|
||||
MPLICcell
|
||||
(
|
||||
const bool unweighted = true,
|
||||
const bool multiCut = true
|
||||
);
|
||||
|
||||
|
||||
// Member functions
|
||||
|
||||
//- Match cell volume ratios
|
||||
bool matchAlpha
|
||||
(
|
||||
const MPLICcellStorage& cellInfo
|
||||
);
|
||||
|
||||
//- Return face volume fraction
|
||||
inline const DynamicList<scalar>& alphaf() const;
|
||||
|
||||
//- Return cut normal
|
||||
inline const vector& cutNormal() const;
|
||||
|
||||
//- Return volume fraction corresponding to the cut
|
||||
inline scalar cutAlpha() const;
|
||||
|
||||
//- Return sub-cell volume
|
||||
inline scalar subCellVolume() const;
|
||||
};
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#include "MPLICcellI.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
293
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICcellI.H
Normal file
293
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICcellI.H
Normal file
@ -0,0 +1,293 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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 "MPLICcell.H"
|
||||
|
||||
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
|
||||
|
||||
inline void Foam::MPLICcell::calcAddressing
|
||||
(
|
||||
const MPLICcellStorage& cellInfo
|
||||
)
|
||||
{
|
||||
localEdgeFaces_.setSize(cellInfo.cellEdges().size());
|
||||
localFaceEdges_.setSize(cellInfo.size());
|
||||
|
||||
// Create edge map, setting edge faces to zero
|
||||
Map<label> edgeMap;
|
||||
forAll(cellInfo.cellEdges(), edgei)
|
||||
{
|
||||
edgeMap.set(cellInfo.cellEdges()[edgei], edgei);
|
||||
localEdgeFaces_[edgei].clear();
|
||||
}
|
||||
|
||||
// Set size of each face edges to zero
|
||||
forAll(localFaceEdges_, i)
|
||||
{
|
||||
localFaceEdges_[i].clear();
|
||||
}
|
||||
|
||||
forAll(cellInfo.cellFaces(), facei)
|
||||
{
|
||||
const label faceN = cellInfo.cellFaces()[facei];
|
||||
const labelList& faceEdges = cellInfo.faceEdges()[faceN];
|
||||
forAll(faceEdges, edgei)
|
||||
{
|
||||
const label edg = faceEdges[edgei];
|
||||
const label localEdgeIndex = edgeMap[edg];
|
||||
localEdgeFaces_[localEdgeIndex].append(facei);
|
||||
localFaceEdges_[facei].append(localEdgeIndex);
|
||||
}
|
||||
}
|
||||
addressingCalculated_ = true;
|
||||
}
|
||||
|
||||
|
||||
inline bool Foam::MPLICcell::cutStatusCalcSf()
|
||||
{
|
||||
bool cutOrientationDiffers = false;
|
||||
const point pAvg = sum(cutPoints_)/cutPoints_.size();
|
||||
for (label i=0; i<cutPoints_.size(); i+=2)
|
||||
{
|
||||
const vector area = (cutPoints_[i] - pAvg)^(cutPoints_[i+1] - pAvg);
|
||||
cutSf_ += area;
|
||||
if
|
||||
(
|
||||
sign(area.x()*cutSf_.x()) == -1
|
||||
|| sign(area.y()*cutSf_.y()) == -1
|
||||
|| sign(area.z()*cutSf_.z()) == -1
|
||||
)
|
||||
{
|
||||
cutOrientationDiffers = true;
|
||||
}
|
||||
}
|
||||
cutSf_ *= 0.5;
|
||||
|
||||
return cutOrientationDiffers;
|
||||
}
|
||||
|
||||
|
||||
inline Foam::vector Foam::MPLICcell::calcCutSf() const
|
||||
{
|
||||
vector cutArea = Zero;
|
||||
const point pAvg = sum(cutPoints_)/cutPoints_.size();
|
||||
for (label i=0; i<cutPoints_.size(); i+=2)
|
||||
{
|
||||
cutArea += (cutPoints_[i] - pAvg)^(cutPoints_[i+1] - pAvg);
|
||||
}
|
||||
cutArea *= 0.5;
|
||||
|
||||
return cutArea;
|
||||
}
|
||||
|
||||
|
||||
inline Foam::vector Foam::MPLICcell::calcCutCf(const vector& cutSf) const
|
||||
{
|
||||
const vector sumAHat = normalised(cutSf);
|
||||
const point pAvg = sum(cutPoints_)/cutPoints_.size();
|
||||
|
||||
scalar sumAn = 0;
|
||||
vector sumAnc = Zero;
|
||||
|
||||
for (label i=0; i < cutPoints_.size(); i+=2)
|
||||
{
|
||||
const vector a = (cutPoints_[i] - pAvg) ^ (cutPoints_[i+1] - pAvg);
|
||||
const vector c = cutPoints_[i] + cutPoints_[i+1] + pAvg;
|
||||
const scalar an = a & sumAHat;
|
||||
sumAn += an;
|
||||
sumAnc += an*c;
|
||||
}
|
||||
|
||||
if (sumAn > vSmall)
|
||||
{
|
||||
return (1.0/3.0)*sumAnc/sumAn;
|
||||
}
|
||||
else
|
||||
{
|
||||
return pAvg;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::MPLICcell::appendSfCf
|
||||
(
|
||||
const vector& Sf,
|
||||
const vector& Cf,
|
||||
const scalar magSf,
|
||||
const bool own
|
||||
)
|
||||
{
|
||||
if (magSf > 0)
|
||||
{
|
||||
if (own)
|
||||
{
|
||||
subFaceAreas_.append(Sf);
|
||||
}
|
||||
else
|
||||
{
|
||||
subFaceAreas_.append(-Sf);
|
||||
}
|
||||
subFaceCentres_.append(Cf);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::MPLICcell::phiU
|
||||
(
|
||||
const pointField& points,
|
||||
const faceList& faces,
|
||||
const labelList& cFaces,
|
||||
const vectorField& pointsU
|
||||
)
|
||||
{
|
||||
const label nFaces = cFaces.size();
|
||||
|
||||
// Set size and initialize alphaPhiU
|
||||
alphaPhiU_.setSize(nFaces);
|
||||
alphaPhiU_ = 0;
|
||||
|
||||
// Set size and initialize phiU
|
||||
phiU_.setSize(nFaces);
|
||||
|
||||
// Reconstruct fluxes
|
||||
forAll(cFaces, facei)
|
||||
{
|
||||
phiU_[facei] =
|
||||
MPLICface().alphaPhiU(pointsU, points, faces[cFaces[facei]]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::MPLICcell::resetFaceFields(const label nFaces)
|
||||
{
|
||||
alphaf_.setSize(nFaces);
|
||||
alphaf_ = 0;
|
||||
if (unweighted_)
|
||||
{
|
||||
subFaceMagSf_.setSize(nFaces);
|
||||
subFaceMagSf_ = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
alphaPhiU_.setSize(nFaces);
|
||||
alphaPhiU_ = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::MPLICcell::calcAlphaf
|
||||
(
|
||||
const UIndirectList<scalar>& magSfs
|
||||
)
|
||||
{
|
||||
const label nFaces = magSfs.size();
|
||||
alphaf_.setSize(nFaces);
|
||||
forAll(alphaf_, facei)
|
||||
{
|
||||
if (magSfs[facei] > vSmall)
|
||||
{
|
||||
alphaf_[facei] = subFaceMagSf_[facei]/magSfs[facei];
|
||||
|
||||
// Bound between 0 and 1 (it is always > 0)
|
||||
alphaf_[facei] = (alphaf_[facei] > 1) ? 1 : alphaf_[facei];
|
||||
}
|
||||
else
|
||||
{
|
||||
alphaf_[facei] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::MPLICcell::calcAlphaUf()
|
||||
{
|
||||
const label nFaces = alphaPhiU_.size();
|
||||
alphaf_.setSize(nFaces);
|
||||
forAll(alphaf_, facei)
|
||||
{
|
||||
if (mag(phiU_[facei]) > vSmall)
|
||||
{
|
||||
alphaf_[facei] = alphaPhiU_[facei]/phiU_[facei];
|
||||
|
||||
// Bound between 0 and 1
|
||||
alphaf_[facei] = (alphaf_[facei] > 1) ? 1 : alphaf_[facei];
|
||||
alphaf_[facei] = (alphaf_[facei] < 0) ? 0 : alphaf_[facei];
|
||||
}
|
||||
else
|
||||
{
|
||||
alphaf_[facei] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::MPLICcell::clearOneCut()
|
||||
{
|
||||
cutPoints_.clear();
|
||||
cutEdges_.clear();
|
||||
subFaceAreas_.clear();
|
||||
subFaceCentres_.clear();
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::MPLICcell::clear()
|
||||
{
|
||||
clearOneCut();
|
||||
alphaPhiU_.clear();
|
||||
subFaceMagSf_.clear();
|
||||
cutAlpha_ = -1;
|
||||
cutNormal_ = Zero;
|
||||
cutSf_ = Zero;
|
||||
subCellVolume_ = 0;
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
inline const Foam::DynamicList<Foam::scalar>& Foam::MPLICcell::alphaf() const
|
||||
{
|
||||
return alphaf_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::vector& Foam::MPLICcell::cutNormal() const
|
||||
{
|
||||
return cutNormal_;
|
||||
}
|
||||
|
||||
|
||||
inline Foam::scalar Foam::MPLICcell::subCellVolume() const
|
||||
{
|
||||
return subCellVolume_;
|
||||
}
|
||||
|
||||
|
||||
inline Foam::scalar Foam::MPLICcell::cutAlpha() const
|
||||
{
|
||||
return cutAlpha_;
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
174
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICcellStorage.C
Normal file
174
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICcellStorage.C
Normal file
@ -0,0 +1,174 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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 "MPLICcellStorage.H"
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
|
||||
|
||||
Foam::boolList Foam::MPLICcellStorage::calcIsOwner
|
||||
(
|
||||
const primitiveMesh& mesh,
|
||||
const label celli
|
||||
) const
|
||||
{
|
||||
const cell& c = mesh.cells()[celli];
|
||||
boolList cOwns(c.size(), false);
|
||||
forAll(c, i)
|
||||
{
|
||||
const label ow = mesh.faceOwner()[c[i]];
|
||||
if (ow == celli)
|
||||
{
|
||||
cOwns[i] = true;
|
||||
}
|
||||
}
|
||||
return cOwns;
|
||||
}
|
||||
|
||||
|
||||
Foam::scalar Foam::MPLICcellStorage::calcAlphaMin() const
|
||||
{
|
||||
// Initialize with the first value in the list
|
||||
scalar cellAlphaMin(pointsAlpha_.first());
|
||||
|
||||
// Loop through the rest and compare element-wise
|
||||
for (label i = 1; i < cPoints_.size(); ++i)
|
||||
{
|
||||
const label pI = cPoints_[i];
|
||||
cellAlphaMin = min(cellAlphaMin, pointsAlpha_[pI]);
|
||||
}
|
||||
|
||||
// Return minimum value
|
||||
return cellAlphaMin;
|
||||
}
|
||||
|
||||
|
||||
Foam::scalar Foam::MPLICcellStorage::calcAlphaMax() const
|
||||
{
|
||||
// Initialize with the first value in the list
|
||||
scalar cellAlphaMax(pointsAlpha_.first());
|
||||
|
||||
// Loop through the rest and compare element-wise
|
||||
for (label i = 1; i < cPoints_.size(); ++i)
|
||||
{
|
||||
const label pI = cPoints_[i];
|
||||
cellAlphaMax = max(cellAlphaMax, pointsAlpha_[pI]);
|
||||
}
|
||||
|
||||
// Return maximum value
|
||||
return cellAlphaMax;
|
||||
}
|
||||
|
||||
|
||||
Foam::scalarField Foam::MPLICcellStorage::calcFacesAlphaMin() const
|
||||
{
|
||||
scalarField facesAlphaMin(cFaces_.size());
|
||||
|
||||
forAll(cFaces_, facei)
|
||||
{
|
||||
// Face
|
||||
const face& f = faces_[cFaces_[facei]];
|
||||
|
||||
// Initialize with the first value in the list
|
||||
scalar fAlphaMin(pointsAlpha_[f.first()]);
|
||||
|
||||
// Loop through the rest and compare element-wise
|
||||
for (label i = 1; i < f.size(); ++i)
|
||||
{
|
||||
fAlphaMin = min(fAlphaMin, pointsAlpha_[f[i]]);
|
||||
}
|
||||
|
||||
facesAlphaMin[facei] = fAlphaMin;
|
||||
}
|
||||
|
||||
// Return minimum value
|
||||
return facesAlphaMin;
|
||||
}
|
||||
|
||||
|
||||
Foam::scalarField Foam::MPLICcellStorage::calcFacesAlphaMax() const
|
||||
{
|
||||
scalarField facesAlphaMax(cFaces_.size());
|
||||
|
||||
forAll(cFaces_, facei)
|
||||
{
|
||||
// Face
|
||||
const face& f = faces_[cFaces_[facei]];
|
||||
|
||||
// Initialize with the first value in the list
|
||||
scalar fAlphaMax(pointsAlpha_[f.first()]);
|
||||
|
||||
// Loop through the rest and compare element-wise
|
||||
for (label i = 1; i < f.size(); ++i)
|
||||
{
|
||||
fAlphaMax = max(fAlphaMax, pointsAlpha_[f[i]]);
|
||||
}
|
||||
|
||||
facesAlphaMax[facei] = fAlphaMax;
|
||||
}
|
||||
|
||||
// Return maximum
|
||||
return facesAlphaMax;
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
|
||||
|
||||
Foam::MPLICcellStorage::MPLICcellStorage
|
||||
(
|
||||
const primitiveMesh& mesh,
|
||||
const scalarField& pointsAlpha,
|
||||
const vectorField& pointsU,
|
||||
const scalar cellAlpha,
|
||||
const vector& cellU,
|
||||
const label celli
|
||||
)
|
||||
:
|
||||
points_(mesh.points()),
|
||||
faces_(mesh.faces()),
|
||||
edges_(mesh.edges()),
|
||||
edgeFaces_(mesh.faceEdges()),
|
||||
cPoints_(mesh.cellPoints()[celli]),
|
||||
cFaces_(mesh.cells()[celli]),
|
||||
cEdges_(mesh.cellEdges()[celli]),
|
||||
pointsAlpha_(pointsAlpha),
|
||||
pointsU_(pointsU),
|
||||
cellAlpha_(cellAlpha),
|
||||
celllU_(cellU),
|
||||
owns_(calcIsOwner(mesh, celli)),
|
||||
volume_(mesh.cellVolumes()[celli]),
|
||||
centre_(mesh.cellCentres()[celli]),
|
||||
Sf_(mesh.faceAreas(), cFaces_),
|
||||
Cf_(mesh.faceCentres(), cFaces_),
|
||||
magSf_(mesh.magFaceAreas(), cFaces_),
|
||||
cellAlphaMin_(calcAlphaMin()),
|
||||
cellAlphaMax_(calcAlphaMax()),
|
||||
facesAlphaMin_(calcFacesAlphaMin()),
|
||||
facesAlphaMax_(calcFacesAlphaMax()),
|
||||
faceEdges_(mesh.faceEdges())
|
||||
{}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
241
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICcellStorage.H
Normal file
241
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICcellStorage.H
Normal file
@ -0,0 +1,241 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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::MPLICcellStorage
|
||||
|
||||
Description
|
||||
Provides local cell addressing for geometry and data for MPLIC class.
|
||||
|
||||
SourceFiles
|
||||
MPLICcellStorage.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef MPLICcellStorage_H
|
||||
#define MPLICcellStorage_H
|
||||
|
||||
#include "primitiveMesh.H"
|
||||
#include "UIndirectList.H"
|
||||
#include "uindirectPrimitivePatch.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class MPLICcell Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
class MPLICcellStorage
|
||||
{
|
||||
// Private data
|
||||
|
||||
//- Reference to the mesh points
|
||||
const pointField& points_;
|
||||
|
||||
//- Reference to the mesh faces
|
||||
const faceList& faces_;
|
||||
|
||||
//- Reference to the mesh edges
|
||||
const edgeList& edges_;
|
||||
|
||||
//- Reference to the mesh face edges
|
||||
const labelListList& edgeFaces_;
|
||||
|
||||
//- Reference to the cell points
|
||||
const labelList& cPoints_;
|
||||
|
||||
//- Reference to face list
|
||||
const labelList& cFaces_;
|
||||
|
||||
//- Reference to cell edges
|
||||
const labelList& cEdges_;
|
||||
|
||||
//- Alpha at the cell vertices
|
||||
const scalarField& pointsAlpha_;
|
||||
|
||||
//- Velocity at the cell vertices
|
||||
const vectorField& pointsU_;
|
||||
|
||||
//- Cell centre value of alpha
|
||||
const scalar cellAlpha_;
|
||||
|
||||
//- Cell centre value of velocity
|
||||
const vector& celllU_;
|
||||
|
||||
//- Owner? For all faces on the cell
|
||||
const boolList owns_;
|
||||
|
||||
//- Cell volume
|
||||
const scalar volume_;
|
||||
|
||||
//- Cell centre
|
||||
const vector& centre_;
|
||||
|
||||
//- Face area vectors
|
||||
const UIndirectList<vector> Sf_;
|
||||
|
||||
//- Face centres
|
||||
const UIndirectList<vector> Cf_;
|
||||
|
||||
//- Face areas
|
||||
const UIndirectList<scalar> magSf_;
|
||||
|
||||
//- Cell alpha min
|
||||
const scalar cellAlphaMin_;
|
||||
|
||||
//- Cell alpha max
|
||||
const scalar cellAlphaMax_;
|
||||
|
||||
//- Face alpha mins
|
||||
const scalarField facesAlphaMin_;
|
||||
|
||||
//- Face alpha maxs
|
||||
const scalarField facesAlphaMax_;
|
||||
|
||||
//- Global face edges
|
||||
const labelListList& faceEdges_;
|
||||
|
||||
|
||||
// Private Member Functions
|
||||
|
||||
//- Return the face owner list for the faces of the cell
|
||||
boolList calcIsOwner
|
||||
(
|
||||
const primitiveMesh& mesh, const label celli
|
||||
) const;
|
||||
|
||||
//- Calculate minimum point alpha value in the cell
|
||||
scalar calcAlphaMin() const;
|
||||
|
||||
//- Calculate maximum point alpha value in the cell
|
||||
scalar calcAlphaMax() const;
|
||||
|
||||
//- Calculate minimum point alpha value on the cell faces
|
||||
scalarField calcFacesAlphaMin() const;
|
||||
|
||||
//- Calculate maximum point alpha value on the cell faces
|
||||
scalarField calcFacesAlphaMax() const;
|
||||
|
||||
|
||||
public:
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct from components
|
||||
MPLICcellStorage
|
||||
(
|
||||
const primitiveMesh& mesh,
|
||||
const scalarField& pointsAlpha,
|
||||
const vectorField& pointsU,
|
||||
const scalar cellAlpha,
|
||||
const vector& cellU,
|
||||
const label celli
|
||||
);
|
||||
|
||||
|
||||
// Public Member Functions
|
||||
|
||||
//- Return reference to mesh points
|
||||
inline const pointField& points() const;
|
||||
|
||||
//- Return reference to the mesh faces
|
||||
inline const faceList& faces() const;
|
||||
|
||||
//- Return reference to the mesh edges
|
||||
inline const edgeList& edges() const;
|
||||
|
||||
//- Return reference to the mesh face edges
|
||||
inline const labelListList& faceEdges() const;
|
||||
|
||||
//- Return reference to the cell points
|
||||
inline const labelList& cellPoints() const;
|
||||
|
||||
//- Return reference to face list
|
||||
inline const labelList& cellFaces() const;
|
||||
|
||||
//- Return reference to cell edges
|
||||
inline const labelList& cellEdges() const;
|
||||
|
||||
//- Return isOwners
|
||||
inline const boolList& isOwner() const;
|
||||
|
||||
//- Return point alphas
|
||||
inline const scalarField& pointsAlpha() const;
|
||||
|
||||
//- Return point velocities
|
||||
inline const vectorField& pointsU() const;
|
||||
|
||||
//- Return cell alpha
|
||||
inline scalar cellAlpha() const;
|
||||
|
||||
//- Return cell velocity
|
||||
inline const vector& cellU() const;
|
||||
|
||||
//- Return cell volume
|
||||
inline scalar V() const;
|
||||
|
||||
//- Return cell centre
|
||||
inline const vector& C() const;
|
||||
|
||||
//- Return face surface area vectors
|
||||
inline const UIndirectList<vector>& Sf() const;
|
||||
|
||||
//- Return face centres
|
||||
inline const UIndirectList<vector>& Cf() const;
|
||||
|
||||
//- Return face areas
|
||||
inline const UIndirectList<scalar>& magSf() const;
|
||||
|
||||
//- Return maximum point alpha value in the cell
|
||||
inline scalar cellAlphaMax() const;
|
||||
|
||||
//- Return minimum point alpha value in the cell
|
||||
inline scalar cellAlphaMin() const;
|
||||
|
||||
//- Return minimum point alpha value on the cell faces
|
||||
inline const scalarField& facesAlphaMin() const;
|
||||
|
||||
//- Return maximum point alpha value on the cell faces
|
||||
inline const scalarField& facesAlphaMax() const;
|
||||
|
||||
//- Return number of faces in the the cell
|
||||
inline label size() const;
|
||||
};
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
}// End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#include "MPLICcellStorageI.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
164
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICcellStorageI.H
Normal file
164
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICcellStorageI.H
Normal file
@ -0,0 +1,164 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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 "MPLICcellStorage.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
inline const Foam::pointField& Foam::MPLICcellStorage::points() const
|
||||
{
|
||||
return points_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::faceList& Foam::MPLICcellStorage::faces() const
|
||||
{
|
||||
return faces_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::edgeList& Foam::MPLICcellStorage::edges() const
|
||||
{
|
||||
return edges_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::labelListList& Foam::MPLICcellStorage::faceEdges() const
|
||||
{
|
||||
return faceEdges_;
|
||||
}
|
||||
|
||||
inline const Foam::labelList& Foam::MPLICcellStorage::cellPoints() const
|
||||
{
|
||||
return cPoints_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::labelList& Foam::MPLICcellStorage::cellFaces() const
|
||||
{
|
||||
return cFaces_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::labelList& Foam::MPLICcellStorage::cellEdges() const
|
||||
{
|
||||
return cEdges_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::boolList& Foam::MPLICcellStorage::isOwner() const
|
||||
{
|
||||
return owns_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::scalarField& Foam::MPLICcellStorage::pointsAlpha() const
|
||||
{
|
||||
return pointsAlpha_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::vectorField& Foam::MPLICcellStorage::pointsU() const
|
||||
{
|
||||
return pointsU_;
|
||||
}
|
||||
|
||||
|
||||
inline Foam::scalar Foam::MPLICcellStorage::cellAlpha() const
|
||||
{
|
||||
return cellAlpha_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::vector& Foam::MPLICcellStorage::cellU() const
|
||||
{
|
||||
return celllU_;
|
||||
}
|
||||
|
||||
|
||||
inline Foam::scalar Foam::MPLICcellStorage::V() const
|
||||
{
|
||||
return volume_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::vector& Foam::MPLICcellStorage::C() const
|
||||
{
|
||||
return centre_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::UIndirectList<Foam::vector>&
|
||||
Foam::MPLICcellStorage::Sf() const
|
||||
{
|
||||
return Sf_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::UIndirectList<Foam::vector>&
|
||||
Foam::MPLICcellStorage::Cf() const
|
||||
{
|
||||
return Cf_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::UIndirectList<Foam::scalar>&
|
||||
Foam::MPLICcellStorage::magSf() const
|
||||
{
|
||||
return magSf_;
|
||||
}
|
||||
|
||||
|
||||
inline Foam::scalar Foam::MPLICcellStorage::cellAlphaMax() const
|
||||
{
|
||||
return cellAlphaMax_;
|
||||
}
|
||||
|
||||
|
||||
inline Foam::scalar Foam::MPLICcellStorage::cellAlphaMin() const
|
||||
{
|
||||
return cellAlphaMin_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::scalarField& Foam::MPLICcellStorage::facesAlphaMin() const
|
||||
{
|
||||
return facesAlphaMin_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::scalarField& Foam::MPLICcellStorage::facesAlphaMax() const
|
||||
{
|
||||
return facesAlphaMax_;
|
||||
}
|
||||
|
||||
|
||||
inline Foam::label Foam::MPLICcellStorage::size() const
|
||||
{
|
||||
return cFaces_.size();
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
279
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICface.C
Normal file
279
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICface.C
Normal file
@ -0,0 +1,279 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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 "MPLICface.H"
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
|
||||
|
||||
Foam::MPLICface::MPLICface(const bool unweighted)
|
||||
:
|
||||
unweighted_(unweighted)
|
||||
{};
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
Foam::label Foam::MPLICface::cutFace
|
||||
(
|
||||
const labelList& f,
|
||||
const labelList& faceEdges,
|
||||
const pointField& points,
|
||||
const boolList& isEdgeCutOld,
|
||||
boolList& isEdgeCut,
|
||||
label& faceEdgei,
|
||||
const UList<scalar>& pointsAlpha,
|
||||
const UList<vector>& pointsU,
|
||||
const label facei,
|
||||
const scalar target,
|
||||
const bool ow
|
||||
)
|
||||
{
|
||||
// Clear all the storage
|
||||
cutPoints_.clear();
|
||||
subPoints_.clear();
|
||||
cutEdges_.clear();
|
||||
subPointsU_.clear();
|
||||
|
||||
// Direction of face circulators
|
||||
flipped_ = false;
|
||||
|
||||
label fp;
|
||||
if (faceEdgei == -1)
|
||||
{
|
||||
const UIndirectList<scalar> fAlphas(pointsAlpha, f);
|
||||
|
||||
// Starting from this point on the face
|
||||
fp = findMin(fAlphas);
|
||||
flipped_ = ow ? false : true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Finding first index of the edge in the face point list
|
||||
const label startPoint = faceEdgei;
|
||||
|
||||
// Pick up starting point and decide direction of circulators
|
||||
const label fwd = f.fcIndex(startPoint);
|
||||
const label back = f.rcIndex(startPoint);
|
||||
const label lEdgeP = f[fwd] == f[f.fcIndex(faceEdgei)] ? fwd : back;
|
||||
|
||||
// Starting from this point on the face
|
||||
fp = pointsAlpha[f[startPoint]] < pointsAlpha[f[lEdgeP]]
|
||||
? startPoint : lEdgeP;
|
||||
|
||||
if
|
||||
(
|
||||
!(
|
||||
(
|
||||
lEdgeP == fwd
|
||||
&& pointsAlpha[f[startPoint]] < pointsAlpha[f[lEdgeP]]
|
||||
)
|
||||
|| (
|
||||
lEdgeP == back
|
||||
&& pointsAlpha[f[startPoint]] > pointsAlpha[f[lEdgeP]]
|
||||
)
|
||||
)
|
||||
)
|
||||
{
|
||||
flipped_ = true;
|
||||
}
|
||||
}
|
||||
|
||||
label nextFp, edgei;
|
||||
if (flipped_)
|
||||
{
|
||||
nextFp = f.rcIndex(fp);
|
||||
edgei = nextFp;
|
||||
}
|
||||
else
|
||||
{
|
||||
nextFp = f.fcIndex(fp);
|
||||
edgei = fp;
|
||||
}
|
||||
|
||||
forAll(f, i)
|
||||
{
|
||||
// Edge points field value
|
||||
const scalar& fl = pointsAlpha[f[fp]];
|
||||
const scalar& fk = pointsAlpha[f[nextFp]];
|
||||
|
||||
const point& pL = points[f[fp]];
|
||||
const point& pK = points[f[nextFp]];
|
||||
|
||||
const label edg = faceEdges[edgei];
|
||||
|
||||
// Collect sub-point if the iso-value is bigger than target value
|
||||
if (fl >= target && cutPoints_.size() > 0)
|
||||
{
|
||||
subPoints_.append(pL);
|
||||
if (!unweighted_)
|
||||
{
|
||||
subPointsU_.append(pointsU[f[fp]]);
|
||||
}
|
||||
}
|
||||
|
||||
// Cut the edge
|
||||
if
|
||||
(
|
||||
!isEdgeCutOld[edg]
|
||||
&& ((fl < target && fk >= target) || (fl >= target && fk < target))
|
||||
)
|
||||
{
|
||||
const scalar coeff = (target - fk)/(fl - fk);
|
||||
const point cut = pK + coeff*(pL - pK);
|
||||
if (!unweighted_)
|
||||
{
|
||||
subPointsU_.append
|
||||
(
|
||||
pointsU[f[nextFp]]
|
||||
+ coeff*(pointsU[f[fp]] - pointsU[f[nextFp]])
|
||||
);
|
||||
}
|
||||
cutPoints_.append(cut);
|
||||
subPoints_.append(cut);
|
||||
cutEdges_.append(edg);
|
||||
isEdgeCut[edg] = true;
|
||||
}
|
||||
|
||||
// Termination control
|
||||
if (cutPoints_.size() == 2)
|
||||
{
|
||||
faceEdgei = edgei;
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (flipped_)
|
||||
{
|
||||
fp = f.rcIndex(fp);
|
||||
nextFp = f.rcIndex(fp);
|
||||
edgei = nextFp;
|
||||
}
|
||||
else
|
||||
{
|
||||
fp = f.fcIndex(fp);
|
||||
nextFp = f.fcIndex(fp);
|
||||
edgei = fp;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
Foam::label Foam::MPLICface::cutFace
|
||||
(
|
||||
const UList<label>& f,
|
||||
const UList<point>& points,
|
||||
const UList<scalar>& pointsAlpha,
|
||||
const UList<vector>& pointsU,
|
||||
const scalar target,
|
||||
const bool ow
|
||||
)
|
||||
{
|
||||
// Clear all the storage
|
||||
cutPoints_.clear();
|
||||
subPoints_.clear();
|
||||
subPointsU_.clear();
|
||||
|
||||
// Direction of face circulators
|
||||
flipped_ = ow ? false : true;
|
||||
|
||||
const UIndirectList<scalar> fAlphas(pointsAlpha, f);
|
||||
|
||||
// Starting from point with minimum alpha value
|
||||
label fp = findMin(fAlphas);
|
||||
|
||||
// Second point index
|
||||
label nextFp = flipped_ ? f.rcIndex(fp) : f.fcIndex(fp);
|
||||
|
||||
forAll(f, i)
|
||||
{
|
||||
// Edge points field value
|
||||
const scalar& fl = pointsAlpha[f[fp]];
|
||||
const scalar& fk = pointsAlpha[f[nextFp]];
|
||||
|
||||
const point& pL = points[f[fp]];
|
||||
const point& pK = points[f[nextFp]];
|
||||
|
||||
// Collect sub-point if the iso-value is bigger than target value
|
||||
if (fl >= target && cutPoints_.size() > 0)
|
||||
{
|
||||
subPoints_.append(pL);
|
||||
if (!unweighted_)
|
||||
{
|
||||
subPointsU_.append(pointsU[f[fp]]);
|
||||
}
|
||||
}
|
||||
|
||||
// Cut the edge
|
||||
if ((fl < target && fk >= target) || (fl >= target && fk < target))
|
||||
{
|
||||
const scalar coeff = (target - fk)/(fl - fk);
|
||||
const point cut = pK + coeff*(pL - pK);
|
||||
if (!unweighted_)
|
||||
{
|
||||
subPointsU_.append
|
||||
(
|
||||
pointsU[f[nextFp]]
|
||||
+ coeff*(pointsU[f[fp]] - pointsU[f[nextFp]])
|
||||
);
|
||||
}
|
||||
cutPoints_.append(cut);
|
||||
subPoints_.append(cut);
|
||||
}
|
||||
|
||||
if (flipped_)
|
||||
{
|
||||
fp = f.rcIndex(fp);
|
||||
nextFp = f.rcIndex(fp);
|
||||
}
|
||||
else
|
||||
{
|
||||
fp = f.fcIndex(fp);
|
||||
nextFp = f.fcIndex(fp);
|
||||
}
|
||||
}
|
||||
|
||||
// Simple cut
|
||||
if (cutPoints_.size() == 2)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Multiple cuts through the face
|
||||
else if (cutPoints_.size() > 2)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
// No cut
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
176
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICface.H
Normal file
176
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICface.H
Normal file
@ -0,0 +1,176 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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::MPLICface
|
||||
|
||||
Description
|
||||
Class that deals with cutting faces based on face point values and target
|
||||
value.
|
||||
|
||||
SourceFiles
|
||||
MPLICface.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef MPLICface_H
|
||||
#define MPLICface_H
|
||||
|
||||
#include "face.H"
|
||||
#include "pointField.H"
|
||||
#include "DynamicList.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class MPLICface Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
class MPLICface
|
||||
{
|
||||
// Private Member variables
|
||||
|
||||
//- Store all the cut points
|
||||
DynamicList<point> cutPoints_;
|
||||
|
||||
//- Store points of sub face
|
||||
DynamicList<point> subPoints_;
|
||||
|
||||
//- Labels of cut edges
|
||||
DynamicList<label> cutEdges_;
|
||||
|
||||
//- Store velocity point values
|
||||
DynamicList<vector> subPointsU_;
|
||||
|
||||
//- Keep truck of face orientation
|
||||
bool flipped_;
|
||||
|
||||
//- Select unweighted interpolation if true
|
||||
// velocity flux corrected if false
|
||||
const bool unweighted_;
|
||||
|
||||
|
||||
public:
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct empty
|
||||
MPLICface(const bool unweighted = true);
|
||||
|
||||
// - Destructor
|
||||
~MPLICface()
|
||||
{}
|
||||
|
||||
|
||||
// Member functions
|
||||
|
||||
//- Function to cut for multi cut
|
||||
// Returns:
|
||||
// - 0: no cut
|
||||
// - 1: cut
|
||||
label cutFace
|
||||
(
|
||||
const labelList& f,
|
||||
const labelList& faceEdges,
|
||||
const pointField& points,
|
||||
const boolList& isEdgeCutOld,
|
||||
boolList& isEdgeCut,
|
||||
label& faceEdgei,
|
||||
const UList<scalar>& pointsAlpha,
|
||||
const UList<vector>& pointsU,
|
||||
const label facei,
|
||||
const scalar target,
|
||||
const bool ow
|
||||
);
|
||||
|
||||
//- Cut the face and return the type of cut
|
||||
// Returns:
|
||||
// - -1: multi cut
|
||||
// - 0: no cut
|
||||
// - +1: single cut
|
||||
label cutFace
|
||||
(
|
||||
const UList<label>& f,
|
||||
const UList<point>& points,
|
||||
const UList<scalar>& pointsAlpha,
|
||||
const UList<vector>& pointsU,
|
||||
const scalar target,
|
||||
const bool ow
|
||||
);
|
||||
|
||||
//- Calculate and return alphaPhiU
|
||||
inline scalar alphaPhiU() const;
|
||||
|
||||
//- Calculate and return alphaPhiU
|
||||
template<class VectorList, class PointList>
|
||||
inline scalar alphaPhiU
|
||||
(
|
||||
const VectorList& pointsU,
|
||||
const PointList& points
|
||||
) const;
|
||||
|
||||
//- Calculate and return alphaPhiU
|
||||
template<class VectorList, class PointList>
|
||||
inline scalar alphaPhiU
|
||||
(
|
||||
const VectorList& pointsU,
|
||||
const PointList& points,
|
||||
const labelList& f
|
||||
) const;
|
||||
|
||||
//- Access to cut points
|
||||
inline const DynamicList<point>& cutPoints() const;
|
||||
|
||||
//- Access to submerged face points
|
||||
inline const DynamicList<point>& subPoints() const;
|
||||
|
||||
//- Access to cut edges
|
||||
inline const DynamicList<label>& cutEdges() const;
|
||||
|
||||
//- Return subface surface area vector
|
||||
inline const vector Sf() const;
|
||||
|
||||
//- Return subface centre
|
||||
inline const vector Cf(const vector& area) const;
|
||||
|
||||
//- Return interpolated U values
|
||||
inline const DynamicList<vector>& U() const;
|
||||
};
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#include "MPLICfaceI.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
178
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICfaceI.H
Normal file
178
src/twoPhaseModels/twoPhaseMixture/MPLIC/MPLICfaceI.H
Normal file
@ -0,0 +1,178 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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 "MPLICface.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
Foam::scalar Foam::MPLICface::alphaPhiU() const
|
||||
{
|
||||
if (flipped_)
|
||||
{
|
||||
return -alphaPhiU(subPointsU_, subPoints_);
|
||||
}
|
||||
else
|
||||
{
|
||||
return alphaPhiU(subPointsU_, subPoints_);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class VectorList, class PointList>
|
||||
inline Foam::scalar Foam::MPLICface::alphaPhiU
|
||||
(
|
||||
const VectorList& pointsU,
|
||||
const PointList& points
|
||||
) const
|
||||
{
|
||||
const point& baseP = points[0];
|
||||
const vector& baseU = pointsU[0];
|
||||
|
||||
scalar alphaPhiU = 0;
|
||||
for(label i=1; i < points.size()-1; ++i)
|
||||
{
|
||||
// 1/2 Triangle area
|
||||
const vector area = (points[i] - baseP) ^ (points[i + 1] - baseP);
|
||||
|
||||
// Calculate face area weighted velocity field
|
||||
// Average is missing 1/3 and area 1/2
|
||||
alphaPhiU += (baseU + pointsU[i] + pointsU[i + 1]) & area;
|
||||
}
|
||||
alphaPhiU /= 6.0;
|
||||
|
||||
return alphaPhiU;
|
||||
}
|
||||
|
||||
|
||||
template<class VectorList, class PointList>
|
||||
inline Foam::scalar Foam::MPLICface::alphaPhiU
|
||||
(
|
||||
const VectorList& pointsU,
|
||||
const PointList& points,
|
||||
const labelList& f
|
||||
) const
|
||||
{
|
||||
const point& baseP = points[f[0]];
|
||||
const vector& baseU = pointsU[f[0]];
|
||||
|
||||
scalar alphaPhiU = 0;
|
||||
for(label i=1; i < f.size()-1; ++i)
|
||||
{
|
||||
// 1/2 Triangle area
|
||||
const vector area = (points[f[i]] - baseP) ^ (points[f[i + 1]] - baseP);
|
||||
|
||||
// Calculate face area weighted velocity field
|
||||
// Average is missing 1/3 and area 1/2
|
||||
alphaPhiU += (baseU + pointsU[f[i]] + pointsU[f[i + 1]]) & area;
|
||||
}
|
||||
alphaPhiU /= 6.0;
|
||||
|
||||
return alphaPhiU;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::DynamicList<Foam::point>& Foam::MPLICface::cutPoints() const
|
||||
{
|
||||
return cutPoints_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::DynamicList<Foam::point>&
|
||||
Foam::MPLICface::subPoints() const
|
||||
{
|
||||
return subPoints_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::DynamicList<Foam::label>& Foam::MPLICface::cutEdges() const
|
||||
{
|
||||
return cutEdges_;
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::vector Foam::MPLICface::Sf() const
|
||||
{
|
||||
return face::area(subPoints_);
|
||||
}
|
||||
|
||||
|
||||
inline const Foam::vector Foam::MPLICface::Cf
|
||||
(
|
||||
const vector& area
|
||||
) const
|
||||
{
|
||||
// If the face is a triangle, do a direct calculation
|
||||
if (subPoints_.size() == 3)
|
||||
{
|
||||
return (1.0/3.0)*(subPoints_[0] + subPoints_[1] + subPoints_[2]);
|
||||
}
|
||||
|
||||
// For more complex faces, decompose into triangles ...
|
||||
|
||||
// Compute an estimate of the centre as the average of the points
|
||||
point pAvg = Zero;
|
||||
forAll(subPoints_, pi)
|
||||
{
|
||||
pAvg += subPoints_[pi];
|
||||
}
|
||||
pAvg /= subPoints_.size();
|
||||
|
||||
const vector sumAHat = normalised(area);
|
||||
|
||||
// Compute the area-weighted sum of the triangle centres. Note use
|
||||
// the triangle area projected in the direction of the face normal
|
||||
// as the weight, *not* the triangle area magnitude. Only the
|
||||
// former makes the calculation independent of the initial estimate.
|
||||
scalar sumAn = 0;
|
||||
vector sumAnc = Zero;
|
||||
forAll(subPoints_, pi)
|
||||
{
|
||||
const point& p = subPoints_[pi];
|
||||
const point& pNext = subPoints_[subPoints_.fcIndex(pi)];
|
||||
|
||||
const vector a = (pNext - p)^(pAvg - p);
|
||||
const vector c = p + pNext + pAvg;
|
||||
|
||||
const scalar an = a & sumAHat;
|
||||
|
||||
sumAn += an;
|
||||
sumAnc += an*c;
|
||||
}
|
||||
|
||||
// Complete calculating centres and areas. If the face is too small
|
||||
// for the sums to be reliably divided then just set the centre to
|
||||
// the initial estimate.
|
||||
if (sumAn > vSmall)
|
||||
{
|
||||
return (1.0/3.0)*sumAnc/sumAn;
|
||||
}
|
||||
else
|
||||
{
|
||||
return pAvg;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -1,4 +1,14 @@
|
||||
twoPhaseMixture/twoPhaseMixture.C
|
||||
|
||||
interfaceCompression/interfaceCompression.C
|
||||
|
||||
MPLIC/MPLICface.C
|
||||
MPLIC/MPLICcellStorage.C
|
||||
MPLIC/MPLICcell.C
|
||||
MPLIC/MPLIC.C
|
||||
MPLIC/MPLICU.C
|
||||
|
||||
PLIC/PLIC.C
|
||||
PLIC/PLICU.C
|
||||
|
||||
LIB = $(FOAM_LIBBIN)/libtwoPhaseMixture
|
||||
|
||||
68
src/twoPhaseModels/twoPhaseMixture/PLIC/PLIC.C
Normal file
68
src/twoPhaseModels/twoPhaseMixture/PLIC/PLIC.C
Normal file
@ -0,0 +1,68 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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 "PLIC.H"
|
||||
#include "slicedSurfaceFields.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
defineTypeNameAndDebug(PLIC, 0);
|
||||
|
||||
surfaceInterpolationScheme<scalar>::addMeshFluxConstructorToTable<PLIC>
|
||||
addPLICScalarMeshFluxConstructorToTable_;
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
Foam::tmp<Foam::surfaceScalarField> Foam::PLIC::interpolate
|
||||
(
|
||||
const volScalarField& vf
|
||||
) const
|
||||
{
|
||||
tmp<surfaceScalarField> tvff(tScheme_().interpolate(vf));
|
||||
|
||||
scalarField spicedTvff
|
||||
(
|
||||
slicedSurfaceScalarField
|
||||
(
|
||||
IOobject
|
||||
(
|
||||
"spicedTvff",
|
||||
vf.mesh().time().timeName(),
|
||||
vf.mesh()
|
||||
),
|
||||
tvff.ref(),
|
||||
false
|
||||
).splice()
|
||||
);
|
||||
|
||||
return surfaceAlpha(vf, phi_, spicedTvff, true, 1e-6, false);
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
142
src/twoPhaseModels/twoPhaseMixture/PLIC/PLIC.H
Normal file
142
src/twoPhaseModels/twoPhaseMixture/PLIC/PLIC.H
Normal file
@ -0,0 +1,142 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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::PLIC
|
||||
|
||||
Description
|
||||
Piecewise-Linear Interface Calculation (PLIC) corrected scheme is a surface
|
||||
interpolation scheme for flux calculation in advection of a bounded
|
||||
variable, e.g. phase fraction and for interface capturing in the volume of
|
||||
fluid (VoF) method.
|
||||
|
||||
The interface is represented by single cuts which split each cell to match
|
||||
the volume fraction of the phase in the cell. The cut planes are oriented
|
||||
according to the point field of the local phase fraction. The phase
|
||||
fraction at each cell face - the interpolated value - is then calculated
|
||||
from the face area on either side of the cut. For cases where the
|
||||
single-cut does not accurately represent the cell volume fraction the
|
||||
specified default scheme is used, e.g. interfaceCompression.
|
||||
|
||||
Example:
|
||||
\verbatim
|
||||
divSchemes
|
||||
{
|
||||
.
|
||||
.
|
||||
div(phi,alpha) Gauss PLIC interfaceCompression vanLeer 1;
|
||||
.
|
||||
.
|
||||
}
|
||||
\endverbatim
|
||||
|
||||
See also
|
||||
Foam::PLICU
|
||||
Foam::MPLIC
|
||||
Foam::MPLICU
|
||||
Foam::interfaceCompression
|
||||
|
||||
SourceFiles
|
||||
PLIC.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef PLIC_H
|
||||
#define PLIC_H
|
||||
|
||||
#include "MPLIC.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class PLIC Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
class PLIC
|
||||
:
|
||||
public MPLIC
|
||||
{
|
||||
|
||||
protected:
|
||||
|
||||
// Protected member data
|
||||
|
||||
const surfaceScalarField& phi_;
|
||||
|
||||
//- Base scheme to which the compression is applied
|
||||
tmp<surfaceInterpolationScheme<scalar>> tScheme_;
|
||||
|
||||
|
||||
public:
|
||||
|
||||
//- Runtime type information
|
||||
TypeName("PLIC");
|
||||
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct from faceFlux and Istream
|
||||
PLIC
|
||||
(
|
||||
const fvMesh& mesh,
|
||||
const surfaceScalarField& faceFlux,
|
||||
Istream& is
|
||||
)
|
||||
:
|
||||
MPLIC(mesh, faceFlux, is),
|
||||
phi_(faceFlux),
|
||||
tScheme_
|
||||
(
|
||||
surfaceInterpolationScheme<scalar>::New(mesh, faceFlux, is)
|
||||
)
|
||||
{}
|
||||
|
||||
|
||||
// Member Functions
|
||||
|
||||
//- Return the face-interpolate of the given cell field
|
||||
virtual tmp<surfaceScalarField> interpolate
|
||||
(
|
||||
const volScalarField& vf
|
||||
) const;
|
||||
|
||||
|
||||
// Member Operators
|
||||
|
||||
//- Disallow default bitwise assignment
|
||||
void operator=(const PLIC&) = delete;
|
||||
};
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
68
src/twoPhaseModels/twoPhaseMixture/PLIC/PLICU.C
Normal file
68
src/twoPhaseModels/twoPhaseMixture/PLIC/PLICU.C
Normal file
@ -0,0 +1,68 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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 "PLICU.H"
|
||||
#include "slicedSurfaceFields.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
defineTypeNameAndDebug(PLICU, 0);
|
||||
|
||||
surfaceInterpolationScheme<scalar>::addMeshFluxConstructorToTable<PLICU>
|
||||
addPLICUScalarMeshFluxConstructorToTable_;
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
Foam::tmp<Foam::surfaceScalarField> Foam::PLICU::interpolate
|
||||
(
|
||||
const volScalarField& vf
|
||||
) const
|
||||
{
|
||||
tmp<surfaceScalarField> tvff(tScheme_().interpolate(vf));
|
||||
|
||||
scalarField spicedTvff
|
||||
(
|
||||
slicedSurfaceScalarField
|
||||
(
|
||||
IOobject
|
||||
(
|
||||
"spicedTvff",
|
||||
vf.mesh().time().timeName(),
|
||||
vf.mesh()
|
||||
),
|
||||
tvff.ref(),
|
||||
false
|
||||
).splice()
|
||||
);
|
||||
|
||||
return surfaceAlpha(vf, phi_, spicedTvff, false, 1e-6, false);
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
130
src/twoPhaseModels/twoPhaseMixture/PLIC/PLICU.H
Normal file
130
src/twoPhaseModels/twoPhaseMixture/PLIC/PLICU.H
Normal file
@ -0,0 +1,130 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020 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::PLICU
|
||||
|
||||
Description
|
||||
Velocity-weighted Piecewise-Linear Interface Calculation (PLICU) corrected
|
||||
scheme is a surface interpolation scheme for flux calculation in advection
|
||||
of a bounded variable, e.g. phase fraction and for interface capturing in
|
||||
the volume of fluid (VoF) method.
|
||||
|
||||
The interface is represented by single cuts which split each cell to match
|
||||
the volume fraction of the phase in the cell. The cut planes are oriented
|
||||
according to the point field of the local phase fraction. The phase
|
||||
fraction at each cell face - the interpolated value - is then calculated
|
||||
from the face area on either side of the cut. For cases where the
|
||||
single-cut does not accurately represent the cell volume fraction the
|
||||
specified default scheme is used, e.g. interfaceCompression.
|
||||
|
||||
Additionally the face point velocity values are used to calculate the face
|
||||
flux which is likely to be more accurate in the presence of high shear.
|
||||
|
||||
Example:
|
||||
\verbatim
|
||||
divSchemes
|
||||
{
|
||||
.
|
||||
.
|
||||
div(phi,alpha) Gauss PLICU interfaceCompression vanLeer 1;
|
||||
.
|
||||
.
|
||||
}
|
||||
\endverbatim
|
||||
|
||||
See also
|
||||
Foam::PLIC
|
||||
Foam::MPLIC
|
||||
Foam::MPLICU
|
||||
Foam::interfaceCompression
|
||||
|
||||
SourceFiles
|
||||
PLICU.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef PLICU_H
|
||||
#define PLICU_H
|
||||
|
||||
#include "PLIC.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class PLIC Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
class PLICU
|
||||
:
|
||||
public PLIC
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
//- Runtime type information
|
||||
TypeName("PLICU");
|
||||
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct from faceFlux and Istream
|
||||
PLICU
|
||||
(
|
||||
const fvMesh& mesh,
|
||||
const surfaceScalarField& faceFlux,
|
||||
Istream& is
|
||||
)
|
||||
:
|
||||
PLIC(mesh, faceFlux, is)
|
||||
{}
|
||||
|
||||
|
||||
// Member Functions
|
||||
|
||||
//- Return the face-interpolate of the given cell field
|
||||
virtual tmp<surfaceScalarField> interpolate
|
||||
(
|
||||
const volScalarField& vf
|
||||
) const;
|
||||
|
||||
|
||||
// Member Operators
|
||||
|
||||
//- Disallow default bitwise assignment
|
||||
void operator=(const PLICU&) = delete;
|
||||
};
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
58
tutorials/multiphase/interFoam/RAS/planningHullW3/0/U
Normal file
58
tutorials/multiphase/interFoam/RAS/planningHullW3/0/U
Normal file
@ -0,0 +1,58 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class volVectorField;
|
||||
location "0";
|
||||
object U;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
UMean 4.598;
|
||||
|
||||
dimensions [0 1 -1 0 0 0 0];
|
||||
|
||||
internalField uniform (#neg $UMean 0 0);
|
||||
|
||||
boundaryField
|
||||
{
|
||||
//- Set patchGroups for constraint patches
|
||||
#includeEtc "caseDicts/setConstraintTypes"
|
||||
|
||||
inlet
|
||||
{
|
||||
type fixedValue;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
outlet
|
||||
{
|
||||
type outletPhaseMeanVelocity;
|
||||
alpha alpha.water;
|
||||
UnMean $UMean;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
atmosphere
|
||||
{
|
||||
type pressureInletOutletVelocity;
|
||||
tangentialVelocity $internalField;
|
||||
value uniform (0 0 0);
|
||||
}
|
||||
|
||||
hull
|
||||
{
|
||||
type movingWallVelocity;
|
||||
value uniform (0 0 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,54 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class volScalarField;
|
||||
location "0";
|
||||
object alpha;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
dimensions [0 0 0 0 0 0 0];
|
||||
|
||||
internalField uniform 0;
|
||||
|
||||
boundaryField
|
||||
{
|
||||
//- Set patchGroups for constraint patches
|
||||
#includeEtc "caseDicts/setConstraintTypes"
|
||||
|
||||
inlet
|
||||
{
|
||||
type fixedValue;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
outlet
|
||||
{
|
||||
type variableHeightFlowRate;
|
||||
lowerBound 0;
|
||||
upperBound 1;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
atmosphere
|
||||
{
|
||||
type inletOutlet;
|
||||
inletValue $internalField;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
hull
|
||||
{
|
||||
type interfaceCompression;
|
||||
}
|
||||
}
|
||||
|
||||
// ************************************************************************* //
|
||||
54
tutorials/multiphase/interFoam/RAS/planningHullW3/0/k
Normal file
54
tutorials/multiphase/interFoam/RAS/planningHullW3/0/k
Normal file
@ -0,0 +1,54 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class volScalarField;
|
||||
location "0";
|
||||
object k;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
dimensions [0 2 -2 0 0 0 0];
|
||||
|
||||
internalField uniform 0.0005;
|
||||
|
||||
boundaryField
|
||||
{
|
||||
//- Set patchGroups for constraint patches
|
||||
#includeEtc "caseDicts/setConstraintTypes"
|
||||
|
||||
inlet
|
||||
{
|
||||
type fixedValue;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
outlet
|
||||
{
|
||||
type inletOutlet;
|
||||
inletValue $internalField;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
atmosphere
|
||||
{
|
||||
type inletOutlet;
|
||||
inletValue $internalField;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
hull
|
||||
{
|
||||
type kqRWallFunction;
|
||||
value $internalField;
|
||||
}
|
||||
}
|
||||
|
||||
// ************************************************************************* //
|
||||
53
tutorials/multiphase/interFoam/RAS/planningHullW3/0/nut
Normal file
53
tutorials/multiphase/interFoam/RAS/planningHullW3/0/nut
Normal file
@ -0,0 +1,53 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class volScalarField;
|
||||
location "0";
|
||||
object nut;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
dimensions [0 2 -1 0 0 0 0];
|
||||
|
||||
internalField uniform 5e-07;
|
||||
|
||||
boundaryField
|
||||
{
|
||||
//- Set patchGroups for constraint patches
|
||||
#includeEtc "caseDicts/setConstraintTypes"
|
||||
|
||||
inlet
|
||||
{
|
||||
type fixedValue;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
outlet
|
||||
{
|
||||
type zeroGradient;
|
||||
}
|
||||
|
||||
atmosphere
|
||||
{
|
||||
type zeroGradient;
|
||||
}
|
||||
|
||||
hull
|
||||
{
|
||||
type nutkRoughWallFunction;
|
||||
Ks uniform 100e-6;
|
||||
Cs uniform 0.5;
|
||||
value $internalField;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
56
tutorials/multiphase/interFoam/RAS/planningHullW3/0/omega
Normal file
56
tutorials/multiphase/interFoam/RAS/planningHullW3/0/omega
Normal file
@ -0,0 +1,56 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class volScalarField;
|
||||
location "0";
|
||||
object omega;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
dimensions [0 0 -1 0 0 0 0];
|
||||
|
||||
internalField uniform 240;
|
||||
|
||||
boundaryField
|
||||
{
|
||||
//- Set patchGroups for constraint patches
|
||||
#includeEtc "caseDicts/setConstraintTypes"
|
||||
|
||||
inlet
|
||||
{
|
||||
type fixedValue;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
outlet
|
||||
{
|
||||
type inletOutlet;
|
||||
inletValue $internalField;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
atmosphere
|
||||
{
|
||||
type inletOutlet;
|
||||
inletValue $internalField;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
hull
|
||||
{
|
||||
type omegaWallFunction;
|
||||
value $internalField;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
51
tutorials/multiphase/interFoam/RAS/planningHullW3/0/p_rgh
Normal file
51
tutorials/multiphase/interFoam/RAS/planningHullW3/0/p_rgh
Normal file
@ -0,0 +1,51 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class volScalarField;
|
||||
location "0";
|
||||
object p_rgh;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
dimensions [1 -1 -2 0 0 0 0];
|
||||
|
||||
internalField uniform 0;
|
||||
|
||||
boundaryField
|
||||
{
|
||||
//- Set patchGroups for constraint patches
|
||||
#includeEtc "caseDicts/setConstraintTypes"
|
||||
|
||||
inlet
|
||||
{
|
||||
type fixedFluxPressure;
|
||||
value $internalField;
|
||||
}
|
||||
|
||||
outlet
|
||||
{
|
||||
type zeroGradient;
|
||||
}
|
||||
|
||||
atmosphere
|
||||
{
|
||||
type prghEntrainmentPressure;
|
||||
p0 uniform 0;
|
||||
}
|
||||
|
||||
hull
|
||||
{
|
||||
type fixedFluxPressure;
|
||||
value $internalField;
|
||||
}
|
||||
}
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,52 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class pointVectorField;
|
||||
location "0";
|
||||
object pointDisplacement;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
dimensions [0 1 0 0 0 0 0];
|
||||
|
||||
internalField uniform (0 0 0);
|
||||
|
||||
boundaryField
|
||||
{
|
||||
//- Set patchGroups for constraint patches
|
||||
#includeEtc "caseDicts/setConstraintTypes"
|
||||
|
||||
inlet
|
||||
{
|
||||
type fixedValue;
|
||||
value uniform (0 0 0);
|
||||
}
|
||||
|
||||
outlet
|
||||
{
|
||||
type fixedValue;
|
||||
value uniform (0 0 0);
|
||||
}
|
||||
|
||||
atmosphere
|
||||
{
|
||||
type fixedValue;
|
||||
value uniform (0 0 0);
|
||||
}
|
||||
|
||||
hull
|
||||
{
|
||||
type calculated;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
15
tutorials/multiphase/interFoam/RAS/planningHullW3/Allclean
Executable file
15
tutorials/multiphase/interFoam/RAS/planningHullW3/Allclean
Executable file
@ -0,0 +1,15 @@
|
||||
#!/bin/sh
|
||||
cd ${0%/*} || exit 1 # Run from this directory
|
||||
|
||||
# Source tutorial clean functions
|
||||
. $WM_PROJECT_DIR/bin/tools/CleanFunctions
|
||||
|
||||
# Remove surface
|
||||
rm -rf constant/extendedFeatureEdgeMesh > /dev/null 2>&1
|
||||
rm -f constant/triSurface/w3.eMesh > /dev/null 2>&1
|
||||
rm -f constant/triSurface/w3.stl > /dev/null 2>&1
|
||||
rm -rf sequencedVTK > /dev/null 2>&1
|
||||
|
||||
cleanCase
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
29
tutorials/multiphase/interFoam/RAS/planningHullW3/Allmesh.1
Executable file
29
tutorials/multiphase/interFoam/RAS/planningHullW3/Allmesh.1
Executable file
@ -0,0 +1,29 @@
|
||||
#!/bin/sh
|
||||
cd ${0%/*} || exit 1 # Run from this directory
|
||||
|
||||
# Source tutorial run functions
|
||||
. $WM_PROJECT_DIR/bin/tools/RunFunctions
|
||||
|
||||
runApplication surfaceTransformPoints -translate '(-0.586 0 -0.156)' \
|
||||
constant/triSurface/w3_orig.stl constant/triSurface/w3.stl
|
||||
runApplication -a surfaceTransformPoints -rollPitchYaw '(0 -3.485 0)' \
|
||||
constant/triSurface/w3.stl constant/triSurface/w3.stl
|
||||
runApplication -a surfaceTransformPoints -translate '(0.586 0 0.156)' \
|
||||
constant/triSurface/w3.stl constant/triSurface/w3.stl
|
||||
|
||||
runApplication surfaceFeatures
|
||||
|
||||
runApplication blockMesh -dict system/blockMeshDict.1
|
||||
|
||||
for i in 1 2 3 4 5 6 7
|
||||
do
|
||||
runApplication -a foamDictionary system/refineMeshDict -entry set -set c${i}
|
||||
runApplication -a topoSet -dict system/topoSetDict.1
|
||||
runApplication -a refineMesh -dict system/refineMeshDict -overwrite
|
||||
done
|
||||
|
||||
runApplication snappyHexMesh -dict system/snappyHexMeshDict.1 -overwrite
|
||||
|
||||
runApplication renumberMesh -noFields -overwrite
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
29
tutorials/multiphase/interFoam/RAS/planningHullW3/Allmesh.2
Executable file
29
tutorials/multiphase/interFoam/RAS/planningHullW3/Allmesh.2
Executable file
@ -0,0 +1,29 @@
|
||||
#!/bin/sh
|
||||
cd ${0%/*} || exit 1 # Run from this directory
|
||||
|
||||
# Source tutorial run functions
|
||||
. $WM_PROJECT_DIR/bin/tools/RunFunctions
|
||||
|
||||
runApplication surfaceTransformPoints -translate '(-0.586 0 -0.156)' \
|
||||
constant/triSurface/w3_orig.stl constant/triSurface/w3.stl
|
||||
runApplication -a surfaceTransformPoints -rollPitchYaw '(0 -3.485 0)' \
|
||||
constant/triSurface/w3.stl constant/triSurface/w3.stl
|
||||
runApplication -a surfaceTransformPoints -translate '(0.586 0 0.156)' \
|
||||
constant/triSurface/w3.stl constant/triSurface/w3.stl
|
||||
|
||||
runApplication surfaceFeatures
|
||||
|
||||
runApplication blockMesh -dict system/blockMeshDict.2
|
||||
|
||||
for i in 1 2 3 4
|
||||
do
|
||||
runApplication -a foamDictionary system/refineMeshDict -entry set -set c${i}
|
||||
runApplication -a topoSet -dict system/topoSetDict.2
|
||||
runApplication -a refineMesh -dict system/refineMeshDict -overwrite
|
||||
done
|
||||
|
||||
runApplication snappyHexMesh -dict system/snappyHexMeshDict.2 -overwrite
|
||||
|
||||
runApplication renumberMesh -noFields -overwrite
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
75
tutorials/multiphase/interFoam/RAS/planningHullW3/Allrun
Executable file
75
tutorials/multiphase/interFoam/RAS/planningHullW3/Allrun
Executable file
@ -0,0 +1,75 @@
|
||||
#!/bin/sh
|
||||
|
||||
usage () {
|
||||
exec 1>&2
|
||||
while [ "$#" -ge 1 ]; do echo "$1"; shift; done
|
||||
cat <<USAGE
|
||||
Usage: ${0##*/} [OPTIONS]
|
||||
|
||||
Options:
|
||||
-i | -interface no refinment in vertical direction of the mesh
|
||||
-l | -local mesh with local refinment
|
||||
-h | -help help
|
||||
|
||||
Ship hull simulation to demonstrate two different meshing strategies that can be
|
||||
used with PLIC type schemes.
|
||||
|
||||
USAGE
|
||||
exit 1
|
||||
}
|
||||
|
||||
meshType=0
|
||||
|
||||
# OPTIONS
|
||||
while [ "$#" -gt 0 ]
|
||||
do
|
||||
case "$1" in
|
||||
-i | -interface)
|
||||
meshType=1
|
||||
break
|
||||
;;
|
||||
-l | -local)
|
||||
meshType=2
|
||||
break
|
||||
;;
|
||||
-h | -help)
|
||||
usage
|
||||
;;
|
||||
-*)
|
||||
usage "Invalid option '$1'"
|
||||
;;
|
||||
*)
|
||||
usage "Invalid option '$1'"
|
||||
break
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
|
||||
# Run from this directory
|
||||
cd "${0%/*}" || exit 1
|
||||
|
||||
# Source tutorial run functions
|
||||
. "$WM_PROJECT_DIR/bin/tools/RunFunctions"
|
||||
|
||||
if [ $meshType -eq 0 ] || [ $meshType -eq 1 ]; then
|
||||
{
|
||||
./Allmesh.1
|
||||
}
|
||||
elif [$meshType -eq 2 ]; then
|
||||
{
|
||||
./Allmesh.2
|
||||
}
|
||||
fi
|
||||
|
||||
runApplication setFields
|
||||
|
||||
runApplication decomposePar
|
||||
|
||||
runParallel $(getApplication)
|
||||
|
||||
runApplication reconstructPar
|
||||
|
||||
runApplication foamSequenceVTKFiles
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
49
tutorials/multiphase/interFoam/RAS/planningHullW3/README
Normal file
49
tutorials/multiphase/interFoam/RAS/planningHullW3/README
Normal file
@ -0,0 +1,49 @@
|
||||
Overview
|
||||
========
|
||||
+ W3 example case of hydrodynamics of a planing hull
|
||||
|
||||
Mesh
|
||||
====
|
||||
+ The example includes two different approaches for meshing the case
|
||||
+ The first approach uses no cell refinement in the vertical direction
|
||||
+ The second approach includes local cell refinement, producing a smaller mesh
|
||||
+ Cell refinement can cause disturbances of the interface
|
||||
+ Where refinement is present, PLIC-based schemes perform much better,
|
||||
producing far less interface disturbance than the standard interface
|
||||
compression scheme.
|
||||
+ The first approach has the advantage of avoiding interface disturbances but
|
||||
for the potential cost of a larger mesh than with local refinement
|
||||
|
||||
Experimental results (ref. 1)
|
||||
=============================
|
||||
+ Velocity = 4.598 m/s
|
||||
+ Trim angle = 3.485 deg
|
||||
+ Drag = 50.691 N
|
||||
|
||||
Numerical results mesh 1
|
||||
========================
|
||||
Without local refinement
|
||||
+ Velocity = 4.598 m/s
|
||||
+ Trim angle = 2.794 deg
|
||||
+ Drag = 48.616 N
|
||||
|
||||
Numerical results mesh 2
|
||||
========================
|
||||
With local refinement
|
||||
+ Velocity = 4.598 m/s
|
||||
+ Trim angle = 3.027 deg
|
||||
+ Drag = 47.987 N
|
||||
|
||||
Acknowledgment
|
||||
==============
|
||||
+ Thanks to Raffaele Ponzini, Ph.D. Eng. from CINECA, for kindly sharing the
|
||||
W3 hull geometry and for his valuable insight into the science of ship hulls
|
||||
|
||||
References
|
||||
==========
|
||||
1. Begovic, E. and Bertorello, C., 2012. Resistance assessment of warped
|
||||
hullform. Ocean Engineering, 56, pp.28-42
|
||||
|
||||
2. Ponzini, R., Salvadore, F., Begovic, E. and Bertorello, C., 2020.
|
||||
Automatic CFD Analysis Of Planing Hulls By Means Of A New Web-Based Application:
|
||||
Usage, Experimental Data Comparison And Opportunities
|
||||
@ -0,0 +1,70 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
object dynamicMeshDict;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
dynamicFvMesh dynamicMotionSolverFvMesh;
|
||||
|
||||
motionSolverLibs ("librigidBodyMeshMotion.so");
|
||||
|
||||
motionSolver rigidBodyMotion;
|
||||
|
||||
report on;
|
||||
|
||||
solver
|
||||
{
|
||||
type Newmark;
|
||||
}
|
||||
|
||||
accelerationRelaxation 0.4;
|
||||
|
||||
bodies
|
||||
{
|
||||
hull
|
||||
{
|
||||
type rigidBody;
|
||||
parent root;
|
||||
|
||||
centreOfMass (0 0 0);
|
||||
mass 16.146;
|
||||
inertia (0.4 0 0 5 0 5);
|
||||
transform (
|
||||
0.9981507467 0 0.06078722637
|
||||
0 1 0
|
||||
-0.06078722637 0 0.9981507467
|
||||
)
|
||||
(0.586 0 0.156);
|
||||
|
||||
joint
|
||||
{
|
||||
type composite;
|
||||
joints
|
||||
(
|
||||
{
|
||||
type Pz;
|
||||
}
|
||||
{
|
||||
type Ry;
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
patches (hull);
|
||||
innerDistance 0.02;
|
||||
outerDistance 0.6;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
21
tutorials/multiphase/interFoam/RAS/planningHullW3/constant/g
Normal file
21
tutorials/multiphase/interFoam/RAS/planningHullW3/constant/g
Normal file
@ -0,0 +1,21 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class uniformDimensionedVectorField;
|
||||
location "constant";
|
||||
object g;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
dimensions [0 1 -2 0 0 0 0];
|
||||
value (0 0 -9.81);
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,30 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
location "constant";
|
||||
object momentumTransport;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
simulationType RAS;
|
||||
|
||||
RAS
|
||||
{
|
||||
model kOmegaSST;
|
||||
|
||||
turbulence on;
|
||||
|
||||
printCoeffs on;
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,36 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
location "constant";
|
||||
object transportProperties;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
phases (water air);
|
||||
|
||||
water
|
||||
{
|
||||
transportModel Newtonian;
|
||||
nu 1.09e-06;
|
||||
rho 997.0;
|
||||
}
|
||||
|
||||
air
|
||||
{
|
||||
transportModel Newtonian;
|
||||
nu 1.48e-05;
|
||||
rho 1;
|
||||
}
|
||||
|
||||
sigma 0;
|
||||
|
||||
// ************************************************************************* //
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,221 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
object blockMeshDict;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
#inputSyntax slash;
|
||||
|
||||
backgroundMesh
|
||||
{
|
||||
xMin -14;
|
||||
xMax 6;
|
||||
yMin -5;
|
||||
yMax 0;
|
||||
zMin -7;
|
||||
zMid1 -2.4;
|
||||
zMid2 -0.6;
|
||||
zMid3 -0.05;
|
||||
zMid4 0.1;
|
||||
zMid5 0.4;
|
||||
zMax 3;
|
||||
|
||||
xCells 20;
|
||||
yCells 4;
|
||||
|
||||
zCells1 10;
|
||||
zCells2 8;
|
||||
zCells3 32;
|
||||
zCells4 48;
|
||||
zCells5 40;
|
||||
zCells6 8;
|
||||
}
|
||||
|
||||
|
||||
convertToMeters 1;
|
||||
|
||||
vertices
|
||||
(
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMin $!backgroundMesh/zMin) // 0
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMin $!backgroundMesh/zMin) // 1
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMax $!backgroundMesh/zMin) // 2
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMax $!backgroundMesh/zMin) // 3
|
||||
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMin $!backgroundMesh/zMid1) // 4
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMin $!backgroundMesh/zMid1) // 5
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMax $!backgroundMesh/zMid1) // 6
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMax $!backgroundMesh/zMid1) // 7
|
||||
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMin $!backgroundMesh/zMid2) // 8
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMin $!backgroundMesh/zMid2) // 9
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMax $!backgroundMesh/zMid2) // 10
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMax $!backgroundMesh/zMid2) // 11
|
||||
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMin $!backgroundMesh/zMid3) // 12
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMin $!backgroundMesh/zMid3) // 13
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMax $!backgroundMesh/zMid3) // 14
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMax $!backgroundMesh/zMid3) // 15
|
||||
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMin $!backgroundMesh/zMid4) // 16
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMin $!backgroundMesh/zMid4) // 17
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMax $!backgroundMesh/zMid4) // 18
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMax $!backgroundMesh/zMid4) // 19
|
||||
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMin $!backgroundMesh/zMid5) // 20
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMin $!backgroundMesh/zMid5) // 21
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMax $!backgroundMesh/zMid5) // 22
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMax $!backgroundMesh/zMid5) // 23
|
||||
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMin $!backgroundMesh/zMax) // 24
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMin $!backgroundMesh/zMax) // 25
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMax $!backgroundMesh/zMax) // 26
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMax $!backgroundMesh/zMax) // 27
|
||||
);
|
||||
|
||||
blocks
|
||||
(
|
||||
// Block 1
|
||||
hex (0 1 2 3 4 5 6 7)
|
||||
(
|
||||
$!backgroundMesh/xCells
|
||||
$!backgroundMesh/yCells
|
||||
$!backgroundMesh/zCells1
|
||||
)
|
||||
simpleGrading (1 0.5 0.2)
|
||||
|
||||
// Block 2
|
||||
hex (4 5 6 7 8 9 10 11)
|
||||
(
|
||||
$!backgroundMesh/xCells
|
||||
$!backgroundMesh/yCells
|
||||
$!backgroundMesh/zCells2
|
||||
)
|
||||
simpleGrading (1 0.5 1)
|
||||
|
||||
// Block 3
|
||||
hex (8 9 10 11 12 13 14 15)
|
||||
(
|
||||
$!backgroundMesh/xCells
|
||||
$!backgroundMesh/yCells
|
||||
$!backgroundMesh/zCells3
|
||||
)
|
||||
simpleGrading (1 0.5 0.1)
|
||||
|
||||
// Block 4
|
||||
hex (12 13 14 15 16 17 18 19)
|
||||
(
|
||||
$!backgroundMesh/xCells
|
||||
$!backgroundMesh/yCells
|
||||
$!backgroundMesh/zCells4
|
||||
)
|
||||
simpleGrading (1 0.5 1)
|
||||
|
||||
// Block 5
|
||||
hex (16 17 18 19 20 21 22 23)
|
||||
(
|
||||
$!backgroundMesh/xCells
|
||||
$!backgroundMesh/yCells
|
||||
$!backgroundMesh/zCells5
|
||||
)
|
||||
simpleGrading (1 0.5 2)
|
||||
|
||||
// Block 6
|
||||
hex (20 21 22 23 24 25 26 27)
|
||||
(
|
||||
$!backgroundMesh/xCells
|
||||
$!backgroundMesh/yCells
|
||||
$!backgroundMesh/zCells6
|
||||
)
|
||||
simpleGrading (1 0.5 20)
|
||||
);
|
||||
|
||||
edges
|
||||
(
|
||||
);
|
||||
|
||||
boundary
|
||||
(
|
||||
atmosphere
|
||||
{
|
||||
type patch;
|
||||
faces
|
||||
(
|
||||
(24 25 26 27)
|
||||
);
|
||||
}
|
||||
inlet
|
||||
{
|
||||
type patch;
|
||||
faces
|
||||
(
|
||||
(1 2 6 5)
|
||||
(5 6 10 9)
|
||||
(9 10 14 13)
|
||||
(13 14 18 17)
|
||||
(17 18 22 21)
|
||||
(21 22 26 25)
|
||||
);
|
||||
}
|
||||
outlet
|
||||
{
|
||||
type patch;
|
||||
faces
|
||||
(
|
||||
(0 4 7 3)
|
||||
(4 8 11 7)
|
||||
(8 12 15 11)
|
||||
(12 16 19 15)
|
||||
(16 20 23 19)
|
||||
(20 24 27 23)
|
||||
);
|
||||
}
|
||||
bottom
|
||||
{
|
||||
type symmetryPlane;
|
||||
faces
|
||||
(
|
||||
(0 3 2 1)
|
||||
);
|
||||
}
|
||||
side
|
||||
{
|
||||
type symmetryPlane;
|
||||
faces
|
||||
(
|
||||
(0 1 5 4)
|
||||
(4 5 9 8)
|
||||
(8 9 13 12)
|
||||
(12 13 17 16)
|
||||
(16 17 21 20)
|
||||
(20 21 25 24)
|
||||
);
|
||||
}
|
||||
midPlane
|
||||
{
|
||||
type symmetryPlane;
|
||||
faces
|
||||
(
|
||||
(3 7 6 2)
|
||||
(7 11 10 6)
|
||||
(11 15 14 10)
|
||||
(15 19 18 14)
|
||||
(19 23 22 18)
|
||||
(23 27 26 22)
|
||||
);
|
||||
}
|
||||
);
|
||||
|
||||
mergePatchPairs
|
||||
(
|
||||
);
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,166 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
object blockMeshDict;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
#inputSyntax slash;
|
||||
|
||||
backgroundMesh
|
||||
{
|
||||
xMin -14.16;
|
||||
xMax 6.0;
|
||||
yMin -4.8;
|
||||
yMax 0.0;
|
||||
zMin -6.6;
|
||||
zMid1 -0.36;
|
||||
zMid2 0.6;
|
||||
zMax 3.0;
|
||||
|
||||
xCells 21;
|
||||
yCells 5;
|
||||
|
||||
zCells1 20;
|
||||
zCells2 16;
|
||||
zCells3 12;
|
||||
}
|
||||
|
||||
|
||||
convertToMeters 1;
|
||||
|
||||
vertices
|
||||
(
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMin $!backgroundMesh/zMin) // 0
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMin $!backgroundMesh/zMin) // 1
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMax $!backgroundMesh/zMin) // 2
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMax $!backgroundMesh/zMin) // 3
|
||||
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMin $!backgroundMesh/zMid1) // 4
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMin $!backgroundMesh/zMid1) // 5
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMax $!backgroundMesh/zMid1) // 6
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMax $!backgroundMesh/zMid1) // 7
|
||||
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMin $!backgroundMesh/zMid2) // 8
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMin $!backgroundMesh/zMid2) // 9
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMax $!backgroundMesh/zMid2) // 10
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMax $!backgroundMesh/zMid2) // 11
|
||||
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMin $!backgroundMesh/zMax) // 12
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMin $!backgroundMesh/zMax) // 13
|
||||
($!backgroundMesh/xMax $!backgroundMesh/yMax $!backgroundMesh/zMax) // 14
|
||||
($!backgroundMesh/xMin $!backgroundMesh/yMax $!backgroundMesh/zMax) // 15
|
||||
);
|
||||
|
||||
blocks
|
||||
(
|
||||
// Block 1
|
||||
hex (0 1 2 3 4 5 6 7)
|
||||
(
|
||||
$!backgroundMesh/xCells
|
||||
$!backgroundMesh/yCells
|
||||
$!backgroundMesh/zCells1
|
||||
)
|
||||
simpleGrading (1 1 0.1)
|
||||
|
||||
// Block 2
|
||||
hex (4 5 6 7 8 9 10 11)
|
||||
(
|
||||
$!backgroundMesh/xCells
|
||||
$!backgroundMesh/yCells
|
||||
$!backgroundMesh/zCells2
|
||||
)
|
||||
simpleGrading (1 1 1)
|
||||
|
||||
// Block 3
|
||||
hex (8 9 10 11 12 13 14 15)
|
||||
(
|
||||
$!backgroundMesh/xCells
|
||||
$!backgroundMesh/yCells
|
||||
$!backgroundMesh/zCells3
|
||||
)
|
||||
simpleGrading (1 1 10)
|
||||
|
||||
);
|
||||
|
||||
edges
|
||||
(
|
||||
);
|
||||
|
||||
boundary
|
||||
(
|
||||
|
||||
atmosphere
|
||||
{
|
||||
type patch;
|
||||
faces
|
||||
(
|
||||
(12 13 14 15)
|
||||
);
|
||||
}
|
||||
|
||||
inlet
|
||||
{
|
||||
type patch;
|
||||
faces
|
||||
(
|
||||
(1 2 6 5)
|
||||
(5 6 10 9)
|
||||
(9 10 14 13)
|
||||
);
|
||||
}
|
||||
|
||||
outlet
|
||||
{
|
||||
type patch;
|
||||
faces
|
||||
(
|
||||
(0 4 7 3)
|
||||
(4 8 11 7)
|
||||
(8 12 15 11)
|
||||
);
|
||||
}
|
||||
bottom
|
||||
{
|
||||
type symmetryPlane;
|
||||
faces
|
||||
(
|
||||
(0 3 2 1)
|
||||
);
|
||||
}
|
||||
side
|
||||
{
|
||||
type symmetryPlane;
|
||||
faces
|
||||
(
|
||||
(0 1 5 4)
|
||||
(4 5 9 8)
|
||||
(8 9 13 12)
|
||||
);
|
||||
}
|
||||
midPlane
|
||||
{
|
||||
type symmetryPlane;
|
||||
faces
|
||||
(
|
||||
(3 7 6 2)
|
||||
(7 11 10 6)
|
||||
(11 15 14 10)
|
||||
);
|
||||
}
|
||||
|
||||
);
|
||||
|
||||
mergePatchPairs
|
||||
(
|
||||
);
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,78 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
location "system";
|
||||
object controlDict;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
application interFoam;
|
||||
|
||||
startFrom latestTime;
|
||||
|
||||
startTime 0;
|
||||
|
||||
stopAt endTime;
|
||||
|
||||
endTime 5;
|
||||
|
||||
deltaT 1e-4;
|
||||
|
||||
writeControl adjustableRunTime;
|
||||
|
||||
writeInterval 1.0;
|
||||
|
||||
purgeWrite 0;
|
||||
|
||||
writeFormat binary;
|
||||
|
||||
writePrecision 6;
|
||||
|
||||
writeCompression off;
|
||||
|
||||
timeFormat general;
|
||||
|
||||
timePrecision 6;
|
||||
|
||||
runTimeModifiable yes;
|
||||
|
||||
adjustTimeStep yes;
|
||||
|
||||
maxCo 5;
|
||||
maxAlphaCo 5;
|
||||
maxDeltaT 0.002;
|
||||
|
||||
functions
|
||||
{
|
||||
forces
|
||||
{
|
||||
type forces;
|
||||
libs ("libforces.so");
|
||||
patches (hull);
|
||||
rhoInf 997.0;
|
||||
log on;
|
||||
writeControl timeStep;
|
||||
writeInterval 1;
|
||||
CofR (0 0 0);
|
||||
}
|
||||
|
||||
rigidBodyState
|
||||
{
|
||||
type rigidBodyState;
|
||||
libs ("librigidBodyState.so");
|
||||
angleFormat degrees;
|
||||
}
|
||||
|
||||
#includeFunc surfaces
|
||||
}
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,23 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
location "system";
|
||||
object decomposeParDict;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
numberOfSubdomains 16;
|
||||
|
||||
method scotch;
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,61 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
location "system";
|
||||
object fvSchemes;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
ddtSchemes
|
||||
{
|
||||
default Euler;
|
||||
}
|
||||
|
||||
gradSchemes
|
||||
{
|
||||
default Gauss linear;
|
||||
limitedGrad cellLimited Gauss linear 1;
|
||||
}
|
||||
|
||||
divSchemes
|
||||
{
|
||||
default none;
|
||||
div(rhoPhi,U) Gauss cellCoBlended 2 linearUpwind grad(U) 5 upwind;
|
||||
div(phi,alpha) Gauss PLIC interfaceCompression vanLeer 1;
|
||||
div(phirb,alpha) Gauss linear;
|
||||
div(phi,k) Gauss linearUpwind limitedGrad;
|
||||
div(phi,omega) Gauss linearUpwind limitedGrad;
|
||||
div(((rho*nuEff)*dev2(T(grad(U))))) Gauss linear;
|
||||
}
|
||||
|
||||
laplacianSchemes
|
||||
{
|
||||
default Gauss linear corrected;
|
||||
}
|
||||
|
||||
interpolationSchemes
|
||||
{
|
||||
default linear;
|
||||
}
|
||||
|
||||
snGradSchemes
|
||||
{
|
||||
default corrected;
|
||||
}
|
||||
|
||||
wallDist
|
||||
{
|
||||
method meshWave;
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,99 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
location "system";
|
||||
object fvSolution;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
solvers
|
||||
{
|
||||
"alpha.water.*"
|
||||
{
|
||||
nAlphaCorr 2;
|
||||
nAlphaSubCycles 1;
|
||||
|
||||
MULESCorr yes;
|
||||
nLimiterIter 15;
|
||||
alphaApplyPrevCorr yes;
|
||||
|
||||
solver smoothSolver;
|
||||
smoother symGaussSeidel;
|
||||
tolerance 1e-10;
|
||||
relTol 0;
|
||||
minIter 1;
|
||||
}
|
||||
|
||||
"pcorr.*"
|
||||
{
|
||||
solver GAMG;
|
||||
smoother DIC;
|
||||
|
||||
tolerance 1e-2;
|
||||
relTol 0;
|
||||
};
|
||||
|
||||
p_rgh
|
||||
{
|
||||
solver GAMG;
|
||||
smoother DIC;
|
||||
|
||||
tolerance 5e-8;
|
||||
relTol 0;
|
||||
};
|
||||
|
||||
p_rghFinal
|
||||
{
|
||||
$p_rgh;
|
||||
relTol 0;
|
||||
}
|
||||
|
||||
"(U|k|omega).*"
|
||||
{
|
||||
solver smoothSolver;
|
||||
smoother symGaussSeidel;
|
||||
|
||||
nSweeps 1;
|
||||
tolerance 1e-7;
|
||||
relTol 0;
|
||||
minIter 1;
|
||||
};
|
||||
}
|
||||
|
||||
PIMPLE
|
||||
{
|
||||
momentumPredictor no;
|
||||
|
||||
nOuterCorrectors 3;
|
||||
nCorrectors 1;
|
||||
nNonOrthogonalCorrectors 0;
|
||||
|
||||
correctPhi yes;
|
||||
moveMeshOuterCorrectors yes;
|
||||
turbOnFinalIterOnly yes;
|
||||
}
|
||||
|
||||
relaxationFactors
|
||||
{
|
||||
equations
|
||||
{
|
||||
".*" 1;
|
||||
}
|
||||
}
|
||||
|
||||
cache
|
||||
{
|
||||
grad(U);
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,86 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
location "system";
|
||||
object meshQualityDict;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
//- Maximum non-orthogonality allowed. Set to 180 to disable.
|
||||
maxNonOrtho 70;
|
||||
|
||||
//- Max skewness allowed. Set to <0 to disable.
|
||||
maxBoundarySkewness 20;
|
||||
maxInternalSkewness 4;
|
||||
|
||||
//- Max concaveness allowed. Is angle (in degrees) below which concavity
|
||||
// is allowed. 0 is straight face, <0 would be convex face.
|
||||
// Set to 180 to disable.
|
||||
maxConcave 80;
|
||||
|
||||
//- Minimum pyramid volume. Is absolute volume of cell pyramid.
|
||||
// Set to a sensible fraction of the smallest cell volume expected.
|
||||
// Set to very negative number (e.g. -1E30) to disable.
|
||||
minVol 1e-13;
|
||||
|
||||
//- Minimum quality of the tet formed by the face-centre
|
||||
// and variable base point minimum decomposition triangles and
|
||||
// the cell centre. Set to very negative number (e.g. -1E30) to
|
||||
// disable.
|
||||
// <0 = inside out tet,
|
||||
// 0 = flat tet
|
||||
// 1 = regular tet
|
||||
minTetQuality 1e-30;
|
||||
|
||||
//- Minimum face area. Set to <0 to disable.
|
||||
minArea -1;
|
||||
|
||||
//- Minimum face twist. Set to <-1 to disable. dot product of face normal
|
||||
// and face centre triangles normal
|
||||
minTwist 0.05;
|
||||
|
||||
//- Minimum normalised cell determinant
|
||||
// 1 = hex, <= 0 = folded or flattened illegal cell
|
||||
minDeterminant 0.001;
|
||||
|
||||
//- minFaceWeight (0 -> 0.5)
|
||||
minFaceWeight 0.05;
|
||||
|
||||
//- minVolRatio (0 -> 1)
|
||||
minVolRatio 0.01;
|
||||
|
||||
//must be >0 for Fluent compatibility
|
||||
minTriangleTwist -1;
|
||||
|
||||
//- If >0 : preserve single cells with all points on the surface if the
|
||||
// resulting volume after snapping (by approximation) is larger than
|
||||
// minVolCollapseRatio times old volume (i.e. not collapsed to flat cell).
|
||||
// If <0 : delete always.
|
||||
//minVolCollapseRatio 0.5;
|
||||
|
||||
|
||||
// Advanced
|
||||
|
||||
//- Number of error distribution iterations
|
||||
nSmoothScale 4;
|
||||
//- Amount to scale back displacement at error points
|
||||
errorReduction 0.75;
|
||||
|
||||
|
||||
|
||||
// Optional : some meshing phases allow usage of relaxed rules.
|
||||
// See e.g. addLayersControls::nRelaxedIter.
|
||||
relaxed
|
||||
{
|
||||
//- Maximum non-orthogonality allowed. Set to 180 to disable.
|
||||
maxNonOrtho 75;
|
||||
}
|
||||
@ -0,0 +1,43 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
location "system";
|
||||
object refineMeshDict;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
set c7;
|
||||
|
||||
coordinateSystem global;
|
||||
|
||||
globalCoeffs
|
||||
{
|
||||
tan1 ( 1 0 0 );
|
||||
tan2 ( 0 1 0 );
|
||||
}
|
||||
|
||||
patchLocalCoeffs
|
||||
{
|
||||
patch outside;
|
||||
tan1 ( 1 0 0 );
|
||||
}
|
||||
|
||||
directions ( tan1 tan2 );
|
||||
|
||||
useHexTopology no;
|
||||
|
||||
geometricCut yes;
|
||||
|
||||
writeMesh no;
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,49 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
location "system";
|
||||
object setFieldsDict;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
defaultFieldValues
|
||||
(
|
||||
volScalarFieldValue alpha.water 0
|
||||
);
|
||||
|
||||
regions
|
||||
(
|
||||
// Set cell values
|
||||
// (does zerogradient on boundaries)
|
||||
boxToCell
|
||||
{
|
||||
box (-999 -999 -999) (999 999 0.065);
|
||||
|
||||
fieldValues
|
||||
(
|
||||
volScalarFieldValue alpha.water 1
|
||||
);
|
||||
}
|
||||
|
||||
// Set patch values (using ==)
|
||||
boxToFace
|
||||
{
|
||||
box (-999 -999 -999) (999 999 0.065);
|
||||
|
||||
fieldValues
|
||||
(
|
||||
volScalarFieldValue alpha.water 1
|
||||
);
|
||||
}
|
||||
);
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,284 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
object snappyHexMeshDict;
|
||||
}
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
// Which of the steps to run
|
||||
castellatedMesh true;
|
||||
snap true;
|
||||
addLayers true;
|
||||
|
||||
|
||||
// Geometry. Definition of all surfaces. All surfaces are of class
|
||||
// searchableSurface.
|
||||
// Surfaces are used
|
||||
// - to specify refinement for any mesh cell intersecting it
|
||||
// - to specify refinement for any mesh cell inside/outside/near
|
||||
// - to 'snap' the mesh boundary to the surface
|
||||
geometry
|
||||
{
|
||||
hull
|
||||
{
|
||||
type triSurfaceMesh;
|
||||
file "w3.stl";
|
||||
|
||||
patchInfo
|
||||
{
|
||||
type wall;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
// Settings for the castellatedMesh generation.
|
||||
castellatedMeshControls
|
||||
{
|
||||
|
||||
// Refinement parameters
|
||||
// ~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
// If local number of cells is >= maxLocalCells on any processor
|
||||
// switches from from refinement followed by balancing
|
||||
// (current method) to (weighted) balancing before refinement.
|
||||
maxLocalCells 100000;
|
||||
|
||||
// Overall cell limit (approximately). Refinement will stop immediately
|
||||
// upon reaching this number so a refinement level might not complete.
|
||||
// Note that this is the number of cells before removing the part which
|
||||
// is not 'visible' from the keepPoint. The final number of cells might
|
||||
// actually be a lot less.
|
||||
maxGlobalCells 20000000;
|
||||
|
||||
// The surface refinement loop might spend lots of iterations refining just a
|
||||
// few cells. This setting will cause refinement to stop if <= minimumRefine
|
||||
// are selected for refinement. Note: it will at least do one iteration
|
||||
// (unless the number of cells to refine is 0)
|
||||
minRefinementCells 0;
|
||||
|
||||
// Number of buffer layers between different levels.
|
||||
// 1 means normal 2:1 refinement restriction, larger means slower
|
||||
// refinement.
|
||||
nCellsBetweenLevels 3;
|
||||
|
||||
|
||||
|
||||
// Explicit feature edge refinement
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
// Specifies a level for any cell intersected by its edges.
|
||||
// This is a featureEdgeMesh, read from constant/triSurface for now.
|
||||
features
|
||||
(
|
||||
{
|
||||
file "w3.eMesh";
|
||||
level 0;
|
||||
}
|
||||
);
|
||||
|
||||
|
||||
|
||||
// Surface based refinement
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
// Specifies two levels for every surface. The first is the minimum level,
|
||||
// every cell intersecting a surface gets refined up to the minimum level.
|
||||
// The second level is the maximum level. Cells that 'see' multiple
|
||||
// intersections where the intersections make an
|
||||
// angle > resolveFeatureAngle get refined up to the maximum level.
|
||||
|
||||
refinementSurfaces
|
||||
{
|
||||
hull
|
||||
{
|
||||
// Surface-wise min and max refinement level
|
||||
level (0 0);
|
||||
}
|
||||
}
|
||||
|
||||
resolveFeatureAngle 45;
|
||||
|
||||
|
||||
// Region-wise refinement
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
// Specifies refinement level for cells in relation to a surface. One of
|
||||
// three modes
|
||||
// - distance. 'levels' specifies per distance to the surface the
|
||||
// wanted refinement level. The distances need to be specified in
|
||||
// descending order.
|
||||
// - inside. 'levels' is only one entry and only the level is used. All
|
||||
// cells inside the surface get refined up to the level. The surface
|
||||
// needs to be closed for this to be possible.
|
||||
// - outside. Same but cells outside.
|
||||
|
||||
refinementRegions
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
// Mesh selection
|
||||
// ~~~~~~~~~~~~~~
|
||||
|
||||
// After refinement patches get added for all refinementSurfaces and
|
||||
// all cells intersecting the surfaces get put into these patches. The
|
||||
// section reachable from the locationInMesh is kept.
|
||||
// NOTE: This point should never be on a face, always inside a cell, even
|
||||
// after refinement.
|
||||
locationInMesh (-0.7 0 0);
|
||||
|
||||
|
||||
// Whether any faceZones (as specified in the refinementSurfaces)
|
||||
// are only on the boundary of corresponding cellZones or also allow
|
||||
// free-standing zone faces. Not used if there are no faceZones.
|
||||
allowFreeStandingZoneFaces true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Settings for the snapping.
|
||||
snapControls
|
||||
{
|
||||
//- Number of patch smoothing iterations before finding correspondence
|
||||
// to surface
|
||||
nSmoothPatch 3;
|
||||
|
||||
//- Relative distance for points to be attracted by surface feature point
|
||||
// or edge. True distance is this factor times local
|
||||
// maximum edge length.
|
||||
// tolerance 4.0;
|
||||
tolerance 1.0;
|
||||
|
||||
//- Number of mesh displacement relaxation iterations.
|
||||
nSolveIter 100;
|
||||
|
||||
//- Maximum number of snapping relaxation iterations. Should stop
|
||||
// before upon reaching a correct mesh.
|
||||
nRelaxIter 5;
|
||||
|
||||
nFeatureSnapIter 10;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Settings for the layer addition.
|
||||
addLayersControls
|
||||
{
|
||||
// Are the thickness parameters below relative to the undistorted
|
||||
// size of the refined cell outside layer (true) or absolute sizes (false).
|
||||
relativeSizes true;
|
||||
|
||||
// Per final patch (so not geometry!) the layer information
|
||||
layers
|
||||
{
|
||||
hull
|
||||
{
|
||||
nSurfaceLayers 3;
|
||||
}
|
||||
}
|
||||
|
||||
// Expansion factor for layer mesh
|
||||
expansionRatio 1.5;
|
||||
|
||||
|
||||
// Wanted thickness of final added cell layer. If multiple layers
|
||||
// is the thickness of the layer furthest away from the wall.
|
||||
// Relative to undistorted size of cell outside layer.
|
||||
// See relativeSizes parameter.
|
||||
finalLayerThickness 0.7;
|
||||
|
||||
// Minimum thickness of cell layer. If for any reason layer
|
||||
// cannot be above minThickness do not add layer.
|
||||
// See relativeSizes parameter.
|
||||
minThickness 0.25;
|
||||
|
||||
// If points get not extruded do nGrow layers of connected faces that are
|
||||
// also not grown. This helps convergence of the layer addition process
|
||||
// close to features.
|
||||
// Note: changed(corrected) w.r.t 17x! (didn't do anything in 17x)
|
||||
nGrow 0;
|
||||
|
||||
|
||||
// Advanced settings
|
||||
|
||||
// When not to extrude surface. 0 is flat surface, 90 is when two faces
|
||||
// are perpendicular
|
||||
featureAngle 60;
|
||||
|
||||
// Maximum number of snapping relaxation iterations. Should stop
|
||||
// before upon reaching a correct mesh.
|
||||
nRelaxIter 5;
|
||||
|
||||
// Number of smoothing iterations of surface normals
|
||||
nSmoothSurfaceNormals 1;
|
||||
|
||||
// Number of smoothing iterations of interior mesh movement direction
|
||||
nSmoothNormals 3;
|
||||
|
||||
// Smooth layer thickness over surface patches
|
||||
nSmoothThickness 10;
|
||||
|
||||
// Stop layer growth on highly warped cells
|
||||
maxFaceThicknessRatio 0.5;
|
||||
|
||||
// Reduce layer growth where ratio thickness to medial
|
||||
// distance is large
|
||||
maxThicknessToMedialRatio 0.3;
|
||||
|
||||
// Angle used to pick up medial axis points
|
||||
// Note: changed(corrected) w.r.t 17x! 90 degrees corresponds to 130 in 17x.
|
||||
minMedianAxisAngle 90;
|
||||
|
||||
// Create buffer region for new layer terminations
|
||||
nBufferCellsNoExtrude 0;
|
||||
|
||||
|
||||
// Overall max number of layer addition iterations. The mesher will exit
|
||||
// if it reaches this number of iterations; possibly with an illegal
|
||||
// mesh.
|
||||
nLayerIter 50;
|
||||
|
||||
// Max number of iterations after which relaxed meshQuality controls
|
||||
// get used. Up to nRelaxIter it uses the settings in meshQualityControls,
|
||||
// after nRelaxIter it uses the values in meshQualityControls::relaxed.
|
||||
nRelaxedIter 20;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Generic mesh quality settings. At any undoable phase these determine
|
||||
// where to undo.
|
||||
meshQualityControls
|
||||
{
|
||||
#include "meshQualityDict"
|
||||
}
|
||||
|
||||
|
||||
// Advanced
|
||||
|
||||
// Flags for optional output
|
||||
// 0 : only write final meshes
|
||||
// 1 : write intermediate meshes
|
||||
// 2 : write volScalarField with cellLevel for postprocessing
|
||||
// 4 : write current intersections as .obj files
|
||||
debug 0;
|
||||
|
||||
|
||||
// Merge tolerance. Is fraction of overall bounding box of initial mesh.
|
||||
// Note: the write tolerance needs to be higher than this.
|
||||
mergeTolerance 1E-6;
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,301 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
object snappyHexMeshDict;
|
||||
}
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
// Which of the steps to run
|
||||
castellatedMesh true;
|
||||
snap true;
|
||||
addLayers true;
|
||||
|
||||
|
||||
// Geometry. Definition of all surfaces. All surfaces are of class
|
||||
// searchableSurface.
|
||||
// Surfaces are used
|
||||
// - to specify refinement for any mesh cell intersecting it
|
||||
// - to specify refinement for any mesh cell inside/outside/near
|
||||
// - to 'snap' the mesh boundary to the surface
|
||||
geometry
|
||||
{
|
||||
hull
|
||||
{
|
||||
type triSurfaceMesh;
|
||||
file "w3.stl";
|
||||
|
||||
patchInfo
|
||||
{
|
||||
type wall;
|
||||
}
|
||||
}
|
||||
wakeRegion
|
||||
{
|
||||
type searchableBox;
|
||||
min (-1.5 -0.4 -0.15);
|
||||
max (0.1 0.0 0.15);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
// Settings for the castellatedMesh generation.
|
||||
castellatedMeshControls
|
||||
{
|
||||
|
||||
// Refinement parameters
|
||||
// ~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
// If local number of cells is >= maxLocalCells on any processor
|
||||
// switches from from refinement followed by balancing
|
||||
// (current method) to (weighted) balancing before refinement.
|
||||
maxLocalCells 100000;
|
||||
|
||||
// Overall cell limit (approximately). Refinement will stop immediately
|
||||
// upon reaching this number so a refinement level might not complete.
|
||||
// Note that this is the number of cells before removing the part which
|
||||
// is not 'visible' from the keepPoint. The final number of cells might
|
||||
// actually be a lot less.
|
||||
maxGlobalCells 20000000;
|
||||
|
||||
// The surface refinement loop might spend lots of iterations refining just a
|
||||
// few cells. This setting will cause refinement to stop if <= minimumRefine
|
||||
// are selected for refinement. Note: it will at least do one iteration
|
||||
// (unless the number of cells to refine is 0)
|
||||
minRefinementCells 0;
|
||||
|
||||
// Number of buffer layers between different levels.
|
||||
// 1 means normal 2:1 refinement restriction, larger means slower
|
||||
// refinement.
|
||||
nCellsBetweenLevels 3;
|
||||
|
||||
|
||||
|
||||
// Explicit feature edge refinement
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
// Specifies a level for any cell intersected by its edges.
|
||||
// This is a featureEdgeMesh, read from constant/triSurface for now.
|
||||
features
|
||||
(
|
||||
{
|
||||
file "w3.eMesh";
|
||||
level 3;
|
||||
}
|
||||
);
|
||||
|
||||
|
||||
|
||||
// Surface based refinement
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
// Specifies two levels for every surface. The first is the minimum level,
|
||||
// every cell intersecting a surface gets refined up to the minimum level.
|
||||
// The second level is the maximum level. Cells that 'see' multiple
|
||||
// intersections where the intersections make an
|
||||
// angle > resolveFeatureAngle get refined up to the maximum level.
|
||||
|
||||
refinementSurfaces
|
||||
{
|
||||
hull
|
||||
{
|
||||
// Surface-wise min and max refinement level
|
||||
level (3 3);
|
||||
}
|
||||
}
|
||||
|
||||
resolveFeatureAngle 45;
|
||||
|
||||
|
||||
// Region-wise refinement
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
// Specifies refinement level for cells in relation to a surface. One of
|
||||
// three modes
|
||||
// - distance. 'levels' specifies per distance to the surface the
|
||||
// wanted refinement level. The distances need to be specified in
|
||||
// descending order.
|
||||
// - inside. 'levels' is only one entry and only the level is used. All
|
||||
// cells inside the surface get refined up to the level. The surface
|
||||
// needs to be closed for this to be possible.
|
||||
// - outside. Same but cells outside.
|
||||
|
||||
refinementRegions
|
||||
{
|
||||
hull
|
||||
{
|
||||
mode distance;
|
||||
levels ((0.05 3) (0.1 2) (0.2 2));
|
||||
}
|
||||
|
||||
wakeRegion
|
||||
{
|
||||
mode inside;
|
||||
levels ((1.0 2));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Mesh selection
|
||||
// ~~~~~~~~~~~~~~
|
||||
|
||||
// After refinement patches get added for all refinementSurfaces and
|
||||
// all cells intersecting the surfaces get put into these patches. The
|
||||
// section reachable from the locationInMesh is kept.
|
||||
// NOTE: This point should never be on a face, always inside a cell, even
|
||||
// after refinement.
|
||||
locationInMesh (-0.7 0 0);
|
||||
|
||||
|
||||
// Whether any faceZones (as specified in the refinementSurfaces)
|
||||
// are only on the boundary of corresponding cellZones or also allow
|
||||
// free-standing zone faces. Not used if there are no faceZones.
|
||||
allowFreeStandingZoneFaces true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Settings for the snapping.
|
||||
snapControls
|
||||
{
|
||||
//- Number of patch smoothing iterations before finding correspondence
|
||||
// to surface
|
||||
nSmoothPatch 3;
|
||||
|
||||
//- Relative distance for points to be attracted by surface feature point
|
||||
// or edge. True distance is this factor times local
|
||||
// maximum edge length.
|
||||
// tolerance 4.0;
|
||||
tolerance 1.0;
|
||||
|
||||
//- Number of mesh displacement relaxation iterations.
|
||||
nSolveIter 100;
|
||||
|
||||
//- Maximum number of snapping relaxation iterations. Should stop
|
||||
// before upon reaching a correct mesh.
|
||||
nRelaxIter 5;
|
||||
|
||||
nFeatureSnapIter 10;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Settings for the layer addition.
|
||||
addLayersControls
|
||||
{
|
||||
// Are the thickness parameters below relative to the undistorted
|
||||
// size of the refined cell outside layer (true) or absolute sizes (false).
|
||||
relativeSizes true;
|
||||
|
||||
// Per final patch (so not geometry!) the layer information
|
||||
layers
|
||||
{
|
||||
hull
|
||||
{
|
||||
nSurfaceLayers 3;
|
||||
}
|
||||
}
|
||||
|
||||
// Expansion factor for layer mesh
|
||||
expansionRatio 1.5;
|
||||
|
||||
|
||||
// Wanted thickness of final added cell layer. If multiple layers
|
||||
// is the thickness of the layer furthest away from the wall.
|
||||
// Relative to undistorted size of cell outside layer.
|
||||
// See relativeSizes parameter.
|
||||
finalLayerThickness 0.7;
|
||||
|
||||
// Minimum thickness of cell layer. If for any reason layer
|
||||
// cannot be above minThickness do not add layer.
|
||||
// See relativeSizes parameter.
|
||||
minThickness 0.25;
|
||||
|
||||
// If points get not extruded do nGrow layers of connected faces that are
|
||||
// also not grown. This helps convergence of the layer addition process
|
||||
// close to features.
|
||||
// Note: changed(corrected) w.r.t 17x! (didn't do anything in 17x)
|
||||
nGrow 0;
|
||||
|
||||
|
||||
// Advanced settings
|
||||
|
||||
// When not to extrude surface. 0 is flat surface, 90 is when two faces
|
||||
// are perpendicular
|
||||
featureAngle 60;
|
||||
|
||||
// Maximum number of snapping relaxation iterations. Should stop
|
||||
// before upon reaching a correct mesh.
|
||||
nRelaxIter 5;
|
||||
|
||||
// Number of smoothing iterations of surface normals
|
||||
nSmoothSurfaceNormals 1;
|
||||
|
||||
// Number of smoothing iterations of interior mesh movement direction
|
||||
nSmoothNormals 3;
|
||||
|
||||
// Smooth layer thickness over surface patches
|
||||
nSmoothThickness 10;
|
||||
|
||||
// Stop layer growth on highly warped cells
|
||||
maxFaceThicknessRatio 0.5;
|
||||
|
||||
// Reduce layer growth where ratio thickness to medial
|
||||
// distance is large
|
||||
maxThicknessToMedialRatio 0.3;
|
||||
|
||||
// Angle used to pick up medial axis points
|
||||
// Note: changed(corrected) w.r.t 17x! 90 degrees corresponds to 130 in 17x.
|
||||
minMedianAxisAngle 90;
|
||||
|
||||
// Create buffer region for new layer terminations
|
||||
nBufferCellsNoExtrude 0;
|
||||
|
||||
|
||||
// Overall max number of layer addition iterations. The mesher will exit
|
||||
// if it reaches this number of iterations; possibly with an illegal
|
||||
// mesh.
|
||||
nLayerIter 50;
|
||||
|
||||
// Max number of iterations after which relaxed meshQuality controls
|
||||
// get used. Up to nRelaxIter it uses the settings in meshQualityControls,
|
||||
// after nRelaxIter it uses the values in meshQualityControls::relaxed.
|
||||
nRelaxedIter 20;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Generic mesh quality settings. At any undoable phase these determine
|
||||
// where to undo.
|
||||
meshQualityControls
|
||||
{
|
||||
#include "meshQualityDict"
|
||||
}
|
||||
|
||||
|
||||
// Advanced
|
||||
|
||||
// Flags for optional output
|
||||
// 0 : only write final meshes
|
||||
// 1 : write intermediate meshes
|
||||
// 2 : write volScalarField with cellLevel for postprocessing
|
||||
// 4 : write current intersections as .obj files
|
||||
debug 0;
|
||||
|
||||
|
||||
// Merge tolerance. Is fraction of overall bounding box of initial mesh.
|
||||
// Note: the write tolerance needs to be higher than this.
|
||||
mergeTolerance 1E-6;
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,31 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
object surfaceFeaturesDict;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
surfaces ("w3.stl");
|
||||
|
||||
// Identify a feature when angle between faces < includedAngle
|
||||
includedAngle 150;
|
||||
|
||||
subsetFeatures
|
||||
{
|
||||
// Keep nonManifold edges (edges with >2 connected faces)
|
||||
nonManifoldEdges yes;
|
||||
|
||||
// Keep open edges (edges with 1 connected face)
|
||||
openEdges yes;
|
||||
}
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,41 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
surfaces
|
||||
{
|
||||
type surfaces;
|
||||
libs ("libsampling.so");
|
||||
writeControl runTime;
|
||||
writeInterval 0.02;
|
||||
|
||||
surfaceFormat vtk;
|
||||
writeFormat binary;
|
||||
fields (alpha.water);
|
||||
|
||||
interpolationScheme cellPoint;
|
||||
|
||||
surfaces
|
||||
(
|
||||
iso-alpha
|
||||
{
|
||||
type isoSurface;
|
||||
isoField alpha.water;
|
||||
isoValue 0.5;
|
||||
interpolate true;
|
||||
}
|
||||
|
||||
hull
|
||||
{
|
||||
type patch;
|
||||
patches (hull);
|
||||
interpolate true;
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,93 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
location "system";
|
||||
object topoSetDict;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
actions
|
||||
(
|
||||
{
|
||||
name c1;
|
||||
type cellSet;
|
||||
action new;
|
||||
source boxToCell;
|
||||
sourceInfo
|
||||
{
|
||||
box (-4.0 -3.0 -2) (4.0 0 3.0);
|
||||
}
|
||||
}
|
||||
{
|
||||
name c2;
|
||||
type cellSet;
|
||||
action new;
|
||||
source boxToCell;
|
||||
sourceInfo
|
||||
{
|
||||
box (-3.0 -2.0 -1.4) (3.5 0 1.7);
|
||||
}
|
||||
}
|
||||
{
|
||||
name c3;
|
||||
type cellSet;
|
||||
action new;
|
||||
source boxToCell;
|
||||
sourceInfo
|
||||
{
|
||||
box (-2.5 -0.8 -0.6) (3.0 0 0.8);
|
||||
}
|
||||
}
|
||||
{
|
||||
name c4;
|
||||
type cellSet;
|
||||
action new;
|
||||
source boxToCell;
|
||||
sourceInfo
|
||||
{
|
||||
box (-2.0 -0.6 -0.4) (2.5 0 0.5);
|
||||
}
|
||||
}
|
||||
{
|
||||
name c5;
|
||||
type cellSet;
|
||||
action new;
|
||||
source boxToCell;
|
||||
sourceInfo
|
||||
{
|
||||
box (-1.0 -0.4 -0.2) (2.2 0.0 0.4);
|
||||
}
|
||||
}
|
||||
{
|
||||
name c6;
|
||||
type cellSet;
|
||||
action new;
|
||||
source boxToCell;
|
||||
sourceInfo
|
||||
{
|
||||
box (-0.8 -0.4 -0.1) (2.1 0.0 0.35);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
name c7;
|
||||
type cellSet;
|
||||
action new;
|
||||
source boxToCell;
|
||||
sourceInfo
|
||||
{
|
||||
box (-0.2 -0.25 -0.05) (2.05 0.0 0.3);
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,62 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Version: dev
|
||||
\\/ M anipulation |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
format ascii;
|
||||
class dictionary;
|
||||
location "system";
|
||||
object topoSetDict;
|
||||
}
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
actions
|
||||
(
|
||||
{
|
||||
name c1;
|
||||
type cellSet;
|
||||
action new;
|
||||
source boxToCell;
|
||||
sourceInfo
|
||||
{
|
||||
box (-4.0 -3.0 -2) (4.0 0 3.0);
|
||||
}
|
||||
}
|
||||
{
|
||||
name c2;
|
||||
type cellSet;
|
||||
action new;
|
||||
source boxToCell;
|
||||
sourceInfo
|
||||
{
|
||||
box (-3.0 -2.0 -1.4) (3.5 0 1.7);
|
||||
}
|
||||
}
|
||||
{
|
||||
name c3;
|
||||
type cellSet;
|
||||
action new;
|
||||
source boxToCell;
|
||||
sourceInfo
|
||||
{
|
||||
box (-2.5 -0.8 -0.6) (3.0 0 1.1);
|
||||
}
|
||||
}
|
||||
{
|
||||
name c4;
|
||||
type cellSet;
|
||||
action new;
|
||||
source boxToCell;
|
||||
sourceInfo
|
||||
{
|
||||
box (-2.0 -0.6 -0.4) (2.5 0 0.7);
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -28,7 +28,7 @@ gradSchemes
|
||||
divSchemes
|
||||
{
|
||||
div(rhoPhi,U) Gauss upwind;
|
||||
div(phi,alpha) Gauss interfaceCompression vanLeer 1;
|
||||
div(phi,alpha) Gauss MPLIC;
|
||||
div(phi,k) Gauss upwind;
|
||||
div(phi,omega) Gauss upwind;
|
||||
div(((rho*nuEff)*dev2(T(grad(U))))) Gauss linear;
|
||||
|
||||
Reference in New Issue
Block a user