PDRblock.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) 2019-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::PDRblock
 
Description
    A single block x-y-z rectilinear mesh addressable as i,j,k with
    simplified creation. Some of the input is similar to blockMeshDict,
    but since this specialization is for a single-block that is aligned
    with the x-y-z directions, it provides a different means of specifying
    the mesh.
 
    Dictionary controls
    \table
        Property    | Description                          | Required | Default
        x           | X-direction grid specification       | yes |
        y           | Y-direction grid specification       | yes |
        z           | Z-direction grid specification       | yes |
        scale       | Point scaling                        | no  | 1.0
        expansion   | Type of expansion (ratio/relative)   | no  | ratio
        boundary    | Boundary patches                     | yes |
        defaultPatch | Default patch specification         | no  |
    \endtable
 
    Grid coordinate controls
    \table
        Property| Description                               | Required | Default
        points  | Locations defining the mesh segment       | yes |
        nCells  | Divisions per mesh segment                | yes |
        ratios  | Expansion values per segment              | no  |
    \endtable
 
    A negative expansion value is trapped and treated as its reciprocal.
    by default, the expansion is as per blockMesh and represents the ratio
    of end-size / start-size for the section.
    Alternatively, the relative size can be given.
 
SourceFiles
    PDRblockI.H
    PDRblock.C
    PDRblockCreate.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef Foam_PDRblock_H
#define Foam_PDRblock_H
 
#include "ijkMesh.H"
#include "boundBox.H"
#include "pointField.H"
#include "faceList.H"
#include "Enum.H"
#include "vector2D.H"
#include "labelVector2D.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
// Forward Declarations
class IOobject;
class blockMesh;
class polyMesh;
class gradingDescriptors;
 
/*---------------------------------------------------------------------------*\
                           Class PDRblock Declaration
\*---------------------------------------------------------------------------*/
 
