refinementParameters.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-2014 OpenFOAM Foundation
    Copyright (C) 2015-2020,2023 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::refinementParameters
 
Description
    Simple container to keep together refinement specific information.
 
SourceFiles
    refinementParameters.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef refinementParameters_H
#define refinementParameters_H
 
#include "dictionary.H"
#include "pointField.H"
#include "Switch.H"
#include "wordPairHashes.H"
#include "surfaceZonesInfo.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
// Forward Declarations
class polyMesh;
 
/*---------------------------------------------------------------------------*\
                           Class refinementParameters Declaration
\*---------------------------------------------------------------------------*/
 
class refinementParameters
{
    // Private Data
 
        //- Total number of cells
        const label maxGlobalCells_;
 
        //- Per processor max number of cells
        const label maxLocalCells_;
 
        //- When to stop refining
        const label minRefineCells_;
 
        //- Curvature
        scalar curvature_;
 
        //- Planarity criterion
        const scalar planarAngle_;
 
        //- Number of layers between different refinement levels
        const label nBufferLayers_;
 
 
        // Selection of areas
 
            //- Areas not to keep
            const pointField locationsOutsideMesh_;
 
            //- Areas to keep
            pointField locationsInMesh_;
 
            //- How to handle connections between inside and outside points
            const bool useLeakClosure_;
 
            //- Region for location
            wordList zonesInMesh_;
 
            //- Information on how to handle faces on faceZones
            const dictionary faceZoneControls_;
 
 
        //- FaceZone faces allowed which have owner and neighbour in same
        //  cellZone?
        const Switch allowFreeStandingZoneFaces_;
 
        //- Use old topology based problem-cell removal (cells with 8 points
        //  on surface)
        const Switch useTopologicalSnapDetection_;
 
        //- Allowed load unbalance
        const scalar maxLoadUnbalance_;
 
        //- Trigger cell count to start balancing
        const label maxCellUnbalance_;
 
        const Switch handleSnapProblems_;
 
        const Switch interfaceRefine_;
 
        const label nErodeCellZone_;
 
        const label nFilterIter_;
 
        const scalar minCellFraction_;
 
        const label nMinCells_;
 
        //- Force final balancing after castellation
        const bool balanceAtEnd_;
 
        //const bool dryRun_;
 
 
    // Private Member Functions
 
        //- No copy construct
        refinementParameters(const refinementParameters&) = delete;
 
        //- No copy assignment
        void operator=(const refinementParameters&) = delete;
 
 
public:
 
    // Constructors
 
        //- Construct from dictionary - new syntax
        refinementParameters(const dictionary& dict, const bool dryRun = false);
 
 
    // Member Functions
 
        // Access
 
            //- Total number of cells
            label maxGlobalCells() const
            {
                return maxGlobalCells_;
            }
 
            //- Per processor max number of cells
            label maxLocalCells() const
            {
                return maxLocalCells_;
            }
 
            //- When to stop refining
            label minRefineCells() const
            {
                return minRefineCells_;
            }
 
            //- Curvature
            scalar curvature() const
            {
                return curvature_;
            }
 
            //- Angle when two intersections are considered to be planar
            scalar planarAngle() const
            {
                return planarAngle_;
            }
 
            //- Number of layers between different refinement levels
            label nBufferLayers() const
            {
                return nBufferLayers_;
            }
 
            //- Areas to keep
            const pointField& locationsInMesh() const
            {
                return locationsInMesh_;
            }
 
            //- Per area the zone name
            const wordList& zonesInMesh() const
            {
                return zonesInMesh_;
            }
 
            //- Optional points which are checked to be outside the mesh
            const pointField& locationsOutsideMesh() const
            {
                return locationsOutsideMesh_;
            }
 
            //- Whether to attempt to close any 'leak' between
            //  locationsInsideMesh and locationsOutsideMesh. Default is
            //  false (dump path and exit with error)
            //  (see also refinementSurfaces::leakLevel to force surfaces to
            //  be checked for leaks early-on in the refinement)
            bool useLeakClosure() const
            {
                return useLeakClosure_;
            }
 
            //- Are zone faces allowed only inbetween different cell zones
            //  or also just free standing?
            bool allowFreeStandingZoneFaces() const
            {
                return allowFreeStandingZoneFaces_;
            }
 
            //- Use old topology based problem-cell removal
            //  (cells with 8 points on surface)
            bool useTopologicalSnapDetection() const
            {
                return useTopologicalSnapDetection_;
            }
 
            //- Allowed load unbalance
            scalar maxLoadUnbalance() const
            {
                return maxLoadUnbalance_;
            }
 
            //- Trigger cell count to start balancing
            label maxCellUnbalance() const
            {
                return maxCellUnbalance_;
            }
 
            bool handleSnapProblems() const
            {
                return handleSnapProblems_;
            }
 
            //- Refine cell with opposite faces with different refinement level
            bool interfaceRefine() const
            {
                return interfaceRefine_;
            }
 
            //- Number of iterations of erosion to get a consistent cellZone
            label nErodeCellZone() const
            {
                return nErodeCellZone_;
            }
 
            //- Number of iterations of infill/erosion to get a smoother
            //  blockage
            label nFilterIter() const
            {
                return nFilterIter_;
            }
 
            //- When are disconnected regions small. Fraction of overall size
            //  of a zone or background. Default 0.
            scalar minCellFraction() const
            {
                return minCellFraction_;
            }
 
            //- When are disconnected regions small. Absolute number of cells
            //  in a zone or background. Default 0.
            label nMinCells() const
            {
                return nMinCells_;
            }
 
            //- Force final balancing after castallation
            bool balanceAtEnd() const
            {
                return balanceAtEnd_;
            }
 
 
        // Other
 
            //- Get patchInfo and faceType for faceZone
            dictionary getZoneInfo
            (
                const word& fzName,
                surfaceZonesInfo::faceZoneType& faceType
            ) const;
 
            //- Add cellZones to mesh. Return indices of cellZones (or -1)
            labelList addCellZonesToMesh(polyMesh&) const;
 
            //- Checks that cells are in mesh. Returns cells (or -1) they
            //  are in.
            static labelList findCells
            (
                const bool checkInsideMesh,
                const polyMesh&,
                const pointField& locations
            );
 
            //- Extract indices of named locations (so excludes 'keepPoints')
            static labelList zonedLocations(const wordList& zonesInMesh);
 
            //- Extract indices of unnamed locations ('keepPoints')
            static labelList unzonedLocations(const wordList& zonesInMesh);
 
            //- Helper: per zone (entry in zonesInMesh) the locations with
            //          additionally locationsOutsideMesh as last. Used in
            //          hole filling
            static List<pointField> zonePoints
            (
                const pointField& locationsInMesh,
                const wordList& zonesInMesh,
                const pointField& locationsOutsideMesh
            );
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //