cuttingSurfaceBaseSelection.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) 2018-2022 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 "cuttingSurfaceBase.H"
#include "polyMesh.H"

// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //

void Foam::cuttingSurfaceBase::checkOverlap
(
    const word callerName,
    const boundBox& meshBounds,
    const boundBox& userBounds
)
{
    // User bounding-box does not overlap with (global) mesh!
    if (userBounds.good() && !userBounds.overlaps(meshBounds))
    {
        WarningInFunction
            << nl << callerName
            << " : Bounds " << userBounds
            << " do not overlap the mesh bounding box " << meshBounds
            << nl << endl;
    }
}


Foam::bitSet Foam::cuttingSurfaceBase::cellSelection
(
    const polyMesh& mesh,
    const boundBox& userBounds,
    const wordRes& zoneNames,
    boundBox& meshBounds
)
{
    bitSet cellsToSelect;

    // Zones requested and in use?
    const bool hasZones =
        returnReduceAnd(-1 != mesh.cellZones().findIndex(zoneNames));

    if (hasZones)
    {
        cellsToSelect = mesh.cellZones().selection(zoneNames);
    }


    // Subset the zoned cells with the userBounds.
    // For a full mesh, use the bounds to define the cell selection.

    // If there are zones cells, use them to build the effective mesh
    // bound box.
    // Note that for convenience we use cell centres here instead of
    // cell points, since it will only be used for checking.


    meshBounds = mesh.bounds();  // Use the regular mesh bounding box

    const auto& cellCentres = static_cast<const fvMesh&>(mesh).C();

    if (userBounds.empty())
    {
        // No bounds restriction, but may need effective mesh
        // bounding-box for later checks

        if (hasZones)
        {
            meshBounds.clear();

            for (const label celli : cellsToSelect)
            {
                const point& cc = cellCentres[celli];

                meshBounds.add(cc);
            }

            meshBounds.reduce();
        }
    }
    else if (hasZones)
    {
        // Subset zoned cells with the user bounding-box

        for (const label celli : cellsToSelect)
        {
            const point& cc = cellCentres[celli];

            meshBounds.add(cc);

            if (!userBounds.contains(cc))
            {
                cellsToSelect.unset(celli);
            }
        }

        meshBounds.reduce();
    }
    else
    {
        // Create cell selection from user bounding-box

        const label len = mesh.nCells();

        cellsToSelect.resize(len);

        for (label celli=0; celli < len; ++celli)
        {
            const point& cc = cellCentres[celli];

            if (userBounds.contains(cc))
            {
                cellsToSelect.set(celli);
            }
        }
    }

    return cellsToSelect;
}


Foam::bitSet Foam::cuttingSurfaceBase::cellSelection
(
    const polyMesh& mesh,
    const boundBox& userBounds,
    const wordRes& zoneNames,
    const word callerName,
    const bool warn
)
{
    boundBox meshBounds;

    bitSet cellsToSelect =
        cuttingSurfaceBase::cellSelection
        (
            mesh, userBounds, zoneNames, meshBounds
        );

    if (warn)
    {
        checkOverlap(callerName, meshBounds, userBounds);
    }

    return cellsToSelect;
}


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