fvcSurfaceOps.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2024 M.Janssens
-------------------------------------------------------------------------------
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/>.
 
InNamespace
    Foam::fvc
 
Description
    Surface integrate surfaceField creating a volField.
    Surface sum a surfaceField creating a volField.
 
SourceFiles
    fvcSurfaceOps.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef Foam_fvcSurfaceOps_H
#define Foam_fvcSurfaceOps_H
 
#include "primitiveFieldsFwd.H"
#include "volFieldsFwd.H"
#include "surfaceFieldsFwd.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
//- In-place operations on Fields. Add to FieldFunctions.C ?
#define INPLACE_PRODUCT_OPERATOR(product, CombineOp, Op, OpFunc)               \
                                                                               \
template<class Type1, class Type2>                                             \
void OpFunc                                                                    \
(                                                                              \
    Field<typename product<Type1, Type2>::type>& result,                       \
    const UList<Type1>& f1,                                                    \
    const UList<Type2>& f2                                                     \
)                                                                              \
{                                                                              \
    typedef typename product<Type1, Type2>::type resultType;                   \
    TFOR_ALL_F_OP_F_OP_F                                                       \
    (resultType, result, CombineOp, Type1, f1, Op, Type2, f2)                  \
}
 
 
INPLACE_PRODUCT_OPERATOR(outerProduct, +=, *, multiplyAdd)
INPLACE_PRODUCT_OPERATOR(outerProduct, -=, *, multiplySubtract)
 
#undef INPLACE_PRODUCT_OPERATOR
 
 
 
/*---------------------------------------------------------------------------*\
                     Namespace fvc functions Declaration
\*---------------------------------------------------------------------------*/
 
namespace fvc
{
    // Interpolation
 
        //- Interpolate to face (using cop) and additional face field
        template<class Type, class FType, class ResultType, class CellToFaceOp>
        void interpolate
        (
            const surfaceScalarField& lambdas,
            const GeometricField<Type, fvPatchField, volMesh>& vf,
            const GeometricField<FType, fvsPatchField, surfaceMesh>& sf,
            const CellToFaceOp& cop,
            GeometricField<ResultType, fvsPatchField, surfaceMesh>& result
        );
 
        //- Interpolate to face (using cop)
        template
        <
            class Type0,
            class Type1,
            class ResultType,
            class CellToFaceOp
        >
        void interpolate
        (
            const surfaceScalarField& weights,
            const GeometricField<Type0, fvPatchField, volMesh>& vf0,
            const GeometricField<Type1, fvPatchField, volMesh>& vf1,
            const CellToFaceOp& cop,
            GeometricField<ResultType, fvsPatchField, surfaceMesh>& result
        );
 
 
    // Interpolation and accumulation
 
        //- Interpolate to face (using cop) and accumulate.
        template<class Type, class ResultType, class CellToFaceOp>
        void surfaceSum
        (
            const surfaceScalarField& lambdas,
            const GeometricField<Type, fvPatchField, volMesh>& vf,
            const CellToFaceOp& cop,
            GeometricField<ResultType, fvPatchField, volMesh>& result,
            const bool doCorrectBoundaryConditions = true
        );
 
        //- Interpolate to face (using cop) and accumulate. Additional
        //- face field
        template<class Type, class FType, class ResultType, class CellToFaceOp>
        void surfaceSum
        (
            const surfaceScalarField& lambdas,
            const GeometricField<Type, fvPatchField, volMesh>& vf,
            const GeometricField<FType, fvsPatchField, surfaceMesh>& sf,
            const CellToFaceOp& cop,
            GeometricField<ResultType, fvPatchField, volMesh>& result,
            const bool doCorrectBoundaryConditions = true
        );
 
        //- Interpolate to face (using cop) and accumulate. Additional
        //- face fields
        template
        <
            class Type,
            class FType0,
            class FType1,
            class ResultType,
            class CellToFaceOp
        >
        void surfaceSum
        (
            const surfaceScalarField& lambdas,
            const GeometricField<Type, fvPatchField, volMesh>& vf,
 
            const GeometricField<FType0, fvsPatchField, surfaceMesh>& sf0,
            const GeometricField<FType1, fvsPatchField, surfaceMesh>& sf1,
 
            const CellToFaceOp& cop,
 
            GeometricField<ResultType, fvPatchField, volMesh>& result,
            const bool doCorrectBoundaryConditions = true
        );
 
        //- Interpolate to face (using cop) and apply Gauss. Note: uses V(),
        //  not Vsc()
        template<class Type, class ResultType, class CellToFaceOp>
        void GaussOp
        (
            const surfaceScalarField& lambdas,
            const GeometricField<Type, fvPatchField, volMesh>& vf,
            const CellToFaceOp& cop,
            GeometricField<ResultType, fvPatchField, volMesh>& result
        );
 
 
    // Difference and accumulation
 
        //- sum of snGrad
        template<class Type, class ResultType, class CellToFaceOp>
        void surfaceSnSum
        (
            const surfaceScalarField& deltaCoeffs,
            const GeometricField<Type, fvPatchField, volMesh>& vf,
 
            const CellToFaceOp& cop,
 
            GeometricField<ResultType, fvPatchField, volMesh>& result,
            const bool doCorrectBoundaryConditions
        );
        //- sum of snGrad with additional surface field
        template<class Type, class ResultType, class CellToFaceOp>
        void surfaceSnSum
        (
            const surfaceScalarField& deltaCoeffs,
            const GeometricField<Type, fvPatchField, volMesh>& vf,
            const GeometricField<Type, fvsPatchField, surfaceMesh>& sadd,
 
            const CellToFaceOp& cop,
 
            GeometricField<ResultType, fvPatchField, volMesh>& result,
            const bool doCorrectBoundaryConditions
        );
 
        //- sum of snGrad with additional (interpolated) volField
        template<class Type, class GType, class ResultType, class CellToFaceOp>
        void surfaceSnSum
        (
            const surfaceScalarField& gammaWeights,
            const GeometricField<GType, fvPatchField, volMesh>& gamma,
 
            const surfaceScalarField& deltaCoeffs,
            const GeometricField<Type, fvPatchField, volMesh>& vf,
 
            const CellToFaceOp& cop,
 
            GeometricField<ResultType, fvPatchField, volMesh>& result,
            const bool doCorrectBoundaryConditions
        );
 
        //- sum of snGrad with additional (interpolated) volfields
        template
        <
            class Type,
            class GType0,
            class GType1,
            class ResultType,
            class CellToFaceOp
        >
        void surfaceSnSum
        (
            const surfaceScalarField& weights,
 
            const GeometricField<GType0, fvPatchField, volMesh>& gamma0,
            const GeometricField<GType1, fvPatchField, volMesh>& gamma1,
 
            const surfaceScalarField& deltaCoeffs,
            const GeometricField<Type, fvPatchField, volMesh>& vf,
 
            const CellToFaceOp& cop,
 
            GeometricField<ResultType, fvPatchField, volMesh>& result,
            const bool doCorrectBoundaryConditions
        );
 
        //- sum of snGrad with additional surface field
        template<class Type, class GType, class ResultType, class CellToFaceOp>
        void surfaceSnSum
        (
            const surfaceScalarField& gammaWeights,
            const GeometricField<GType, fvPatchField, volMesh>& gamma,
 
            const surfaceScalarField& deltaCoeffs,
            const GeometricField<Type, fvPatchField, volMesh>& vf,
 
            const GeometricField<Type, fvsPatchField, surfaceMesh>& sadd,
 
            const CellToFaceOp& cop,
 
            GeometricField<ResultType, fvPatchField, volMesh>& result,
            const bool doCorrectBoundaryConditions
        );
 
 
    // Other
 
        //- Interpolate to face (using cop) and apply distribution vectors
        template<class Type, class ResultType, class CellToFaceOp>
        void surfaceOp
        (
            const GeometricField<Type, fvPatchField, volMesh>& vf,
            const surfaceVectorField& ownLs,
            const surfaceVectorField& neiLs,
            const CellToFaceOp& cop,
            GeometricField<ResultType, fvPatchField, volMesh>& result
        );
}
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#ifdef NoRepository
    #include "fvcSurfaceOps.C"
#endif
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //