Modern API

The modern API is available through gmshparser.read() and gmshparser.api. It is immutable, tag-addressable, and intended for application code.

Top-level gmshparser.parse() continues to return the compatibility model. gmshparser.api.parse() is the modern alias.

Entry points

gmshparser.api.read(source, *, name=None)

Read a path or text stream into the modern API.

Top-level :func:gmshparser.parse intentionally retains the mutable compatibility API. Within :mod:gmshparser.api, :func:parse is an alias for this modern reader.

Source code in gmshparser/api.py

def read(
    source: str | os.PathLike[str] | TextIO,
    *,
    name: str | None = None,
) -> Mesh:
    """Read a path or text stream into the modern API.

    Top-level :func:`gmshparser.parse` intentionally retains the mutable
    compatibility API. Within :mod:`gmshparser.api`, :func:`parse` is an alias
    for this modern reader.
    """
    if hasattr(source, "read"):
        stream = cast(TextIO, source)
        mesh_name = name or str(getattr(stream, "name", "<stream>"))
        return _read_stream(stream, mesh_name)

    path = os.fspath(source)
    with open(path, encoding="utf-8") as stream:
        return _read_stream(stream, name or path)

gmshparser.api.parse(source, *, name=None)

Parse into the modern model inside the explicit gmshparser.api namespace.

Source code in gmshparser/api.py

def parse(
    source: str | os.PathLike[str] | TextIO,
    *,
    name: str | None = None,
) -> Mesh:
    """Parse into the modern model inside the explicit ``gmshparser.api`` namespace."""
    return read(source, name=name)

Key types

The module defines these tuple aliases:

type EntityKey = tuple[int, int]
type PhysicalGroupKey = tuple[int, int]
type PeriodicLinkKey = tuple[int, int]

Each key is (dimension, tag).

Mesh and metadata

gmshparser.api.Mesh dataclass

A read-only, Pythonic representation of a parsed Gmsh mesh.

Source code in gmshparser/api.py

@dataclass(frozen=True, slots=True)
class Mesh:
    """A read-only, Pythonic representation of a parsed Gmsh mesh."""

    name: str
    version: Version | None
    is_ascii: bool
    data_size: int
    nodes: NodeCollection
    elements: ElementCollection
    entities: EntityCollection
    physical_groups: PhysicalGroupCollection
    periodic_links: PeriodicLinkCollection = field(
        default_factory=lambda: PeriodicLinkCollection(())
    )

    @classmethod
    def from_legacy(cls, mesh: LegacyMesh) -> Mesh:
        """Build the modern model from the compatibility model."""
        nodes_by_entity: dict[EntityKey, list[Node]] = {}
        all_nodes: list[Node] = []

        for legacy_node_entity in mesh.get_node_entities():
            key = legacy_node_entity.get_dimension(), legacy_node_entity.get_tag()
            entity_nodes = nodes_by_entity.setdefault(key, [])

            for legacy_node in legacy_node_entity.get_nodes():
                raw_coordinates = tuple(legacy_node.get_coordinates())
                if len(raw_coordinates) < 3:
                    raise ValueError(
                        f"Node {legacy_node.get_tag()} has fewer than three coordinates"
                    )

                node = Node(
                    tag=legacy_node.get_tag(),
                    coordinates=cast(
                        tuple[float, float, float],
                        raw_coordinates[:3],
                    ),
                    dimension=key[0],
                    entity_tag=key[1],
                    parametric_coordinates=raw_coordinates[3:],
                    physical_tags=mesh.get_entity_physical_tags(*key),
                )
                entity_nodes.append(node)
                all_nodes.append(node)

        nodes = NodeCollection(all_nodes)
        elements_by_entity: dict[EntityKey, list[Element]] = {}
        all_elements: list[Element] = []

        for legacy_element_entity in mesh.get_element_entities():
            key = (
                legacy_element_entity.get_dimension(),
                legacy_element_entity.get_tag(),
            )
            entity_element_values = elements_by_entity.setdefault(key, [])
            element_type = ElementType(legacy_element_entity.get_element_type())
            entity_physical_tags = mesh.get_entity_physical_tags(*key)

            for legacy_element in legacy_element_entity.get_elements():
                element_nodes: list[Node] = []
                for node_tag in legacy_element.get_connectivity():
                    resolved_node = nodes.get(node_tag)
                    if resolved_node is None:
                        raise ValueError(
                            f"Element {legacy_element.get_tag()} references "
                            f"unknown node {node_tag}"
                        )
                    element_nodes.append(resolved_node)

                element_physical_tags = mesh.get_element_physical_tags(
                    legacy_element.get_tag()
                )
                if not element_physical_tags:
                    element_physical_tags = entity_physical_tags

                element = Element(
                    tag=legacy_element.get_tag(),
                    element_type=element_type,
                    nodes=tuple(element_nodes),
                    dimension=key[0],
                    entity_tag=key[1],
                    physical_tags=element_physical_tags,
                )
                entity_element_values.append(element)
                all_elements.append(element)

        elements = ElementCollection(all_elements)
        entity_keys = dict.fromkeys(
            [
                *mesh.get_entity_physical_assignments(),
                *nodes_by_entity,
                *elements_by_entity,
            ]
        )
        entity_values: list[Entity] = []

        for dimension, tag in entity_keys:
            key = dimension, tag
            entity_elements = ElementCollection(elements_by_entity.get(key, ()))
            physical_tags = list(mesh.get_entity_physical_tags(*key))
            for element in entity_elements:
                for physical_tag in element.physical_tags:
                    if physical_tag not in physical_tags:
                        physical_tags.append(physical_tag)

            entity_values.append(
                Entity(
                    dimension=dimension,
                    tag=tag,
                    nodes=NodeCollection(nodes_by_entity.get(key, ())),
                    elements=entity_elements,
                    physical_tags=tuple(physical_tags),
                )
            )

        entities = EntityCollection(entity_values)
        physical_names = mesh.get_physical_names()
        physical_keys = dict.fromkeys(physical_names)

        for entity in entities:
            for physical_tag in entity.physical_tags:
                physical_keys.setdefault((entity.dimension, physical_tag), None)
        for element in elements:
            for physical_tag in element.physical_tags:
                physical_keys.setdefault((element.dimension, physical_tag), None)

        physical_group_values: list[PhysicalGroup] = []
        for dimension, physical_tag in physical_keys:
            group_entities = entities.where(
                dimension=dimension,
                physical_tag=physical_tag,
            )
            group_elements = elements.where(
                dimension=dimension,
                physical_tag=physical_tag,
            )
            node_tags = {node.tag for entity in group_entities for node in entity.nodes}
            node_tags.update(
                node.tag for element in group_elements for node in element.nodes
            )
            physical_group_values.append(
                PhysicalGroup(
                    dimension=dimension,
                    tag=physical_tag,
                    name=physical_names.get((dimension, physical_tag)),
                    entities=group_entities,
                    elements=group_elements,
                    nodes=NodeCollection(
                        node for node in nodes if node.tag in node_tags
                    ),
                )
            )

        physical_groups = PhysicalGroupCollection(physical_group_values)

        periodic_links = PeriodicLinkCollection(
            PeriodicLink(
                dimension=dimension,
                entity_tag=entity_tag,
                master_entity_tag=master_entity_tag,
                affine_transform=affine_transform,
                node_pairs=node_pairs,
            )
            for (
                dimension,
                entity_tag,
                master_entity_tag,
                affine_transform,
                node_pairs,
            ) in mesh.get_periodic_links()
        )

        major = mesh.get_version_major()
        minor = mesh.get_version_minor()
        version = None if major is None or minor is None else Version(major, minor)

        return cls(
            name=mesh.get_name(),
            version=version,
            is_ascii=mesh.get_ascii(),
            data_size=mesh.get_precision(),
            nodes=nodes,
            elements=elements,
            entities=entities,
            physical_groups=physical_groups,
            periodic_links=periodic_links,
        )

    def entity(self, dimension: int, tag: int) -> Entity:
        """Return one elementary entity without constructing a tuple key."""
        return self.entities[(dimension, tag)]

    def physical_group(
        self,
        name_or_tag: str | int,
        *,
        dimension: int | None = None,
    ) -> PhysicalGroup:
        """Return a physical group by name or by tag and dimension."""
        if isinstance(name_or_tag, str):
            return self.physical_groups[name_or_tag]
        if dimension is None:
            matches = [
                group for group in self.physical_groups if group.tag == name_or_tag
            ]
            if len(matches) == 1:
                return matches[0]
            if not matches:
                raise KeyError(name_or_tag)
            raise KeyError(
                f"Physical tag {name_or_tag} exists in multiple dimensions; "
                "provide dimension="
            )
        return self.physical_groups[(dimension, name_or_tag)]

    def periodic_link(self, dimension: int, tag: int) -> PeriodicLink:
        """Return the periodic relation for one slave entity."""
        return self.periodic_links[(dimension, tag)]

    @property
    def points(self) -> EntityCollection:
        """Zero-dimensional entities."""
        return self.entities.by_dimension(0)

    @property
    def curves(self) -> EntityCollection:
        """One-dimensional entities."""
        return self.entities.by_dimension(1)

    @property
    def surfaces(self) -> EntityCollection:
        """Two-dimensional entities."""
        return self.entities.by_dimension(2)

    @property
    def volumes(self) -> EntityCollection:
        """Three-dimensional entities."""
        return self.entities.by_dimension(3)

    @property
    def dimension(self) -> int | None:
        """Highest entity dimension present in the mesh."""
        dimensions = [entity.dimension for entity in self.entities]
        return max(dimensions, default=None)

    @property
    def element_types(self) -> frozenset[ElementType]:
        """Element types present in the mesh."""
        return self.elements.types

    @property
    def bounds(
        self,
    ) -> tuple[tuple[float, float, float], tuple[float, float, float]] | None:
        """Axis-aligned ``(minimum, maximum)`` Cartesian coordinates."""
        if not self.nodes:
            return None

        coordinates = self.nodes.coordinates
        minimum = tuple(min(axis) for axis in zip(*coordinates, strict=True))
        maximum = tuple(max(axis) for axis in zip(*coordinates, strict=True))
        return cast(
            tuple[tuple[float, float, float], tuple[float, float, float]],
            (minimum, maximum),
        )

    def __repr__(self) -> str:
        version = None if self.version is None else str(self.version)
        return (
            f"Mesh(name={self.name!r}, version={version!r}, "
            f"nodes={len(self.nodes)}, elements={len(self.elements)}, "
            f"physical_groups={len(self.physical_groups)}, "
            f"periodic_links={len(self.periodic_links)})"
        )

    __str__ = __repr__

