snappySnapDriver_8H_source.html

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

  =========                 |

  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox

   \\    /   O peration     |

    \\  /    A nd           | www.openfoam.com

     \\/     M anipulation  |

-------------------------------------------------------------------------------

    Copyright (C) 2011-2015 OpenFOAM Foundation

    Copyright (C) 2020 OpenCFD Ltd.

-------------------------------------------------------------------------------

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::snappySnapDriver


Description

    All to do with snapping to surface


SourceFiles

    snappySnapDriver.C

    snappySnapDriverFeature.C


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


#ifndef snappySnapDriver_H

#define snappySnapDriver_H


#include "meshRefinement.H"

#include "DynamicField.H"

#include "pointConstraint.H"


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


namespace Foam

{


// Forward declaration of classes

class motionSmoother;

class refinementParameters;

class snapParameters;

class pointConstraint;

class layerParameters;

class displacementMotionSolver;

class addPatchCellLayer;


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

                           Class snappySnapDriver Declaration

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


class snappySnapDriver

{

    // Private data


        //- Mesh+surface

        meshRefinement& meshRefiner_;


        //- From global surface region to master side patch

        const labelList globalToMasterPatch_;


        //- From global surface region to slave side patch

        const labelList globalToSlavePatch_;


        //- Are we operating in test mode?

        const bool dryRun_;


    // Private Member Functions


        // Snapping


            //- Top-level: snap onto surface & features and add buffer layer

            void doSnapBufferLayers

            (

                const dictionary& snapDict,

                const dictionary& motionDict,

                const meshRefinement::FaceMergeType mergeType,

                const scalar featureCos,

                const scalar planarAngle,

                const snapParameters& snapParams

            );


            //- Calculates (geometric) shared points

            //  Requires bitSet to be sized and initialised

            static label getCollocatedPoints

            (

                const scalar tol,

                const pointField&,

                bitSet&

            );


            //- Calculate displacement (over all mesh points) to move points

            //  to average of connected cell centres

            static tmp<pointField> smoothInternalDisplacement

            (

                const meshRefinement& meshRefiner,

                const motionSmoother&

            );


            //- Calculate displacement per patch point to smooth out patch.

            //  Quite complicated in determining which points to move where.

            static tmp<pointField> smoothPatchDisplacement

            (

                const motionSmoother&,

                const List<labelPair>&

            );


            static tmp<pointField> avg

            (

                const polyMesh& mesh,

                const bitSet& isMasterPoint,

                const indirectPrimitivePatch&,

                const pointField&

            );


            //- Calculate displacement per patch point. Wip.

            static tmp<pointField> smoothLambdaMuPatchDisplacement

            (

                const polyMesh& mesh,

                const indirectPrimitivePatch& pp,

                const List<labelPair>& baffles

            );


            tmp<scalarField> wantedThickness

            (

                const indirectPrimitivePatch& pp,

                const scalar cellSizeFraction

            ) const;


            //- Create/update pointMesh

            const pointMesh& makePointMesh

            (

                const indirectPrimitivePatch& pp,

                const pointConstraintList& pointConstraints,

                const word& allEdgePatchName,

                const word& allPointPatchName

            ) const;


            autoPtr<displacementMotionSolver> makeMotionSolver

            (

                const pointMesh& pMesh,

                const dictionary& snapDict,

                const labelList& adaptPatchIDs

            ) const;


            void setDisplacement

            (

                const indirectPrimitivePatch& pp,

                const pointField& patchDisp,

                const labelList& adaptPatchIDs,

                const pointField& points0,

                pointVectorField& fld

            );


            autoPtr<mapPolyMesh> addBufferLayers

            (

                const indirectPrimitivePatch& pp,


                //const scalar cellSizeFraction,

                const pointField& thickness,

                // Layer mesh modifier

                addPatchCellLayer& addLayer

            );


            //- Check that face zones are synced

            void checkCoupledFaceZones() const;


            //- Per edge distance to patch

            static tmp<scalarField> edgePatchDist

            (

                const pointMesh&,

                const indirectPrimitivePatch&

            );


            //- Write displacement as .obj file.

            static void dumpMove

            (

                const fileName&,

                const pointField&,

                const pointField&

            );


            //- Check displacement is outwards pointing

            static bool outwardsDisplacement

            (

                const indirectPrimitivePatch&,

                const vectorField&

            );


            //- Freeze points on pointZone or (inside of) faceZone

            static void freezeExposedPoints

            (

                const meshRefinement& meshRefiner,

                const word& fzName,     // faceZone name

                const word& pzName,     // pointZone name

                const indirectPrimitivePatch& outside,

                vectorField& patchDisp

            );


            //- Detect warpage

            void detectWarpedFaces

            (

                const scalar featureCos,

                const indirectPrimitivePatch& pp,


                DynamicList<label>& splitFaces,

                DynamicList<labelPair>& splits

            ) const;


            //- Get per face -1 or label of opposite face if on internal/baffle

            //  faceZone

            labelList getInternalOrBaffleDuplicateFace() const;


            //- Get points both on patch and facezone.

            static void getZoneSurfacePoints

            (

                const fvMesh& mesh,

                const indirectPrimitivePatch&,

                const word& zoneName,


                bitSet& pointOnZone

            );


            //- Get points both on patch and facezone.

            template<class FaceList>

            static labelList getFacePoints

            (

                const indirectPrimitivePatch& pp,

                const FaceList& faces

            );


            //- Per patch point calculate point on nearest surface.

            //  Return displacement of patch points.

            static void calcNearestSurface

            (

                const refinementSurfaces& surfaces,


                const labelList& surfacesToTest,

                const labelListList& regionsToTest,


                const pointField& localPoints,

                const labelList& zonePointIndices,


                scalarField& minSnapDist,

                labelList& snapSurf,

                vectorField& patchDisp,


                // Optional: nearest point, normal

                pointField& nearestPoint,

                vectorField& nearestNormal

            );


            // Feature line snapping


                //- Is point on two feature edges that make a largish angle?

                bool isFeaturePoint

                (

                    const scalar featureCos,

                    const indirectPrimitivePatch& pp,

                    const bitSet& isFeatureEdge,

                    const label pointi

                ) const;


                void smoothAndConstrain

                (

                    const bitSet& isMasterEdge,

                    const indirectPrimitivePatch& pp,

                    const labelList& meshEdges,

                    const List<pointConstraint>& constraints,

                    vectorField& disp

                ) const;

                //void smoothAndConstrain2

                //(

                //    const bool applyConstraints,

                //    const indirectPrimitivePatch& pp,

                //    const List<pointConstraint>& constraints,

                //    vectorField& disp

                //) const;

                void calcNearest

                (

                    const label iter,

                    const indirectPrimitivePatch& pp,

                    vectorField& pointDisp,

                    vectorField& pointSurfaceNormal,

                    vectorField& pointRotation

                ) const;

                void calcNearestFace

                (

                    const label iter,

                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const scalarField& faceSnapDist,

                    vectorField& faceDisp,

                    vectorField& faceSurfaceNormal,

                    labelList& faceSurfaceRegion

                    //vectorField& faceRotation

                ) const;

                void calcNearestFacePointProperties

                (

                    const label iter,

                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,


                    const vectorField& faceDisp,

                    const vectorField& faceSurfaceNormal,

                    const labelList& faceSurfaceRegion,


                    List<List<point>>& pointFaceSurfNormals,

                    List<List<point>>& pointFaceDisp,

                    List<List<point>>& pointFaceCentres,

                    List<labelList>&    pointFacePatchID

                ) const;

                void correctAttraction

                (

                    const UList<point>& surfacePoints,

                    const UList<label>& surfaceCounts,

                    const point& edgePt,

                    const vector& edgeNormal,   // normalised normal

                    const point& pt,

                    vector& edgeOffset  // offset from pt to point on edge

                ) const;


                //- For any reverse (so from feature back to mesh) attraction:

                //  add attraction if diagonal points on face attracted

                void stringFeatureEdges

