triangle_mesh.hpp

Go to the documentation of this file.

// OpenBEM - Copyright (C) 2026 Shashwat Sharma
 
// This file is part of OpenBEM.
 
// OpenBEM is free software: you can redistribute it and/or modify it under the terms of the
// GNU General Public License as published by the Free Software Foundation, either version 3
// of the License, or (at your option) any later version.
 
// You should have received a copy of the GNU General Public License along with OpenBEM.
// If not, see <https://www.gnu.org/licenses/>.
 
 
#ifndef GEOM_TRIANGLE_MESH_H
#define GEOM_TRIANGLE_MESH_H
 
#include "types.hpp"
#include "geometry/mesh/base.hpp"
#include "geometry/primitives/triangle.hpp"
 
 
namespace bem
{
 
template <uint8_t dim>
class TriangleMesh: public MeshBase<dim, 3>
{
 
    using base = MeshBase<dim, 3>;
 
    static_assert((dim == 2 || dim == 3), "TriangleMesh: `dim` must be 2 or 3.");
 
public:
 
    TriangleMesh() {};
 
 
    TriangleMesh(
        ConstEigRef<EigMatNX<Float, dim>> verts,
        ConstEigRef<EigMatNX<Index, 3>> elems,
        const bool decoupled_edges = false
        )
    {
        EigRowVec<Index> elem_tags = EigRowVec<Index>::Zero(1, elems.cols());
        set_data(verts, elems, elem_tags, decoupled_edges);
        return;
    };
 
 
    TriangleMesh(
        ConstEigRef<EigMatNX<Float, dim>> verts,
        ConstEigRef<EigMatNX<Index, 3>> elems,
        ConstEigRef<EigRowVec<Index>> elem_tags,
        const bool decoupled_edges = false
        )
    {
        set_data(verts, elems, elem_tags, decoupled_edges);
        return;
    };
 
 
    void set_data(
        ConstEigRef<EigMatNX<Float, dim>> verts,
        ConstEigRef<EigMatNX<Index, 3>> elems,
        ConstEigRef<EigRowVec<Index>> elem_tags,
        const bool decoupled_edges = false
        );
 
 
    const EigMatNX<Index, 2>& edges() const
    { return edges_; };
 
 
    EigColVecN<Index, 2> edges(Index idx) const
    { return edges_.col(idx); };
 
 
    Index edges(uint8_t vert, Index edge) const
    { return edges_(vert, edge); };
 
 
    const EigMatNX<Index, 3>& elem_edges() const
    { return elem_edges_; };
 
 
    EigColVecN<Index, 3> elem_edges(Index idx) const
    { return elem_edges_.col(idx); };
 
 
    Index elem_edges(uint8_t edge, Index elem) const
    { return elem_edges_(edge, elem); };
 
 
    const EigMatNX<Float, 3>& elem_edge_polarities() const
    { return elem_edge_polarities_; };
 
 
    EigColVecN<Float, 3> elem_edge_polarities(Index idx) const
    { return elem_edge_polarities_.col(idx); };
 
 
    Float elem_edge_polarities(uint8_t edge, Index elem) const
    { return elem_edge_polarities_(edge, elem); };
 
 
    const EigRowVec<Index>& boundary_elems() const
    { return boundary_elems_; };
 
 
    const EigRowVec<Index>& junction_elems() const
    { return junction_elems_; };
 
 
    const EigRowVec<Index>& internal_elems() const
    { return internal_elems_; };
 
 
    const EigRowVec<Index>& boundary_edges() const
    { return boundary_edges_; };
 
 
    const EigRowVec<Index>& junction_edges() const
    { return junction_edges_; };
 
 
    const EigRowVec<Index>& internal_edges() const
    { return internal_edges_; };
 
 
    Index num_edges() const
    { return edges_.cols(); };
 
 
    void partition_by_elems(
        MeshBase<dim, 3>& partition,
        ConstEigRef<EigRowVec<Index>> elem_inds
        ) const;
 
 
    void partition_by_bbox(
        MeshBase<dim, 3>& partition,
        ConstEigRef<EigMatMN<Float, dim, 2>> bbox,
        const bool strict = true
        ) const;
 
 
    Triangle<dim> elem_primitive(Index elem) const
    {
        return Triangle<dim> (
            base::verts()(Eigen::placeholders::all, base::elems(elem)),
            elem_edge_polarities(elem)
            );
    };
 
 
    virtual void reverse_orientation()
    {
        base::elems_ = base::elems_.colwise().reverse().eval();
        generate_edges();
        return;
    };
 
 
protected:
 
    void generate_edges();
 
 
    bool decoupled_edges_ = false;
 
    EigMatNX<Index, 2> edges_;
    EigMatNX<Index, 3> elem_edges_;
    EigMatNX<Float, 3> elem_edge_polarities_;
 
    EigRowVec<Index> boundary_elems_;
    EigRowVec<Index> junction_elems_;
    EigRowVec<Index> internal_elems_;
 
    EigRowVec<Index> boundary_edges_;
    EigRowVec<Index> junction_edges_;
    EigRowVec<Index> internal_edges_;
 
};
 
}
 
#ifndef BEM_LINKED
#include "geometry/mesh/triangle_mesh.cpp"
#endif
 
#endif