__str__ = __repr__ class-attribute instance-attribute

bounds property

Axis-aligned (minimum, maximum) Cartesian coordinates.

curves property

One-dimensional entities.

data_size instance-attribute

dimension property

Highest entity dimension present in the mesh.

element_types property

Element types present in the mesh.

elements instance-attribute

entities instance-attribute

is_ascii instance-attribute

name instance-attribute

nodes instance-attribute

periodic_links = field(default_factory=(lambda: PeriodicLinkCollection(()))) class-attribute instance-attribute

physical_groups instance-attribute

points property

Zero-dimensional entities.

surfaces property

Two-dimensional entities.

version instance-attribute

volumes property

Three-dimensional entities.

__init__(name, version, is_ascii, data_size, nodes, elements, entities, physical_groups, periodic_links=(lambda: PeriodicLinkCollection(()))())

__repr__()

Source code in gmshparser/api.py

def __repr__(self) -> str:
    version = None if self.version is None else str(self.version)
    return (
        f"Mesh(name={self.name!r}, version={version!r}, "
        f"nodes={len(self.nodes)}, elements={len(self.elements)}, "
        f"physical_groups={len(self.physical_groups)}, "
        f"periodic_links={len(self.periodic_links)})"
    )

entity(dimension, tag)

Return one elementary entity without constructing a tuple key.

Source code in gmshparser/api.py

def entity(self, dimension: int, tag: int) -> Entity:
    """Return one elementary entity without constructing a tuple key."""
    return self.entities[(dimension, tag)]

from_legacy(mesh) classmethod

Build the modern model from the compatibility model.

Source code in gmshparser/api.py