                (

                    const label iter,

                    const scalar featureCos,


                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const scalarField& snapDist,


                    const vectorField& rawPatchAttraction,

                    const List<pointConstraint>& rawPatchConstraints,


                    vectorField& patchAttraction,

                    List<pointConstraint>& patchConstraints

                ) const;


                //- Remove constraints of points next to multi-patch points

                //  to give a bit more freedom of the mesh to conform to the

                //  multi-patch points. Bit dodgy for simple cases.

                void releasePointsNextToMultiPatch

                (

                    const label iter,

                    const scalar featureCos,


                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const scalarField& snapDist,


                    const List<List<point>>& pointFaceCentres,

                    const labelListList& pointFacePatchID,


                    const vectorField& rawPatchAttraction,

                    const List<pointConstraint>& rawPatchConstraints,


                    vectorField& patchAttraction,

                    List<pointConstraint>& patchConstraints

                ) const;


                //- Detect any diagonal attraction. Returns indices in face

                //  or (-1, -1) if none

                labelPair findDiagonalAttraction

                (

                    const indirectPrimitivePatch& pp,

                    const vectorField& patchAttraction,

                    const List<pointConstraint>& patchConstraints,

                    const label facei

                ) const;


                scalar pyrVol

                (

                    const indirectPrimitivePatch& pp,

                    const vectorField& featureAttraction,

                    const face& localF,

                    const point& cc

                ) const;

                void facePoints

                (

                    const indirectPrimitivePatch& pp,

                    const vectorField& featureAttraction,

                    const vectorField& nearestAttraction,

                    const face& f,

                    DynamicField<point>& points

                ) const;

                scalar pyrVol

                (

                    const indirectPrimitivePatch& pp,

                    const vectorField& featureAttraction,

                    const vectorField& nearestAttraction,

                    const face& localF,

                    const point& cc

                ) const;

                Tuple2<point, vector> centreAndNormal

                (

                    const indirectPrimitivePatch& pp,

                    const vectorField& featureAttraction,

                    const vectorField& nearestAttraction,

                    const face& localF

                ) const;

                bool isSplitAlignedWithFeature

                (

                    const scalar featureCos,

                    const point& newPt0,

                    const pointConstraint& pc0,

                    const point& newPt1,

                    const pointConstraint& pc1

                ) const;

                bool isConcave

                (

                    const point& c0,

                    const vector& area0,

                    const point& c1,

                    const vector& area1,

                    const scalar concaveCos

                ) const;

                labelPair findDiagonalAttraction

                (

                    const scalar featureCos,

                    const scalar concaveCos,

                    const scalar minAreaFraction,

                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const vectorField& patchAttraction,

                    const List<pointConstraint>& patchConstraints,

                    const vectorField& nearestAttraction,

                    const vectorField& nearestNormal,

                    const label faceI,


                    DynamicField<point>& points0,

                    DynamicField<point>& points1

                ) const;


                //- Do all logic on whether to add face cut to diagonal

                //  attraction

                void splitDiagonals

                (

                    const scalar featureCos,

                    const scalar concaveCos,

                    const scalar minAreaFraction,


                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const vectorField& nearestAttraction,

                    const vectorField& nearestNormal,

                    const List<labelList>& pointFacePatchID,


                    vectorField& patchAttraction,

                    List<pointConstraint>& patchConstraints,

                    DynamicList<label>& splitFaces,

                    DynamicList<labelPair>& splits,

                    DynamicList<labelPair>& splitPatches

                ) const;


                //- Avoid attraction across face diagonal since would

                //  cause face squeeze

                void avoidDiagonalAttraction

                (

                    const label iter,

                    const scalar featureCos,

                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    vectorField& patchAttraction,

                    List<pointConstraint>& patchConstraints

                ) const;


                //- Write some stats about constraints

                void writeStats

                (

                    const indirectPrimitivePatch& pp,

                    const bitSet& isMasterPoint,

                    const List<pointConstraint>& patchConstraints

                ) const;


                //- Return hit if on multiple points

                pointIndexHit findMultiPatchPoint

                (

                    const point& pt,

                    const labelList& patchIDs,

                    const List<point>& faceCentres

                ) const;


                //- Return hit if faces-on-the-same-normalplane are on multiple

