autoPatch.C

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) 2014 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/>.
 
\*---------------------------------------------------------------------------*/
 
#include "autoPatch.H"
#include "addToRunTimeSelectionTable.H"
#include "surfaceFeatures.H"
#include "triSurfaceMesh.H"
#include "PatchTools.H"
 
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
namespace Foam
{
namespace searchableSurfaceModifiers
{
    defineTypeNameAndDebug(autoPatch, 0);
    addToRunTimeSelectionTable
    (
        searchableSurfaceModifier,
        autoPatch,
        dictionary
    );
}
}
 
// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
Foam::searchableSurfaceModifiers::autoPatch::autoPatch
(
    const searchableSurfaces& geometry,
    const dictionary& dict
)
:
    searchableSurfaceModifier(geometry, dict),
    featureAngle_(dict.get<scalar>("featureAngle"))
{}
 
 
// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
bool Foam::searchableSurfaceModifiers::autoPatch::modify
(
    const labelList& regions,
    searchableSurface& geom
) const
{
    triSurface& surf = refCast<triSurfaceMesh>(geom);
 
    surfaceFeatures set(surf, 180.0-featureAngle_);
 
    Info<< nl
        << "Feature set:" << nl
        << "    feature points : " << set.featurePoints().size() << nl
        << "    feature edges  : " << set.featureEdges().size() << nl
        << "    of which" << nl
        << "        region edges   : " << set.nRegionEdges() << nl
        << "        external edges : " << set.nExternalEdges() << nl
        << "        internal edges : " << set.nInternalEdges() << nl
        << endl;
 
 
    // Get per-edge status.
    boolList borderEdge(surf.nEdges(), false);
    forAll(set.featureEdges(), i)
    {
        borderEdge[set.featureEdges()[i]] = true;
    }
 
 
    bool changed = false;
 
    forAll(regions, i)
    {
        label regionI = regions[i];
 
        labelList subRegion(surf.size(), -1);
        label nSub = 0;
 
        forAll(surf, faceI)
        {
            if (surf[faceI].region() == regionI && subRegion[faceI] == -1)
            {
                PatchTools::markZone(surf, borderEdge, faceI, nSub, subRegion);
                nSub++;
            }
        }
 
        Info<< "For region " << surf.patches()[regionI].name()
            << " detected sub regions " << nSub << endl;
 
 
        if (nSub > 1)
        {
            label nOldPatches = surf.patches().size();
 
            for (label subI = 0; subI < nSub; subI++)
            {
                geometricSurfacePatch patch
                (
                    surf.patches()[regionI].name() + Foam::name(subI),
                    surf.patches().size(),
                    surf.patches()[regionI].geometricType()
                );
 
 
                Info<< "For region " << surf.patches()[regionI].name()
                    << " creating region " << patch.name() << endl;
 
                surf.patches().append(patch);
            }
 
            forAll(subRegion, faceI)
            {
                if (subRegion[faceI] != -1)
                {
                    surf[faceI].region() = nOldPatches + subRegion[faceI];
                }
            }
            changed = true;
        }
    }
 
    return changed;
}
 
 
// ************************************************************************* //