@classmethod
def from_legacy(cls, mesh: LegacyMesh) -> Mesh:
    """Build the modern model from the compatibility model."""
    nodes_by_entity: dict[EntityKey, list[Node]] = {}
    all_nodes: list[Node] = []

    for legacy_node_entity in mesh.get_node_entities():
        key = legacy_node_entity.get_dimension(), legacy_node_entity.get_tag()
        entity_nodes = nodes_by_entity.setdefault(key, [])

        for legacy_node in legacy_node_entity.get_nodes():
            raw_coordinates = tuple(legacy_node.get_coordinates())
            if len(raw_coordinates) < 3:
                raise ValueError(
                    f"Node {legacy_node.get_tag()} has fewer than three coordinates"
                )

            node = Node(
                tag=legacy_node.get_tag(),
                coordinates=cast(
                    tuple[float, float, float],
                    raw_coordinates[:3],
                ),
                dimension=key[0],
                entity_tag=key[1],
                parametric_coordinates=raw_coordinates[3:],
                physical_tags=mesh.get_entity_physical_tags(*key),
            )
            entity_nodes.append(node)
            all_nodes.append(node)

    nodes = NodeCollection(all_nodes)
    elements_by_entity: dict[EntityKey, list[Element]] = {}
    all_elements: list[Element] = []

    for legacy_element_entity in mesh.get_element_entities():
        key = (
            legacy_element_entity.get_dimension(),
            legacy_element_entity.get_tag(),
        )
        entity_element_values = elements_by_entity.setdefault(key, [])
        element_type = ElementType(legacy_element_entity.get_element_type())
        entity_physical_tags = mesh.get_entity_physical_tags(*key)

        for legacy_element in legacy_element_entity.get_elements():
            element_nodes: list[Node] = []
            for node_tag in legacy_element.get_connectivity():
                resolved_node = nodes.get(node_tag)
                if resolved_node is None:
                    raise ValueError(
                        f"Element {legacy_element.get_tag()} references "
                        f"unknown node {node_tag}"
                    )
                element_nodes.append(resolved_node)

            element_physical_tags = mesh.get_element_physical_tags(
                legacy_element.get_tag()
            )
            if not element_physical_tags:
                element_physical_tags = entity_physical_tags

            element = Element(
                tag=legacy_element.get_tag(),
                element_type=element_type,
                nodes=tuple(element_nodes),
                dimension=key[0],
                entity_tag=key[1],
                physical_tags=element_physical_tags,
            )
            entity_element_values.append(element)
            all_elements.append(element)

    elements = ElementCollection(all_elements)
    entity_keys = dict.fromkeys(
        [
            *mesh.get_entity_physical_assignments(),
            *nodes_by_entity,
            *elements_by_entity,
        ]
    )
    entity_values: list[Entity] = []

    for dimension, tag in entity_keys:
        key = dimension, tag
        entity_elements = ElementCollection(elements_by_entity.get(key, ()))
        physical_tags = list(mesh.get_entity_physical_tags(*key))
        for element in entity_elements:
            for physical_tag in element.physical_tags:
                if physical_tag not in physical_tags:
                    physical_tags.append(physical_tag)

        entity_values.append(
            Entity(
                dimension=dimension,
                tag=tag,
                nodes=NodeCollection(nodes_by_entity.get(key, ())),
                elements=entity_elements,
                physical_tags=tuple(physical_tags),
            )
        )

    entities = EntityCollection(entity_values)
    physical_names = mesh.get_physical_names()
    physical_keys = dict.fromkeys(physical_names)

    for entity in entities:
        for physical_tag in entity.physical_tags:
            physical_keys.setdefault((entity.dimension, physical_tag), None)
    for element in elements:
        for physical_tag in element.physical_tags:
            physical_keys.setdefault((element.dimension, physical_tag), None)

    physical_group_values: list[PhysicalGroup] = []
    for dimension, physical_tag in physical_keys:
        group_entities = entities.where(
            dimension=dimension,
            physical_tag=physical_tag,
        )
        group_elements = elements.where(
            dimension=dimension,
            physical_tag=physical_tag,
        )
        node_tags = {node.tag for entity in group_entities for node in entity.nodes}
        node_tags.update(
            node.tag for element in group_elements for node in element.nodes
        )
        physical_group_values.append(
            PhysicalGroup(
                dimension=dimension,
                tag=physical_tag,
                name=physical_names.get((dimension, physical_tag)),
                entities=group_entities,
                elements=group_elements,
                nodes=NodeCollection(
                    node for node in nodes if node.tag in node_tags
                ),
            )
        )

    physical_groups = PhysicalGroupCollection(physical_group_values)

    periodic_links = PeriodicLinkCollection(
        PeriodicLink(
            dimension=dimension,
            entity_tag=entity_tag,
            master_entity_tag=master_entity_tag,
            affine_transform=affine_transform,
            node_pairs=node_pairs,
        )
        for (
            dimension,
            entity_tag,
            master_entity_tag,
            affine_transform,
            node_pairs,
        ) in mesh.get_periodic_links()
    )

    major = mesh.get_version_major()
    minor = mesh.get_version_minor()
    version = None if major is None or minor is None else Version(major, minor)

    return cls(
        name=mesh.get_name(),
        version=version,
        is_ascii=mesh.get_ascii(),
        data_size=mesh.get_precision(),
        nodes=nodes,
        elements=elements,
        entities=entities,
        physical_groups=physical_groups,
        periodic_links=periodic_links,
    )

periodic_link(dimension, tag)

Return the periodic relation for one slave entity.

Source code in gmshparser/api.py

def periodic_link(self, dimension: int, tag: int) -> PeriodicLink:
    """Return the periodic relation for one slave entity."""
    return self.periodic_links[(dimension, tag)]

physical_group(name_or_tag, *, dimension=None)

Return a physical group by name or by tag and dimension.

Source code in gmshparser/api.py

def physical_group(
    self,
    name_or_tag: str | int,
    *,
    dimension: int | None = None,
) -> PhysicalGroup:
    """Return a physical group by name or by tag and dimension."""
    if isinstance(name_or_tag, str):
        return self.physical_groups[name_or_tag]
    if dimension is None:
        matches = [
            group for group in self.physical_groups if group.tag == name_or_tag
        ]
        if len(matches) == 1:
            return matches[0]
        if not matches:
            raise KeyError(name_or_tag)
        raise KeyError(
            f"Physical tag {name_or_tag} exists in multiple dimensions; "
            "provide dimension="
        )
    return self.physical_groups[(dimension, name_or_tag)]

Mesh.from_legacy() explicitly converts an existing compatibility mesh. Normal new code should call read() directly.

gmshparser.api.Version dataclass

A semantic MSH format version such as 4.1.

Source code in gmshparser/api.py

@dataclass(frozen=True, order=True, slots=True)
class Version:
    """A semantic MSH format version such as ``4.1``."""

    major: int
    minor: int

    def __str__(self) -> str:
        return f"{self.major}.{self.minor}"

    def __float__(self) -> float:
        return float(str(self))

major instance-attribute

minor instance-attribute

__float__()

Source code in gmshparser/api.py

def __float__(self) -> float:
    return float(str(self))

__init__(major, minor)

__str__()

Source code in gmshparser/api.py

def __str__(self) -> str:
    return f"{self.major}.{self.minor}"

Element topology

gmshparser.api.ElementType

Bases: IntEnum

Numeric element types from the Gmsh MSH specification.

Unknown numeric values remain representable as TYPE_<id> pseudo-members. Their topology metadata is None and parsers reject them when metadata is required to interpret a flat element record.

Source code in gmshparser/element_types.py

class ElementType(IntEnum):
    """Numeric element types from the Gmsh MSH specification.

    Unknown numeric values remain representable as ``TYPE_<id>`` pseudo-members.
    Their topology metadata is ``None`` and parsers reject them when metadata is
    required to interpret a flat element record.
    """

    LINE = 1
    TRIANGLE = 2
    QUADRANGLE = 3
    TETRAHEDRON = 4
    HEXAHEDRON = 5
    PRISM = 6
    PYRAMID = 7
    SECOND_ORDER_LINE = 8
    SECOND_ORDER_TRIANGLE = 9
    SECOND_ORDER_QUADRANGLE = 10
    SECOND_ORDER_TETRAHEDRON = 11
    SECOND_ORDER_HEXAHEDRON = 12
    SECOND_ORDER_PRISM = 13
    SECOND_ORDER_PYRAMID = 14
    POINT = 15
    SECOND_ORDER_QUADRANGLE_INCOMPLETE = 16
    SECOND_ORDER_HEXAHEDRON_INCOMPLETE = 17
    SECOND_ORDER_PRISM_INCOMPLETE = 18
    SECOND_ORDER_PYRAMID_INCOMPLETE = 19
    THIRD_ORDER_TRIANGLE_INCOMPLETE = 20
    THIRD_ORDER_TRIANGLE = 21
    FOURTH_ORDER_TRIANGLE_INCOMPLETE = 22
    FOURTH_ORDER_TRIANGLE = 23
    FIFTH_ORDER_TRIANGLE_INCOMPLETE = 24
    FIFTH_ORDER_TRIANGLE = 25
    THIRD_ORDER_LINE = 26
    FOURTH_ORDER_LINE = 27
    FIFTH_ORDER_LINE = 28
    THIRD_ORDER_TETRAHEDRON = 29
    FOURTH_ORDER_TETRAHEDRON = 30
    FIFTH_ORDER_TETRAHEDRON = 31
    THIRD_ORDER_HEXAHEDRON = 92
    FOURTH_ORDER_HEXAHEDRON = 93

    @classmethod
    def _missing_(cls, value: object) -> ElementType | None:
        if not isinstance(value, int):
            return None

        member = int.__new__(cls, value)
        member._name_ = f"TYPE_{value}"
        member._value_ = value
        cls._value2member_map_[value] = member
        return member

    @property
    def info(self) -> ElementTypeInfo | None:
        """Registered topology metadata, or ``None`` for an unknown type."""
        return _ELEMENT_TYPE_INFO.get(int(self))

    @property
    def is_known(self) -> bool:
        """Whether topology metadata is registered for this numeric type."""
        return self.info is not None

    @property
    def family(self) -> ElementFamily | None:
        """Topological family, or ``None`` for an unknown type."""
        return None if self.info is None else self.info.family

    @property
    def dimension(self) -> int | None:
        """Topological dimension, or ``None`` for an unknown type."""
        return None if self.info is None else self.info.dimension

    @property
    def order(self) -> int | None:
        """Polynomial order, or ``None`` for an unknown type."""
        return None if self.info is None else self.info.order

    @property
    def node_count(self) -> int | None:
        """Required number of nodes, or ``None`` for an unknown type."""
        return None if self.info is None else self.info.node_count

    @property
    def primary_node_count(self) -> int | None:
        """Number of first-order corner nodes, or ``None`` when unknown."""
        return None if self.info is None else self.info.primary_node_count

    @property
    def is_complete(self) -> bool | None:
        """Whether all interior high-order nodes are present, or ``None``."""
        return None if self.info is None else self.info.complete

    @property
    def is_linear(self) -> bool:
        """Whether this is a registered first-order element."""
        return self.info is not None and self.info.is_linear

    @property
    def is_high_order(self) -> bool:
        """Whether this is a registered second- or higher-order element."""
        return self.info is not None and self.info.is_high_order

