Layered overlap fringe strategy. Author: Vuko Vukcevic. Merge: Hrvoje Jasak.

src/overset/oversetMesh/Make/files

@@ -5,6 +5,7 @@ oversetFringe/oversetFringe/newOversetFringe.C
 oversetFringe/manualFringe/manualFringe.C
 oversetFringe/faceCellsFringe/faceCellsFringe.C
 oversetFringe/overlapFringe/overlapFringe/overlapFringe.C
+oversetFringe/overlapFringe/layeredOverlapFringe/layeredOverlapFringe.C
 oversetFringe/overlapFringe/adaptiveOverlapFringe/adaptiveOverlapFringe.C
 oversetFringe/compositeFringe/compositeFringe.C
 

src/overset/oversetMesh/oversetFringe/overlapFringe/adaptiveOverlapFringe/adaptiveOverlapFringe.C

@@ -418,7 +418,6 @@ Foam::adaptiveOverlapFringe::adaptiveOverlapFringe
         dict.lookupOrDefault<scalar>("orphanSuitability", 1)
     ),
     suitablePairsSuit_(0)
-
 {}
 
 

src/overset/oversetMesh/oversetFringe/overlapFringe/layeredOverlapFringe/layeredOverlapFringe.C

@@ -0,0 +1,474 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     4.1
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "layeredOverlapFringe.H"
+#include "oversetRegion.H"
+#include "oversetMesh.H"
+#include "polyPatchID.H"
+#include "processorFvPatchFields.H"
+#include "oversetFvPatchFields.H"
+#include "typeInfo.H"
+#include "cellSet.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(layeredOverlapFringe, 0);
+    addToRunTimeSelectionTable(oversetFringe, layeredOverlapFringe, dictionary);
+}
+
+
+// * * * * * * * * * * * * * Static Member Functions  * * * * * * * * * * * * //
+
+void Foam::layeredOverlapFringe::evaluateNonOversetBoundaries
+(
+    volScalarField::GeometricBoundaryField& psib
+)
+{
+    // Code practically copy/pasted from GeometricBoundaryField::evaluateCoupled
+    // GeometricBoundaryField should be redesigned to accomodate for such needs
+    if
+    (
+        Pstream::defaultComms() == Pstream::blocking
+     || Pstream::defaultComms() == Pstream::nonBlocking
+    )
+    {
+        forAll(psib, patchI)
+        {
+            // Get fvPatchField
+            fvPatchScalarField& psip = psib[patchI];
+
+            if (psip.coupled() && !isA<oversetFvPatchScalarField>(psip))
+            {
+                psip.initEvaluate(Pstream::defaultComms());
+            }
+        }
+
+        // Block for any outstanding requests
+        if (Pstream::defaultComms() == Pstream::nonBlocking)
+        {
+            IPstream::waitRequests();
+            OPstream::waitRequests();
+        }
+
+        forAll(psib, patchI)
+        {
+            // Get fvPatchField
+            fvPatchScalarField& psip = psib[patchI];
+
+            if (psip.coupled() && !isA<oversetFvPatchScalarField>(psip))
+            {
+                psip.evaluate(Pstream::defaultComms());
+            }
+        }
+    }
+    else if (Pstream::defaultComms() == Pstream::scheduled)
+    {
+        // Get the mesh by looking at first fvPatchField
+        const lduSchedule& patchSchedule =
+            psib[0].dimensionedInternalField().mesh().globalData().
+            patchSchedule();
+
+        forAll(patchSchedule, patchEvalI)
+        {
+            if (patchSchedule[patchEvalI].init)
+            {
+                // Get fvPatchField
+                fvPatchScalarField psip = psib[patchSchedule[patchEvalI].patch];
+
+                if (psip.coupled() && !isA<oversetFvPatchScalarField>(psip))
+                {
+                    psip.initEvaluate(Pstream::scheduled);
+                }
+            }
+            else
+            {
+                // Get fvPatchField
+                fvPatchScalarField psip = psib[patchSchedule[patchEvalI].patch];
+
+                if (psip.coupled() && !isA<oversetFvPatchScalarField>(psip))
+                {
+                    psip.evaluate(Pstream::scheduled);
+                }
+            }
+        }
+    }
+    else
+    {
+        FatalErrorIn("layeredOverlapFringe::evaluateNonOversetBoundaries()")
+            << "Unsuported communications type "
+            << Pstream::commsTypeNames[Pstream::defaultCommsType()]
+            << exit(FatalError);
+    }
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::layeredOverlapFringe::calcAddressing() const
+{
+    if (fringeHolesPtr_ || acceptorsPtr_)
+    {
+        FatalErrorIn("void layeredOverlapFringe::calcAddressing() const")
+            << "Fringe addressing already calculated"
+            << abort(FatalError);
+    }
+
+    // Get initial holes and surrounding acceptors
+    // Algorithm:
+    //    - Create indicator field for correct data exchange accross processor
+    //      boundaries
+    //    - Get holes from overset region (and optionally from specified set)
+    //      and mark immediate neighbours of holes as acceptors
+
+    // Get necessary mesh data
+    const fvMesh& mesh = region().mesh();
+    const labelListList& cc = mesh.cellCells();
+
+    // Get cut holes from overset region
+    const labelList& cutHoles = region().cutHoles();
+
+    // Debug
+    if (oversetMesh::debug && cutHoles.empty())
+    {
+        Pout<< "Did not find any holes to initialise the overlap fringe "
+            << "assembly. Proceeding to specified holes..."
+            << endl;
+    }
+
+    // Initialise mask field for eligible acceptors (cells that are not
+    // holes)
+    boolList eligibleAcceptors(mesh.nCells(), true);
+
+    // Read user specified holes into allHoles list. Note: if the cell set
+    // is not found, the list will be empty
+    cellSet allHoles
+    (
+        mesh,
+        holesSetName_,
+        IOobject::READ_IF_PRESENT,
+        IOobject::NO_WRITE
+    );
+
+    // Extend allHoles with cutHoles
+    allHoles.insert(cutHoles);
+
+    // Note: Because we cannot assume anything about parallel decomposition and
+    // we use neighbourhood walk algorithm, there is no easy way to go across
+    // processor boundaries. We will create an indicator field marking all
+    // possible cut cells and all possible face cells of given patches. Then, we
+    // will use this indicator field to transfer the search to the other side.
+
+    // Create the indicator field
+    volScalarField processorIndicator
+    (
+        IOobject
+        (
+            "processorIndicator",
+            mesh.time().timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        mesh,
+        dimensionedScalar("minusOne", dimless, -1.0)
+    );
+    scalarField& processorIndicatorIn = processorIndicator.internalField();
+
+    // Mark all holes
+    forAllConstIter (cellSet, allHoles, iter)
+    {
+        const label& holeCellI = iter.key();
+
+        // Mask eligible acceptors
+        eligibleAcceptors[holeCellI] = false;
+
+        // Mark cut hole cell in processor indicator field
+        processorIndicatorIn[holeCellI] = 1.0;
+    }
+
+    // Hash set for storing acceptors
+    labelHashSet candidateAcceptors(mesh.nCells());
+
+    // Extend nLayers away from initial set. Note postfix increment
+    while (layerIter_++ != nLayers_)
+    {
+        // Append candidate acceptors to holes for this iteration and reset
+        // candidate acceptors
+        allHoles += candidateAcceptors;
+        candidateAcceptors.clear();
+
+        // Loop through all holes and find acceptor candidates
+        forAllConstIter (cellSet, allHoles, iter)
+        {
+            const label& holeCellI = iter.key();
+
+            // Get neighbours of this hole cell
+            const labelList& hNbrs = cc[holeCellI];
+
+            // Loop through neighbours of this hole cell
+            forAll (hNbrs, nbrI)
+            {
+                // Check whether the neighbouring cell is eligible
+                const label& nbrCellI = hNbrs[nbrI];
+
+                if (eligibleAcceptors[nbrCellI])
+                {
+                    // Append the cell and mask it to avoid duplicate entries
+                    candidateAcceptors.insert(nbrCellI);
+                    eligibleAcceptors[nbrCellI] = false;
+                }
+            }
+        }
+
+        // Get boundary field
+        volScalarField::GeometricBoundaryField& processorIndicatorBf =
+            processorIndicator.boundaryField();
+
+        // Perform update accross coupled boundaries, excluding overset patch
+        evaluateNonOversetBoundaries(processorIndicatorBf);
+
+        // Loop through boundary field
+        forAll (processorIndicatorBf, patchI)
+        {
+            // Get patch field
+            const fvPatchScalarField& chipf = processorIndicatorBf[patchI];
+
+            // Only perform acceptor search if this is a processor boundary
+            if (isA<processorFvPatchScalarField>(chipf))
+            {
+                // Get neighbour field
+                const scalarField nbrProcIndicator =
+                    chipf.patchNeighbourField();
+
+                // Get face cells
+                const unallocLabelList& fc = chipf.patch().faceCells();
+
+                // Loop through neighbouring processor field
+                forAll (nbrProcIndicator, pfaceI)
+                {
+                    if
+                    (
+                        nbrProcIndicator[pfaceI] > 0.0
+                     && eligibleAcceptors[fc[pfaceI]]
+                    )
+                    {
+                        // The cell on the other side is a hole or acceptor from
+                        // face cells of a given patch, while the cell on this
+                        // side has not been marked yet neither as an acceptor
+                        // or as a hole. Append the cell to candidate acceptors
+                        // and mark it as ineligible in order to propage the
+                        // fringe on this side
+                        candidateAcceptors.insert(fc[pfaceI]);
+                        eligibleAcceptors[fc[pfaceI]] = false;
+                    }
+                }
+            }
+        }
+    }
+
+    // Issue an error if no acceptors have been found for initial guess
+    if (returnReduce(candidateAcceptors.size(), sumOp<label>()) == 0)
+    {
+        FatalErrorIn
+        (
+            "void adaptiveOverlapFringe::calcAddressing() const"
+        )   << "Did not find any acceptors to begin with."
+            << "Check definition of adaptiveOverlap in oversetMeshDict"
+            << " for region: " << this->region().name() << nl
+            << "More specifically, check definition of:" << nl
+            << "1. holePatches (mandatory entry)" << nl
+            << "2. holes (optional entry)" << nl
+            << abort(FatalError);
+    }
+
+    // Now we have a nice layout of acceptors that are nLayers away from
+    // specified holes. Copy into members
+    acceptorsPtr_ = new labelList(candidateAcceptors.toc());
+    fringeHolesPtr_ = new labelList(allHoles.toc());
+}
+
+
+void Foam::layeredOverlapFringe::clearAddressing() const
+{
+    deleteDemandDrivenData(fringeHolesPtr_);
+    deleteDemandDrivenData(acceptorsPtr_);
+    deleteDemandDrivenData(finalDonorAcceptorsPtr_);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from dictionary
+Foam::layeredOverlapFringe::layeredOverlapFringe
+(
+    const fvMesh& mesh,
+    const oversetRegion& region,
+    const dictionary& dict
+)
+:
+    oversetFringe(mesh, region, dict),
+    fringeHolesPtr_(NULL),
+    acceptorsPtr_(NULL),
+    finalDonorAcceptorsPtr_(NULL),
+
+    nLayers_(readLabel(dict.lookup("nLayers"))),
+    layerIter_(0),
+
+    holesSetName_(dict.lookupOrDefault<word>("holes", word()))
+{
+    // Sanity check
+    if (nLayers_ < 1)
+    {
+        FatalIOErrorIn
+        (
+            "layeredOverlapFringe::layeredOverlapFringe\n"
+            "(\n"
+            "    const fvMesh& mesh,\n"
+            "    const oversetRegion& region,\n"
+            "    const dictionary& dict,\n"
+            ")\n",
+            dict
+        )   << "Invalid number of layers specified. "
+            << nl
+            << "Please specify value above 1."
+            << exit(FatalIOError);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::layeredOverlapFringe::~layeredOverlapFringe()
+{
+    clearAddressing();
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::layeredOverlapFringe::updateIteration
+(
+    donorAcceptorList& donorAcceptorRegionData
+) const
+{
+    if (!fringeHolesPtr_ || !acceptorsPtr_)
+    {
+        FatalErrorIn("layeredOverlapFringe::updateIteration()")
+            << "fringeHolesPtr_ or acceptorsPtr_ is not allocated. "
+            << "Make sure you have called acceptors() or fringeHoles() to "
+            << "calculate the initial set of donor/acceptors before "
+            << "actually updating iteration."
+            << abort(FatalError);
+    }
+
+    if (finalDonorAcceptorsPtr_)
+    {
+        FatalErrorIn("layeredOverlapFringe::updateIteration()")
+            << "Called iteration update with finalDonorAcceptorsPtr_ "
+            << "allocated. This means that the final overlap has been "
+            << "achieved, prohibiting calls to updateIteration."
+            << abort(FatalError);
+    }
+
+    // Allocate the list by reusing the argument list. Note: all the work has
+    // been done in calcAddressing actually since this is not an iterative
+    // process by definition
+    finalDonorAcceptorsPtr_ = new donorAcceptorList
+    (
+        donorAcceptorRegionData,
+        true
+    );
+
+    // Set the flag to true and return
+    updateSuitableOverlapFlag(true);
+
+    return foundSuitableOverlap();
+}
+
+
+const Foam::labelList& Foam::layeredOverlapFringe::fringeHoles() const
+{
+    if (!fringeHolesPtr_)
+    {
+        calcAddressing();
+    }
+
+    return *fringeHolesPtr_;
+}
+
+
+const Foam::labelList& Foam::layeredOverlapFringe::candidateAcceptors() const
+{
+    if (!acceptorsPtr_)
+    {
+        calcAddressing();
+    }
+
+    return *acceptorsPtr_;
+}
+
+
+Foam::donorAcceptorList& Foam::layeredOverlapFringe::finalDonorAcceptors() const
+{
+    if (!finalDonorAcceptorsPtr_)
+    {
+        FatalErrorIn("layeredOverlapFringe::finalDonorAcceptors()")
+            << "finalDonorAcceptorPtr_ not allocated. Make sure you have "
+            << "called layeredOverlapFringe::updateIteration() before asking for "
+            << "final set of donor/acceptor pairs."
+            << abort(FatalError);
+    }
+
+    if (!foundSuitableOverlap())
+    {
+        FatalErrorIn("layeredOverlapFringe::finalDonorAcceptors()")
+            << "Attemted to access finalDonorAcceptors but suitable overlap "
+            << "has not been found. This is not allowed. "
+            << abort(FatalError);
+    }
+
+    return *finalDonorAcceptorsPtr_;
+}
+
+
+void Foam::layeredOverlapFringe::update() const
+{
+    Info<< "layeredOverlapFringe::update() const" << endl;
+
+    // Clear everything, including acceptors and fringe holes
+    clearAddressing();
+
+    // Reset counter to zero
+    layerIter_ = 0;
+
+    // Set flag to false and clear final donor/acceptors only
+    updateSuitableOverlapFlag(false);
+}
+
+
+// ************************************************************************* //

src/overset/oversetMesh/oversetFringe/overlapFringe/layeredOverlapFringe/layeredOverlapFringe.H

@@ -0,0 +1,180 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     4.1
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    layeredOverlapFringe
+
+Description
+    Layered overlap fringe algorithm. Uses neighbourhood walk nLayers deep to
+    run away from user specified holes (holePatches and optional manual cell set
+    containing holes) and identify acceptors.
+
+    Holds and manages following data:
+
+      - fringeHolesPtr_: holds fringe holes
+      - acceptorsPtr_: holds acceptors
+      - finalDonorAcceptorsPtr_: holds final set of donor/acceptors
+      - fringeIter_: iteration counter
+
+    No need to control the iterative process in updateIteration member function,
+    acceptors are found in calcAddressing as in e.g. faceCells fringe.
+    Member function updateIteration controls the iterative process:
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+SourceFiles
+    layeredOverlapFringe.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef layeredOverlapFringe_H
+#define layeredOverlapFringe_H
+
+#include "oversetFringe.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class layeredOverlapFringe Declaration
+\*---------------------------------------------------------------------------*/
+
+class layeredOverlapFringe
+:
+    public oversetFringe
+{
+    // Private data
+
+        //- Fringe hole cells
+        mutable labelList* fringeHolesPtr_;
+
+        //- Acceptor cells
+        mutable labelList* acceptorsPtr_;
+
+        //- Final donor/acceptor pairs for this region (fringe)
+        mutable donorAcceptorList* finalDonorAcceptorsPtr_;
+
+        //- Number of layers
+        const label nLayers_;
+
+        //- Iteration counter
+        mutable label layerIter_;
+
+
+        // Optional initialization data
+
+            //- Name of the cell set defining initial holes (empty by default).
+            //  Useful when the resolution of the background mesh is much
+            //  coarser than the front mesh and no hole is found
+            const word holesSetName_;
+
+
+    // Private Member Functions
+
+        // Copy control
+
+            //- Disallow default bitwise copy construct
+            layeredOverlapFringe(const layeredOverlapFringe&);
+
+            //- Disallow default bitwise assignment
+            void operator=(const layeredOverlapFringe&);
+
+
+        // Addressing calculation functions
+
+            //- Calculate hole-acceptor addressing
+            void calcAddressing() const;
+
+            //- Clear hole-acceptor addressing
+            void clearAddressing() const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("layeredOverlap");
+
+
+    // Static Member Functions
+
+        //- Helper function used to evaluate coupled boundaries, excluding
+        //  overset patch
+        static void evaluateNonOversetBoundaries
+        (
+            volScalarField::GeometricBoundaryField& psib
+        );
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        layeredOverlapFringe
+        (
+            const fvMesh& mesh,
+            const oversetRegion& region,
+            const dictionary& dict
+        );
+
+
+    //- Destructor
+    virtual ~layeredOverlapFringe();
+
+
+    // Member Functions
+
+        //- Update iteration.
+        virtual bool updateIteration
+        (
+            donorAcceptorList& donorAcceptorRegionData
+        ) const;
+
+        //- Return list of hole cells
+        //  Fringe hole cells are collected in addition to geometric hole
+        //  cells, which fall outside of all donor regions
+        virtual const labelList& fringeHoles() const;
+
+        //- Return list of acceptor cells
+        virtual const labelList& candidateAcceptors() const;
+
+        //- Return list of final donor acceptor pairs. Note: caller may
+        //  invalidate finalDonorAcceptorsPtr_ for optimisation purposes
+        virtual donorAcceptorList& finalDonorAcceptors() const;
+
+        //- Update the fringe
+        virtual void update() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/overset/oversetMesh/oversetFringe/overlapFringe/overlapFringe/overlapFringe.C

@@ -419,19 +419,20 @@ Foam::overlapFringe::overlapFringe
     // Sanity check
     if (minGlobalFraction_ < SMALL || minGlobalFraction_ > 1.0)
     {
-        FatalErrorIn
+        FatalIOErrorIn
         (
             "overlapFringe::overlapFringe\n"
             "(\n"
             "    const fvMesh& mesh,\n"
             "    const oversetRegion& region,\n"
             "    const dictionary& dict,\n"
-            ")\n"
+            ")\n",
+            dict
         )   << "Invalid suitablePairFraction found while reading the overlap "
             << "fringe dictionary."
             << nl
             << "Please specify value between 0 and 1."
-            << endl;
+            << exit(FatalIOError);
     }
 }