class PDRblock
:
    public ijkMesh
{
public:
 
    // Data Types
 
        //- The expansion type
        enum expansionType : uint8_t
        {
            EXPAND_UNIFORM,     
            EXPAND_RATIO,       
            EXPAND_RELATIVE     
        };
 
        //- Named enumerations for the expansion type
        const static Enum<expansionType> expansionNames_;
 
 
    // Public Classes
 
        //- Grid locations in an axis direction.
        //  The number of points is one larger than the number of elements
        //  it represents
        class location
        :
            public scalarList
        {
        public:
 
            //- Reset with min/max range and number of divisions
            void reset(const scalar low, const scalar upp, const label nCells);
 
            //- The location list is valid if it contains 2 or more points
            inline bool good() const noexcept;
 
            //- The number of cells in this direction.
            inline label nCells() const noexcept;
 
            //- The number of points in this direction.
            inline label nPoints() const noexcept;
 
            //- True if the location is within the range
            inline bool contains(const scalar p) const;
 
            //- The first() value is considered the min value.
            inline const scalar& min() const;
 
            //- The last() value is considered the max value.
            inline const scalar& max() const;
 
            //- Mid-point location, zero for an empty list.
            inline scalar centre() const;
 
            //- The difference between min/max values, zero for an empty list.
            inline scalar length() const;
 
            //- Check that element index is within valid range.
            inline void checkIndex(const label i) const;
 
            //- Cell size at element position.
            inline scalar width(const label i) const;
 
            //- Cell centre at element position.
            //  Treats -1 and nCells positions like a halo cell.
            inline scalar C(const label i) const;
 
            //- Return min/max edge lengths
            scalarMinMax edgeLimits() const;
 
            //- Return edge grading descriptors for the locations
            //  \see Foam::gradingDescriptor
            gradingDescriptors grading() const;
 
            //- Find the cell index enclosing this location
            //  \return -1 for out-of-bounds
            label findCell(const scalar p) const;
 
            //- Find the grid index, within the given tolerance
            //  Return -1 for out-of-bounds and -2 for a point that is
            //  within bounds, but not aligned with a grid point.
            label findIndex(const scalar p, const scalar tol) const;
 
            //- Return value clamped to min/max limits.
            //  If the range is invalid, always return the value.
            inline const scalar& clamp(const scalar& val) const;
 
            //- Return value clamped to min/max limits.
            const scalar& clip(const scalar& val) const { return clamp(val); }
        };
 
 
        //- The begin/end nodes for each segment,
        //- with divisions and expansion for each segment
        //  Not normally used outside of PDRblock
        struct gridControl
        :
            public scalarList
        {
            //- The number of division per segment
            labelList divisions_;
 
            //- The expansion ratio per segment
            scalarList expansion_;
 
            //- Total number of cells in this direction
            label nCells() const;
 
            //- Return edge grading descriptors for the locations
            //  \see Foam::gradingDescriptor
            gradingDescriptors grading() const;
 
            //- Resize lists
            void resize(label len);
 
            //- Add point/divisions/expand to end of list (push_back)
            void append(const scalar p, label nDiv, scalar expRatio=1);
 
            //- Add point/divisions/expand to front of list (push_front)
            void prepend(const scalar p, label nDiv, scalar expRatio=1);
 
            //- Write as dictionary contents for specified vector direction
            void writeDict(Ostream& os, const direction cmpt) const;
        };
 
 
private:
 
    // Private Classes
 
        //- Extracted patch settings
        struct boundaryEntry
        {
            //- The patch name
            word name_;
 
            //- The patch type
            word type_;
 
            //- The patch size
            label size_;
 
            //- The associated block face ids [0,5]
            labelList faces_;
        };
 
        //- The begin/end nodes for each segment,
        //- with divisions and expansion for each segment
        struct outerControl
        {
            //- The control type
            enum controlType : uint8_t
            {
                OUTER_NONE = 0,     
                OUTER_EXTEND,       
                OUTER_BOX,          
                OUTER_SPHERE        
            };
 
            //- Named enumerations for the control type
            const static Enum<controlType> controlNames_;
 
            //- The control type
            controlType type_;
 
            //- The expansion type
            expansionType expandType_;
 
            //- True if on the ground
            bool onGround_;
 
            //- Relative size(s) for the outer region
            vector2D relSize_;
 
            //- Number of cells in outer region
            //  Generally only single component is used
            labelVector2D nCells_;
 
            //- Expansion ratio(s) for the outer region
            vector2D expansion_;
 
 
        // Constructors
 
            //- Default construct. NONE
            outerControl();
 
 
        // Member Functions
 
            //- Reset to default (NONE) values
            void clear();
 
            //- Is enabled (not NONE)
            bool active() const;
 
            //- Project on to sphere (is SPHERE)
            bool isSphere() const;
 
            //- Is the outer region on the ground?
            bool onGround() const;
 
            //- Define that the outer region is on the ground or not
            //  \return the old value
            bool onGround(const bool on);
 
            //- Read content from dictionary
            void read(const dictionary& dict);
 
            //- Report information about outer region
            void report(Ostream& os) const;
        };
 
 
    // Private Data
 
        //- Reference to mesh dictionary
        const dictionary& meshDict_;
 
        //- The grid controls in (i,j,k / x,y,z) directions.
        Vector<gridControl> control_;
 
        //- The grid points in all (i,j,k / x,y,z) directions,
        //- after applying the internal subdivisions.
        Vector<location> grid_;
 
        //- Control for the outer-region (if any)
        outerControl outer_;
 
        //- The mesh bounding box
        boundBox bounds_;
 
        //- The boundary patch information
        PtrList<boundaryEntry> patches_;
 
        //- The min/max edge lengths
        scalarMinMax edgeLimits_;
 
        //- Verbosity
        bool verbose_;
 
 
    // Private Member Functions
 
        //- Check that points increase monotonically
        static bool checkMonotonic
        (
            const direction cmpt,
            const UList<scalar>& pts
        );
 
        //- Add zero-sized patches with default naming/types
        void addDefaultPatches();
 
        //- Adjust sizing for updated grid points
        void adjustSizes();
 
        //- Read and define grid points in given direction
        void readGridControl
        (
            const direction cmpt,
            const dictionary& dict,
            const scalar scaleFactor = -1,
            expansionType expandType = expansionType::EXPAND_RATIO
        );
 
        //- Read "boundary" information
        void readBoundary(const dictionary& dict);
 
        //- Populate point field for the block
        void createPoints(pointField& pts) const;
 
        //- Add internal faces to lists.
        //  Lists must be properly sized!
        //  \return the number of faces added
        label addInternalFaces
        (
            faceList::iterator& faceIter,
            labelList::iterator& ownIter,
            labelList::iterator& neiIter
        ) const;
 
        //- Add boundary faces for the shape face to lists
        //  Lists must be properly sized!
        //  \return the number of faces added
        label addBoundaryFaces
        (
            const direction shapeFacei,
            faceList::iterator& faceIter,
            labelList::iterator& ownIter
        ) const;
 
        //- Obtain i,j,k index for cell enclosing this location
        //  \return false for out-of-bounds
        bool findCell(const point& pt, labelVector& pos) const;
 
        //- Obtain i,j,k grid index for point location
        //  \return false for out-of-bounds and off-grid
        bool gridIndex
        (
            const point& pt,
            labelVector& pos,
            const scalar tol
        ) const;
 
        //- The bounding box of the grid points
        static boundBox bounds
        (
            const scalarList& x, 
            const scalarList& y, 
            const scalarList& z  
        );
 
        //- Equivalent edge grading descriptors in (x,y,z) directions.
        static Vector<gradingDescriptors> grading
        (
            const Vector<gridControl>& ctrl
        );
 
        //- Mesh sizes based on the controls
        static labelVector sizes
        (
            const Vector<gridControl>& ctrl
        );
 
 
    // Mesh Generation
 
        //- Create a blockMesh
        autoPtr<blockMesh> createBlockMesh(const IOobject& io) const;
 
        //- Create polyMesh via blockMesh
        autoPtr<polyMesh> meshBlockMesh(const IOobject& io) const;
 
 
public:
 
    // Static Member Functions
 
        //- Return a null PDRblock (reference to a nullObject).
        static const PDRblock& null() noexcept
        {
            return NullObjectRef<PDRblock>();
        }
 
 
    // Constructors
 
        //- Default construct, zero-size, inverted bounds etc
        PDRblock();
 
        //- Construct from components
        PDRblock
        (
            const UList<scalar>& xgrid,
            const UList<scalar>& ygrid,
            const UList<scalar>& zgrid
        );
 
        //- Construct from cube with specified griding
        PDRblock(const boundBox& box, const labelVector& nCells);
 
        //- Construct from dictionary
        explicit PDRblock(const dictionary& dict, bool verboseOutput=false);
 
 
    // Member Functions
 
        //- Read dictionary
        bool read(const dictionary& dict);
 
        //- Reset grid locations and mesh i-j-k sizing
        void reset
        (
            const UList<scalar>& xgrid,
            const UList<scalar>& ygrid,
            const UList<scalar>& zgrid
        );
 
        //- Reset cube and mesh i-j-k sizing
        void reset(const boundBox& box, const labelVector& nCells);
 
 
    // Access
 
        //- The grid point locations in the i,j,k (x,y,z) directions.
        const Vector<location>& grid() const noexcept { return grid_; }
 
        //- Equivalent edge grading descriptors in (x,y,z) directions.
        Vector<gradingDescriptors> grading() const;
 
        //- Equivalent edge grading descriptors in specified (x,y,z) direction.
        gradingDescriptors grading(const direction cmpt) const;
 
 
    // Mesh Information
 
        //- Mesh sizing as per ijkMesh
        using ijkMesh::sizes;
 
        //- The mesh bounding box
        const boundBox& bounds() const noexcept { return bounds_; }
 
        //- The min/max edge length
        const scalarMinMax& edgeLimits() const noexcept { return edgeLimits_; }
 
        //- Cell size in x-direction at i position.
        inline scalar dx(const label i) const;
 
        //- Cell size in x-direction at i position.
        inline scalar dx(const labelVector& ijk) const;
 
        //- Cell size in y-direction at j position.
        inline scalar dy(const label j) const;
 
        //- Cell size in y-direction at j position.
        inline scalar dy(const labelVector& ijk) const;
 
        //- Cell size in z-direction at k position.
        inline scalar dz(const label k) const;
 
        //- Cell size in z-direction at k position.
        inline scalar dz(const labelVector& ijk) const;
 
        //- Cell dimensions at i,j,k position.
        inline vector span(const label i, const label j, const label k) const;
 
        //- Cell dimensions at i,j,k position.
        inline vector span(const labelVector& ijk) const;
 
        //- Grid point at i,j,k position.
        inline point grid(const label i, const label j, const label k) const;
 
        //- Grid point at i,j,k position.
        inline point grid(const labelVector& ijk) const;
 
        //- Cell centre at i,j,k position.
        inline point C(const label i, const label j, const label k) const;
 
        //- Cell centre at i,j,k position.
        inline point C(const labelVector& ijk) const;
 
        //- Cell volume at i,j,k position.
        inline scalar V(const label i, const label j, const label k) const;
 
        //- Cell volume at i,j,k position.
        inline scalar V(const labelVector& ijk) const;
 
        //- Characteristic cell size at i,j,k position.
        //  This is the cubic root of the volume
        inline scalar width(const label i, const label j, const label k) const;
 
        //- Characteristic cell size at i,j,k position.
        //  This is the cubic root of the volume
        inline scalar width(const labelVector& ijk) const;
 
 
    // Searching
 
        //- Return i,j,k index for cell enclosing this location
        //  The value (-1,-1,-1) is returned for out-of-bounds (not found).
        labelVector findCell(const point& pt) const;
 
        //- Obtain i,j,k grid index for point location within specified
        //  relative tolerance of the min edge length
        //  The value (-1,-1,-1) is returned for out-of-bounds (not found).
        //  and off-grid
        labelVector gridIndex(const point& pt, const scalar relTol=0.01) const;
 
 
    // Mesh Generation
 
        //- Output content for an equivalent blockMeshDict
        //  Optionally generate header/footer content
        Ostream& blockMeshDict(Ostream& os, const bool withHeader=false) const;
 
        //- Content for an equivalent blockMeshDict
        dictionary blockMeshDict() const;
 
        //- Write an equivalent blockMeshDict
        void writeBlockMeshDict(const IOobject& io) const;
 
        //- Create polyMesh for grid definition and patch information
        autoPtr<polyMesh> mesh(const IOobject& io) const;
 
        //- Create polyMesh for inner-mesh only,
        //- ignore any outer block definitions
        autoPtr<polyMesh> innerMesh(const IOobject& io) const;
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#include "PDRblockI.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //