fvMeshStitcher.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  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::fvMeshStitcher
 
Description
    Mesh manipulator that uses the intersection provided by the cyclic
    non-conformal poly patches to create non-conformal finite volume
    interfaces.
 
SourceFiles
    fvMeshStitcher.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef fvMeshStitcher_H
#define fvMeshStitcher_H
 
#include "fvMesh.H"
#include "intersectionPatchToPatch.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
class nonConformalCyclicFvPatch;
 
/*---------------------------------------------------------------------------*\
                        Class fvMeshStitcher Declaration
\*---------------------------------------------------------------------------*/
 
class fvMeshStitcher
{
protected:
 
    // Protected Typedefs
 
        //- Alias for surface boundary fields to reduce verbosity of method
        //  definitions below
        template<class Type>
        using SurfaceFieldBoundary =
            GeometricBoundaryField<Type, fvsPatchField, surfaceMesh>;
 
        //- Alias the patchToPatch intersection part struct
        using part = patchToPatches::intersection::part;
 
        //- Alias the patchToPatch intersection couple struct
        using couple = patchToPatches::intersection::couple;
 
 
private:
 
    // Private Static Data
 
        //- Prefix applied to the names of non-conformal fields which are
        //  stored for mapping purposes
        static const word nccFieldPrefix_;
 
 
    // Private Data
 
        //- Non-const fvMesh reference to allow update
        fvMesh& mesh_;
 
 
    // Private Member Functions
 
        // Intersection
 
            //- Perform intersections for the given non-conformal interface
            void intersectNonConformalCyclic
            (
                const nonConformalCyclicFvPatch& nccFvp,
                SurfaceFieldBoundary<label>& polyFacesBf,
                SurfaceFieldBoundary<vector>& SfBf,
                SurfaceFieldBoundary<vector>& CfBf,
                const tmp<SurfaceFieldBoundary<label>>& tOrigFacesNbrBf,
                const tmp<SurfaceFieldBoundary<vector>>& tOrigSfNbrBf,
                const tmp<SurfaceFieldBoundary<point>>& tOrigCfNbrBf,
                List<part>& origEdgeParts
            ) const;
 
            //- Convert per-patch lists of edge parts into a single
            //  owner-orig-boundary list of edge parts that can be applied to
            //  the mesh
            List<part> calculateOwnerOrigBoundaryEdgeParts
            (
                const List<List<part>>& patchEdgeParts
            ) const;
 
            //- Apply a list of owner-orig-boundary edge parts to
            //  non-orig-patch faces (both internal and boundary)
            void applyOwnerOrigBoundaryEdgeParts
            (
                surfaceVectorField& SfSf,
                surfaceVectorField& CfSf,
                const List<part>& ownerOrigBoundaryEdgeParts
            ) const;
 
            //- Stabilise the faces that have had non-conformal coupled parts
            //  cut out from them
            void stabiliseOrigPatchFaces
            (
                SurfaceFieldBoundary<vector>& SfBf,
                SurfaceFieldBoundary<vector>& CfBf
            ) const;
 
            //- Perform intersections for all non-conformal interfaces
            void intersectNonConformalCyclics
            (
                SurfaceFieldBoundary<label>& polyFacesBf,
                surfaceVectorField& SfSf,
                surfaceVectorField& CfSf,
                const bool haveTopology
            ) const;
 
            //- Apply the given non-conformal topology (polyFacesBf) to the
            //  face geometry fields for the given patch type. Just set small
            //  stabilisation values. Don't actually do any cutting. Used for
            //  initialisation, or in situations when cutting cannot be done
            //  (e.g., when post processing a processor case).
            template<class NonConformalFvPatch>
            inline void createNonConformalStabilisationGeometry
            (
                const SurfaceFieldBoundary<label>& polyFacesBf,
                surfaceVectorField& SfSf,
                surfaceVectorField& CfSf
            ) const;
 
 
        // Motion
 
            //- Return whether or not this stitcher supports a changing mesh
            virtual bool changing() const = 0;
 
            //- Correct the mesh fluxes following a conform operation
            virtual void conformCorrectMeshPhi(surfaceScalarField& phi) = 0;
 
            //- Initialise correction of the mesh fluxes
            virtual void createNonConformalCorrectMeshPhiGeometry
            (
                SurfaceFieldBoundary<label>& polyFacesBf,
                surfaceVectorField& SfSf,
                surfaceVectorField& CfSf
            ) = 0;
 
            //- Correct the mesh fluxes following an unconform operation
            virtual void unconformCorrectMeshPhi
            (
                const SurfaceFieldBoundary<label>& polyFacesBf,
                surfaceVectorField& SfSf,
                surfaceVectorField& CfSf,
                surfaceScalarField& phi
            ) = 0;
 
 
        // Field Mapping
 
            //- Resize the patch fields of a given type and class to match the
            //  mesh
            template<class Type, template<class> class GeoField>
            void resizePatchFields();
 
            //- Resize the patch fields of a given class to match the mesh
            template<template<class> class GeoField>
            void resizePatchFields();
 
            //- Pre-conform surface fields of a given type by separating NCC
            //  and original parts of non-conformal couplings and storing them
            //  in the database as separate fields
            template<class Type>
            void preConformSurfaceFields();
 
            //- Pre-conform surface fields by separating NCC and original
            //  parts of non-conformal couplings and storing them in the
            //  database as separate fields
            inline void preConformSurfaceFields();
 
            //- Post-non-conform surface fields of a given type by looking up
            //  NCC and original parts of non-conformal couplings and combining
            //  them into a single non-conformal boundary field
            template<class Type>
            void postNonConformSurfaceFields();
 
