pointBoundaryMesh.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) 2011-2017 OpenFOAM Foundation
    Copyright (C) 2018-2025 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 "pointBoundaryMesh.H"
#include "polyBoundaryMesh.H"
#include "facePointPatch.H"
#include "pointMesh.H"
#include "PstreamBuffers.H"
#include "lduSchedule.H"
#include "globalMeshData.H"
#include "processorPointPatch.H"

// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

namespace Foam
{
    defineTypeNameAndDebug(pointBoundaryMesh, 0);
}

// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //

bool Foam::pointBoundaryMesh::hasGroupIDs() const
{
    if (groupIDsPtr_)
    {
        // Use existing cache
        return !groupIDsPtr_->empty();
    }

    const auto& patches = *this;

    for (const auto& p : patches)
    {
        if (!p.inGroups().empty())
        {
            return true;
        }
    }

    return false;
}


void Foam::pointBoundaryMesh::calcGroupIDs() const
{
    if (groupIDsPtr_)
    {
        return;  // Or FatalError
    }

    groupIDsPtr_.emplace(16);
    auto& groupLookup = *groupIDsPtr_;

    const auto& patches = *this;

    forAll(patches, patchi)
    {
        for (const word& groupName : patches[patchi].inGroups())
        {
            groupLookup(groupName).push_back(patchi);
        }
    }

    // Remove groups that clash with patch names
    forAll(patches, patchi)
    {
        if (groupLookup.empty())
        {
            break;  // Early termination
        }
        else if (groupLookup.erase(patches[patchi].name()))
        {
            WarningInFunction
                << "Removed group '" << patches[patchi].name()
                << "' which clashes with patch " << patchi
                << " of the same name."
                << endl;
        }
    }
}


void Foam::pointBoundaryMesh::addPatches(const polyBoundaryMesh& pbm)
{
    // Set boundary patches
    pointPatchList& patches = *this;

    patches.resize_null(pbm.size());

    forAll(pbm, patchi)
    {
        // NB: needs ptr() to get *pointPatch instead of *facePointPatch
        patches.set(patchi, facePointPatch::New(pbm[patchi], *this).ptr());
    }
}


// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

Foam::pointBoundaryMesh::pointBoundaryMesh
(
    const pointMesh& m,
    const polyBoundaryMesh& pbm
)
:
    pointPatchList(),
    regIOobject
    (
        IOobject
        (
            "boundary",
            //m.thisDb().time().findInstance(m.meshDir(), "boundary"),
            pbm.mesh().facesInstance(),
            polyMesh::meshSubDir/pointMesh::meshSubDir,
            m.thisDb(),
            IOobject::NO_READ,
            IOobject::NO_WRITE,
            false                   // Avoid conflict with polyMesh/boundary
        )
    ),
    mesh_(m)
{
    addPatches(pbm);

    if (debug)
    {
        pointPatchList& Patches = *this;

        Pout<< "pointBoundaryMesh::pointBoundaryMesh"
            << "(const pointMesh&, const polyBoundaryMesh&): "
            << "constructed pointBoundaryMesh:" << endl;
        Pout<< incrIndent;
        for (const auto& pp : Patches)
        {
            Pout<< indent
                << "index:" << pp.index() << " patch:" << pp.name()
                << " type:" << pp.type() << endl;
        }
        Pout<< decrIndent;
    }
}


