Rodin::Geometry namespace

Module for dealing with geometries.

Namespaces

namespace Euclidean
Module for dealing with Euclidean geometries.

Classes

class AttributeIndex
Manages attribute assignments for mesh polytopes.
class BalancedCompactPartitioner
Partitioner that creates balanced, spatially compact partitions.
class BoundedIndexGenerator
Index generator for a bounded range of indices.
class CCL
Connected component labeling result.
class Cell
Represents a cell (highest-dimensional element) in a mesh.
class CellIterator
Iterator over mesh cells (highest-dimensional polytopes).
template<class ContextType>
class Connectivity
Template for connectivity information.
template<>
class Connectivity<Context::Local>
Mesh connectivity for sequential (local) meshes.
class ConnectivityBase
Abstract base class for mesh connectivity.
template<class T>
class ContainerIndexGenerator
Index generator that wraps a container's iterators.
class EmptyIndexGenerator
Index generator that represents an empty sequence.
class Face
Represents a face (codimension-1 element) in a mesh.
class FaceIterator
Iterator over mesh faces (codimension-1 polytopes).
template<class T>
class GeometryIndexed
Template container indexed by polytope geometry types.
class GreedyPartitioner
Partitioner using a greedy algorithm.
class IdentityTransformation
Polytope identity transformation.
class IndexGeneratorBase
Abstract base class for index generators.
template<class FE>
class IsoparametricTransformation
Template for isoparametric transformations.
template<class Iterator>
class IteratorIndexGenerator
Index generator that wraps an iterator pair.
template<class ContextType = Context::Local>
class Mesh
Represents a polyhedral complex.
template<>
class Mesh<Context::Local>
Represents the subdivision of some domain into faces of (possibly) different geometries.
class MeshBase
Abstract base class for all mesh implementations.
class Partitioner
Abstract base class for mesh partitioning strategies.
class Point
Concrete implementation of a spatial point on a mesh.
class PointBase
Base class for spatial points on a discrete mesh.
class Polytope
Base class for all geometric elements in finite element meshes.
class PolytopeIterator
Iterator over general polytopes of specified dimension.
template<class T, class Derived>
class PolytopeIteratorBase
Base class template for polytope iterators.
class PolytopeTransformation
Abstract base class for polytope geometric transformations.
class PolytopeTransformationIndex
Thread-safe index for managing polytope transformations.
class SetIndexGenerator
Index generator backed by a set of indices.
class Shard
Advanced mesh shard for distributed parallel computing.
template<class Context>
class Sharder
Interface for mesh sharding algorithms.
template<>
class Sharder<Context::MPI>
Utility for distributing a global mesh across MPI ranks by splitting into per-rank shards, scattering them from a root, and gathering the local mesh on each rank.
template<class Context>
class SubMesh
Represents a subset of a Mesh.
template<>
class SubMesh<Context::Local>
SubMesh representing a subregion of a parent mesh.
class SubMeshBase
Abstract base class for SubMesh implementations.
template<class Context>
class SubMeshBuilder
Builder for constructing SubMesh objects.
class VectorIndexGenerator
Index generator backed by a vector of indices.
class Vertex
Represents a vertex (0-dimensional element) in a mesh.
class VertexIterator
Iterator over mesh vertices (0-dimensional polytopes).

Enums

enum class Region { Cells, Faces, Boundary, Interface }
Enumeration of standard mesh regions.

Typedefs

using SequentialConnectivity = Connectivity<Context::Local>
Type alias for sequential (non-distributed) connectivity.
using LocalMesh = Mesh<Context::Local>
Type alias for Mesh<Context::Local>
using Attribute = std::size_t
Standard type for representing material attributes in a mesh.
using Incidence = std::vector<std::vector<Index>>
Represents the incidence relation between polytopes.

Functions

template<class EigenDerived>
auto operator+(const Geometry::Point& p, const Eigen::MatrixBase<EigenDerived>& q) -> auto
Addition operator for Point and Eigen vector.
template<class EigenDerived>
auto operator+(const Eigen::MatrixBase<EigenDerived>& p, const Geometry::Point& q) -> auto
Addition operator for Eigen vector and Point.
template<class EigenDerived>
auto operator-(const Geometry::Point& p, const Eigen::MatrixBase<EigenDerived>& q) -> auto
Subtraction operator for Point and Eigen vector.
template<class EigenDerived>
auto operator-(const Eigen::MatrixBase<EigenDerived>& p, const Geometry::Point& q) -> auto
Subtraction operator for Eigen vector and Point.
auto operator+(const Geometry::Point& p, const Geometry::Point& q) -> auto
Addition operator for two Points.
auto operator-(const Geometry::Point& p, const Geometry::Point& q) -> auto
Subtraction operator for two Points.
auto operator*(Real s, const Geometry::Point& p) -> auto
Scalar multiplication (scalar * Point).
auto operator*(const Geometry::Point& p, Real s) -> auto
Scalar multiplication (Point * scalar).
auto operator<<(std::ostream& os, const Polytope::Type& p) -> std::ostream&
Stream output operator for polytope types.
auto operator==(const Polytope& lhs, const Polytope& rhs) -> bool
Equality comparison for polytopes.
auto operator<(const Polytope& lhs, const Polytope& rhs) -> bool
Less-than comparison for polytopes.