FIFTH_ORDER_LINE = 28 class-attribute instance-attribute

FIFTH_ORDER_TETRAHEDRON = 31 class-attribute instance-attribute

FIFTH_ORDER_TRIANGLE = 25 class-attribute instance-attribute

FIFTH_ORDER_TRIANGLE_INCOMPLETE = 24 class-attribute instance-attribute

FOURTH_ORDER_HEXAHEDRON = 93 class-attribute instance-attribute

FOURTH_ORDER_LINE = 27 class-attribute instance-attribute

FOURTH_ORDER_TETRAHEDRON = 30 class-attribute instance-attribute

FOURTH_ORDER_TRIANGLE = 23 class-attribute instance-attribute

FOURTH_ORDER_TRIANGLE_INCOMPLETE = 22 class-attribute instance-attribute

HEXAHEDRON = 5 class-attribute instance-attribute

LINE = 1 class-attribute instance-attribute

POINT = 15 class-attribute instance-attribute

PRISM = 6 class-attribute instance-attribute

PYRAMID = 7 class-attribute instance-attribute

QUADRANGLE = 3 class-attribute instance-attribute

SECOND_ORDER_HEXAHEDRON = 12 class-attribute instance-attribute

SECOND_ORDER_HEXAHEDRON_INCOMPLETE = 17 class-attribute instance-attribute

SECOND_ORDER_LINE = 8 class-attribute instance-attribute

SECOND_ORDER_PRISM = 13 class-attribute instance-attribute

SECOND_ORDER_PRISM_INCOMPLETE = 18 class-attribute instance-attribute

SECOND_ORDER_PYRAMID = 14 class-attribute instance-attribute

SECOND_ORDER_PYRAMID_INCOMPLETE = 19 class-attribute instance-attribute

SECOND_ORDER_QUADRANGLE = 10 class-attribute instance-attribute

SECOND_ORDER_QUADRANGLE_INCOMPLETE = 16 class-attribute instance-attribute

SECOND_ORDER_TETRAHEDRON = 11 class-attribute instance-attribute

SECOND_ORDER_TRIANGLE = 9 class-attribute instance-attribute

TETRAHEDRON = 4 class-attribute instance-attribute

THIRD_ORDER_HEXAHEDRON = 92 class-attribute instance-attribute

THIRD_ORDER_LINE = 26 class-attribute instance-attribute

THIRD_ORDER_TETRAHEDRON = 29 class-attribute instance-attribute

THIRD_ORDER_TRIANGLE = 21 class-attribute instance-attribute

THIRD_ORDER_TRIANGLE_INCOMPLETE = 20 class-attribute instance-attribute

TRIANGLE = 2 class-attribute instance-attribute

dimension property

Topological dimension, or None for an unknown type.

family property

Topological family, or None for an unknown type.

info property

Registered topology metadata, or None for an unknown type.

is_complete property

Whether all interior high-order nodes are present, or None.

is_high_order property

Whether this is a registered second- or higher-order element.

is_known property

Whether topology metadata is registered for this numeric type.

is_linear property

Whether this is a registered first-order element.

node_count property

Required number of nodes, or None for an unknown type.

order property

Polynomial order, or None for an unknown type.

primary_node_count property

Number of first-order corner nodes, or None when unknown.

_missing_(value) classmethod

Source code in gmshparser/element_types.py

@classmethod
def _missing_(cls, value: object) -> ElementType | None:
    if not isinstance(value, int):
        return None

    member = int.__new__(cls, value)
    member._name_ = f"TYPE_{value}"
    member._value_ = value
    cls._value2member_map_[value] = member
    return member

gmshparser.api.ElementFamily

Bases: StrEnum

Topological family of a Gmsh element.

Source code in gmshparser/element_types.py

class ElementFamily(StrEnum):
    """Topological family of a Gmsh element."""

    POINT = "point"
    LINE = "line"
    TRIANGLE = "triangle"
    QUADRANGLE = "quadrangle"
    TETRAHEDRON = "tetrahedron"
    HEXAHEDRON = "hexahedron"
    PRISM = "prism"
    PYRAMID = "pyramid"

HEXAHEDRON = 'hexahedron' class-attribute instance-attribute

LINE = 'line' class-attribute instance-attribute

POINT = 'point' class-attribute instance-attribute

PRISM = 'prism' class-attribute instance-attribute

PYRAMID = 'pyramid' class-attribute instance-attribute

QUADRANGLE = 'quadrangle' class-attribute instance-attribute

TETRAHEDRON = 'tetrahedron' class-attribute instance-attribute

TRIANGLE = 'triangle' class-attribute instance-attribute

gmshparser.api.ElementTypeInfo dataclass

Static topology metadata for one numeric Gmsh element type.

Source code in gmshparser/element_types.py

@dataclass(frozen=True, slots=True)
class ElementTypeInfo:
    """Static topology metadata for one numeric Gmsh element type."""

    name: str
    family: ElementFamily
    dimension: int
    order: int
    node_count: int
    primary_node_count: int
    complete: bool = True

    @property
    def is_linear(self) -> bool:
        """Whether this is a first-order element."""
        return self.order == 1

    @property
    def is_high_order(self) -> bool:
        """Whether this is a second- or higher-order element."""
        return self.order > 1

complete = True class-attribute instance-attribute

dimension instance-attribute

family instance-attribute

is_high_order property

Whether this is a second- or higher-order element.

is_linear property

Whether this is a first-order element.

name instance-attribute

node_count instance-attribute

order instance-attribute

primary_node_count instance-attribute

__init__(name, family, dimension, order, node_count, primary_node_count, complete=True)

ElementType is an IntEnum: known Gmsh IDs have descriptive names, while unknown numeric IDs remain representable as TYPE_<id> pseudo-members. Topology metadata is None for unknown values.

Collections

All modern collections preserve parser order. Node and element collections index by original Gmsh tag. Entity, physical-group, and periodic-link collections use (dimension, tag) keys.

gmshparser.api.NodeCollection

Bases: _TaggedCollection[Node]

All nodes in a mesh, entity, physical group, or filtered selection.

Source code in gmshparser/api.py

class NodeCollection(_TaggedCollection[Node]):
    """All nodes in a mesh, entity, physical group, or filtered selection."""

    def where(
        self,
        *,
        dimension: int | None = None,
        entity_tag: int | None = None,
        entity: EntityKey | None = None,
        parametric: bool | None = None,
        physical_tag: int | None = None,
    ) -> NodeCollection:
        """Return nodes matching the supplied metadata."""
        if entity is not None:
            dimension, entity_tag = entity

        return NodeCollection(
            node
            for node in self
            if (dimension is None or node.dimension == dimension)
            and (entity_tag is None or node.entity_tag == entity_tag)
            and (parametric is None or node.is_parametric is parametric)
            and (physical_tag is None or physical_tag in node.physical_tags)
        )

    def by_entity(self, dimension: int, tag: int) -> NodeCollection:
        """Return nodes owned by one elementary entity."""
        return self.where(entity=(dimension, tag))

    @property
    def coordinates(self) -> tuple[tuple[float, float, float], ...]:
        """Cartesian coordinates in collection order."""
        return tuple(node.coordinates for node in self)

coordinates property

Cartesian coordinates in collection order.

by_entity(dimension, tag)

Return nodes owned by one elementary entity.

Source code in gmshparser/api.py

def by_entity(self, dimension: int, tag: int) -> NodeCollection:
    """Return nodes owned by one elementary entity."""
    return self.where(entity=(dimension, tag))

where(*, dimension=None, entity_tag=None, entity=None, parametric=None, physical_tag=None)

Return nodes matching the supplied metadata.

Source code in gmshparser/api.py

def where(
    self,
    *,
    dimension: int | None = None,
    entity_tag: int | None = None,
    entity: EntityKey | None = None,
    parametric: bool | None = None,
    physical_tag: int | None = None,
) -> NodeCollection:
    """Return nodes matching the supplied metadata."""
    if entity is not None:
        dimension, entity_tag = entity

    return NodeCollection(
        node
        for node in self
        if (dimension is None or node.dimension == dimension)
        and (entity_tag is None or node.entity_tag == entity_tag)
        and (parametric is None or node.is_parametric is parametric)
        and (physical_tag is None or physical_tag in node.physical_tags)
    )

gmshparser.api.ElementCollection

Bases: _TaggedCollection[Element]

All elements in a mesh, entity, physical group, or filtered selection.

Source code in gmshparser/api.py

class ElementCollection(_TaggedCollection[Element]):
    """All elements in a mesh, entity, physical group, or filtered selection."""

    def where(
        self,
        *,
        element_type: ElementType | int | None = None,
        dimension: int | None = None,
        entity_tag: int | None = None,
        entity: EntityKey | None = None,
        physical_tag: int | None = None,
    ) -> ElementCollection:
        """Return elements matching the supplied metadata."""
        if entity is not None:
            dimension, entity_tag = entity
        wanted_type = None if element_type is None else ElementType(element_type)

        return ElementCollection(
            element
            for element in self
            if (wanted_type is None or element.element_type is wanted_type)
            and (dimension is None or element.dimension == dimension)
            and (entity_tag is None or element.entity_tag == entity_tag)
            and (physical_tag is None or physical_tag in element.physical_tags)
        )

    def by_type(self, element_type: ElementType | int) -> ElementCollection:
        """Return elements with one Gmsh element type."""
        return self.where(element_type=element_type)

    def by_entity(self, dimension: int, tag: int) -> ElementCollection:
        """Return elements owned by one elementary entity."""
        return self.where(entity=(dimension, tag))

    @property
    def types(self) -> frozenset[ElementType]:
        """Element types present in the collection."""
        return frozenset(element.element_type for element in self)

types property

Element types present in the collection.

by_entity(dimension, tag)

Return elements owned by one elementary entity.

Source code in gmshparser/api.py

def by_entity(self, dimension: int, tag: int) -> ElementCollection:
    """Return elements owned by one elementary entity."""
    return self.where(entity=(dimension, tag))

by_type(element_type)

Return elements with one Gmsh element type.

Source code in gmshparser/api.py

def by_type(self, element_type: ElementType | int) -> ElementCollection:
    """Return elements with one Gmsh element type."""
    return self.where(element_type=element_type)

where(*, element_type=None, dimension=None, entity_tag=None, entity=None, physical_tag=None)

Return elements matching the supplied metadata.

Source code in gmshparser/api.py

def where(
    self,
    *,
    element_type: ElementType | int | None = None,
    dimension: int | None = None,
    entity_tag: int | None = None,
    entity: EntityKey | None = None,
    physical_tag: int | None = None,
) -> ElementCollection:
    """Return elements matching the supplied metadata."""
    if entity is not None:
        dimension, entity_tag = entity
    wanted_type = None if element_type is None else ElementType(element_type)

    return ElementCollection(
        element
        for element in self
        if (wanted_type is None or element.element_type is wanted_type)
        and (dimension is None or element.dimension == dimension)
        and (entity_tag is None or element.entity_tag == entity_tag)
        and (physical_tag is None or physical_tag in element.physical_tags)
    )

gmshparser.api.EntityCollection

Immutable entities keyed by (dimension, tag).

Source code in gmshparser/api.py

class EntityCollection:
    """Immutable entities keyed by ``(dimension, tag)``."""

    __slots__ = ("_items", "_by_key")

    def __init__(self, items: Iterable[Entity]):
        self._items = tuple(items)
        self._by_key = {entity.key: entity for entity in self._items}
        if len(self._by_key) != len(self._items):
            raise ValueError("Entity keys must be unique")

    def __iter__(self) -> Iterator[Entity]:
        return iter(self._items)

    def __len__(self) -> int:
        return len(self._items)

    def __getitem__(self, key: EntityKey) -> Entity:
        return self._by_key[key]

    def __contains__(self, value: object) -> bool:
        if isinstance(value, tuple) and len(value) == 2:
            return value in self._by_key
        return value in self._items

    def __repr__(self) -> str:
        return f"EntityCollection({list(self._items)!r})"

    def __eq__(self, other: object) -> bool:
        return isinstance(other, EntityCollection) and self._items == other._items

    def __hash__(self) -> int:
        return hash(self._items)

    def get(
        self,
        key: EntityKey,
        default: Entity | None = None,
    ) -> Entity | None:
        """Return an entity by ``(dimension, tag)``."""
        return self._by_key.get(key, default)

    def where(
        self,
        *,
        dimension: int | None = None,
        element_type: ElementType | int | None = None,
        has_nodes: bool | None = None,
        has_elements: bool | None = None,
        physical_tag: int | None = None,
    ) -> EntityCollection:
        """Return entities matching dimension, contents, or element type."""
        wanted_type = None if element_type is None else ElementType(element_type)
        return EntityCollection(
            entity
            for entity in self
            if (dimension is None or entity.dimension == dimension)
            and (has_nodes is None or bool(entity.nodes) is has_nodes)
            and (has_elements is None or bool(entity.elements) is has_elements)
            and (wanted_type is None or wanted_type in entity.element_types)
            and (physical_tag is None or physical_tag in entity.physical_tags)
        )

    def by_dimension(self, dimension: int) -> EntityCollection:
        """Return entities of one topological dimension."""
        return self.where(dimension=dimension)

    @property
    def keys(self) -> tuple[EntityKey, ...]:
        """Entity keys in parser order."""
        return tuple(self._by_key)

__slots__ = ('_items', '_by_key') class-attribute instance-attribute

_by_key = {(entity.key): entity for entity in (self._items)} instance-attribute

_items = tuple(items) instance-attribute

keys property

Entity keys in parser order.

__contains__(value)

Source code in gmshparser/api.py

def __contains__(self, value: object) -> bool:
    if isinstance(value, tuple) and len(value) == 2:
        return value in self._by_key
    return value in self._items

__eq__(other)

Source code in gmshparser/api.py

def __eq__(self, other: object) -> bool:
    return isinstance(other, EntityCollection) and self._items == other._items

__getitem__(key)

Source code in gmshparser/api.py

def __getitem__(self, key: EntityKey) -> Entity:
    return self._by_key[key]

__hash__()

Source code in gmshparser/api.py

def __hash__(self) -> int:
    return hash(self._items)

__init__(items)

Source code in gmshparser/api.py

def __init__(self, items: Iterable[Entity]):
    self._items = tuple(items)
    self._by_key = {entity.key: entity for entity in self._items}
    if len(self._by_key) != len(self._items):
        raise ValueError("Entity keys must be unique")

__iter__()

Source code in gmshparser/api.py

def __iter__(self) -> Iterator[Entity]:
    return iter(self._items)

__len__()

Source code in gmshparser/api.py

def __len__(self) -> int:
    return len(self._items)

__repr__()

Source code in gmshparser/api.py

def __repr__(self) -> str:
    return f"EntityCollection({list(self._items)!r})"

by_dimension(dimension)

Return entities of one topological dimension.

Source code in gmshparser/api.py

def by_dimension(self, dimension: int) -> EntityCollection:
    """Return entities of one topological dimension."""
    return self.where(dimension=dimension)

get(key, default=None)

Return an entity by (dimension, tag).

Source code in gmshparser/api.py

def get(
    self,
    key: EntityKey,
    default: Entity | None = None,
) -> Entity | None:
    """Return an entity by ``(dimension, tag)``."""
    return self._by_key.get(key, default)

where(*, dimension=None, element_type=None, has_nodes=None, has_elements=None, physical_tag=None)

Return entities matching dimension, contents, or element type.

Source code in gmshparser/api.py

def where(
    self,
    *,
    dimension: int | None = None,
    element_type: ElementType | int | None = None,
    has_nodes: bool | None = None,
    has_elements: bool | None = None,
    physical_tag: int | None = None,
) -> EntityCollection:
    """Return entities matching dimension, contents, or element type."""
    wanted_type = None if element_type is None else ElementType(element_type)
    return EntityCollection(
        entity
        for entity in self
        if (dimension is None or entity.dimension == dimension)
        and (has_nodes is None or bool(entity.nodes) is has_nodes)
        and (has_elements is None or bool(entity.elements) is has_elements)
        and (wanted_type is None or wanted_type in entity.element_types)
        and (physical_tag is None or physical_tag in entity.physical_tags)
    )

gmshparser.api.PhysicalGroupCollection

Physical groups keyed by (dimension, tag) and unambiguous names.

Source code in gmshparser/api.py

class PhysicalGroupCollection:
    """Physical groups keyed by ``(dimension, tag)`` and unambiguous names."""

    __slots__ = ("_items", "_by_key", "_by_name")

    def __init__(self, items: Iterable[PhysicalGroup]):
        self._items = tuple(items)
        self._by_key = {group.key: group for group in self._items}
        if len(self._by_key) != len(self._items):
            raise ValueError("Physical group keys must be unique")

        self._by_name: dict[str, list[PhysicalGroup]] = {}
        for group in self._items:
            if group.name is not None:
                self._by_name.setdefault(group.name, []).append(group)

    def __iter__(self) -> Iterator[PhysicalGroup]:
        return iter(self._items)

    def __len__(self) -> int:
        return len(self._items)

    def __getitem__(self, key: PhysicalGroupKey | str) -> PhysicalGroup:
        if isinstance(key, str):
            matches = self._by_name.get(key, ())
            if len(matches) == 1:
                return matches[0]
            if not matches:
                raise KeyError(key)
            raise KeyError(
                f"Physical group name {key!r} is ambiguous; use (dimension, tag)"
            )
        return self._by_key[key]

    def __contains__(self, value: object) -> bool:
        if isinstance(value, str):
            return value in self._by_name
        if isinstance(value, tuple) and len(value) == 2:
            return value in self._by_key
        return value in self._items

    def __repr__(self) -> str:
        return f"PhysicalGroupCollection({list(self._items)!r})"

    def get(
        self,
        key: PhysicalGroupKey | str,
        default: PhysicalGroup | None = None,
    ) -> PhysicalGroup | None:
        """Return a physical group, or *default* only when the key is absent.

        Ambiguous names still raise :class:`KeyError`; callers must use the
        explicit ``(dimension, tag)`` key in that case.
        """
        if isinstance(key, str):
            matches = self._by_name.get(key, ())
            if len(matches) == 1:
                return matches[0]
            if not matches:
                return default
            raise KeyError(
                f"Physical group name {key!r} is ambiguous; use (dimension, tag)"
            )
        return self._by_key.get(key, default)

    def where(self, *, dimension: int | None = None) -> PhysicalGroupCollection:
        """Return physical groups of the selected dimension."""
        return PhysicalGroupCollection(
            group for group in self if dimension is None or group.dimension == dimension
        )

    def by_dimension(self, dimension: int) -> PhysicalGroupCollection:
        """Return physical groups of one topological dimension."""
        return self.where(dimension=dimension)

    @property
    def keys(self) -> tuple[PhysicalGroupKey, ...]:
        """Physical group keys in parser order."""
        return tuple(self._by_key)

    @property
    def names(self) -> tuple[str, ...]:
        """Declared physical group names in parser order."""
        return tuple(group.name for group in self if group.name is not None)

__slots__ = ('_items', '_by_key', '_by_name') class-attribute instance-attribute

_by_key = {(group.key): group for group in (self._items)} instance-attribute

_by_name = {} instance-attribute

_items = tuple(items) instance-attribute

keys property

Physical group keys in parser order.

names property

Declared physical group names in parser order.

__contains__(value)

Source code in gmshparser/api.py

def __contains__(self, value: object) -> bool:
    if isinstance(value, str):
        return value in self._by_name
    if isinstance(value, tuple) and len(value) == 2:
        return value in self._by_key
    return value in self._items

__getitem__(key)

Source code in gmshparser/api.py

def __getitem__(self, key: PhysicalGroupKey | str) -> PhysicalGroup:
    if isinstance(key, str):
        matches = self._by_name.get(key, ())
        if len(matches) == 1:
            return matches[0]
        if not matches:
            raise KeyError(key)
        raise KeyError(
            f"Physical group name {key!r} is ambiguous; use (dimension, tag)"
        )
    return self._by_key[key]

__init__(items)

Source code in gmshparser/api.py

def __init__(self, items: Iterable[PhysicalGroup]):
    self._items = tuple(items)
    self._by_key = {group.key: group for group in self._items}
    if len(self._by_key) != len(self._items):
        raise ValueError("Physical group keys must be unique")

    self._by_name: dict[str, list[PhysicalGroup]] = {}
    for group in self._items:
        if group.name is not None:
            self._by_name.setdefault(group.name, []).append(group)

__iter__()

Source code in gmshparser/api.py

def __iter__(self) -> Iterator[PhysicalGroup]:
    return iter(self._items)

__len__()

Source code in gmshparser/api.py

