void Foam::shapeToCell::combine(topoSet& set, const bool add) const
{
    if (type_ == "splitHex")
    {
        for (label cellI = 0; cellI < mesh_.nCells(); cellI++)
        {
            cellFeatures superCell(mesh_, featureCos, cellI);

            if (hexMatcher().isA(superCell.faces()))
            {
                addOrDelete(set, cellI, add);
            }
        }
    }
    else
    {
        const cellModel& wantedModel = *(cellModeller::lookup(type_));

        const cellShapeList& cellShapes = mesh_.cellShapes();

        forAll(cellShapes, cellI)
        {
            if (cellShapes[cellI].model() == wantedModel)
            {
                addOrDelete(set, cellI, add);
            }
        }
    }
}
void Foam::badQualityToCell::combine(topoSet& set, const bool add) const
{
    faceSet faces(mesh_, "meshQualityFaces", mesh_.nFaces()/100+1);
    motionSmoother::checkMesh(false, mesh_, dict_, faces);
    faces.sync(mesh_);

    forAllConstIter(faceSet, faces, iter)
    {
        label faceI = iter.key();
        addOrDelete(set, mesh_.faceOwner()[faceI], add);
        if (mesh_.isInternalFace(faceI))
        {
            addOrDelete(set, mesh_.faceNeighbour()[faceI], add);
        }
    }
Beispiel #3
0
void Foam::patchToFace::combine(topoSet& set, const bool add) const
{
    labelHashSet patchIDs = mesh_.boundaryMesh().patchSet
    (
        List<wordRe>(1, patchName_),
        true,           // warn if not found
        true            // use patch groups if available
    );

    forAllConstIter(labelHashSet, patchIDs, iter)
    {
        label patchi = iter.key();

        const polyPatch& pp = mesh_.boundaryMesh()[patchi];

        Info<< "    Found matching patch " << pp.name()
            << " with " << pp.size() << " faces." << endl;

        for
        (
            label facei = pp.start();
            facei < pp.start() + pp.size();
            facei++
        )
        {
            addOrDelete(set, facei, add);
        }
    }
void Foam::surfaceToPoint::combine(topoSet& set, const bool add) const
{
    cpuTime timer;

    triSurface surf(surfName_);

    Info<< "    Read surface from " << surfName_
        << " in = "<< timer.cpuTimeIncrement() << " s" << endl << endl;

    // Construct search engine on surface
    triSurfaceSearch querySurf(surf);

    if (includeInside_ || includeOutside_)
    {
        boolList pointInside(querySurf.calcInside(mesh_.points()));

        forAll(pointInside, pointI)
        {
            bool isInside = pointInside[pointI];

            if ((isInside && includeInside_) || (!isInside && includeOutside_))
            {
                addOrDelete(set, pointI, add);
            }
        }
void Foam::cellToFace::combine(topoSet& set, const bool add) const
{
    // Load the set
    if (!exists(mesh_.time().path()/topoSet::localPath(mesh_, setName_)))
    {
        SeriousError<< "Cannot load set "
            << setName_ << endl;
    }
    
    cellSet loadedSet(mesh_, setName_);

    if (option_ == ALL)
    {
        // Add all faces from cell
        for
        (
            cellSet::const_iterator iter = loadedSet.begin();
            iter != loadedSet.end();
            ++iter
        )
        {
            label cellI = iter.key();

            const labelList& cFaces = mesh_.cells()[cellI];

            forAll(cFaces, cFaceI)
            {
                addOrDelete(set, cFaces[cFaceI], add);
            }
        }
    }
void Foam::cellToPoint::combine(topoSet& set, const bool add) const
{
    // Load the set
    cellSet loadedSet(mesh_, setName_);

    // Add all point from cells in loadedSet
    for
    (
        cellSet::const_iterator iter = loadedSet.begin();
        iter != loadedSet.end();
        ++iter
    )
    {
        label cellI = iter.key();

        const labelList& cFaces = mesh_.cells()[cellI];

        forAll(cFaces, cFaceI)
        {
            const face& f = mesh_.faces()[cFaces[cFaceI]];

            forAll(f, fp)
            {
                addOrDelete(set, f[fp], add);
            }
        }
    }
void Foam::pointToFace::combine(topoSet& set, const bool add) const
{
    // Load the set
    pointSet loadedSet(mesh_, setName_);

    if (option_ == ANY)
    {
        // Add faces with any point in loadedSet
        for
        (
            pointSet::const_iterator iter = loadedSet.begin();
            iter != loadedSet.end();
            ++iter
        )
        {
            label pointI = iter.key();

            const labelList& pFaces = mesh_.pointFaces()[pointI];

            forAll(pFaces, pFaceI)
            {
                addOrDelete(set, pFaces[pFaceI], add);
            }
        }
    }
Beispiel #8
0
void Foam::expressionToCell::combine(topoSet& set, const bool add) const
{
    fvMesh mesh(set.db());

    FieldValueExpressionDriver driver
        (
            mesh.time().timeName(),
            mesh.time(),
            mesh,
            true, // cache stuff
            true, // search in memory
            true  // search on disc
        );

    if(dict_.valid()) {
        driver.readVariablesAndTables(dict_());
        driver.clearVariables();
    }
    driver.parse(expression_);
    if(!driver.resultIsTyp<volScalarField>(true)) {
        FatalErrorIn("Foam::expressionToCell::combine(topoSet& set, const bool add) const")
            << "Expression " << expression_ << " does not evaluate to a logical expression"
                << endl
                << exit(FatalError);
    }
    const volScalarField &condition=driver.getResult<volScalarField>();

    forAll(condition, cellI)
    {
        if (condition[cellI])
        {
            addOrDelete(set, cellI, add);
        }
    }
}
void Foam::nearestToCell::combine(topoSet& set, const bool add) const
{
    // Construct search engine withouth tet decomposition.
    meshSearch queryMesh(mesh_, false);

    forAll(points_, pointI)
    {
        addOrDelete(set, queryMesh.findNearestCell(points_[pointI]), add);
    }
void Foam::boxToPoint::combine(topoSet& set, const bool add) const
{
    const pointField& pts = mesh_.points();

    forAll(pts, pointI)
    {
        if (bb_.contains(pts[pointI]))
        {
            addOrDelete(set, pointI, add);
        }
    }
}
void Foam::boxToCell::combine(topoSet& set, const bool add) const
{
    const pointField& ctrs = mesh_.cellCentres();

    forAll(ctrs, cellI)
    {
        if (bb_.contains(ctrs[cellI]))
        {
            addOrDelete(set, cellI, add);
        }
    }
}
Beispiel #12
0
void Foam::boundaryToFace::combine(topoSet& set, const bool add) const
{
    for
    (
        label facei = mesh().nInternalFaces();
        facei < mesh().nFaces();
        facei++
    )
    {
        addOrDelete(set, facei, add);
    }
}
Beispiel #13
0
void Foam::boxToFace::combine(topoSet& set, const bool add) const
{
    const pointField& ctrs = mesh_.faceCentres();

    forAll(ctrs, faceI)
    {
        if (bb_.contains(ctrs[faceI]))
        {
            addOrDelete(set, faceI, add);
        }
    }
}
Beispiel #14
0
void Foam::faceToPoint::combine(topoSet& set, const bool add) const
{
    // Load the set
    faceSet loadedSet(mesh_, setName_);

    // Add all points from faces in loadedSet
    forAllConstIter(faceSet, loadedSet, iter)
    {
        const face& f = mesh_.faces()[iter.key()];

        forAll(f, fp)
        {
            addOrDelete(set, f[fp], add);
        }
    }
Beispiel #15
0
    forAll(ctrs, cellI)
    {
        bool inside = true;

        forAll(boxFaces, i)
        {
            const face& f = boxFaces[i];

            if (((ctrs[cellI] - boxPoints[f[0]]) & boxFaceNormals[i]) > 0)
            {
                inside = false;
                break;
            }
        }

        if (inside)
        {
            addOrDelete(set, cellI, add);
        }
    }
void Foam::faceToPoint::combine(topoSet& set, const bool add) const
{
    // Load the set
    faceSet loadedSet(mesh_, setName_);

    // Add all points from faces in loadedSet
    for
    (
        faceSet::const_iterator iter = loadedSet.begin();
        iter != loadedSet.end();
        ++iter
    )
    {
        const face& f = mesh_.faces()[iter.key()];

        forAll(f, fp)
        {
            addOrDelete(set, f[fp], add);
        }
    }
Beispiel #17
0
void Foam::cylinderToCell::combine(topoSet& set, const bool add) const
{
    const vector axis = p2_ - p1_;
    const scalar rad2 = sqr(radius_);
    const scalar magAxis2 = magSqr(axis);

    const pointField& ctrs = mesh_.cellCentres();

    forAll(ctrs, celli)
    {
        vector d = ctrs[celli] - p1_;
        scalar magD = d & axis;

        if ((magD > 0) && (magD < magAxis2))
        {
            scalar d2 = (d & d) - sqr(magD)/magAxis2;
            if (d2 < rad2)
            {
                addOrDelete(set, celli, add);
            }
        }
    }
Beispiel #18
0
    forAll(points_, pointI)
    {
        const pointField& pts = mesh_.points();

        if (pts.size())
        {
            label minPointI = 0;
            scalar minDistSqr = magSqr(pts[minPointI] - points_[pointI]);

            for (label i = 1; i < pts.size(); i++)
            {
                scalar distSqr = magSqr(pts[i] - points_[pointI]);

                if (distSqr < minDistSqr)
                {
                    minDistSqr = distSqr;
                    minPointI = i;
                }
            }

            addOrDelete(set, minPointI, add);
        }
    }
Beispiel #19
0
 forAll(labels_, labelI)
 {
     addOrDelete(set, labels_[labelI], add);
 }
Beispiel #20
0
void Foam::regionToCell::combine(topoSet& set, const bool add) const
{
    label cellI = mesh_.findCell(insidePoint_);

    // Load the subset of cells
    boolList blockedFace(mesh_.nFaces(), false);
    {
        Info<< "Loading subset " << setName_ << " to delimit search region."
            << endl;
        cellSet subSet(mesh_, setName_);

        boolList inSubset(mesh_.nCells(), false);
        forAllConstIter(cellSet, subSet, iter)
        {
            inSubset[iter.key()] = true;
        }

        if (cellI != -1 && inSubset[cellI])
        {
            Pout<< "Point " << insidePoint_ << " is inside cellSet "
                << setName_ << endl
                << "Collecting all cells connected to " << cellI
                << " and inside cellSet " << setName_ << endl;
        }
        else
        {
            Pout<< "Point " << insidePoint_ << " is outside cellSet "
                << setName_ << endl
                << "Collecting all cells connected to " << cellI
                << " and outside cellSet " << setName_ << endl;
        }

        // Get coupled cell status
        label nInt = mesh_.nInternalFaces();
        boolList neiSet(mesh_.nFaces()-nInt, false);
        for (label faceI = nInt; faceI < mesh_.nFaces(); faceI++)
        {
             neiSet[faceI-nInt] = inSubset[mesh_.faceOwner()[faceI]];
        }
        syncTools::swapBoundaryFaceList(mesh_, neiSet, false);

        // Find faces inbetween subSet and non-subset.
        for (label faceI = 0; faceI < nInt; faceI++)
        {
            bool ownInSet = inSubset[mesh_.faceOwner()[faceI]];
            bool neiInSet = inSubset[mesh_.faceNeighbour()[faceI]];
            blockedFace[faceI] = (ownInSet != neiInSet);
        }
        for (label faceI = nInt; faceI < mesh_.nFaces(); faceI++)
        {
            bool ownInSet = inSubset[mesh_.faceOwner()[faceI]];
            bool neiInSet = neiSet[faceI-nInt];
            blockedFace[faceI] = (ownInSet != neiInSet);
        }
    }

    // Find connected regions without crossing boundary of the cellset.
    regionSplit regions(mesh_, blockedFace);

    // Get the region containing the insidePoint
    label regionI = -1;

    if (cellI != -1)
    {
        // On processor that has found cell.
        regionI = regions[cellI];
    }

    reduce(regionI, maxOp<label>());

    if (regionI == -1)
    {
        WarningIn
        (
            "regionToCell::combine(topoSet&, const bool) const"
        )   << "Point " << insidePoint_
            << " is not inside the mesh." << nl
            << "Bounding box of the mesh:" << mesh_.globalData().bb()
            << endl;
        return;
    }


    // Pick up the cells of the region
    const labelList regionCells(findIndices(regions, regionI));

    forAll(regionCells, i)
    {
        addOrDelete(set, regionCells[i], add);
    }
Beispiel #21
0
void Foam::faceToCell::combine(topoSet& set, const bool add) const
{
    // Load the set
    faceSet loadedSet(mesh_, setName_);


    // Handle owner/neighbour/any selection
    forAllConstIter(faceSet, loadedSet, iter)
    {
        const label faceI = iter.key();

        if ((option_ == OWNER) || (option_ == ANY))
        {
            const label cellI = mesh_.faceOwner()[faceI];

            addOrDelete(set, cellI, add);
        }

        if (mesh_.isInternalFace(faceI))
        {
            if ((option_ == NEIGHBOUR) || (option_ == ANY))
            {
                const label cellI = mesh_.faceNeighbour()[faceI];

                addOrDelete(set, cellI, add);
            }
        }
    }

    // Handle all selection.
    if (option_ == ALL)
    {
        // Count number of selected faces per cell.

        Map<label> facesPerCell(loadedSet.size());

        forAllConstIter(faceSet, loadedSet, iter)
        {
            const label faceI = iter.key();
            const label own = mesh_.faceOwner()[faceI];

            Map<label>::iterator fndOwn = facesPerCell.find(own);

            if (fndOwn == facesPerCell.end())
            {
                facesPerCell.insert(own, 1);
            }
            else
            {
                fndOwn()++;
            }

            if (mesh_.isInternalFace(faceI))
            {
                label nei = mesh_.faceNeighbour()[faceI];

                Map<label>::iterator fndNei = facesPerCell.find(nei);

                if (fndNei == facesPerCell.end())
                {
                    facesPerCell.insert(nei, 1);
                }
                else
                {
                    fndNei()++;
                }
            }
        }

        // Include cells that are referenced as many times as they have faces
        // -> all faces in set.
        forAllConstIter(Map<label>, facesPerCell, iter)
        {
            const label cellI = iter.key();

            if (iter() == mesh_.cells()[cellI].size())
            {
                addOrDelete(set, cellI, add);
            }
        }
    }