meshDualiser.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) 2011-2016 OpenFOAM Foundation
-------------------------------------------------------------------------------
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::meshDualiser

Description
    Creates dual of polyMesh. Every point becomes a cell (or multiple cells
    for feature points), a walk around every edge creates faces between them.

    Put all points you want in the final mesh into featurePoints; all edge(mid)s
    you want in the final mesh into featureEdges; all face(centre)s in
    faceFaces.

    Usually to preserve boundaries:
        - all boundary faces are featureFaces
        - all edges and points inbetween different patches are
          featureEdges/points.

    In same way you can also preserve internal faces (e.g. faceZones)

SourceFiles
    Foam::meshDualiser.C

\*---------------------------------------------------------------------------*/

#ifndef Foam_meshDualiser_H
#define Foam_meshDualiser_H

#include "bitSet.H"
#include "boolList.H"
#include "typeInfo.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

class polyMesh;
class polyTopoChange;

/*---------------------------------------------------------------------------*\
                           Class meshDualiser Declaration
\*---------------------------------------------------------------------------*/

class meshDualiser
{
    // Private data

        const polyMesh& mesh_;

        //- From point on cell to dual cell. Either single entry or
        //  one entry per pointCells
        labelListList pointToDualCells_;

        //- From point to dual point (or -1 if not feature point).
        labelList pointToDualPoint_;

        //- From cell to dual point. All cells become point
        labelList cellToDualPoint_;

        //- From face to dual point (or -1 if not feature face)
        labelList faceToDualPoint_;

        //- From edge to dual point (or -1 if not feature edge)
        labelList edgeToDualPoint_;


    // Private Member Functions

        static void checkPolyTopoChange(const polyTopoChange&);

        static void dumpPolyTopoChange(const polyTopoChange&, const fileName&);

        //- Find dual cell given point and cell
        label findDualCell(const label celli, const label pointi) const;

        //- Helper function to generate dualpoints on all boundary edges
        //  emanating from (boundary & feature) point
        void generateDualBoundaryEdges
        (
            const bitSet& isBoundaryEdge,
            const label pointi,
            polyTopoChange& meshMod
        );

        //- Check that owner and neighbour of face have same dual cell
        bool sameDualCell
        (
            const label facei,
            const label pointi
        ) const;

        //- Add internal face
        label addInternalFace
        (
            const label masterPointi,
            const label masterEdgeI,
            const label masterFacei,

            const bool edgeOrder,
            const label dualCell0,
            const label dualCell1,
            const labelUList& verts,
            polyTopoChange& meshMod
        ) const;

        //- Add boundary face
        label addBoundaryFace
        (
            const label masterPointi,
            const label masterEdgeI,
            const label masterFacei,

            const label dualCelli,
            const label patchi,
            const labelUList& verts,
            polyTopoChange& meshMod
        ) const;

        //- Create internal faces walking around edge
        void createFacesAroundEdge
        (
            const bool splitFace,
            const bitSet& isBoundaryEdge,
            const label edgeI,
            const label startFacei,
            polyTopoChange& meshMod,
            boolList& doneEFaces
        ) const;

        //- Create single internal face from internal face
        void createFaceFromInternalFace
        (
            const label facei,
            label& fp,
            polyTopoChange&
        ) const;

        //- Creates boundary faces walking around point on patchi.
        void createFacesAroundBoundaryPoint
        (
            const label patchi,
            const label patchPointi,
            const label startFacei,
            polyTopoChange&,
            boolList& donePFaces            // pFaces visited
        ) const;

        //- No copy construct
        meshDualiser(const meshDualiser&) = delete;

        //- No copy assignment
        void operator=(const meshDualiser&) = delete;


public:

    //- Runtime type information
    ClassName("meshDualiser");


    // Constructors

        //- Construct from mesh
        meshDualiser(const polyMesh&);


    // Member Functions

        // Access

            //- From point on cell to dual cell. Either single entry or
            //  one entry per pointCells.
            const labelListList& pointToDualCells() const
            {
                return pointToDualCells_;
            }

            //- From point to dual point (or -1 if not feature point).
            const labelList& pointToDualPoint() const
            {
                return pointToDualPoint_;
            }

            //- From cell to dual point (at cell centre). All cells become
            //  points.
            const labelList& cellToDualPoint() const
            {
                return cellToDualPoint_;
            }

            //- From face to dual point (at face centre; or -1 if not
            //  feature face).
            const labelList& faceToDualPoint() const
            {
                return faceToDualPoint_;
            }

            //- From edge to dual point (at edge mid; or -1 if not feature
            //  edge).
            const labelList& edgeToDualPoint() const
            {
                return edgeToDualPoint_;
            }


        // Edit


            //- Insert all changes into meshMod to convert the polyMesh into
            //  its dual.
            //  featureFaces  : faces where we want a point at the face centre
            //  featureEdges  : edges           ,,                 edge mid
            //  featurePoints : points          ,,    point. Two variants:
            //      singleCellFeaturePoints : point becomes one dualcell.
            //          Use this for e.g. convex boundary points.
            //      multiCellFeaturePoints : one dualcell per original cell
            //          around point. Use this for e.g. concave boundary points
            //          since it prevents big concave boundary cells.
            void setRefinement
            (
                const bool splitFace,
                const labelList& featureFaces,
                const labelList& featureEdges,
                const labelList& singleCellFeaturePoints,
                const labelList& multiCellFeaturePoints,
                polyTopoChange& meshMod
            );
};

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //