base.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_MESH_BASE_H
#define GEOM_MESH_BASE_H
 
#include <string>
 
#include "types.hpp"
 
 
namespace bem
{
 
template <uint8_t dim, uint8_t verts_per_elem>
class MeshBase
{
 
    static_assert((dim == 1 || dim == 2 || dim == 3), "MeshBase: `dim` must be 1, 2, or 3.");
 
public:
 
    const EigMatNX<Float, dim>& verts() const
    { return verts_; };
 
 
    EigColVecN<Float, dim> verts(Index vert) const
    { return verts_.col(vert); };
 
 
    const EigMatNX<Index, verts_per_elem>& elems() const
    { return elems_; };
 
 
    EigColVecN<Index, 3> elems(Index elem) const
    { return elems_.col(elem); };
 
 
    Index elems(uint8_t vert, Index elem) const
    { return elems_(vert, elem); };
 
 
    const EigRowVec<Index>& elem_tags() const
    { return elem_tags_; };
 
 
    Index elem_tags(Index elem) const
    { return elem_tags_[elem]; };
 
 
    Index num_verts() const
    { return verts_.cols(); };
 
 
    Index num_elems() const
    { return elems_.cols(); };
 
 
    virtual void partition_by_elems(
        MeshBase<dim, verts_per_elem>& partition,
        ConstEigRef<EigRowVec<Index>> elem_inds
        ) const = 0;
 
 
    EigMatNX<Float, dim> elem_centroids() const
    {
        EigMatNX<Float, dim> centroids = EigMatNX<Float, dim>::Zero(dim, elems_.cols());
        for (Index ii = 0; ii < elems_.cols(); ++ii)
        {
            EigMatMN<Float, dim, verts_per_elem> coords = verts_(
                Eigen::placeholders::all, elems_.col(ii)
                );
            centroids(Eigen::placeholders::all, ii) = coords.rowwise().mean();
        }
        return centroids;
    };
 
 
    virtual void reverse_orientation()
    {
        elems_ = elems_.colwise().reverse().eval();
        return;
    };
 
 
    virtual ~MeshBase() = default;
 
 
protected:
 
    EigMatNX<Float, dim> verts_;
    EigMatNX<Index, verts_per_elem> elems_;
    EigRowVec<Index> elem_tags_;
 
};
 
 
template <typename MeshType>
class MeshView
{
public:
 
    MeshView(
        const MeshType& mesh,
        ConstEigRef<EigRowVec<Index>> elem_inds,
        const std::string name = "view"
        ): mesh_(mesh), elem_inds_(elem_inds), name_(name) {};
 
 
    MeshView(
        const MeshType& mesh,
        const std::string name = "view"
        ): mesh_(mesh), name_(name)
    {
        elem_inds_ = EigRowVec<Index>::LinSpaced(mesh_.num_elems(), 0, mesh_.num_elems() - 1);
        return;
    };
 
 
    MeshType mesh() const
    {
        MeshType submesh;
        mesh_.partition_by_elems(submesh, elem_inds_);
        return submesh;
    };
 
 
    const EigRowVec<Index>& elem_inds() const { return elem_inds_; };
 
 
    const std::string& name() const { return name_; };
 
 
protected:
 
    const MeshType& mesh_;
    const EigRowVec<Index> elem_inds_;
    const std::string name_ = "view";
 
};
 
}
 
#endif