                //  patches

                pointIndexHit findMultiPatchPoint

                (

                    const point& pt,

                    const labelList& pfPatchID,

                    const UList<vector>& surfaceNormals,

                    const labelList& faceToNormalBin

                ) const;


                //- Return index of similar normal

                label findNormal

                (

                    const scalar featureCos,

                    const vector& faceSurfaceNormal,

                    const UList<vector>& surfaceNormals

                ) const;


                //- Determine attraction and constraints for single point

                //  using sampled surrounding of the point

                void featureAttractionUsingReconstruction

                (

                    const label iter,

                    const scalar featureCos,


                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const scalarField& snapDist,

                    const vectorField& nearestDisp,

                    const label pointi,


                    const List<List<point>>& pointFaceSurfNormals,

                    const List<List<point>>& pointFaceDisp,

                    const List<List<point>>& pointFaceCentres,

                    const labelListList& pointFacePatchID,


                    DynamicList<point>& surfacePoints,

                    DynamicList<vector>& surfaceNormals,

                    labelList& faceToNormalBin,


                    vector& patchAttraction,

                    pointConstraint& patchConstraint

                ) const;


                //- Determine attraction and constraints for all points

                //  using sampled surrounding of the point

                void featureAttractionUsingReconstruction

                (

                    const label iter,

                    const scalar featureCos,

                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const scalarField& snapDist,

                    const vectorField& nearestDisp,


                    const List<List<point>>& pointFaceSurfNormals,

                    const List<List<point>>& pointFaceDisp,

                    const List<List<point>>& pointFaceCentres,

                    const labelListList& pointFacePatchID,


                    vectorField& patchAttraction,

                    List<pointConstraint>& patchConstraints

                ) const;


                //- Determine geometric features and attraction to equivalent

                //  surface features

                void determineFeatures

                (

                    const label iter,

                    const scalar featureCos,

                    const bool multiRegionFeatureSnap,

                    const bool strictRegionFeatureSnap, // special feat-point


                    const indirectPrimitivePatch&,

                    const pointField& ppLocalPoints,

                    const scalarField& snapDist,

                    const vectorField& nearestDisp,


                    const List<List<point>>& pointFaceSurfNormals,

                    const List<List<point>>& pointFaceDisp,

                    const List<List<point>>& pointFaceCentres,

                    const labelListList& pointFacePatchID,


                    List<labelList>& pointAttractor,

                    List<List<pointConstraint>>& pointConstraints,

                    // Feature-edge to pp point

                    List<List<DynamicList<point>>>& edgeAttractors,

                    List<List<DynamicList<pointConstraint>>>& edgeConstraints,

                    vectorField& patchAttraction,

                    List<pointConstraint>& patchConstraints

                ) const;


                //- Determine features originating from bafles and

                //  and add attraction to equivalent surface features

                void determineBaffleFeatures

                (

                    const label iter,

                    const bool baffleFeaturePoints,

                    const scalar featureCos,


                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const scalarField& snapDist,


                    // Feature-point to pp point

                    List<labelList>& pointAttractor,

                    List<List<pointConstraint>>& pointConstraints,

                    // Feature-edge to pp point

                    List<List<DynamicList<point>>>& edgeAttractors,

                    List<List<DynamicList<pointConstraint>>>& edgeConstraints,

                    // pp point to nearest feature

                    vectorField& patchAttraction,

                    List<pointConstraint>& patchConstraints

                ) const;

                void reverseAttractMeshPoints

                (

                    const label iter,


                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const scalarField& snapDist,


                    // Feature-point to pp point

                    const List<labelList>& pointAttractor,

                    const List<List<pointConstraint>>& pointConstraints,

                    // Feature-edge to pp point

                    const List<List<DynamicList<point>>>& edgeAttractors,

                    const List<List<DynamicList<pointConstraint>>>&,


                    const vectorField& rawPatchAttraction,

                    const List<pointConstraint>& rawPatchConstraints,


                    // pp point to nearest feature

                    vectorField& patchAttraction,

                    List<pointConstraint>& patchConstraints

                ) const;


