interface.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 <cmath>
 
#include "bitpit_common.hpp"
#include "bitpit_operators.hpp"
 
#include "cell.hpp"
#include "interface.hpp"
 
namespace bitpit {
 
Interface::Interface()
    : Element()
{
    _initialize(NULL_ID, -1, NULL_ID, -1);
}
 
Interface::Interface(long id, ElementType type)
    : Element(id, type)
{
    _initialize(NULL_ID, -1, NULL_ID, -1);
}
 
Interface::Interface(long id, ElementType type, int connectSize)
    : Element(id, type, connectSize)
{
    _initialize(NULL_ID, -1, NULL_ID, -1);
}
 
Interface::Interface(long id, ElementType type, std::unique_ptr<long[]> &&connectStorage)
    : Element(id, type, std::move(connectStorage))
{
    _initialize(NULL_ID, -1, NULL_ID, -1);
}
 
void Interface::swap(Interface &other) noexcept
{
    Element::swap(other);
 
    std::swap(other.m_owner, m_owner);
    std::swap(other.m_ownerFace, m_ownerFace);
    std::swap(other.m_neigh, m_neigh);
    std::swap(other.m_neighFace, m_neighFace);
}
 
void Interface::initialize(long id, ElementType type)
{
    Element::initialize(id, type);
 
    _initialize(NULL_ID, -1, NULL_ID, -1);
}
 
void Interface::initialize(long id, ElementType type, int connectSize)
{
    Element::initialize(id, type, connectSize);
 
    _initialize(NULL_ID, -1, NULL_ID, -1);
}
 
void Interface::initialize(long id, ElementType type, std::unique_ptr<long[]> &&connectStorage)
{
    Element::initialize(id, type, std::move(connectStorage));
 
    _initialize(NULL_ID, -1, NULL_ID, -1);
}
 
void Interface::_initialize(long owner, long ownerFace, long neigh, long neighFace)
{
    m_owner     = owner;
    m_ownerFace = ownerFace;
 
    m_neigh     = neigh;
    m_neighFace = neighFace;
}
 
std::array<std::array<double, 3>, 3> Interface::evalRotationFromCartesian(std::array<double, 3> &versor)
{
    // The rotation matrix has in its rows the versors that define
    // the interface coordinate system.
    //
    //                | [x_int] |
    //          R =   | [y_int] |
    //                | [z_int] |
    //
    std::array<std::array<double, 3>, 3> R = {{{{0., 0., 0.}}, {{0., 0., 0.}}, {{0., 0., 0.}}}};
 
    // x-interface axis
    for (int k = 0; k < 3; ++k) {
        R[0][k] = versor[k];
    }
 
    // y-interface axis
    if (std::abs(std::abs(versor[2]) - 1.) > 1e-8) {
        std::array<double, 3> z = {{0.0, 0.0, 1.0}};
        R[1] = crossProduct(z, R[0]);
    } else {
        std::array<double, 3> x = {{1.0, 0.0, 0.0}};
        R[1] = crossProduct(x, R[0]);
    }
    R[1] = R[1] / norm2(R[1]);
 
    // z-interface axis
    R[2] = crossProduct(R[0], R[1]);
    R[2] = R[2] / norm2(R[2]);
 
    return R;
}
 
std::array<std::array<double, 3>, 3> Interface::evalRotationToCartesian(std::array<double, 3> &versor)
{
    return evalRotationInverse(evalRotationFromCartesian(versor));
}
 
std::array<std::array<double, 3>, 3> Interface::evalRotationInverse(const std::array<std::array<double, 3>, 3> &R)
{
    return evalRotationTranspose(R);
}
 
std::array<std::array<double, 3>, 3> Interface::evalRotationTranspose(const std::array<std::array<double, 3>, 3> &R)
{
    std::array<std::array<double, 3>, 3> R_transposed = {{{{0., 0., 0.}}, {{0., 0., 0.}}, {{0., 0., 0.}}}};
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            R_transposed[j][i] = R[i][j];
        }
    }
 
    return R_transposed;
}
 
bool Interface::isBorder() const
{
    return (m_neigh < 0);
}
 
void Interface::setOwner(long owner, int onwerFace)
{
    m_owner     = owner;
    m_ownerFace = onwerFace;
}
 
void Interface::unsetOwner()
{
    m_owner     = Element::NULL_ID;
    m_ownerFace = -1;
}
 
long Interface::getOwner() const
{
  return m_owner;
}
 
int Interface::getOwnerFace() const
{
  return m_ownerFace;
}
 
void Interface::setNeigh(long neigh, int neighFace)
{
    m_neigh     = neigh;
    m_neighFace = neighFace;
}
 
void Interface::unsetNeigh()
{
    m_neigh     = Element::NULL_ID;
    m_neighFace = -1;
}
 
long Interface::getNeigh() const
{
  return m_neigh;
}
 
int Interface::getNeighFace() const
{
  return m_neighFace;
}
 
std::array<long, 2> Interface::getOwnerNeigh() const
{
    return {{m_owner, m_neigh}};
}
 
void Interface::display(std::ostream &out, unsigned short int indent) const
{
    std::string t_s = std::string(indent, ' ');
 
    // If the type is unknown there are no information to display
    if (getType() == ElementType::UNDEFINED) {
        out << t_s << "interface type:    (unknown)" << std::endl;
        return;
    }
 
    // General info ----------------------------------------------------- //
    out << t_s << "interface type: " << getType() << std::endl;
    out << t_s << "ID:             " << getId() << std::endl;
    out << t_s << "is border:      ";
    if (getNeigh() >= 0)  { out << "(false)"; }
    else                  { out << "(true)"; }
    out << std::endl;
 
    // Connectivity infos --------------------------------------------------- //
    int nVertices = getVertexCount();
    ConstProxyVector<long> cellVertexIds = getVertexIds();
    out << t_s << "connectivity: [ ";
    for (int i = 0; i < nVertices - 1; ++i) {
        out << cellVertexIds[i] << ", ";
    } //next i
    out << cellVertexIds[nVertices - 1] << " ]" << std::endl;
 
    // Onwer infos ---------------------------------------------------------- //
    out << t_s << "onwer ID:    " << getOwner() << std::endl;
    out << t_s << "owner face:  " << getOwnerFace() << std::endl;
 
    // Onwer infos ---------------------------------------------------------- //
    if (getNeigh() >= 0) {
        out << t_s << "neighbour ID:    " << getNeigh() << std::endl;
        out << t_s << "neighbour face:  " << getNeighFace() << std::endl;
    }
}
 
// Explicit instantiation of the Interface containers
template class PiercedVector<Interface>;
 
template class QualifiedInterfaceHalfEdge<Interface>;
template class QualifiedInterfaceHalfEdge<const Interface>;
 
}