element.h

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
// Copyright (c) 2026, Liam Pohlmann
 
#ifndef HUMMINGBIRD_MESH_ELEMENT_H_
#define HUMMINGBIRD_MESH_ELEMENT_H_
 
#include <armadillo>
#include <memory>
#include <vector>
 
#include "banks/material_bank.h"
#include "node.h"
#include "physics/material.h"
#include "quadrature/angular/ordinate.h"
#include "quadrature/gauss_lobatto_legendre.h"
 
namespace hummingbird {
class Mesh;
class SourceBank;
 
/**
 * @brief Defines a subset of the domain (an "element")
 *
 */
class Element {
 public:
  /**
   * @brief Construct a new Element object
   *
   * @param material_id Material ID
   * @param source_id Source ID
   */
  Element(const int material_id, const int source_id);
 
  /**
   * @brief Destroy the Element object. Virtual because Element is used
   * polymorphically through std::unique_ptr<Element> (see Mesh::elements_).
   *
   */
  virtual ~Element() = default;
 
  /**
   * @brief Create nodes by mapping the Gauss-Lobatto-Legendre quadrature set
   * from the reference to the real domain
   *
   * @param existing_nodes Vector of nodes that already exist in the mesh.
   * Starting ID for new nodes will be equal to the number of nodes that already
   * exist to ensure no duplicates
   * @param gll_quadrature GaussLobattoLegendre quadrature set
   */
  virtual std::vector<Node> CreateInteriorNodes(
 
      const std::vector<Node>& existing_nodes,
      const GaussLobattoLegendre& gll_quadrature) = 0;
 
  /**
   * @brief Get node IDs
   *
   * @return std::vector<size_t>
   */
  std::vector<size_t> node_ids() const { return node_ids_; }
 
  /**
   * @brief Get Material ID
   *
   * @return int
   */
  int material_id() const { return material_id_; }
 
  /**
   * @brief Get Source ID
   *
   * @return int
   */
  int source_id() const { return source_id_; }
 
  /**
   * @brief Set the Material ID, e.g. once it has been resolved from a raw
   * gmsh tag to a MaterialBank-assigned ID (see Mesh::ResolveIDs)
   *
   * @param material_id Material ID
   */
  void SetMaterialID(const int material_id) { material_id_ = material_id; }
 
  /**
   * @brief Set the Source ID, e.g. once it has been resolved from a raw
   * gmsh tag to a SourceBank-assigned ID (see Mesh::ResolveIDs)
   *
   * @param source_id Source ID
   */
  void SetSourceID(const int source_id) { source_id_ = source_id; }
 
  /**
   * @brief Set the new Node ID
   *
   * @param prev_id Previous ID (currently stored in object)
   * @param new_id New ID
   */
  void SetNewNodeID(const size_t prev_id, const size_t new_id);
 
  /**
   * @brief Replace all node IDs at once, e.g. when renumbering. Unlike
   * SetNewNodeID, this does not search by value, so it is safe to use when
   * remapped IDs could otherwise collide with not-yet-remapped IDs.
   *
   * @param node_ids New node IDs, in the same order as the existing ones
   */
  void SetNodeIDs(std::vector<size_t> node_ids) {
    node_ids_ = std::move(node_ids);
  }
 
  /**
   * @brief Compute and set the source flux values on this element's nodes
   * using this element's material and source IDs
   *
   * @param mesh Mesh
   * @param material_bank Material bank
   * @param source_bank Source bank
   * @param angular_quadrature Angular quadrature set
   */
  void SetNodeSourceFluxes(Mesh& mesh, const MaterialBank& material_bank,
                           const SourceBank& source_bank,
                           const QuadratureBase<Ordinate>& angular_quadrature);
 
  /**
   * @brief Construct the local forcing vector for this element at a given
   * ordinate
   *
   * @param gll_quad GaussLobattoLegendre quadrature set
   * @param mesh Mesh
   * @param material_bank Material bank
   * @param ordinate Ordinate (direction)
   * @param ordinate_index Index of the ordinate in the angular quadrature
   * @return arma::Col<double>
   */
  virtual arma::Col<double> LocalForcingVector(
      const GaussLobattoLegendre& gll_quad, const Mesh& mesh,
      const MaterialBank& material_bank, const Ordinate& ordinate,
      const size_t ordinate_index) = 0;
 
  /**
   * @brief Construct the local stiffness matrix for this element at a given
   * ordinate
   *
   * @param gll_quad GaussLobattoLegendre quadrature set
   * @param material_bank Material bank
   * @param ordinate Ordinate (direction)
   * @return arma::Mat<double>
   */
  virtual arma::Mat<double> LocalStiffnessMatrix(
      const GaussLobattoLegendre& gll_quad, const MaterialBank& material_bank,
      const Ordinate& ordinate) = 0;
 
  /**
   * @brief Construct the local mass matrix for this element
   *
   * @param gll_quad GaussLobattoLegendre quadrature set
   * @param material_bank Material bank
   * @return arma::SpMat<double>
   */
  virtual arma::SpMat<double> LocalMassMatrix(
      const GaussLobattoLegendre& gll_quad,
      const MaterialBank& material_bank) = 0;
 
  /**
   * @brief Get the spatial dimension of this element type (e.g. 1 for a
   * line segment)
   *
   * @return unsigned int
   */
  virtual unsigned int dimension() const = 0;
 
 protected:
  /// @brief Material ID to access Material Bank. Auto initialized to -1. Value
  /// must be set to a positive value (including 0) to map into the MaterialBank
  int material_id_ = -1;
 
  /// @brief Source ID to access Source Bank. ID of 0 is always NONE, meaning
  /// the element has no external source.
  int source_id_ = 0;
 
  /// @brief IDs of nodes defining the element
  std::vector<size_t> node_ids_;
};
}  // namespace hummingbird
 
#endif  // HUMMINGBIRD_MESH_ELEMENT_H_