line_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 "bitpit_CG.hpp"
#include "line_kernel.hpp"
 
namespace bitpit {
 
 
#if BITPIT_ENABLE_MPI==1
LineKernel::LineKernel(MPI_Comm communicator, std::size_t haloSize,
                       AdaptionMode adaptionMode, PartitioningMode partitioningMode)
    : PatchKernel(communicator, haloSize, adaptionMode, partitioningMode)
#else
LineKernel::LineKernel(AdaptionMode adaptionMode)
    : PatchKernel(adaptionMode)
#endif
{
    initialize();
}
 
#if BITPIT_ENABLE_MPI==1
LineKernel::LineKernel(int dimension, MPI_Comm communicator, std::size_t haloSize,
                       AdaptionMode adaptionMode, PartitioningMode partitioningMode)
    : PatchKernel(dimension, communicator, haloSize, adaptionMode, partitioningMode)
#else
LineKernel::LineKernel(int dimension, AdaptionMode adaptionMode)
    : PatchKernel(dimension, adaptionMode)
#endif
{
    initialize();
}
 
#if BITPIT_ENABLE_MPI==1
LineKernel::LineKernel(int id, int dimension, MPI_Comm communicator, std::size_t haloSize,
                       AdaptionMode adaptionMode, PartitioningMode partitioningMode)
    : PatchKernel(id, dimension, communicator, haloSize, adaptionMode, partitioningMode)
#else
LineKernel::LineKernel(int id, int dimension, AdaptionMode adaptionMode)
    : PatchKernel(id, dimension, adaptionMode)
#endif
{
}

void LineKernel::initialize()
{
    // Nothing to do
}

int LineKernel::getVolumeCodimension() const
{
    return 2;
}

int LineKernel::getSurfaceCodimension() const
{
    return 1;
}

int LineKernel::getLineCodimension() const
{
    return 0;
}

int LineKernel::getPointCodimension() const
{
    return -1;
}

void LineKernel::extractEnvelope(PointKernel &envelope) const
{
    PatchKernel::extractEnvelope(envelope);
}

double LineKernel::evalCellSize(long id) const
{
    return evalCellLength(id);
}

double LineKernel::evalCellLength(long id) const
{
    const Cell &cell = m_cells[id];
    switch (cell.getType()) {
 
    case ElementType::LINE:
    {
        ConstProxyVector<long> cellVertexIds = cell.getVertexIds();
        const Vertex &vertex_0 = getVertex(cellVertexIds[0]);
        const Vertex &vertex_1 = getVertex(cellVertexIds[1]);
        double length = norm2(vertex_1.getCoords() - vertex_0.getCoords());
 
        return length;
    }
 
    default:
    {
        return 0.;
    }
 
    }
}

std::array<double, 3> LineKernel::evalCellNormal(long id, const std::array<double, 3> &orientation) const
{
    const Cell &cell = m_cells[id];
    switch (cell.getType()) {
 
    case ElementType::LINE:
    {
        ConstProxyVector<long> cellVertexIds = cell.getVertexIds();
        const Vertex &vertex_0 = getVertex(cellVertexIds[0]);
        const Vertex &vertex_1 = getVertex(cellVertexIds[1]);
 
        std::array<double, 3> normal = vertex_1.getCoords() - vertex_0.getCoords();
        normal = crossProduct(normal, orientation);
        normal = normal / norm2(normal);
 
        return normal;
    }
 
    default:
    {
        return {{0., 0., 0.}};
    }
 
    }
}

void LineKernel::evalBarycentricCoordinates(long id, const std::array<double, 3> &point, double *lambda) const
{
 
    // ====================================================================== //
    // VARIABLES DECLARATION                                                  //
    // ====================================================================== //
 
    // Local variables
    const Cell                   *cell_ = &m_cells[id];
 
    // Counters
    // none
 
    // ====================================================================== //
    // COMPUTE BARYCENTRIC COORDINATES
    // ====================================================================== //
    switch (cell_->getType()) {
 
    case ElementType::LINE:
    {
        ConstProxyVector<long> vertexIds = cell_->getVertexIds();
 
        std::array<double,3> point0 = getVertexCoords(vertexIds[0]);
        std::array<double,3> point1 = getVertexCoords(vertexIds[1]);
 
        std::array<double, 3> projectionPoint = CGElem::projectPointSegment(point, point0, point1, lambda);
        BITPIT_UNUSED(projectionPoint);
        return;
    }
 
    default:
    {
        int nVertices = cell_->getVertexCount();
        for (int i = 0; i < nVertices; ++i) {
            lambda[i] = 0.0;
        }
        return;
    }
 
    }
}
 
}