                //- Find point on nearest feature edge (within searchDist).

                //  Return point and feature

                //  and store feature-edge to mesh-point and vice versa

                Tuple2<label, pointIndexHit> findNearFeatureEdge

                (

                    const bool isRegionEdge,


                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const scalarField& snapDist,

                    const label pointi,

                    const point& estimatedPt,


                    List<List<DynamicList<point>>>&,

                    List<List<DynamicList<pointConstraint>>>&,

                    vectorField&,

                    List<pointConstraint>&

                ) const;


                //- Find nearest feature point (within searchDist).

                //  Return feature point

                //  and store feature-point to mesh-point and vice versa.

                //  If another mesh point already referring to this feature

                //  point and further away, reset that one to a near feature

                //  edge (using findNearFeatureEdge above)

                Tuple2<label, pointIndexHit> findNearFeaturePoint

                (

                    const bool isRegionEdge,


                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const scalarField& snapDist,

                    const label pointi,

                    const point& estimatedPt,


                    // Feature-point to pp point

                    List<labelList>& pointAttractor,

                    List<List<pointConstraint>>& pointConstraints,

                    // Feature-edge to pp point

                    List<List<DynamicList<point>>>& edgeAttractors,

                    List<List<DynamicList<pointConstraint>>>& edgeConstraints,

                    // pp point to nearest feature

                    vectorField& patchAttraction,

                    List<pointConstraint>& patchConstraints

                ) const;


                void featureAttractionUsingFeatureEdges

                (

                    const label iter,

                    const bool multiRegionFeatureSnap,

                    const bool strictRegionFeatureSnap,


                    const bool detectBaffles,

                    const bool baffleFeaturePoints,

                    const bool releasePoints,

                    const bool stringFeatures,

                    const bool avoidDiagonal,


                    const scalar featureCos,


                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const scalarField& snapDist,

                    const vectorField& nearestDisp,

                    const vectorField& nearestNormal,


                    const List<List<point>>& pointFaceSurfNormals,

                    const List<List<point>>& pointFaceDisp,

                    const List<List<point>>& pointFaceCentres,

                    const labelListList& pointFacePatchID,


                    vectorField& patchAttraction,

                    List<pointConstraint>& patchConstraints

                ) const;


                void preventFaceSqueeze

                (

                    const label iter,

                    const scalar featureCos,

                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    const scalarField& snapDist,

                    const vectorField& nearestAttraction,


                    vectorField& patchAttraction,

                    List<pointConstraint>& patchConstraints

                ) const;


                //- Top level feature attraction routine. Gets given

                //  displacement to nearest surface in nearestDisp

                //  and calculates new displacement taking into account

                //  features

                vectorField calcNearestSurfaceFeature

                (

                    const snapParameters& snapParams,

                    const bool alignMeshEdges,

                    const bool strictRegionFeatureSnap, //points on >=3 patches

                    const label iter,

                    const scalar featureCos,

                    const scalar featureAttract,

                    const scalarField& snapDist,

                    const vectorField& nearestDisp,

                    const vectorField& nearestNormal,

                    const indirectPrimitivePatch& pp,

                    const pointField& ppLocalPoints,

                    vectorField& patchAttraction,

                    List<pointConstraint>& patchConstraints,


                    DynamicList<label>& splitFaces,

                    DynamicList<labelPair>& splits,

                    DynamicList<labelPair>& splitPatches

                ) const;


        //- No copy construct

        snappySnapDriver(const snappySnapDriver&) = delete;


        //- No copy assignment

        void operator=(const snappySnapDriver&) = delete;


public:


    //- Runtime type information

    ClassName("snappySnapDriver");


    // Constructors


        //- Construct from components

        snappySnapDriver

        (

            meshRefinement& meshRefiner,

            const labelList& globalToMasterPatch,

            const labelList& globalToSlavePatch,

            const bool dryRun = false

        );


    // Member Functions


        // Snapping


            //- Merge baffles.

            autoPtr<mapPolyMesh> mergeZoneBaffles(const List<labelPair>&);


            //- Calculate edge length per patch point.

            static scalarField calcSnapDistance

