volume_kernel.cpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit 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 Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#include "volume_kernel.hpp"
 
namespace bitpit {

 
#if BITPIT_ENABLE_MPI==1
    If a null comunicator is provided, a serial patch will be created, this
    means that each processor will be unaware of the existence of the other
    processes.
 
    \param communicator is the communicator to be used for exchanging data
    among the processes. If a null comunicator is provided, a serial patch
    will be created
    \param haloSize is the size, expressed in number of layers, of the ghost
    cells halo
    \param adaptionMode is the adaption mode that will be used for the patch
    \param partitioningMode is the partitioning mode that will be used for the
    patch
*/
VolumeKernel::VolumeKernel(MPI_Comm communicator, std::size_t haloSize,
                           AdaptionMode adaptionMode, PartitioningMode partitioningMode)
    : PatchKernel(communicator, haloSize, adaptionMode, partitioningMode)
#else
VolumeKernel::VolumeKernel(AdaptionMode adaptionMode)
    : PatchKernel(adaptionMode)
#endif
{
}
 
#if BITPIT_ENABLE_MPI==1
VolumeKernel::VolumeKernel(int dimension, MPI_Comm communicator, std::size_t haloSize,
                           AdaptionMode adaptionMode, PartitioningMode partitioningMode)
    : PatchKernel(dimension, communicator, haloSize, adaptionMode, partitioningMode)
#else
VolumeKernel::VolumeKernel(int dimension, AdaptionMode adaptionMode)
    : PatchKernel(dimension, adaptionMode)
#endif
{
}
 
#if BITPIT_ENABLE_MPI==1
VolumeKernel::VolumeKernel(int id, int dimension, MPI_Comm communicator, std::size_t haloSize,
                           AdaptionMode adaptionMode, PartitioningMode partitioningMode)
    : PatchKernel(id, dimension, communicator, haloSize, adaptionMode, partitioningMode)
#else
VolumeKernel::VolumeKernel(int id, int dimension, AdaptionMode adaptionMode)
    : PatchKernel(id, dimension, adaptionMode)
#endif
{
}

int VolumeKernel::getVolumeCodimension() const
{
    return 0;
}

int VolumeKernel::getSurfaceCodimension() const
{
    return -1;
}

int VolumeKernel::getLineCodimension() const
{
    return -2;
}

int VolumeKernel::getPointCodimension() const
{
    return -3;
}

void VolumeKernel::extractEnvelope(SurfaceKernel &envelope) const
{
    PatchKernel::extractEnvelope(envelope);
}

bool VolumeKernel::isPointInside(double x, double y, double z) const
{
    return isPointInside({{x, y, z}});
}

bool VolumeKernel::isPointInside(long id, double x, double y, double z) const
{
    return isPointInside(id, {{x, y, z}});
}

ConstProxyVector<long> VolumeKernel::getFaceOrderedVertexIds(const Cell &cell, int face) const
{
    ConstProxyVector<long> faceVertexIds = cell.getFaceVertexIds(face);
    if (areFaceVerticesOrdered(cell, face)) {
        return faceVertexIds;
    }
 
    std::size_t nFaceVertices = faceVertexIds.size();
    ConstProxyVector<long> orderedFaceVertexIds(ConstProxyVector<long>::INTERNAL_STORAGE, nFaceVertices);
    ConstProxyVector<long>::storage_pointer orderedFaceVertexIdsStorage = orderedFaceVertexIds.storedData();
    for (std::size_t k = 0; k < nFaceVertices; ++k) {
        int vertex = getFaceOrderedLocalVertex(cell, face, k);
        orderedFaceVertexIdsStorage[k] = faceVertexIds[vertex];
    }
 
    return orderedFaceVertexIds;
}

bool VolumeKernel::areFaceVerticesOrdered(const Cell &cell, int face) const
{
    // Early return for low-dimension elements
    if (getDimension() <= 2) {
        return true;
    }
 
    // Check if vertices are ordered
    ElementType faceType = cell.getFaceType(face);
    switch (faceType) {
 
    case (ElementType::POLYGON):
    {
        return true;
    }
 
    default:
    {
        assert(faceType != ElementType::UNDEFINED);
        const Reference2DElementInfo &faceInfo = static_cast<const Reference2DElementInfo &>(ReferenceElementInfo::getInfo(faceType));
        return faceInfo.areVerticesCCWOrdered();
    }
 
    }
}

int VolumeKernel::getFaceOrderedLocalVertex(const Cell &cell, int face, std::size_t n) const
{
    // Early return for low-dimension elements
    if (getDimension() <= 2) {
        return n;
    }
 
    // Get the request index
    ElementType faceType = cell.getFaceType(face);
    switch (faceType) {
 
    case (ElementType::POLYGON):
    {
        return n;
    }
 
    default:
    {
        assert(faceType != ElementType::UNDEFINED);
        const Reference2DElementInfo &faceInfo = static_cast<const Reference2DElementInfo &>(ReferenceElementInfo::getInfo(faceType));
        return faceInfo.getCCWOrderedVertex(n);
    }
 
    }
}
 
}