            //- Post-non-conform surface fields by looking up NCC and
            //  original parts of non-conformal couplings and combining them
            //  into a single non-conformal boundary field
            inline void postNonConformSurfaceFields();
 
            //- Evaluate all non-conformal vol patch fields of a given type
            template<class Type>
            void evaluateVolFields();
 
            //- Evaluate all non-conformal vol patch fields
            inline void evaluateVolFields();
 
            //- Special post-non-conform for surface velocities
            inline void postNonConformSurfaceVelocities();
 
 
protected:
 
    // Protected Member Functions
 
        // Field Mapping
 
            //- Resize the patch field of a given field to match the mesh
            template<class GeoBoundaryField>
            void resizeBoundaryFieldPatchFields
            (
                const SurfaceFieldBoundary<label>& polyFacesBf,
                GeoBoundaryField& fieldBf
            );
 
            //- Resize the patch field of a given field to match the mesh
            template<class GeoField>
            void resizeFieldPatchFields
            (
                const SurfaceFieldBoundary<label>& polyFacesBf,
                GeoField& field
            );
 
            //- Reverse-map sum the values of a field
            template<class Type>
            static tmp<Field<Type>> fieldRMapSum
            (
                const Field<Type>& f,
                const label size,
                const labelUList& addr
            );
 
            //- Reverse-map sum the values of a field
            template<class Type>
            static tmp<Field<Type>> fieldRMapSum
            (
                const tmp<Field<Type>>& f,
                const label size,
                const labelUList& addr
            );
 
            //- Return the total non-conformal area associated with each
            //  original face
            inline tmp<SurfaceFieldBoundary<scalar>> getOrigNccMagSfb() const;
 
            //- Extract the non-conformal-coupled parts of the boundary field
            //  and store it on the conformal faces
            template<class Type>
            tmp<SurfaceFieldBoundary<Type>> conformalNccBoundaryField
            (
                const SurfaceFieldBoundary<Type>& fieldb
            ) const;
 
            //- Extract the original parts of the boundary field and store it
            //  on the conformal faces
            template<class Type>
            tmp<SurfaceFieldBoundary<Type>> conformalOrigBoundaryField
            (
                const SurfaceFieldBoundary<Type>& fieldb
            ) const;
 
            //- Combine non-conformal-coupled and original parts of the
            //  boundary field from the conformal faces to construct the
            //  complete non-conformal boundary field
            template<class Type>
            tmp<SurfaceFieldBoundary<Type>> nonConformalBoundaryField
            (
                const SurfaceFieldBoundary<Type>& nccFieldb,
                const SurfaceFieldBoundary<Type>& origFieldb
            ) const;
 
            //- Synchronise the boundary field by combining corresponding
            //  values across couplings with the given weightings
            template<class Type>
            tmp<SurfaceFieldBoundary<Type>> synchronisedBoundaryField
            (
                const SurfaceFieldBoundary<Type>& fieldb,
                const bool flip,
                const scalar ownerWeight,
                const scalar neighbourWeight
            ) const;
 
            //- Synchronise the boundary field by combining corresponding
            //  values across couplings with equal weightings
            template<class Type>
            tmp<SurfaceFieldBoundary<Type>> synchronisedBoundaryField
            (
                const SurfaceFieldBoundary<Type>& fieldb
            ) const;
 
 
        // Checking
 
            //- Is the connection "geometric", or has the topology just been
            //  loaded and stabilisation geometry applied?
            bool geometric() const;
 
            //- Return the non-dimensional cell openness for debugging/checking
            tmp<DimensionedField<scalar, volMesh>> openness() const;
 
            //- Return the non-dimensional old-time volume conservation error
            //  for a specified old-time index for debugging/checking
            tmp<DimensionedField<scalar, volMesh>> volumeConservationError
            (
                const label n
            ) const;
 
 
public:
 
    //- Runtime type information
    TypeName("fvMeshStitcher");
 
 
    // Declare run-time constructor selection table
 
        declareRunTimeSelectionTable
        (
            autoPtr,
            fvMeshStitcher,
            fvMesh,
            (fvMesh& mesh),
            (mesh)
        );
 
 
    // Constructors
 
        //- Construct from fvMesh
        explicit fvMeshStitcher(fvMesh&);
 
        //- Disallow default bitwise copy construction
        fvMeshStitcher(const fvMeshStitcher&) = delete;
 
 
    // Selectors
 
        //- Select, construct and return the fvMeshStitcher
        static autoPtr<fvMeshStitcher> New(fvMesh&, bool changing);
 
 
    //- Destructor
    virtual ~fvMeshStitcher();
 
 
    // Member Functions
 
        //- Return the fvMesh
        fvMesh& mesh()
        {
            return mesh_;
        }
 
        //- Does this stitcher do anything?
        bool stitches() const;
 
        //- Update local data for topology changes
        virtual void updateMesh(const polyTopoChangeMap&);
 
        //- Update local data for mesh motion
        virtual void movePoints();
 
        //- Disconnect the mesh by removing faces from the nonConformalCyclics
        virtual bool disconnect
        (
            const bool changing,
            const bool geometric
        );
 
        //- Connect the mesh by adding faces into the nonConformalCyclics
        virtual bool connect
        (
            const bool changing,
            const bool geometric,
            const bool load
        );
 
        //- Re-compute the connection. Topology is preserved. Permits a change
        //  in whether or not the connection is "geometric".
        void reconnect(const bool geometric) const;
 
        //- Write the mover state
        virtual bool write(const bool write = true) const
        {
            return true;
        }
 
 
    // Member Operators
 
        //- Disallow default bitwise assignment
        void operator=(const fvMeshStitcher&) = delete;
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#ifdef NoRepository
    #include "fvMeshStitcherTemplates.C"
#endif
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //