volunstructured.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_common.hpp"
 
#include "volunstructured.hpp"
 
namespace bitpit {
 
#if BITPIT_ENABLE_MPI==1
VolUnstructured::VolUnstructured(MPI_Comm communicator, std::size_t haloSize)
    : VolumeKernel(communicator, haloSize, ADAPTION_MANUAL, PARTITIONING_ENABLED)
#else
VolUnstructured::VolUnstructured()
    : VolumeKernel(ADAPTION_MANUAL)
#endif
{
}
 
#if BITPIT_ENABLE_MPI==1
VolUnstructured::VolUnstructured(int dimension, MPI_Comm communicator, std::size_t haloSize)
    : VolUnstructured(PatchManager::AUTOMATIC_ID, dimension, communicator, haloSize)
#else
VolUnstructured::VolUnstructured(int dimension)
    : VolUnstructured(PatchManager::AUTOMATIC_ID, dimension)
#endif
{
}
 
#if BITPIT_ENABLE_MPI==1
VolUnstructured::VolUnstructured(int id, int dimension, MPI_Comm communicator, std::size_t haloSize)
    : VolumeKernel(id, dimension, communicator, haloSize, ADAPTION_MANUAL, PARTITIONING_ENABLED)
#else
VolUnstructured::VolUnstructured(int id, int dimension)
    : VolumeKernel(id, dimension, ADAPTION_MANUAL)
#endif
{
}
 
std::unique_ptr<PatchKernel> VolUnstructured::clone() const
{
    return std::unique_ptr<VolUnstructured>(new VolUnstructured(*this));
}
 
double VolUnstructured::evalCellVolume(long id) const
{
    const Cell &cell = getCell(id);
 
    ConstProxyVector<long> cellVertexIds = cell.getVertexIds();
    std::size_t nCellVertices = cellVertexIds.size();
    BITPIT_CREATE_WORKSPACE(vertexCoordinates, std::array<double BITPIT_COMMA 3>, nCellVertices, ReferenceElementInfo::MAX_ELEM_VERTICES);
    getVertexCoords(nCellVertices, cellVertexIds.data(), vertexCoordinates);
 
    if (isThreeDimensional()) {
        return cell.evalVolume(vertexCoordinates);
    } else {
        return cell.evalArea(vertexCoordinates);
    }
}
 
double VolUnstructured::evalCellSize(long id) const
{
    const Cell &cell = getCell(id);
 
    ConstProxyVector<long> cellVertexIds = cell.getVertexIds();
    std::size_t nCellVertices = cellVertexIds.size();
    BITPIT_CREATE_WORKSPACE(vertexCoordinates, std::array<double BITPIT_COMMA 3>, nCellVertices, ReferenceElementInfo::MAX_ELEM_VERTICES);
    getVertexCoords(nCellVertices, cellVertexIds.data(), vertexCoordinates);
 
    return cell.evalSize(vertexCoordinates);
}
 
double VolUnstructured::evalInterfaceArea(long id) const
{
    const Interface &interface = getInterface(id);
 
    ConstProxyVector<long> interfaceVertexIds = interface.getVertexIds();
    std::size_t nInterfaceVertices = interfaceVertexIds.size();
    BITPIT_CREATE_WORKSPACE(vertexCoordinates, std::array<double BITPIT_COMMA 3>, nInterfaceVertices, ReferenceElementInfo::MAX_ELEM_VERTICES);
    getVertexCoords(nInterfaceVertices, interfaceVertexIds.data(), vertexCoordinates);
 
    if (isThreeDimensional()) {
        return interface.evalArea(vertexCoordinates);
    } else {
        return interface.evalLength(vertexCoordinates);
    }
}
 
std::array<double, 3> VolUnstructured::evalInterfaceNormal(long id) const
{
    const Interface &interface = getInterface(id);
 
    ConstProxyVector<long> interfaceVertexIds = interface.getVertexIds();
    std::size_t nInterfaceVertices = interfaceVertexIds.size();
    BITPIT_CREATE_WORKSPACE(vertexCoordinates, std::array<double BITPIT_COMMA 3>, nInterfaceVertices, ReferenceElementInfo::MAX_ELEM_VERTICES);
    getVertexCoords(nInterfaceVertices, interfaceVertexIds.data(), vertexCoordinates);
 
    std::array<double, 3> orientation = {{0., 0., 0.}};
    if (!isThreeDimensional()) {
        long ownerId = interface.getOwner();
        const Cell &owner = getCell(ownerId);
 
        ConstProxyVector<long> ownerVertexIds = owner.getVertexIds();
        const int nOwnerVertices = ownerVertexIds.size();
 
        const std::array<double, 3> &V_A = getVertex(ownerVertexIds[0]).getCoords();
        const std::array<double, 3> &V_B = getVertex(ownerVertexIds[1]).getCoords();
        const std::array<double, 3> &V_Z = getVertex(ownerVertexIds[nOwnerVertices - 1]).getCoords();
 
        orientation = crossProduct(V_B - V_A, V_Z - V_A);
    }
 
    return interface.evalNormal(vertexCoordinates, orientation);
}
 
int VolUnstructured::_getDumpVersion() const
{
    const int DUMP_VERSION = 2;
 
    return DUMP_VERSION;
}
 
void VolUnstructured::_dump(std::ostream &stream) const
{
    // Dump certices
    dumpVertices(stream);
 
    // Dump cells
    dumpCells(stream);
 
    // Dump cells
    dumpInterfaces(stream);
}
 
void VolUnstructured::_restore(std::istream &stream)
{
    // Restore certices
    restoreVertices(stream);
 
    // Restore cells
    restoreCells(stream);
 
    // Restore cells
    restoreInterfaces(stream);
}
 
bool VolUnstructured::isPointInside(const std::array<double, 3> &point) const
{
    BITPIT_UNUSED(point);
 
    throw std::runtime_error ("The function 'isPointInside' is not implemented yet");
 
    return false;
}
 
bool VolUnstructured::isPointInside(long id, const std::array<double, 3> &point) const
{
    BITPIT_UNUSED(id);
    BITPIT_UNUSED(point);
 
    throw std::runtime_error ("The function 'isPointInside' is not implemented yet");
 
    return false;
}
 
long VolUnstructured::locatePoint(const std::array<double, 3> &point) const
{
    BITPIT_UNUSED(point);
 
    throw std::runtime_error ("The function 'locatePoint' is not implemented yet");
 
    return Cell::NULL_ID;
}
 
#if BITPIT_ENABLE_MPI==1
std::size_t VolUnstructured::_getMaxHaloSize()
{
    return std::numeric_limits<uint32_t>::max();
}
#endif
 
}