            (

                const fvMesh& mesh,

                const snapParameters& snapParams,

                const indirectPrimitivePatch&

            );


            //- Smooth the mesh (patch and internal) to increase visibility

            //  of surface points (on castellated mesh) w.r.t. surface.

            static void preSmoothPatch

            (

                const meshRefinement& meshRefiner,

                const snapParameters& snapParams,

                const label nInitErrors,

                const List<labelPair>& baffles,

                motionSmoother&

            );


            //- Helper: calculate average cell centre per point

            static tmp<pointField> avgCellCentres

            (

                const fvMesh& mesh,

                const indirectPrimitivePatch&

            );


            //- Per patch point override displacement if in gap situation

            void detectNearSurfaces

            (

                const scalar planarCos,

                const indirectPrimitivePatch& pp,

                const pointField& ppLocalPoints,

                const pointField& nearestPoint,

                const vectorField& nearestNormal,

                vectorField& disp

            ) const;


            //- Per patch point calculate point on nearest surface. Set as

            //  boundary conditions of motionSmoother displacement field. Return

            //  displacement of patch points.

            static vectorField calcNearestSurface

            (

                const bool strictRegionSnap,

                const meshRefinement& meshRefiner,

                const labelList& globalToMasterPatch,

                const labelList& globalToSlavePatch,

                const indirectPrimitivePatch& pp,

                const pointField& ppLocalPoints,

                const scalarField& snapDist,

                pointField& nearestPoint,

                vectorField& nearestNormal

            );


            //static vectorField calcNearestLocalSurface

            //(

            //    const meshRefinement& meshRefiner,

            //    const scalarField& snapDist,

            //    const indirectPrimitivePatch&

            //);


            //- Smooth the displacement field to the internal.

            void smoothDisplacement

            (

                const snapParameters& snapParams,

                motionSmoother&

            ) const;


            //- Do the hard work: move the mesh according to displacement,

            //  locally relax the displacement. Return true if ended up with

            //  correct mesh, false if not.

            bool scaleMesh

            (

                const snapParameters& snapParams,

                const label nInitErrors,

                const List<labelPair>& baffles,

                motionSmoother&

            );


            //- Repatch faces according to surface nearest the face centre

            //  - calculate face-wise snap distance as max of point-wise

            //  - calculate face-wise nearest surface point

            //  - repatch face according to patch for surface point.

            autoPtr<mapPolyMesh> repatchToSurface

            (

                const snapParameters& snapParams,

                const labelList& adaptPatchIDs,

                const labelList& preserveFaces

            );


            //- Snap onto surface & features

            void doSnap

            (

                const dictionary& snapDict,

                const dictionary& motionDict,

                const meshRefinement::FaceMergeType mergeType,

                const scalar featureCos,

                const scalar planarAngle,

                const snapParameters& snapParams

            );

};


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


} // End namespace Foam


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


#ifdef NoRepository

#   include "snappySnapDriverTemplates.C"

#endif


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


#endif


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


DynamicField.H

