compressibleVoF: Consolidated library functionality
This commit is contained in:
Will Bainbridge
255
src/twoPhaseModels/interfaceCompression/MPLIC/MPLIC.C
Normal file
255
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "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/interfaceCompression/MPLIC/MPLIC.H
Normal file
176
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Class
|
||||
Foam::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/interfaceCompression/MPLIC/MPLICU.C
Normal file
68
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "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/interfaceCompression/MPLIC/MPLICU.H
Normal file
146
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Class
|
||||
Foam::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/interfaceCompression/MPLIC/MPLICcell.C
Normal file
1054
src/twoPhaseModels/interfaceCompression/MPLIC/MPLICcell.C
Normal file
File diff suppressed because it is too large
Load Diff
399
src/twoPhaseModels/interfaceCompression/MPLIC/MPLICcell.H
Normal file
399
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Class
|
||||
Foam::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/interfaceCompression/MPLIC/MPLICcellI.H
Normal file
293
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "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 initialise alphaPhiU
|
||||
alphaPhiU_.setSize(nFaces);
|
||||
alphaPhiU_ = 0;
|
||||
|
||||
// Set size and initialise 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/interfaceCompression/MPLIC/MPLICcellStorage.C
Normal file
174
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "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
|
||||
{
|
||||
// Initialise 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
|
||||
{
|
||||
// Initialise 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]];
|
||||
|
||||
// Initialise 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]];
|
||||
|
||||
// Initialise 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/interfaceCompression/MPLIC/MPLICcellStorage.H
Normal file
241
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Class
|
||||
Foam::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
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,164 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "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/interfaceCompression/MPLIC/MPLICface.C
Normal file
279
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
177
src/twoPhaseModels/interfaceCompression/MPLIC/MPLICface.H
Normal file
177
src/twoPhaseModels/interfaceCompression/MPLIC/MPLICface.H
Normal file
@ -0,0 +1,177 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Class
|
||||
Foam::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"
|
||||
#include "boolList.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/interfaceCompression/MPLIC/MPLICfaceI.H
Normal file
178
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
13
src/twoPhaseModels/interfaceCompression/Make/files
Normal file
13
src/twoPhaseModels/interfaceCompression/Make/files
Normal file
@ -0,0 +1,13 @@
|
||||
interfaceCompression/interfaceCompression.C
|
||||
noInterfaceCompression/noInterfaceCompression.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)/libinterfaceCompression
|
||||
6
src/twoPhaseModels/interfaceCompression/Make/options
Normal file
6
src/twoPhaseModels/interfaceCompression/Make/options
Normal file
@ -0,0 +1,6 @@
|
||||
EXE_INC = \
|
||||
-I$(LIB_SRC)/physicalProperties/lnInclude \
|
||||
-I$(LIB_SRC)/finiteVolume/lnInclude
|
||||
|
||||
LIB_LIBS = \
|
||||
-lfiniteVolume
|
||||
68
src/twoPhaseModels/interfaceCompression/PLIC/PLIC.C
Normal file
68
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "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/interfaceCompression/PLIC/PLIC.H
Normal file
142
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Class
|
||||
Foam::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/interfaceCompression/PLIC/PLICU.C
Normal file
68
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "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/interfaceCompression/PLIC/PLICU.H
Normal file
130
src/twoPhaseModels/interfaceCompression/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-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Class
|
||||
Foam::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
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,94 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "interfaceCompression.H"
|
||||
#include "linear.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
defineTypeNameAndDebug(interfaceCompressionNew, 0);
|
||||
|
||||
surfaceInterpolationScheme<scalar>::
|
||||
addMeshFluxConstructorToTable<interfaceCompressionNew>
|
||||
addinterfaceCompressionScalarMeshFluxConstructorToTable_;
|
||||
|
||||
const wordHashSet compressionSchemes
|
||||
{
|
||||
"interfaceCompression",
|
||||
"noInterfaceCompression",
|
||||
"PLIC",
|
||||
"PLICU",
|
||||
"MPLIC",
|
||||
"MPLICU"
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
Foam::tmp<Foam::surfaceScalarField>
|
||||
Foam::interfaceCompressionNew::interpolate
|
||||
(
|
||||
const volScalarField& vf
|
||||
) const
|
||||
{
|
||||
const surfaceScalarField& nHatf =
|
||||
mesh().lookupObject<const surfaceScalarField>
|
||||
(
|
||||
"nHatf"
|
||||
);
|
||||
|
||||
const surfaceScalarField vff
|
||||
(
|
||||
linear<scalar>(mesh()).interpolate(vf)
|
||||
);
|
||||
|
||||
surfaceScalarField vfc
|
||||
(
|
||||
cAlpha_*sign(phi_)*vff*(1 - vff)*nHatf/mesh().magSf()
|
||||
);
|
||||
|
||||
surfaceScalarField::Boundary& vfcBf = vfc.boundaryFieldRef();
|
||||
|
||||
// Do not compress interface at non-coupled boundary faces
|
||||
// (inlets, outlets etc.)
|
||||
forAll(vfc.boundaryField(), patchi)
|
||||
{
|
||||
fvsPatchScalarField& vfcp = vfcBf[patchi];
|
||||
|
||||
if (!vfcp.coupled())
|
||||
{
|
||||
vfcp == 0;
|
||||
}
|
||||
}
|
||||
|
||||
tmp<surfaceScalarField> tvff(tScheme_().interpolate(vf) + vfc);
|
||||
tvff.ref().maxMin(0, 1);
|
||||
|
||||
return tvff;
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,157 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2020-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Class
|
||||
Foam::interfaceCompression
|
||||
|
||||
Description
|
||||
Interface compression corrected scheme, based on counter-gradient
|
||||
transport, to maintain sharp interfaces during VoF simulations.
|
||||
|
||||
The interface compression is applied to the face interpolated field from a
|
||||
suitable 2nd-order shape-preserving NVD or TVD scheme, e.g. vanLeer or
|
||||
vanAlbada. A coefficient is supplied to control the degree of compression,
|
||||
with a value of 1 suitable for most VoF cases to ensure interface integrity.
|
||||
A value larger than 1 can be used but the additional compression can bias
|
||||
the interface to follow the mesh more closely while a value smaller than 1
|
||||
can lead to interface smearing.
|
||||
|
||||
Example:
|
||||
\verbatim
|
||||
divSchemes
|
||||
{
|
||||
.
|
||||
.
|
||||
div(phi,alpha) Gauss interfaceCompression vanLeer 1;
|
||||
.
|
||||
.
|
||||
}
|
||||
\endverbatim
|
||||
|
||||
See also
|
||||
Foam::vanLeer
|
||||
Foam::vanAlbada
|
||||
Foam::PLIC
|
||||
Foam::PLICU
|
||||
Foam::MPLIC
|
||||
Foam::MPLICU
|
||||
|
||||
SourceFiles
|
||||
interfaceCompression.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef interfaceCompression_H
|
||||
#define interfaceCompression_H
|
||||
|
||||
#include "surfaceInterpolationScheme.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class interfaceCompression Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
class interfaceCompressionNew
|
||||
:
|
||||
public surfaceInterpolationScheme<scalar>
|
||||
{
|
||||
// Private member data
|
||||
|
||||
const surfaceScalarField& phi_;
|
||||
|
||||
//- Base scheme to which the compression is applied
|
||||
tmp<surfaceInterpolationScheme<scalar>> tScheme_;
|
||||
|
||||
//- Compression factor
|
||||
const scalar cAlpha_;
|
||||
|
||||
|
||||
public:
|
||||
|
||||
//- Runtime type information
|
||||
TypeName("interfaceCompression");
|
||||
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct from faceFlux and Istream
|
||||
interfaceCompressionNew
|
||||
(
|
||||
const fvMesh& mesh,
|
||||
const surfaceScalarField& faceFlux,
|
||||
Istream& is
|
||||
)
|
||||
:
|
||||
surfaceInterpolationScheme<scalar>(mesh),
|
||||
phi_(faceFlux),
|
||||
tScheme_
|
||||
(
|
||||
surfaceInterpolationScheme<scalar>::New(mesh, faceFlux, is)
|
||||
),
|
||||
cAlpha_(readScalar(is))
|
||||
{}
|
||||
|
||||
|
||||
// Member Functions
|
||||
|
||||
//- Return the interpolation weighting factors
|
||||
virtual tmp<surfaceScalarField> weights
|
||||
(
|
||||
const volScalarField&
|
||||
) const
|
||||
{
|
||||
NotImplemented;
|
||||
|
||||
return tmp<surfaceScalarField>(nullptr);
|
||||
}
|
||||
|
||||
//- 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 interfaceCompressionNew&) = delete;
|
||||
};
|
||||
|
||||
|
||||
extern const wordHashSet compressionSchemes;
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,40 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2021-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "noInterfaceCompression.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
defineTypeNameAndDebug(noInterfaceCompressionNew, 0);
|
||||
|
||||
surfaceInterpolationScheme<scalar>::
|
||||
addMeshFluxConstructorToTable<noInterfaceCompressionNew>
|
||||
addnoInterfaceCompressionScalarMeshFluxConstructorToTable_;
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,139 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration | Website: https://openfoam.org
|
||||
\\ / A nd | Copyright (C) 2021-2022 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software: you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Class
|
||||
Foam::noInterfaceCompression
|
||||
|
||||
Description
|
||||
Wrapper scheme to allow VoF solvers to run efficiently without interface
|
||||
compression, e.g. for cavitation simulations.
|
||||
|
||||
Example:
|
||||
\verbatim
|
||||
divSchemes
|
||||
{
|
||||
.
|
||||
.
|
||||
div(phi,alpha) Gauss noInterfaceCompression vanLeer;
|
||||
.
|
||||
.
|
||||
}
|
||||
\endverbatim
|
||||
|
||||
See also
|
||||
Foam::interfaceCompression
|
||||
Foam::vanLeer
|
||||
Foam::vanAlbada
|
||||
|
||||
SourceFiles
|
||||
noInterfaceCompression.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef noInterfaceCompression_H
|
||||
#define noInterfaceCompression_H
|
||||
|
||||
#include "surfaceInterpolationScheme.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class noInterfaceCompression Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
class noInterfaceCompressionNew
|
||||
:
|
||||
public surfaceInterpolationScheme<scalar>
|
||||
{
|
||||
// Private member data
|
||||
|
||||
//- Base scheme to which the compression is applied
|
||||
tmp<surfaceInterpolationScheme<scalar>> tScheme_;
|
||||
|
||||
|
||||
public:
|
||||
|
||||
//- Runtime type information
|
||||
TypeName("noInterfaceCompression");
|
||||
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct from faceFlux and Istream
|
||||
noInterfaceCompressionNew
|
||||
(
|
||||
const fvMesh& mesh,
|
||||
const surfaceScalarField& faceFlux,
|
||||
Istream& is
|
||||
)
|
||||
:
|
||||
surfaceInterpolationScheme<scalar>(mesh),
|
||||
tScheme_
|
||||
(
|
||||
surfaceInterpolationScheme<scalar>::New(mesh, faceFlux, is)
|
||||
)
|
||||
{}
|
||||
|
||||
|
||||
// Member Functions
|
||||
|
||||
//- Return the interpolation weighting factors
|
||||
virtual tmp<surfaceScalarField> weights
|
||||
(
|
||||
const volScalarField&
|
||||
) const
|
||||
{
|
||||
NotImplemented;
|
||||
|
||||
return tmp<surfaceScalarField>(nullptr);
|
||||
}
|
||||
|
||||
//- Return the face-interpolate of the given cell field
|
||||
virtual tmp<surfaceScalarField> interpolate
|
||||
(
|
||||
const volScalarField& vf
|
||||
) const
|
||||
{
|
||||
return tScheme_().interpolate(vf);
|
||||
}
|
||||
|
||||
|
||||
// Member Operators
|
||||
|
||||
//- Disallow default bitwise assignment
|
||||
void operator=(const noInterfaceCompressionNew&) = delete;
|
||||
};
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
Reference in New Issue
Block a user