cell.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<iostream>
 
#include "bitpit_common.hpp"
 
#include "vertex.hpp"
#include "cell.hpp"
 
namespace bitpit {
 
IBinaryStream& operator>>(IBinaryStream &buffer, Cell &cell)
{
    // Write connectivity data ---------------------------------------------- //
    Element &element(cell);
    buffer >> element;
 
    // Write interface data ------------------------------------------------- //
    buffer >> cell.m_interfaces;
 
    // Write adjacencies data ----------------------------------------------- //
    buffer >> cell.m_adjacencies;
 
    return buffer;
}
 
OBinaryStream& operator<<(OBinaryStream  &buffer, const Cell &cell)
{
    // Write connectivity data ---------------------------------------------- //
    const Element &element(cell);
    buffer << element;
 
    // Write interface data ------------------------------------------------- //
    buffer << cell.m_interfaces;
 
    // Write adjacencies data ----------------------------------------------- //
    buffer << cell.m_adjacencies;
 
    return buffer;
}
 
bitpit::FlatVector2D<long> Cell::createNeighbourhoodStorage(bool storeNeighbourhood)
{
    ElementType type = getType();
    if (!storeNeighbourhood || type == ElementType::UNDEFINED) {
        return bitpit::FlatVector2D<long>(false);
    }
 
    int nFaces = getFaceCount();
    if (nFaces <= 0) {
        return bitpit::FlatVector2D<long>(false);
    }
 
    return bitpit::FlatVector2D<long>(nFaces, 0);
}
 
Cell::Cell()
    : Element(),
      m_interfaces(createNeighbourhoodStorage(false)),
      m_adjacencies(createNeighbourhoodStorage(false)),
      m_interior(true)
{
 
}
 
Cell::Cell(long id, ElementType type, bool interior, bool storeNeighbourhood)
    : Cell(id, type, interior, storeNeighbourhood, storeNeighbourhood)
{
}
 
Cell::Cell(long id, ElementType type, int connectSize, bool interior, bool storeNeighbourhood)
    : Cell(id, type, connectSize, interior, storeNeighbourhood, storeNeighbourhood)
{
}
 
Cell::Cell(long id, ElementType type, std::unique_ptr<long[]> &&connectStorage, bool interior, bool storeNeighbourhood)
    : Cell(id, type, std::move(connectStorage), interior, storeNeighbourhood, storeNeighbourhood)
{
}
 
Cell::Cell(long id, ElementType type, bool interior, bool storeInterfaces, bool storeAdjacencies)
    : Element(id, type),
      m_interfaces(createNeighbourhoodStorage(storeInterfaces)),
      m_adjacencies(createNeighbourhoodStorage(storeAdjacencies))
{
    _initialize(interior, false, false, false, false);
}
 
Cell::Cell(long id, ElementType type, int connectSize, bool interior, bool storeInterfaces, bool storeAdjacencies)
    : Element(id, type, connectSize),
      m_interfaces(createNeighbourhoodStorage(storeInterfaces)),
      m_adjacencies(createNeighbourhoodStorage(storeAdjacencies))
{
    _initialize(interior, false, false, false, false);
}
 
Cell::Cell(long id, ElementType type, std::unique_ptr<long[]> &&connectStorage, bool interior, bool storeInterfaces, bool storeAdjacencies)
    : Element(id, type, std::move(connectStorage)),
      m_interfaces(createNeighbourhoodStorage(storeInterfaces)),
      m_adjacencies(createNeighbourhoodStorage(storeAdjacencies))
{
    _initialize(interior, false, false, false, false);
}
 
void Cell::swap(Cell &other) noexcept
{
    Element::swap(other);
 
    std::swap(other.m_interior, m_interior);
 
    other.m_interfaces.swap(m_interfaces);
    other.m_adjacencies.swap(m_adjacencies);
}
 
void Cell::initialize(long id, ElementType type, bool interior, bool storeNeighbourhood)
{
    initialize(id, type, interior, storeNeighbourhood, storeNeighbourhood);
}
 
void Cell::initialize(long id, ElementType type, int connectSize, bool interior, bool storeNeighbourhood)
{
    initialize(id, type, connectSize, interior, storeNeighbourhood, storeNeighbourhood);
}
 
void Cell::initialize(long id, ElementType type, std::unique_ptr<long[]> &&connectStorage, bool interior, bool storeNeighbourhood)
{
    initialize(id, type, std::move(connectStorage), interior, storeNeighbourhood, storeNeighbourhood);
}
 
void Cell::initialize(long id, ElementType type, bool interior, bool storeInterfaces, bool storeAdjacencies)
{
    Element::initialize(id, type);
 
    _initialize(interior, true, storeInterfaces, true, storeAdjacencies);
}
 
void Cell::initialize(long id, ElementType type, int connectSize, bool interior, bool storeInterfaces, bool storeAdjacencies)
{
    Element::initialize(id, type, connectSize);
 
    _initialize(interior, true, storeInterfaces, true, storeAdjacencies);
}
 
void Cell::initialize(long id, ElementType type, std::unique_ptr<long[]> &&connectStorage, bool interior, bool storeInterfaces, bool storeAdjacencies)
{
    Element::initialize(id, type, std::move(connectStorage));
 
    _initialize(interior, true, storeInterfaces, true, storeAdjacencies);
}
 
void Cell::_initialize(bool interior, bool initializeInterfaces, bool storeInterfaces, bool initializeAdjacency, bool storeAdjacencies)
{
    setInterior(interior);
 
    // Interface information
    if (initializeInterfaces) {
        resetInterfaces(storeInterfaces);
    }
 
    // Interface information
    if (initializeAdjacency) {
        resetAdjacencies(storeAdjacencies);
    }
}
 
void Cell::setInterior(bool interior)
{
    m_interior = interior;
}
 
bool Cell::isInterior() const
{
    return m_interior;
}
 
void Cell::deleteInterfaces()
{
    resetInterfaces(false);
}
 
void Cell::resetInterfaces(bool storeInterfaces)
{
    // Early return if no interfaces should be stored
    ElementType type = getType();
    if (!storeInterfaces || type == ElementType::UNDEFINED) {
        m_interfaces.destroy();
        return;
    }
 
    // Early return if not element defines no faces
    int nFaces = getFaceCount();
    if (nFaces <= 0) {
        m_interfaces.destroy();
        return;
    }
 
    // Initialize the interface storage
    m_interfaces.initialize(nFaces, 0);
}
 
void Cell::setInterfaces(const std::vector<std::vector<long>> &interfaces)
{
    if (getType() == ElementType::UNDEFINED) {
        return;
    }
 
    assert((int) interfaces.size() == getFaceCount());
    assert((int) m_interfaces.size() == getFaceCount());
    m_interfaces.initialize(interfaces);
}
 
void Cell::setInterfaces(FlatVector2D<long> &&interfaces)
{
    if (getType() == ElementType::UNDEFINED) {
        return;
    }
 
    assert((int) m_interfaces.size() == getFaceCount());
    assert((int) interfaces.size() == getFaceCount());
    m_interfaces.swap(interfaces);
}
 
void Cell::setInterface(int face, int index, long interface)
{
    m_interfaces.setItem(face, index, interface);
}
 
bool Cell::pushInterface(int face, long interface)
{
    // Do not push an existing interface
    if (findInterface(face, interface) >= 0) {
        return false;
    }
 
    // Add the interface
    m_interfaces.pushBackItem(face, interface);
 
    // Done
    return true;
}
 
void Cell::deleteInterface(int face, int i)
{
    m_interfaces.eraseItem(face, i);
}
 
int Cell::getInterfaceCount() const
{
    return m_interfaces.getItemCount();
}
 
int Cell::getInterfaceCount(int face) const
{
    return m_interfaces.getItemCount(face);
}
 
long Cell::getInterface(int face, int index) const
{
    return m_interfaces.getItem(face, index);
}
 
const long * Cell::getInterfaces() const
{
    if (m_interfaces.empty()) {
        return nullptr;
    }
 
    return m_interfaces.get(0);
}
 
const long * Cell::getInterfaces(int face) const
{
    if (m_interfaces.empty()) {
        return nullptr;
    }
 
    return m_interfaces.get(face);
}
 
long * Cell::getInterfaces()
{
    if (m_interfaces.empty()) {
        return nullptr;
    }
 
    return m_interfaces.get(0);
}
 
long * Cell::getInterfaces(int face)
{
    if (m_interfaces.empty()) {
        return nullptr;
    }
 
    return m_interfaces.get(face);
}
 
int Cell::findInterface(int face, int interface)
{
    long *faceInterfaces = getInterfaces(face);
    int nFaceInterfaces = getInterfaceCount(face);
    for (int i = 0; i < nFaceInterfaces; i++) {
        if (faceInterfaces[i] == interface) {
            return i;
        }
    }
 
    return -1;
}
 
int Cell::findInterface(int interface)
{
    int nCellInterfaces = getInterfaceCount();
    const long *interfaces = getInterfaces();
    for (int i = 0; i < nCellInterfaces; i++) {
        if (interfaces[i] == interface) {
            return i;
        }
    }
 
    return -1;
}
 
void Cell::deleteAdjacencies()
{
    resetAdjacencies(false);
}
 
void Cell::resetAdjacencies(bool storeAdjacencies)
{
    // Early return if no adjacencies should be stored
    ElementType type = getType();
    if (!storeAdjacencies || type == ElementType::UNDEFINED) {
        m_adjacencies.destroy();
        return;
    }
 
    // Early return if not element defines no faces
    int nFaces = getFaceCount();
    if (nFaces <= 0) {
        m_adjacencies.destroy();
        return;
    }
 
    // Initialize the interface storage
    m_adjacencies.initialize(nFaces, 0);
}
 
void Cell::setAdjacencies(const std::vector<std::vector<long>> &adjacencies)
{
    if (getType() == ElementType::UNDEFINED) {
        return;
    }
 
    assert((int) m_adjacencies.size() == getFaceCount());
    assert((int) adjacencies.size() == getFaceCount());
    m_adjacencies.initialize(adjacencies);
}
 
void Cell::setAdjacencies(FlatVector2D<long> &&adjacencies)
{
    if (getType() == ElementType::UNDEFINED) {
        return;
    }
 
    assert((int) m_adjacencies.size() == getFaceCount());
    assert((int) adjacencies.size() == getFaceCount());
    m_adjacencies.swap(adjacencies);
}
 
void Cell::setAdjacency(int face, int index, long adjacency)
{
    m_adjacencies.setItem(face, index, adjacency);
}
 
bool Cell::pushAdjacency(int face, long adjacency)
{
    // Do not push an existing adjacency
    if (findAdjacency(face, adjacency) >= 0) {
        return false;
    }
 
    // Add the adjacency
    m_adjacencies.pushBackItem(face, adjacency);
 
    // Done
    return true;
}
 
void Cell::deleteAdjacency(int face, int i)
{
    m_adjacencies.eraseItem(face, i);
}
 
int Cell::getAdjacencyCount() const
{
    return m_adjacencies.getItemCount();
}
 
int Cell::getAdjacencyCount(int face) const
{
    return m_adjacencies.getItemCount(face);
}
 
long Cell::getAdjacency(int face, int index) const
{
    return m_adjacencies.getItem(face, index);
}
 
const long * Cell::getAdjacencies() const
{
    if (m_adjacencies.empty()) {
        return nullptr;
    }
 
    return m_adjacencies.get(0);
}
 
const long * Cell::getAdjacencies(int face) const
{
    if (m_adjacencies.empty()) {
        return nullptr;
    }
 
    return m_adjacencies.get(face);
}
 
long * Cell::getAdjacencies()
{
    if (m_adjacencies.empty()) {
        return nullptr;
    }
 
    return m_adjacencies.get(0);
}
 
long * Cell::getAdjacencies(int face)
{
    if (m_adjacencies.empty()) {
        return nullptr;
    }
 
    return m_adjacencies.get(face);
}
 
int Cell::findAdjacency(int face, int adjacency)
{
    long *faceAdjacencies = getAdjacencies(face);
    int nFaceAdjacencies = getAdjacencyCount(face);
    for (int i = 0; i < nFaceAdjacencies; i++) {
        if (faceAdjacencies[i] == adjacency) {
            return i;
        }
    }
 
    return -1;
}
 
int Cell::findAdjacency(int adjacency)
{
    int nCellAdjacencies = getAdjacencyCount();
    const long *adjacencies = getAdjacencies();
    for (int i = 0; i < nCellAdjacencies; i++) {
        if (adjacencies[i] == adjacency) {
            return i;
        }
    }
 
    return -1;
}
 
bool Cell::isFaceBorder(int face) const
{
    return (m_adjacencies.getItemCount(face) == 0);
}
 
void Cell::display(std::ostream &out, unsigned short int indent) const
{
    // ====================================================================== //
    // VARIABLES DECLARATION                                                  //
    // ====================================================================== //
 
    // Local variables
    std::string                 t_s(indent, ' ');
 
    // Counters
    int                         i, j;
    int                         nn;
 
    // ====================================================================== //
    // DISPLAY INFOS                                                          //
    // ====================================================================== //
    if (getType() == ElementType::UNDEFINED) {
        out << t_s << "cell type:    (unknown)" << std::endl;
        return;
    }
 
    // Scope variables -------------------------------------------------- //
    int                         nv = getVertexCount();
    int                         nf = getFaceCount();
 
    ConstProxyVector<long>      cellVertexIds = getVertexIds();
 
    // General info ----------------------------------------------------- //
    out << t_s << "cell type:    " << getType() << std::endl;
    out << t_s << "ID:           " << getId() << std::endl;
    out << t_s << "is ghost:     ";
    if (m_interior)     { out << "(false)"; }
    else                { out << "(true)"; }
    out << std::endl;
 
    // Connectivity infos --------------------------------------------------- //
    out << t_s << "connectivity: [ ";
    for (i = 0; i < nv-1; ++i) {
            if (cellVertexIds[i] == Vertex::NULL_ID)   out << "n.a. ";
            else                                   out << cellVertexIds[i] << ", ";
    } //next i
    if (cellVertexIds[nv-1] == Vertex::NULL_ID)    out << "n.a. ";
    else                                       out << cellVertexIds[nv-1] << " ]" << std::endl;
 
    // neighbors infos ------------------------------------------------------ //
        if (m_adjacencies.size() > 0) {
            out << t_s << "neighbors:    [ ";
            for (i = 0; i < nf; ++i) {
                nn = getAdjacencyCount(i);
                out << "[ ";
                if (nn == 0) {
                    out << "n.a. ";
                } else {
                    for (j = 0; j < nn; ++j) {
                        out << getAdjacency(i, j);
                        if (j != (nn - 1)) {
                            out << ",";
                        }
                        out << " ";
                    }
                }
                out << "]";
                if (i != (nf - 1)) {
                    out << ",";
                }
                out << " ";
            }
            out << "]" << std::endl;
        }
 
        // interface infos ------------------------------------------------------ //
        if (m_interfaces.size() > 0) {
            out << t_s << "interfaces:   [ ";
            for (i = 0; i < nf; ++i) {
                nn = getInterfaceCount(i);
                out << "[ ";
                if (nn == 0) {
                    out << "n.a. ";
                } else {
                    for (j = 0; j < nn; ++j) {
                        out << getInterface(i, j);
                        if (j != (nn - 1)) {
                            out << ",";
                        }
                        out << " ";
                    }
                }
                out << "]";
                if (i != (nf - 1)) {
                    out << ",";
                }
                out << " ";
            }
            out << "]" << std::endl;
        }
 
}
 
unsigned int Cell::getBinarySize() const
{
    return (Element::getBinarySize() + m_interfaces.getBinarySize() + m_adjacencies.getBinarySize());
}
 
// Explicit instantiation of the Cell containers
template class PiercedVector<Cell>;
 
template class QualifiedCellHalfEdge<Cell>;
template class QualifiedCellHalfEdge<const Cell>;
 
template class QualifiedCellHalfFace<Cell>;
template class QualifiedCellHalfFace<const Cell>;
 
}