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
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);
    }
 
    }
}
 
}