Foam::pointBoundaryMesh::pointBoundaryMesh
(
    const IOobject& io,
    const pointMesh& m,
    const polyBoundaryMesh& pbm
)
:
    pointPatchList(),
    regIOobject
    (
        IOobject
        (
            "boundary",
            io.instance(),
            polyMesh::meshSubDir/pointMesh::meshSubDir,
            m.thisDb(),
            io.readOpt(),
            io.writeOpt(),
            false   //io.registerObject()     // or always set to false?
        )
    ),
    mesh_(m)
{
    pointPatchList& Patches = *this;

    if (isReadRequired() || (isReadOptional() && headerOk()))
    {
        if (readOpt() == IOobject::MUST_READ_IF_MODIFIED)
        {
            WarningInFunction
                << "Specified IOobject::MUST_READ_IF_MODIFIED but class"
                << " does not support automatic rereading."
                << endl;
        }

        if (debug)
        {
            Pout<< "pointBoundaryMesh::pointBoundaryMesh"
                << "(const IOobject&, const pointMesh&,"
                << " const polyBoundaryMesh&): "
                << "Constructing from boundary file " << objectRelPath()
                << endl;
        }

        // Read pointPatchList
        Istream& is = readStream(typeName);

        PtrList<entry> patchEntries(is);
        Patches.setSize(patchEntries.size());

        forAll(Patches, patchi)
        {
            // Try construct-from-dictionary first
            const word& name = patchEntries[patchi].keyword();

            autoPtr<pointPatch> pPtr
            (
                pointPatch::New
                (
                    name,
                    patchEntries[patchi].dict(),
                    patchi,
                    *this
                )
            );

            if (!pPtr)
            {
                const label polyPatchi = pbm.findPatchID(name, false);
                // Try as facePointPatch from polyPatch
                pPtr = facePointPatch::New(pbm[polyPatchi], *this);
                pPtr->index() = patchi;
            }

            Patches.set(patchi, pPtr);
        }

        // Check state of IOstream
        is.check
        (
            "pointBoundaryMesh::pointBoundaryMesh"
            "(const IOobject&, const pointMesh&,"
            " const polyBoundaryMesh&)"
        );

        close();
    }
    else
    {
        if (debug)
        {
            Pout<< "pointBoundaryMesh::pointBoundaryMesh"
                << "(const IOobject&, const pointMesh&,"
                << " const polyBoundaryMesh&): "
                << "Constructing from polyBoundaryMesh only"
                << endl;
        }

        addPatches(pbm);
    }


    if (debug)
    {
        Pout<< "pointBoundaryMesh::pointBoundaryMesh"
            << "(const IOobject&, const pointMesh&, const polyBoundaryMesh&): "
            << "constructed pointBoundaryMesh:" << endl;
        Pout<< incrIndent;
        for (const auto& pp : Patches)
        {
            Pout<< indent
                << "index:" << pp.index() << " patch:" << pp.name()
                << " type:" << pp.type() << endl;
        }
        Pout<< decrIndent;
    }
}


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

Foam::label Foam::pointBoundaryMesh::nNonProcessor() const
{
    const pointPatchList& patches = *this;

    label count = 0;

    for (const auto& p : patches)
    {
        if (isA<processorPointPatch>(p))
        {
            break;
        }

        ++count;
    }

    return count;
}


Foam::label Foam::pointBoundaryMesh::nProcessorPatches() const
{
    const pointPatchList& patches = *this;

    label count = 0;

    for (const auto& p : patches)
    {
        if (isA<processorPointPatch>(p))
        {
            ++count;
        }
    }

    return count;
}


Foam::wordList Foam::pointBoundaryMesh::names() const
{
    return PtrListOps::get<word>(*this, nameOp<pointPatch>());
}


Foam::wordList Foam::pointBoundaryMesh::types() const
{
    return PtrListOps::get<word>(*this, typeOp<pointPatch>());
}


Foam::wordList Foam::pointBoundaryMesh::physicalTypes() const
{
    return
        PtrListOps::get<word>
        (
            *this,
            [](const pointPatch& p) { return p.physicalType(); }
        );
}


const Foam::HashTable<Foam::labelList>&
Foam::pointBoundaryMesh::groupPatchIDs() const
{
    if (!groupIDsPtr_)
    {
        calcGroupIDs();
    }

    return *groupIDsPtr_;
}


Foam::labelList Foam::pointBoundaryMesh::indices
(
    const wordRe& matcher,
    const bool useGroups
) const
{
    if (matcher.empty())
    {
        return labelList();
    }

    // Only check groups if requested and they exist
    const bool checkGroups = (useGroups && this->hasGroupIDs());

    labelHashSet ids;

    if (matcher.isPattern())
    {
        if (checkGroups)
        {
            const auto& groupLookup = groupPatchIDs();
            forAllConstIters(groupLookup, iter)
            {
                if (matcher(iter.key()))
                {
                    // Add ids associated with the group
                    ids.insert(iter.val());
                }
            }
        }

        if (ids.empty())
        {
            return PtrListOps::findMatching(*this, matcher);
        }
        else
        {
            ids.insert(PtrListOps::findMatching(*this, matcher));
        }
    }
    else
    {
        // Literal string.
        // Special version of above for reduced memory footprint.

        const label patchId = PtrListOps::firstMatching(*this, matcher);

        if (patchId >= 0)
        {
            return labelList(one{}, patchId);
        }
        else if (checkGroups)
        {
            const auto iter = groupPatchIDs().cfind(matcher);

            if (iter.good())
            {
                // Add ids associated with the group
                ids.insert(iter.val());
            }
        }
    }

    return ids.sortedToc();
}