Enum documentation

enum class Rodin::Geometry::Region
#include <Rodin/Geometry/Region.h>

Enumeration of standard mesh regions.

This enumeration defines commonly used subregions of a mesh that can be referenced in variational formulations and boundary conditions.

Enumerators
Cells

Interior cells (elements) of the mesh.
Faces

All faces (d-1 dimensional polytopes) in the mesh.
Boundary

Boundary faces (faces incident to only one cell)
Interface

Interior faces (faces incident to two cells)

Typedef documentation

using Rodin::Geometry::SequentialConnectivity = Connectivity<Context::Local>
#include <Rodin/Geometry/Connectivity.h>

Type alias for sequential (non-distributed) connectivity.

using Rodin::Geometry::LocalMesh = Mesh<Context::Local>
#include <Rodin/Geometry/Mesh.h>

Type alias for Mesh<Context::Local>

using Rodin::Geometry::Attribute = std::size_t
#include <Rodin/Geometry/Types.h>

Standard type for representing material attributes in a mesh.

Attributes are used to mark different regions or materials in a mesh. For example, in a multi-material problem, each material region would have a distinct attribute value.

using Rodin::Geometry::Incidence = std::vector<std::vector<Index>>
#include <Rodin/Geometry/Types.h>

Represents the incidence relation between polytopes.

The incidence relation $ d \longrightarrow d' $ stores for each polytope of dimension $ d $ the indices of all incident polytopes of dimension $ d' $ .

Function documentation

#include <Rodin/Geometry/Point.h>
template<class EigenDerived>
auto Rodin::Geometry::operator+(const Geometry::Point& p, const Eigen::MatrixBase<EigenDerived>& q)

Addition operator for Point and Eigen vector.

Template parameters
EigenDerived Eigen vector type
Parameters
p in Point
q in Vector
Returns Result vector

#include <Rodin/Geometry/Point.h>
template<class EigenDerived>
auto Rodin::Geometry::operator+(const Eigen::MatrixBase<EigenDerived>& p, const Geometry::Point& q)

Addition operator for Eigen vector and Point.

Template parameters
EigenDerived Eigen vector type
Parameters
p in Vector
q in Point
Returns Result vector

#include <Rodin/Geometry/Point.h>
template<class EigenDerived>
auto Rodin::Geometry::operator-(const Geometry::Point& p, const Eigen::MatrixBase<EigenDerived>& q)

Subtraction operator for Point and Eigen vector.

Template parameters
EigenDerived Eigen vector type
Parameters
p in Point
q in Vector
Returns Result vector

#include <Rodin/Geometry/Point.h>
template<class EigenDerived>
auto Rodin::Geometry::operator-(const Eigen::MatrixBase<EigenDerived>& p, const Geometry::Point& q)

Subtraction operator for Eigen vector and Point.

Template parameters
EigenDerived Eigen vector type
Parameters
p in Vector
q in Point
Returns Result vector

auto Rodin::Geometry::operator+(const Geometry::Point& p, const Geometry::Point& q)
#include <Rodin/Geometry/Point.h>

Addition operator for two Points.

Parameters
p in First point
q in Second point
Returns Result vector (sum of physical coordinates)

auto Rodin::Geometry::operator-(const Geometry::Point& p, const Geometry::Point& q)
#include <Rodin/Geometry/Point.h>

Subtraction operator for two Points.

Parameters
p in First point
q in Second point
Returns Result vector (difference of physical coordinates)

auto Rodin::Geometry::operator*(Real s, const Geometry::Point& p)
#include <Rodin/Geometry/Point.h>

Scalar multiplication (scalar * Point).

Parameters
s in Scalar value
p in Point
Returns Scaled vector

auto Rodin::Geometry::operator*(const Geometry::Point& p, Real s)
#include <Rodin/Geometry/Point.h>

Scalar multiplication (Point * scalar).

Parameters
p in Point
s in Scalar value
Returns Scaled vector

std::ostream& Rodin::Geometry::operator<<(std::ostream& os, const Polytope::Type& p)
#include <Rodin/Geometry/Polytope.h>

Stream output operator for polytope types.

Parameters
os in/out Output stream
p in Polytope type to output
Returns Reference to the output stream

bool Rodin::Geometry::operator==(const Polytope& lhs, const Polytope& rhs)
#include <Rodin/Geometry/Polytope.h>

Equality comparison for polytopes.

Parameters
lhs in Left-hand side polytope
rhs in Right-hand side polytope
Returns True if polytopes are equal (same mesh, dimension, and index)

bool Rodin::Geometry::operator<(const Polytope& lhs, const Polytope& rhs)
#include <Rodin/Geometry/Polytope.h>

Less-than comparison for polytopes.

Parameters
lhs in Left-hand side polytope
rhs in Right-hand side polytope
Returns True if lhs < rhs (lexicographic order by dimension then index)