def __len__(self) -> int:
    return len(self._items)

__repr__()

Source code in gmshparser/api.py

def __repr__(self) -> str:
    return f"PhysicalGroupCollection({list(self._items)!r})"

by_dimension(dimension)

Return physical groups of one topological dimension.

Source code in gmshparser/api.py

def by_dimension(self, dimension: int) -> PhysicalGroupCollection:
    """Return physical groups of one topological dimension."""
    return self.where(dimension=dimension)

get(key, default=None)

Return a physical group, or default only when the key is absent.

Ambiguous names still raise :class:KeyError; callers must use the explicit (dimension, tag) key in that case.

Source code in gmshparser/api.py

def get(
    self,
    key: PhysicalGroupKey | str,
    default: PhysicalGroup | None = None,
) -> PhysicalGroup | None:
    """Return a physical group, or *default* only when the key is absent.

    Ambiguous names still raise :class:`KeyError`; callers must use the
    explicit ``(dimension, tag)`` key in that case.
    """
    if isinstance(key, str):
        matches = self._by_name.get(key, ())
        if len(matches) == 1:
            return matches[0]
        if not matches:
            return default
        raise KeyError(
            f"Physical group name {key!r} is ambiguous; use (dimension, tag)"
        )
    return self._by_key.get(key, default)

where(*, dimension=None)

Return physical groups of the selected dimension.

Source code in gmshparser/api.py

def where(self, *, dimension: int | None = None) -> PhysicalGroupCollection:
    """Return physical groups of the selected dimension."""
    return PhysicalGroupCollection(
        group for group in self if dimension is None or group.dimension == dimension
    )

gmshparser.api.PeriodicLinkCollection

Immutable periodic links keyed by their slave (dimension, tag).

Source code in gmshparser/api.py

class PeriodicLinkCollection:
    """Immutable periodic links keyed by their slave ``(dimension, tag)``."""

    __slots__ = ("_items", "_by_key")

    def __init__(self, items: Iterable[PeriodicLink]):
        self._items = tuple(items)
        self._by_key = {link.key: link for link in self._items}
        if len(self._by_key) != len(self._items):
            raise ValueError("Periodic link keys must be unique")

    def __iter__(self) -> Iterator[PeriodicLink]:
        return iter(self._items)

    def __len__(self) -> int:
        return len(self._items)

    def __getitem__(self, key: PeriodicLinkKey) -> PeriodicLink:
        return self._by_key[key]

    def __contains__(self, value: object) -> bool:
        if isinstance(value, tuple) and len(value) == 2:
            return value in self._by_key
        return value in self._items

    def __repr__(self) -> str:
        return f"PeriodicLinkCollection({list(self._items)!r})"

    def __eq__(self, other: object) -> bool:
        return isinstance(other, PeriodicLinkCollection) and self._items == other._items

    def __hash__(self) -> int:
        return hash(self._items)

    def get(
        self,
        key: PeriodicLinkKey,
        default: PeriodicLink | None = None,
    ) -> PeriodicLink | None:
        """Return a periodic link by slave entity key."""
        return self._by_key.get(key, default)

    def where(self, *, dimension: int | None = None) -> PeriodicLinkCollection:
        """Return links for one topological dimension."""
        return PeriodicLinkCollection(
            link for link in self if dimension is None or link.dimension == dimension
        )

    def by_dimension(self, dimension: int) -> PeriodicLinkCollection:
        """Return links for one topological dimension."""
        return self.where(dimension=dimension)

    @property
    def keys(self) -> tuple[PeriodicLinkKey, ...]:
        """Slave entity keys in parser order."""
        return tuple(self._by_key)

__slots__ = ('_items', '_by_key') class-attribute instance-attribute

_by_key = {(link.key): link for link in (self._items)} instance-attribute

_items = tuple(items) instance-attribute

keys property

Slave entity keys in parser order.

__contains__(value)

Source code in gmshparser/api.py

def __contains__(self, value: object) -> bool:
    if isinstance(value, tuple) and len(value) == 2:
        return value in self._by_key
    return value in self._items

__eq__(other)

Source code in gmshparser/api.py

def __eq__(self, other: object) -> bool:
    return isinstance(other, PeriodicLinkCollection) and self._items == other._items

__getitem__(key)

Source code in gmshparser/api.py

def __getitem__(self, key: PeriodicLinkKey) -> PeriodicLink:
    return self._by_key[key]

__hash__()

Source code in gmshparser/api.py

def __hash__(self) -> int:
    return hash(self._items)

__init__(items)

Source code in gmshparser/api.py

def __init__(self, items: Iterable[PeriodicLink]):
    self._items = tuple(items)
    self._by_key = {link.key: link for link in self._items}
    if len(self._by_key) != len(self._items):
        raise ValueError("Periodic link keys must be unique")

__iter__()

Source code in gmshparser/api.py

def __iter__(self) -> Iterator[PeriodicLink]:
    return iter(self._items)

__len__()

Source code in gmshparser/api.py

def __len__(self) -> int:
    return len(self._items)

__repr__()

Source code in gmshparser/api.py

def __repr__(self) -> str:
    return f"PeriodicLinkCollection({list(self._items)!r})"

by_dimension(dimension)

Return links for one topological dimension.

Source code in gmshparser/api.py

def by_dimension(self, dimension: int) -> PeriodicLinkCollection:
    """Return links for one topological dimension."""
    return self.where(dimension=dimension)

get(key, default=None)

Return a periodic link by slave entity key.

Source code in gmshparser/api.py

def get(
    self,
    key: PeriodicLinkKey,
    default: PeriodicLink | None = None,
) -> PeriodicLink | None:
    """Return a periodic link by slave entity key."""
    return self._by_key.get(key, default)

where(*, dimension=None)

Return links for one topological dimension.

Source code in gmshparser/api.py

def where(self, *, dimension: int | None = None) -> PeriodicLinkCollection:
    """Return links for one topological dimension."""
    return PeriodicLinkCollection(
        link for link in self if dimension is None or link.dimension == dimension
    )

Value objects

gmshparser.api.Node dataclass

An immutable mesh node.

coordinates always contains the Cartesian (x, y, z) values. Additional coordinates from parametric MSH node blocks are available in parametric_coordinates.

Source code in gmshparser/api.py

@dataclass(frozen=True, slots=True)
class Node:
    """An immutable mesh node.

    ``coordinates`` always contains the Cartesian ``(x, y, z)`` values.
    Additional coordinates from parametric MSH node blocks are available in
    ``parametric_coordinates``.
    """

    tag: int
    coordinates: tuple[float, float, float]
    dimension: int
    entity_tag: int
    parametric_coordinates: tuple[float, ...] = ()
    physical_tags: tuple[int, ...] = ()

    @property
    def x(self) -> float:
        """X coordinate."""
        return self.coordinates[0]

    @property
    def y(self) -> float:
        """Y coordinate."""
        return self.coordinates[1]

    @property
    def z(self) -> float:
        """Z coordinate."""
        return self.coordinates[2]

    @property
    def entity_key(self) -> EntityKey:
        """Owning entity as ``(dimension, tag)``."""
        return self.dimension, self.entity_tag

    @property
    def is_parametric(self) -> bool:
        """Whether the node carries parametric coordinates."""
        return bool(self.parametric_coordinates)

    def __iter__(self) -> Iterator[float]:
        return iter(self.coordinates)

coordinates instance-attribute

dimension instance-attribute

entity_key property

Owning entity as (dimension, tag).

entity_tag instance-attribute

is_parametric property

Whether the node carries parametric coordinates.

parametric_coordinates = () class-attribute instance-attribute

physical_tags = () class-attribute instance-attribute

tag instance-attribute

x property

X coordinate.

y property

Y coordinate.

z property

Z coordinate.

__init__(tag, coordinates, dimension, entity_tag, parametric_coordinates=(), physical_tags=())

__iter__()

Source code in gmshparser/api.py

def __iter__(self) -> Iterator[float]:
    return iter(self.coordinates)

gmshparser.api.Element dataclass

An immutable element with direct references to its nodes.

Source code in gmshparser/api.py

@dataclass(frozen=True, slots=True)
class Element:
    """An immutable element with direct references to its nodes."""

    tag: int
    element_type: ElementType
    nodes: tuple[Node, ...]
    dimension: int
    entity_tag: int
    physical_tags: tuple[int, ...] = ()

    @property
    def type(self) -> ElementType:
        """Compatibility alias for :attr:`element_type`."""
        return self.element_type

    @property
    def type_id(self) -> int:
        """Raw numeric Gmsh element type."""
        return int(self.element_type)

    @property
    def info(self) -> ElementTypeInfo | None:
        """Registered topology metadata for this element type."""
        return self.element_type.info

    @property
    def family(self) -> ElementFamily | None:
        """Topological element family, or ``None`` when the type is unknown."""
        return self.element_type.family

    @property
    def order(self) -> int | None:
        """Polynomial order, or ``None`` when the type is unknown."""
        return self.element_type.order

    @property
    def expected_node_count(self) -> int | None:
        """Registered connectivity size, or ``None`` when the type is unknown."""
        return self.element_type.node_count

    @property
    def primary_node_count(self) -> int | None:
        """Number of first-order corner nodes, or ``None`` when unknown."""
        return self.element_type.primary_node_count

    @property
    def is_linear(self) -> bool:
        """Whether this is a registered first-order element."""
        return self.element_type.is_linear

    @property
    def is_high_order(self) -> bool:
        """Whether this is a registered second- or higher-order element."""
        return self.element_type.is_high_order

    @property
    def is_complete(self) -> bool | None:
        """Whether all interior high-order nodes are present, or ``None``."""
        return self.element_type.is_complete

    @property
    def node_tags(self) -> tuple[int, ...]:
        """Connectivity as original Gmsh node tags."""
        return tuple(node.tag for node in self.nodes)

    @property
    def connectivity(self) -> tuple[int, ...]:
        """Alias for :attr:`node_tags`."""
        return self.node_tags

    @property
    def entity_key(self) -> EntityKey:
        """Owning entity as ``(dimension, tag)``."""
        return self.dimension, self.entity_tag

    def __iter__(self) -> Iterator[Node]:
        return iter(self.nodes)

    def __len__(self) -> int:
        return len(self.nodes)

connectivity property

Alias for :attr:node_tags.

dimension instance-attribute

element_type instance-attribute

entity_key property

Owning entity as (dimension, tag).

entity_tag instance-attribute

expected_node_count property

Registered connectivity size, or None when the type is unknown.

family property

Topological element family, or None when the type is unknown.

info property

Registered topology metadata for this element type.

is_complete property

Whether all interior high-order nodes are present, or None.

is_high_order property

Whether this is a registered second- or higher-order element.

is_linear property

Whether this is a registered first-order element.

node_tags property

Connectivity as original Gmsh node tags.

nodes instance-attribute

order property

Polynomial order, or None when the type is unknown.

physical_tags = () class-attribute instance-attribute

primary_node_count property

Number of first-order corner nodes, or None when unknown.

tag instance-attribute

type property

Compatibility alias for :attr:element_type.

type_id property

Raw numeric Gmsh element type.

__init__(tag, element_type, nodes, dimension, entity_tag, physical_tags=())

__iter__()

Source code in gmshparser/api.py

def __iter__(self) -> Iterator[Node]:
    return iter(self.nodes)

__len__()

Source code in gmshparser/api.py

def __len__(self) -> int:
    return len(self.nodes)

gmshparser.api.Entity dataclass

A unified Gmsh entity containing both nodes and elements.

Source code in gmshparser/api.py

@dataclass(frozen=True, slots=True)
class Entity:
    """A unified Gmsh entity containing both nodes and elements."""

    dimension: int
    tag: int
    nodes: NodeCollection
    elements: ElementCollection
    physical_tags: tuple[int, ...] = ()

    @property
    def key(self) -> EntityKey:
        """Entity key as ``(dimension, tag)``."""
        return self.dimension, self.tag

    @property
    def element_types(self) -> frozenset[ElementType]:
        """Element types assigned to this entity."""
        return self.elements.types

    @property
    def has_parametric_nodes(self) -> bool:
        """Whether any node carries parametric coordinates."""
        return any(node.is_parametric for node in self.nodes)

dimension instance-attribute

element_types property

Element types assigned to this entity.

elements instance-attribute

has_parametric_nodes property

Whether any node carries parametric coordinates.

key property

Entity key as (dimension, tag).

nodes instance-attribute

physical_tags = () class-attribute instance-attribute

tag instance-attribute

__init__(dimension, tag, nodes, elements, physical_tags=())

gmshparser.api.PhysicalGroup dataclass

A named or anonymous physical group and its resolved mesh contents.

Source code in gmshparser/api.py

@dataclass(frozen=True, slots=True)
class PhysicalGroup:
    """A named or anonymous physical group and its resolved mesh contents."""

    dimension: int
    tag: int
    name: str | None
    entities: EntityCollection
    elements: ElementCollection
    nodes: NodeCollection

    @property
    def key(self) -> PhysicalGroupKey:
        """Physical group key as ``(dimension, tag)``."""
        return self.dimension, self.tag

dimension instance-attribute

elements instance-attribute

entities instance-attribute

key property

Physical group key as (dimension, tag).

name instance-attribute

nodes instance-attribute

tag instance-attribute

__init__(dimension, tag, name, entities, elements, nodes)

gmshparser.api.PeriodicLink dataclass

A periodic slave entity and its master-node correspondence.

Source code in gmshparser/api.py

@dataclass(frozen=True, slots=True)
class PeriodicLink:
    """A periodic slave entity and its master-node correspondence."""

    dimension: int
    entity_tag: int
    master_entity_tag: int
    affine_transform: tuple[float, ...] = ()
    node_pairs: tuple[tuple[int, int], ...] = ()

    @property
    def key(self) -> PeriodicLinkKey:
        """Slave entity key as ``(dimension, tag)``."""
        return self.dimension, self.entity_tag

    @property
    def slave_node_tags(self) -> tuple[int, ...]:
        """Slave node tags in file order."""
        return tuple(slave for slave, _ in self.node_pairs)

    @property
    def master_node_tags(self) -> tuple[int, ...]:
        """Master node tags in file order."""
        return tuple(master for _, master in self.node_pairs)

affine_transform = () class-attribute instance-attribute

dimension instance-attribute

entity_tag instance-attribute

key property

Slave entity key as (dimension, tag).

master_entity_tag instance-attribute

master_node_tags property

Master node tags in file order.

node_pairs = () class-attribute instance-attribute

slave_node_tags property

Slave node tags in file order.

__init__(dimension, entity_tag, master_entity_tag, affine_transform=(), node_pairs=())

Related guides

• Modern Data Model
• Working with Meshes
• Physical Groups and Periodicity