Foam::labelList Foam::pointBoundaryMesh::indices
(
    const wordRes& matcher,
    const bool useGroups
) const
{
    if (matcher.empty())
    {
        return labelList();
    }
    else if (matcher.size() == 1)
    {
        return this->indices(matcher.front(), useGroups);
    }

    labelHashSet ids;

    // Only check groups if requested and they exist
    if (useGroups && this->hasGroupIDs())
    {
        ids.reserve(this->size());

        const auto& groupLookup = groupPatchIDs();
        forAllConstIters(groupLookup, iter)
        {
            if (matcher(iter.key()))
            {
                // Add ids associated with the group
                ids.insert(iter.val());
            }
        }
    }

    if (ids.empty())
    {
        return PtrListOps::findMatching(*this, matcher);
    }
    else
    {
        ids.insert(PtrListOps::findMatching(*this, matcher));
    }

    return ids.sortedToc();
}


Foam::labelList Foam::pointBoundaryMesh::indices
(
    const wordRes& allow,
    const wordRes& deny,
    const bool useGroups
) const
{
    if (allow.empty() && deny.empty())
    {
        // Fast-path: select all
        return identity(this->size());
    }

    const wordRes::filter matcher(allow, deny);

    labelHashSet ids;

    // Only check groups if requested and they exist
    if (useGroups && this->hasGroupIDs())
    {
        ids.reserve(this->size());

        const auto& groupLookup = groupPatchIDs();
        forAllConstIters(groupLookup, iter)
        {
            if (matcher(iter.key()))
            {
                // Add ids associated with the group
                ids.insert(iter.val());
            }
        }
    }

    if (ids.empty())
    {
        return PtrListOps::findMatching(*this, matcher);
    }
    else
    {
        ids.insert(PtrListOps::findMatching(*this, matcher));
    }

    return ids.sortedToc();
}


Foam::label Foam::pointBoundaryMesh::findPatchID
(
    const word& patchName,
    bool allowNotFound
) const
{
    //return mesh().boundaryMesh().findPatchID(patchName);
    if (patchName.empty())
    {
        return -1;
    }

    const label patchId = PtrListOps::firstMatching(*this, patchName);

    if (patchId >= 0)
    {
        return patchId;
    }

    if (!allowNotFound)
    {
        FatalErrorInFunction
            << "Patch '" << patchName << "' not found. "
            << "Available patch names";

        if (polyMesh::defaultRegion != mesh_.name())
        {
            FatalError
                << " in region '" << mesh_.name() << "'";
        }

        FatalError
            << " include: " << names() << endl
            << exit(FatalError);
    }

    // Patch not found
    if (debug)
    {
        Pout<< "label pointBoundaryMesh::findPatchID(const word&) const"
            << " Patch named " << patchName << " not found.  "
            << "Available patch names: " << names() << endl;
    }

    // Not found, return -1
    return -1;
}


const Foam::pointPatch*
Foam::pointBoundaryMesh::cfindPatch(const word& patchName) const
{
    const pointPatchList& patches = *this;

    if (!patchName.empty())
    {
        // Note: get() handles out-of-range access properly
        return patches.get(PtrListOps::firstMatching(patches, patchName));
    }

    return nullptr;
}


void Foam::pointBoundaryMesh::calcGeometry()
{
    PstreamBuffers pBufs(Pstream::defaultCommsType);

    if
    (
        pBufs.commsType() == Pstream::commsTypes::buffered
     || pBufs.commsType() == Pstream::commsTypes::nonBlocking
    )
    {
        forAll(*this, patchi)
        {
            operator[](patchi).initGeometry(pBufs);
        }

        pBufs.finishedSends();

        forAll(*this, patchi)
        {
            operator[](patchi).calcGeometry(pBufs);
        }
    }
    else if (pBufs.commsType() == Pstream::commsTypes::scheduled)
    {
        const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();

        // Dummy.
        pBufs.finishedSends();

        for (const auto& schedEval : patchSchedule)
        {
            const label patchi = schedEval.patch;

            if (schedEval.init)
            {
                operator[](patchi).initGeometry(pBufs);
            }
            else
            {
                operator[](patchi).calcGeometry(pBufs);
            }
        }
    }
}


void Foam::pointBoundaryMesh::movePoints(const pointField& p)
{
    PstreamBuffers pBufs(Pstream::defaultCommsType);

    if
    (
        pBufs.commsType() == Pstream::commsTypes::buffered
     || pBufs.commsType() == Pstream::commsTypes::nonBlocking
    )
    {
        forAll(*this, patchi)
        {
            operator[](patchi).initMovePoints(pBufs, p);
        }

        pBufs.finishedSends();

        forAll(*this, patchi)
        {
            operator[](patchi).movePoints(pBufs, p);
        }
    }
    else if (pBufs.commsType() == Pstream::commsTypes::scheduled)
    {
        const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();

        // Dummy.
        pBufs.finishedSends();

        for (const auto& schedEval : patchSchedule)
        {
            const label patchi = schedEval.patch;

            if (schedEval.init)
            {
                operator[](patchi).initMovePoints(pBufs, p);
            }
            else
            {
                operator[](patchi).movePoints(pBufs, p);
            }
        }
    }
}


void Foam::pointBoundaryMesh::updateMesh()
{
    PstreamBuffers pBufs(Pstream::defaultCommsType);

    if
    (
        pBufs.commsType() == Pstream::commsTypes::buffered
     || pBufs.commsType() == Pstream::commsTypes::nonBlocking
    )
    {
        forAll(*this, patchi)
        {
            operator[](patchi).initUpdateMesh(pBufs);
        }

        pBufs.finishedSends();

        forAll(*this, patchi)
        {
            operator[](patchi).updateMesh(pBufs);
        }
    }
    else if (pBufs.commsType() == Pstream::commsTypes::scheduled)
    {
        const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();

        // Dummy.
        pBufs.finishedSends();

        for (const auto& schedEval : patchSchedule)
        {
            const label patchi = schedEval.patch;

            if (schedEval.init)
            {
                operator[](patchi).initUpdateMesh(pBufs);
            }
            else
            {
                operator[](patchi).updateMesh(pBufs);
            }
        }
    }
}


void Foam::pointBoundaryMesh::reorder
(
    const labelUList& oldToNew,
    const bool validBoundary
)
{
    // Change order of patches
    pointPatchList::reorder(oldToNew);

    // Adapt indices
    pointPatchList& patches = *this;

    forAll(patches, patchi)
    {
        patches[patchi].index() = patchi;
    }

    // Clear group-to-patch addressing. Note: could re-calculate
    groupIDsPtr_.reset(nullptr);

    if (validBoundary)
    {
        updateMesh();
    }

    if (debug)
    {
        pointPatchList& Patches = *this;

        Pout<< "pointBoundaryMesh::reorder"
            << "(const labelUList&, const bool): "
            << "reordered pointBoundaryMesh:" << endl;
        Pout<< incrIndent;
        for (const auto& pp : Patches)
        {
            Pout<< indent
                << "index:" << pp.index() << " patch:" << pp.name()
                << " type:" << pp.type() << endl;
        }
        Pout<< decrIndent;
    }
}


bool Foam::pointBoundaryMesh::writeData(Ostream& os) const
{
    const pointPatchList& patches = *this;

    os  << patches.size() << nl << token::BEGIN_LIST << incrIndent << nl;

    forAll(patches, patchi)
    {
        os  << indent << patches[patchi].name() << nl
            << indent << token::BEGIN_BLOCK << nl
            << incrIndent << patches[patchi] << decrIndent
            << indent << token::END_BLOCK << endl;
    }

    os  << decrIndent << token::END_LIST;

    // Check state of IOstream
    os.check("pointBoundaryMesh::writeData(Ostream& os) const");

    return os.good();
}


//bool Foam::pointBoundaryMesh::writeObject
//(
//    IOstreamOption
//) const
//{
//    return regIOobject::writeObject(fmt, ver, IOstream::UNCOMPRESSED);
//}


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