fld
Info<< nl;Info<< "Write faMesh in vtk format:"<< nl;{ vtk::uindirectPatchWriter writer(aMesh.patch(), fileName(aMesh.time().globalPath()/vtkBaseFileName));writer.writeGeometry();globalIndex procAddr(aMesh.nFaces());labelList cellIDs;if(UPstream::master()) { cellIDs.resize(procAddr.totalSize());for(const labelRange &range :procAddr.ranges()) { auto slice=cellIDs.slice(range);slice=identity(range);} } writer.beginCellData(4);writer.writeProcIDs();writer.write("cellID", cellIDs);writer.write("area", aMesh.S().field());writer.write("normal", aMesh.faceAreaNormals());writer.beginPointData(1);writer.write("normal", aMesh.pointAreaNormals());Info<< " "<< writer.output().name()<< nl;}{ vtk::lineWriter writer(aMesh.points(), aMesh.edges(), fileName(aMesh.time().globalPath()/(vtkBaseFileName+"-edges")));writer.writeGeometry();writer.beginCellData(4);writer.writeProcIDs();{ Field< scalar > fld(faMeshTools::flattenEdgeField(aMesh.magLe(), true))

pp
uindirectPrimitivePatch pp(UIndirectList< face >(mesh.faces(), faceLabels), mesh.points())

patchIDs
labelList patchIDs
Definition checkPatchTopology.H:29

Foam::DynamicField
Dynamically sized Field. Similar to DynamicList, but inheriting from a Field instead of a List.
Definition DynamicField.H:62

Foam::DynamicList
A 1D vector of objects of type <T> that resizes itself as necessary to accept the new objects.
Definition DynamicList.H:68

Foam::List
A 1D array of objects of type <T>, where the size of the vector is known and used for subscript bound...
Definition List.H:72

Foam::Tuple2
A 2-tuple for storing two objects of dissimilar types. The container is similar in purpose to std::pa...
Definition Tuple2.H:51

Foam::UList
A 1D vector of objects of type <T>, where the size of the vector is known and can be used for subscri...
Definition UList.H:89

Foam::addPatchCellLayer
Adds layers of cells to outside (or inside) of polyMesh. Can optionally create stand-alone extruded m...
Definition addPatchCellLayer.H:153

Foam::autoPtr
Pointer management similar to std::unique_ptr, with some additional methods and type checking.
Definition autoPtr.H:65

Foam::bitSet
A bitSet stores bits (elements with only two states) in packed internal format and supports a variety...
Definition bitSet.H:61

Foam::dictionary
A list of keyword definitions, which are a keyword followed by a number of values (eg,...
Definition dictionary.H:133

Foam::displacementMotionSolver
Virtual base class for displacement motion solver.
Definition displacementMotionSolver.H:52

Foam::face
A face is a list of labels corresponding to mesh vertices.
Definition face.H:71

Foam::fileName
A class for handling file names.
Definition fileName.H:75

Foam::fvMesh
Mesh data needed to do the Finite Volume discretisation.
Definition fvMesh.H:85

Foam::layerParameters
Simple container to keep together layer specific information.
Definition layerParameters.H:55

Foam::meshRefinement
Helper class which maintains intersections of (changing) mesh with (static) surfaces.
Definition meshRefinement.H:84

Foam::meshRefinement::FaceMergeType
FaceMergeType
Enumeration for what to do with co-planar patch faces on a single.
Definition meshRefinement.H:155

Foam::motionSmoother
Given a displacement moves the mesh by scaling the displacement back until there are no more mesh err...
Definition motionSmoother.H:92

Foam::pointConstraint
Accumulates point constraints through successive applications of the applyConstraint function.
Definition pointConstraint.H:66

Foam::pointConstraints
Application of (multi-)patch point constraints.
Definition pointConstraints.H:64

Foam::pointMesh
Mesh representing a set of points created from polyMesh.
Definition pointMesh.H:49

Foam::polyMesh
Mesh consisting of general polyhedral cells.
Definition polyMesh.H:79

Foam::refinementParameters
Simple container to keep together refinement specific information.
Definition refinementParameters.H:55

Foam::refinementSurfaces
Container for data on surfaces used for surface-driven refinement. Contains all the data about the le...
Definition refinementSurfaces.H:60

Foam::snapParameters
Simple container to keep together snap specific information.
Definition snapParameters.H:49

Foam::snappySnapDriver::detectNearSurfaces
void detectNearSurfaces(const scalar planarCos, const indirectPrimitivePatch &pp, const pointField &ppLocalPoints, const pointField &nearestPoint, const vectorField &nearestNormal, vectorField &disp) const
Per patch point override displacement if in gap situation.
Definition snappySnapDriver.C:1114

Foam::snappySnapDriver::mergeZoneBaffles
autoPtr< mapPolyMesh > mergeZoneBaffles(const List< labelPair > &)
Merge baffles.

Foam::snappySnapDriver::scaleMesh
bool scaleMesh(const snapParameters &snapParams, const label nInitErrors, const List< labelPair > &baffles, motionSmoother &)
Do the hard work: move the mesh according to displacement,.
Definition snappySnapDriver.C:2203

Foam::snappySnapDriver::ClassName
ClassName("snappySnapDriver")
Runtime type information.

Foam::snappySnapDriver::preSmoothPatch
static void preSmoothPatch(const meshRefinement &meshRefiner, const snapParameters &snapParams, const label nInitErrors, const List< labelPair > &baffles, motionSmoother &)
Smooth the mesh (patch and internal) to increase visibility.
Definition snappySnapDriver.C:867

Foam::snappySnapDriver::avgCellCentres
static tmp< pointField > avgCellCentres(const fvMesh &mesh, const indirectPrimitivePatch &)
Helper: calculate average cell centre per point.
Definition snappySnapDriver.C:1029

Foam::snappySnapDriver::doSnap
void doSnap(const dictionary &snapDict, const dictionary &motionDict, const meshRefinement::FaceMergeType mergeType, const scalar featureCos, const scalar planarAngle, const snapParameters &snapParams)
Snap onto surface & features.
Definition snappySnapDriver.C:2569

Foam::snappySnapDriver::smoothDisplacement
void smoothDisplacement(const snapParameters &snapParams, motionSmoother &) const
Smooth the displacement field to the internal.
Definition snappySnapDriver.C:2129

Foam::snappySnapDriver::repatchToSurface
autoPtr< mapPolyMesh > repatchToSurface(const snapParameters &snapParams, const labelList &adaptPatchIDs, const labelList &preserveFaces)
Repatch faces according to surface nearest the face centre.
Definition snappySnapDriver.C:2270

Foam::snappySnapDriver::calcSnapDistance
static scalarField calcSnapDistance(const fvMesh &mesh, const snapParameters &snapParams, const indirectPrimitivePatch &)
Calculate edge length per patch point.
Definition snappySnapDriver.C:827

Foam::tmp
A class for managing temporary objects.
Definition tmp.H:75

Foam::word
A class for handling words, derived from Foam::string.
Definition word.H:66

ClassName
#define ClassName(TypeNameString)
Add typeName information from argument TypeNameString to a class.
Definition className.H:74

mesh
dynamicFvMesh & mesh
Definition createDynamicFvMesh.H:6

points
const pointField & points
Definition gmvOutputHeader.H:1

meshRefinement.H

Foam
Namespace for OpenFOAM.
Definition atmBoundaryLayer.C:27

Foam::labelPair
Pair< label > labelPair
A pair of labels.
Definition Pair.H:54

Foam::labelListList
List< labelList > labelListList
List of labelList.
Definition labelList.H:38

Foam::labelList
List< label > labelList
A List of labels.
Definition List.H:62

Foam::pointConstraintList
List< pointConstraint > pointConstraintList
List of pointConstraint.
Definition pointConstraint.H:57

Foam::pointVectorField
GeometricField< vector, pointPatchField, pointMesh > pointVectorField
Definition pointFieldsFwd.H:80

Foam::scalarField
Field< scalar > scalarField
Specialisation of Field<T> for scalar.
Definition primitiveFieldsFwd.H:46

Foam::indirectPrimitivePatch
PrimitivePatch< IndirectList< face >, const pointField & > indirectPrimitivePatch
A PrimitivePatch with an IndirectList for the faces, const reference for the point field.
Definition indirectPrimitivePatch.H:51

Foam::vectorField
Field< vector > vectorField
Specialisation of Field<T> for vector.
Definition primitiveFieldsFwd.H:48

Foam::point
vector point
Point is a vector.
Definition point.H:37

Foam::pointField
vectorField pointField
pointField is a vectorField.
Definition pointFieldFwd.H:38

Foam::vector
Vector< scalar > vector
Definition vector.H:57

Foam::pointIndexHit
PointIndexHit< point > pointIndexHit
A PointIndexHit with a 3D point.
Definition pointIndexHit.H:58

pointConstraint.H

f
labelList f(nPoints)

snappySnapDriverTemplates.C

points0
pointField points0(pointIOField(IOobject("points", mesh.time().constant(), polyMesh::meshSubDir, mesh, IOobject::MUST_READ, IOobject::NO_WRITE, IOobject::NO_REGISTER)))