Skip to content

Compatibility API

This page documents the original mutable parser-oriented model returned by gmshparser.parse(). It remains supported for existing applications. New code should normally use gmshparser.read() and the modern API.

Mesh

gmshparser.mesh.Mesh

Mesh is the main compatibility class of the package.

Source code in gmshparser/mesh.py 
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
class Mesh:
    """Mesh is the main compatibility class of the package."""

    def __init__(self) -> None:
        self.name_ = "New Mesh"
        self.version_: float | None = None
        self.version_major_: int | None = None
        self.version_minor_: int | None = None
        self.ascii_ = True
        self.precision_ = 8
        self.number_of_node_entities_ = 0
        self.number_of_nodes_ = 0
        self.min_node_tag_ = 0
        self.max_node_tag_ = 0
        self.node_entities_: dict[EntityKey, NodeEntity] = {}
        self.number_of_element_entities_ = 0
        self.number_of_elements_ = 0
        self.min_element_tag_ = 0
        self.max_element_tag_ = 0
        self.element_entities_: dict[ElementEntityKey, ElementEntity] = {}
        self.physical_names_: dict[EntityKey, str] = {}
        self.entity_physical_tags_: dict[EntityKey, tuple[int, ...]] = {}
        self.element_physical_tags_: dict[int, tuple[int, ...]] = {}
        self.periodic_links_: dict[EntityKey, PeriodicLinkValue] = {}

    def set_name(self, name: str) -> None:
        """Set the name of the mesh."""
        self.name_ = name

    def get_name(self) -> str:
        """Get the name of the mesh."""
        return self.name_

    def set_version(self, version: float) -> None:
        """Set the MSH format version."""
        self.version_ = version
        major = int(version)
        minor = int(round((version - major) * 10))
        self.version_major_ = major
        self.version_minor_ = minor

    def get_version(self) -> float | None:
        """Get the MSH format version."""
        return self.version_

    def get_version_major(self) -> int | None:
        """Get the major version number."""
        return self.version_major_

    def get_version_minor(self) -> int | None:
        """Get the minor version number."""
        return self.version_minor_

    def set_ascii(self, is_ascii: bool) -> None:
        """Set whether the mesh uses the ASCII representation."""
        self.ascii_ = is_ascii

    def get_ascii(self) -> bool:
        """Return whether the mesh uses the ASCII representation."""
        return self.ascii_

    def set_precision(self, precision: int) -> None:
        """Set the MSH data-size field."""
        self.precision_ = precision

    def get_precision(self) -> int:
        """Get the MSH data-size field."""
        return self.precision_

    def set_number_of_node_entities(self, number_of_node_entities: int) -> None:
        """Set the number of node entities."""
        self.number_of_node_entities_ = number_of_node_entities

    def get_number_of_node_entities(self) -> int:
        """Get the number of node entities."""
        return self.number_of_node_entities_

    def set_number_of_nodes(self, number_of_nodes: int) -> None:
        """Set the number of nodes."""
        self.number_of_nodes_ = number_of_nodes

    def get_number_of_nodes(self) -> int:
        """Get the number of nodes."""
        return self.number_of_nodes_

    def set_min_node_tag(self, min_node_tag: int) -> None:
        """Set the minimum node tag."""
        self.min_node_tag_ = min_node_tag

    def get_min_node_tag(self) -> int:
        """Get the minimum node tag."""
        return self.min_node_tag_

    def set_max_node_tag(self, max_node_tag: int) -> None:
        """Set the maximum node tag."""
        self.max_node_tag_ = max_node_tag

    def get_max_node_tag(self) -> int:
        """Get the maximum node tag."""
        return self.max_node_tag_

    def has_node_entity(self, dim: int, tag: int) -> bool:
        """Return whether a node entity exists for ``(dim, tag)``."""
        return (dim, tag) in self.node_entities_

    def add_node_block(
        self,
        dimension: int,
        entity_tag: int,
        parametric_coordinate_count: int,
        nodes: Sequence[RawNodeRecord],
    ) -> None:
        """Build and store one compatibility node block from raw records."""
        entity = NodeEntity()
        entity.set_dimension(dimension)
        entity.set_tag(entity_tag)
        entity.set_number_of_parametric_coordinates(parametric_coordinate_count)
        entity.set_number_of_nodes(len(nodes))
        for node_tag, coordinates in nodes:
            node = Node()
            node.set_tag(node_tag)
            node.set_coordinates(tuple(coordinates))
            entity.add_node(node)
        self.add_node_entity(entity)

    def add_node_entity(self, node_entity: NodeEntity) -> None:
        """Add a node entity to the mesh."""
        dim = node_entity.get_dimension()
        tag = node_entity.get_tag()
        self.node_entities_[(dim, tag)] = node_entity

    def get_node_entity(self, dim: int, tag: int) -> NodeEntity:
        """Get a node entity by dimension and tag."""
        return self.node_entities_[(dim, tag)]

    def get_node_entities(self) -> ValuesView[NodeEntity]:
        """Get all node entities in parser order."""
        return self.node_entities_.values()

    def set_number_of_element_entities(
        self,
        number_of_element_entities: int,
    ) -> None:
        """Set the number of element entities."""
        self.number_of_element_entities_ = number_of_element_entities

    def get_number_of_element_entities(self) -> int:
        """Get the number of element entities."""
        return self.number_of_element_entities_

    def set_number_of_elements(self, number_of_elements: int) -> None:
        """Set the number of elements."""
        self.number_of_elements_ = number_of_elements

    def get_number_of_elements(self) -> int:
        """Get the number of elements."""
        return self.number_of_elements_

    def set_min_element_tag(self, min_element_tag: int) -> None:
        """Set the minimum element tag."""
        self.min_element_tag_ = min_element_tag

    def get_min_element_tag(self) -> int:
        """Get the minimum element tag."""
        return self.min_element_tag_

    def set_max_element_tag(self, max_element_tag: int) -> None:
        """Set the maximum element tag."""
        self.max_element_tag_ = max_element_tag

    def get_max_element_tag(self) -> int:
        """Get the maximum element tag."""
        return self.max_element_tag_

    def has_element_entity(
        self,
        dim: int,
        tag: int,
        element_type: int | None = None,
    ) -> bool:
        """Return whether an element block exists for an entity.

        When ``element_type`` is omitted, this reports whether any element block
        exists for ``(dim, tag)``. Supplying it checks one exact block.
        """
        if element_type is not None:
            return (dim, tag, int(element_type)) in self.element_entities_
        return any(
            entity_dim == dim and entity_tag == tag
            for entity_dim, entity_tag, _ in self.element_entities_
        )

    def add_element_block(
        self,
        dimension: int,
        entity_tag: int,
        element_type: int,
        elements: Sequence[RawElementRecord],
    ) -> None:
        """Build and store one compatibility element block from raw records."""
        entity = ElementEntity()
        entity.set_dimension(dimension)
        entity.set_tag(entity_tag)
        entity.set_element_type(int(element_type))
        entity.set_number_of_elements(len(elements))
        for element_tag, connectivity, physical_tags in elements:
            normalized_physical_tags = tuple(physical_tags)
            if normalized_physical_tags:
                self.set_element_physical_tags(
                    element_tag,
                    normalized_physical_tags,
                )
            element = Element()
            element.set_tag(element_tag)
            element.set_connectivity(list(connectivity))
            entity.add_element(element)
        self.add_element_entity(entity)

    def add_element_entity(self, element_entity: ElementEntity) -> None:
        """Add an element block without overwriting other element types."""
        dim = element_entity.get_dimension()
        tag = element_entity.get_tag()
        element_type = element_entity.get_element_type()
        self.element_entities_[(dim, tag, element_type)] = element_entity

    def get_element_entity(
        self,
        dim: int,
        tag: int,
        element_type: int | None = None,
    ) -> ElementEntity:
        """Get one element block by entity and optionally element type.

        The two-argument form is retained for compatibility and succeeds when
        exactly one element type exists for ``(dim, tag)``. Mixed entities require
        ``element_type`` to avoid returning an arbitrary block.
        """
        if element_type is not None:
            return self.element_entities_[(dim, tag, int(element_type))]

        matches = [
            entity
            for (entity_dim, entity_tag, _), entity in self.element_entities_.items()
            if entity_dim == dim and entity_tag == tag
        ]
        if len(matches) == 1:
            return matches[0]
        if not matches:
            raise KeyError((dim, tag))

        available_types = ", ".join(
            str(entity.get_element_type()) for entity in matches
        )
        raise KeyError(
            f"Element entity ({dim}, {tag}) is ambiguous; provide element_type. "
            f"Available element types: {available_types}"
        )

    def get_element_entities(self) -> ValuesView[ElementEntity]:
        """Get all element blocks in parser order."""
        return self.element_entities_.values()

    def set_physical_name(self, dimension: int, tag: int, name: str) -> None:
        """Store a physical group name without changing the legacy object model."""
        self.physical_names_[(dimension, tag)] = name

    def get_physical_name(self, dimension: int, tag: int) -> str | None:
        """Return a physical group name when one was declared."""
        return self.physical_names_.get((dimension, tag))

    def get_physical_names(self) -> dict[EntityKey, str]:
        """Return declared physical group names keyed by ``(dimension, tag)``."""
        return dict(self.physical_names_)

    def set_entity_physical_tags(
        self,
        dimension: int,
        tag: int,
        physical_tags: Iterable[int],
    ) -> None:
        """Replace physical tags assigned to one elementary entity."""
        self.entity_physical_tags_[(dimension, tag)] = self._normalize_tags(
            physical_tags
        )

    def add_entity_physical_tags(
        self,
        dimension: int,
        tag: int,
        physical_tags: Iterable[int],
    ) -> None:
        """Add physical tags assigned to one elementary entity."""
        existing = self.entity_physical_tags_.get((dimension, tag), ())
        self.entity_physical_tags_[(dimension, tag)] = self._normalize_tags(
            (*existing, *physical_tags)
        )

    def get_entity_physical_tags(self, dimension: int, tag: int) -> tuple[int, ...]:
        """Return physical tags assigned to one elementary entity."""
        return self.entity_physical_tags_.get((dimension, tag), ())

    def get_entity_physical_assignments(self) -> dict[EntityKey, tuple[int, ...]]:
        """Return all declared elementary-entity physical assignments."""
        return dict(self.entity_physical_tags_)

    def set_element_physical_tags(
        self,
        element_tag: int,
        physical_tags: Iterable[int],
    ) -> None:
        """Store physical tags carried directly by one legacy element record."""
        self.element_physical_tags_[element_tag] = self._normalize_tags(physical_tags)

    def get_element_physical_tags(self, element_tag: int) -> tuple[int, ...]:
        """Return physical tags carried directly by one element."""
        return self.element_physical_tags_.get(element_tag, ())

    def has_periodic_link(self, dimension: int, entity_tag: int) -> bool:
        """Return whether a periodic relation exists for one slave entity."""
        return (dimension, entity_tag) in self.periodic_links_

    def add_periodic_link(
        self,
        dimension: int,
        entity_tag: int,
        master_entity_tag: int,
        affine_transform: Iterable[float],
        node_pairs: Iterable[NodePair],
    ) -> None:
        """Store one periodic slave-to-master entity relation."""
        key = int(dimension), int(entity_tag)
        if key in self.periodic_links_:
            raise ValueError(f"Duplicate periodic link for entity {key}")
        self.periodic_links_[key] = (
            int(master_entity_tag),
            tuple(float(value) for value in affine_transform),
            tuple((int(slave), int(master)) for slave, master in node_pairs),
        )

    def get_periodic_link(
        self,
        dimension: int,
        entity_tag: int,
    ) -> PeriodicLinkValue:
        """Return ``(master_tag, affine_transform, node_pairs)`` for an entity."""
        return self.periodic_links_[(dimension, entity_tag)]

    def get_periodic_links(self) -> tuple[PeriodicLinkRecord, ...]:
        """Return periodic relations in parser order."""
        return tuple(
            (dimension, entity_tag, master_tag, affine_transform, node_pairs)
            for (dimension, entity_tag), (
                master_tag,
                affine_transform,
                node_pairs,
            ) in self.periodic_links_.items()
        )

    @staticmethod
    def _normalize_tags(tags: Iterable[int]) -> tuple[int, ...]:
        normalized: list[int] = []
        for tag in tags:
            value = int(tag)
            if value > 0 and value not in normalized:
                normalized.append(value)
        return tuple(normalized)

    def __str__(self) -> str:
        io = StringIO()
        io.write(f"Mesh name: {self.get_name()}\n")
        io.write(f"Mesh version: {self.get_version()}\n")
        io.write(f"Number of nodes: {self.get_number_of_nodes()}\n")
        io.write(f"Minimum node tag: {self.get_min_node_tag()}\n")
        io.write(f"Maximum node tag: {self.get_max_node_tag()}\n")
        nnent = self.get_number_of_node_entities()
        io.write(f"Number of node entities: {nnent}\n")
        io.write(f"Number of elements: {self.get_number_of_elements()}\n")
        io.write(f"Minimum element tag: {self.get_min_element_tag()}\n")
        io.write(f"Maximum element tag: {self.get_max_element_tag()}\n")
        neent = self.get_number_of_element_entities()
        io.write(f"Number of element entities: {neent}")
        return io.getvalue()

ascii_ = True instance-attribute

element_entities_ = {} instance-attribute

element_physical_tags_ = {} instance-attribute

entity_physical_tags_ = {} instance-attribute

max_element_tag_ = 0 instance-attribute

max_node_tag_ = 0 instance-attribute

min_element_tag_ = 0 instance-attribute

min_node_tag_ = 0 instance-attribute

name_ = 'New Mesh' instance-attribute

node_entities_ = {} instance-attribute

number_of_element_entities_ = 0 instance-attribute

number_of_elements_ = 0 instance-attribute

number_of_node_entities_ = 0 instance-attribute

number_of_nodes_ = 0 instance-attribute

periodic_links_ = {} instance-attribute

physical_names_ = {} instance-attribute

precision_ = 8 instance-attribute

version_ = None instance-attribute

version_major_ = None instance-attribute

version_minor_ = None instance-attribute

__init__()

Source code in gmshparser/mesh.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
def __init__(self) -> None:
    self.name_ = "New Mesh"
    self.version_: float | None = None
    self.version_major_: int | None = None
    self.version_minor_: int | None = None
    self.ascii_ = True
    self.precision_ = 8
    self.number_of_node_entities_ = 0
    self.number_of_nodes_ = 0
    self.min_node_tag_ = 0
    self.max_node_tag_ = 0
    self.node_entities_: dict[EntityKey, NodeEntity] = {}
    self.number_of_element_entities_ = 0
    self.number_of_elements_ = 0
    self.min_element_tag_ = 0
    self.max_element_tag_ = 0
    self.element_entities_: dict[ElementEntityKey, ElementEntity] = {}
    self.physical_names_: dict[EntityKey, str] = {}
    self.entity_physical_tags_: dict[EntityKey, tuple[int, ...]] = {}
    self.element_physical_tags_: dict[int, tuple[int, ...]] = {}
    self.periodic_links_: dict[EntityKey, PeriodicLinkValue] = {}

__str__()

Source code in gmshparser/mesh.py 
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
def __str__(self) -> str:
    io = StringIO()
    io.write(f"Mesh name: {self.get_name()}\n")
    io.write(f"Mesh version: {self.get_version()}\n")
    io.write(f"Number of nodes: {self.get_number_of_nodes()}\n")
    io.write(f"Minimum node tag: {self.get_min_node_tag()}\n")
    io.write(f"Maximum node tag: {self.get_max_node_tag()}\n")
    nnent = self.get_number_of_node_entities()
    io.write(f"Number of node entities: {nnent}\n")
    io.write(f"Number of elements: {self.get_number_of_elements()}\n")
    io.write(f"Minimum element tag: {self.get_min_element_tag()}\n")
    io.write(f"Maximum element tag: {self.get_max_element_tag()}\n")
    neent = self.get_number_of_element_entities()
    io.write(f"Number of element entities: {neent}")
    return io.getvalue()

_normalize_tags(tags) staticmethod

Source code in gmshparser/mesh.py 
382
383
384
385
386
387
388
389
@staticmethod
def _normalize_tags(tags: Iterable[int]) -> tuple[int, ...]:
    normalized: list[int] = []
    for tag in tags:
        value = int(tag)
        if value > 0 and value not in normalized:
            normalized.append(value)
    return tuple(normalized)

add_element_block(dimension, entity_tag, element_type, elements)

Build and store one compatibility element block from raw records.

Source code in gmshparser/mesh.py 
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
def add_element_block(
    self,
    dimension: int,
    entity_tag: int,
    element_type: int,
    elements: Sequence[RawElementRecord],
) -> None:
    """Build and store one compatibility element block from raw records."""
    entity = ElementEntity()
    entity.set_dimension(dimension)
    entity.set_tag(entity_tag)
    entity.set_element_type(int(element_type))
    entity.set_number_of_elements(len(elements))
    for element_tag, connectivity, physical_tags in elements:
        normalized_physical_tags = tuple(physical_tags)
        if normalized_physical_tags:
            self.set_element_physical_tags(
                element_tag,
                normalized_physical_tags,
            )
        element = Element()
        element.set_tag(element_tag)
        element.set_connectivity(list(connectivity))
        entity.add_element(element)
    self.add_element_entity(entity)

add_element_entity(element_entity)

Add an element block without overwriting other element types.

Source code in gmshparser/mesh.py 
242
243
244
245
246
247
def add_element_entity(self, element_entity: ElementEntity) -> None:
    """Add an element block without overwriting other element types."""
    dim = element_entity.get_dimension()
    tag = element_entity.get_tag()
    element_type = element_entity.get_element_type()
    self.element_entities_[(dim, tag, element_type)] = element_entity

add_entity_physical_tags(dimension, tag, physical_tags)

Add physical tags assigned to one elementary entity.

Source code in gmshparser/mesh.py 
309
310
311
312
313
314
315
316
317
318
319
def add_entity_physical_tags(
    self,
    dimension: int,
    tag: int,
    physical_tags: Iterable[int],
) -> None:
    """Add physical tags assigned to one elementary entity."""
    existing = self.entity_physical_tags_.get((dimension, tag), ())
    self.entity_physical_tags_[(dimension, tag)] = self._normalize_tags(
        (*existing, *physical_tags)
    )

add_node_block(dimension, entity_tag, parametric_coordinate_count, nodes)

Build and store one compatibility node block from raw records.

Source code in gmshparser/mesh.py 
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
def add_node_block(
    self,
    dimension: int,
    entity_tag: int,
    parametric_coordinate_count: int,
    nodes: Sequence[RawNodeRecord],
) -> None:
    """Build and store one compatibility node block from raw records."""
    entity = NodeEntity()
    entity.set_dimension(dimension)
    entity.set_tag(entity_tag)
    entity.set_number_of_parametric_coordinates(parametric_coordinate_count)
    entity.set_number_of_nodes(len(nodes))
    for node_tag, coordinates in nodes:
        node = Node()
        node.set_tag(node_tag)
        node.set_coordinates(tuple(coordinates))
        entity.add_node(node)
    self.add_node_entity(entity)

add_node_entity(node_entity)

Add a node entity to the mesh.

Source code in gmshparser/mesh.py 
149
150
151
152
153
def add_node_entity(self, node_entity: NodeEntity) -> None:
    """Add a node entity to the mesh."""
    dim = node_entity.get_dimension()
    tag = node_entity.get_tag()
    self.node_entities_[(dim, tag)] = node_entity

Store one periodic slave-to-master entity relation.

Source code in gmshparser/mesh.py 
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
def add_periodic_link(
    self,
    dimension: int,
    entity_tag: int,
    master_entity_tag: int,
    affine_transform: Iterable[float],
    node_pairs: Iterable[NodePair],
) -> None:
    """Store one periodic slave-to-master entity relation."""
    key = int(dimension), int(entity_tag)
    if key in self.periodic_links_:
        raise ValueError(f"Duplicate periodic link for entity {key}")
    self.periodic_links_[key] = (
        int(master_entity_tag),
        tuple(float(value) for value in affine_transform),
        tuple((int(slave), int(master)) for slave, master in node_pairs),
    )

get_ascii()

Return whether the mesh uses the ASCII representation.

Source code in gmshparser/mesh.py 
81
82
83
def get_ascii(self) -> bool:
    """Return whether the mesh uses the ASCII representation."""
    return self.ascii_

get_element_entities()

Get all element blocks in parser order.

Source code in gmshparser/mesh.py 
282
283
284
def get_element_entities(self) -> ValuesView[ElementEntity]:
    """Get all element blocks in parser order."""
    return self.element_entities_.values()

get_element_entity(dim, tag, element_type=None)

Get one element block by entity and optionally element type.

The two-argument form is retained for compatibility and succeeds when exactly one element type exists for (dim, tag). Mixed entities require element_type to avoid returning an arbitrary block.

Source code in gmshparser/mesh.py 
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
def get_element_entity(
    self,
    dim: int,
    tag: int,
    element_type: int | None = None,
) -> ElementEntity:
    """Get one element block by entity and optionally element type.

    The two-argument form is retained for compatibility and succeeds when
    exactly one element type exists for ``(dim, tag)``. Mixed entities require
    ``element_type`` to avoid returning an arbitrary block.
    """
    if element_type is not None:
        return self.element_entities_[(dim, tag, int(element_type))]

    matches = [
        entity
        for (entity_dim, entity_tag, _), entity in self.element_entities_.items()
        if entity_dim == dim and entity_tag == tag
    ]
    if len(matches) == 1:
        return matches[0]
    if not matches:
        raise KeyError((dim, tag))

    available_types = ", ".join(
        str(entity.get_element_type()) for entity in matches
    )
    raise KeyError(
        f"Element entity ({dim}, {tag}) is ambiguous; provide element_type. "
        f"Available element types: {available_types}"
    )

get_element_physical_tags(element_tag)

Return physical tags carried directly by one element.

Source code in gmshparser/mesh.py 
337
338
339
def get_element_physical_tags(self, element_tag: int) -> tuple[int, ...]:
    """Return physical tags carried directly by one element."""
    return self.element_physical_tags_.get(element_tag, ())

get_entity_physical_assignments()

Return all declared elementary-entity physical assignments.

Source code in gmshparser/mesh.py 
325
326
327
def get_entity_physical_assignments(self) -> dict[EntityKey, tuple[int, ...]]:
    """Return all declared elementary-entity physical assignments."""
    return dict(self.entity_physical_tags_)

get_entity_physical_tags(dimension, tag)

Return physical tags assigned to one elementary entity.

Source code in gmshparser/mesh.py 
321
322
323
def get_entity_physical_tags(self, dimension: int, tag: int) -> tuple[int, ...]:
    """Return physical tags assigned to one elementary entity."""
    return self.entity_physical_tags_.get((dimension, tag), ())

get_max_element_tag()

Get the maximum element tag.

Source code in gmshparser/mesh.py 
194
195
196
def get_max_element_tag(self) -> int:
    """Get the maximum element tag."""
    return self.max_element_tag_

get_max_node_tag()

Get the maximum node tag.

Source code in gmshparser/mesh.py 
121
122
123
def get_max_node_tag(self) -> int:
    """Get the maximum node tag."""
    return self.max_node_tag_

get_min_element_tag()

Get the minimum element tag.

Source code in gmshparser/mesh.py 
186
187
188
def get_min_element_tag(self) -> int:
    """Get the minimum element tag."""
    return self.min_element_tag_

get_min_node_tag()

Get the minimum node tag.

Source code in gmshparser/mesh.py 
113
114
115
def get_min_node_tag(self) -> int:
    """Get the minimum node tag."""
    return self.min_node_tag_

get_name()

Get the name of the mesh.

Source code in gmshparser/mesh.py 
53
54
55
def get_name(self) -> str:
    """Get the name of the mesh."""
    return self.name_

get_node_entities()

Get all node entities in parser order.

Source code in gmshparser/mesh.py 
159
160
161
def get_node_entities(self) -> ValuesView[NodeEntity]:
    """Get all node entities in parser order."""
    return self.node_entities_.values()

get_node_entity(dim, tag)

Get a node entity by dimension and tag.

Source code in gmshparser/mesh.py 
155
156
157
def get_node_entity(self, dim: int, tag: int) -> NodeEntity:
    """Get a node entity by dimension and tag."""
    return self.node_entities_[(dim, tag)]

get_number_of_element_entities()

Get the number of element entities.

Source code in gmshparser/mesh.py 
170
171
172
def get_number_of_element_entities(self) -> int:
    """Get the number of element entities."""
    return self.number_of_element_entities_

get_number_of_elements()

Get the number of elements.

Source code in gmshparser/mesh.py 
178
179
180
def get_number_of_elements(self) -> int:
    """Get the number of elements."""
    return self.number_of_elements_

get_number_of_node_entities()

Get the number of node entities.

Source code in gmshparser/mesh.py 
97
98
99
def get_number_of_node_entities(self) -> int:
    """Get the number of node entities."""
    return self.number_of_node_entities_

get_number_of_nodes()

Get the number of nodes.

Source code in gmshparser/mesh.py 
105
106
107
def get_number_of_nodes(self) -> int:
    """Get the number of nodes."""
    return self.number_of_nodes_

Return (master_tag, affine_transform, node_pairs) for an entity.

Source code in gmshparser/mesh.py 
363
364
365
366
367
368
369
def get_periodic_link(
    self,
    dimension: int,
    entity_tag: int,
) -> PeriodicLinkValue:
    """Return ``(master_tag, affine_transform, node_pairs)`` for an entity."""
    return self.periodic_links_[(dimension, entity_tag)]

Return periodic relations in parser order.

Source code in gmshparser/mesh.py 
371
372
373
374
375
376
377
378
379
380
def get_periodic_links(self) -> tuple[PeriodicLinkRecord, ...]:
    """Return periodic relations in parser order."""
    return tuple(
        (dimension, entity_tag, master_tag, affine_transform, node_pairs)
        for (dimension, entity_tag), (
            master_tag,
            affine_transform,
            node_pairs,
        ) in self.periodic_links_.items()
    )

get_physical_name(dimension, tag)

Return a physical group name when one was declared.

Source code in gmshparser/mesh.py 
290
291
292
def get_physical_name(self, dimension: int, tag: int) -> str | None:
    """Return a physical group name when one was declared."""
    return self.physical_names_.get((dimension, tag))

get_physical_names()

Return declared physical group names keyed by (dimension, tag).

Source code in gmshparser/mesh.py 
294
295
296
def get_physical_names(self) -> dict[EntityKey, str]:
    """Return declared physical group names keyed by ``(dimension, tag)``."""
    return dict(self.physical_names_)

get_precision()

Get the MSH data-size field.

Source code in gmshparser/mesh.py 
89
90
91
def get_precision(self) -> int:
    """Get the MSH data-size field."""
    return self.precision_

get_version()

Get the MSH format version.

Source code in gmshparser/mesh.py 
65
66
67
def get_version(self) -> float | None:
    """Get the MSH format version."""
    return self.version_

get_version_major()

Get the major version number.

Source code in gmshparser/mesh.py 
69
70
71
def get_version_major(self) -> int | None:
    """Get the major version number."""
    return self.version_major_

get_version_minor()

Get the minor version number.

Source code in gmshparser/mesh.py 
73
74
75
def get_version_minor(self) -> int | None:
    """Get the minor version number."""
    return self.version_minor_

has_element_entity(dim, tag, element_type=None)

Return whether an element block exists for an entity.

When element_type is omitted, this reports whether any element block exists for (dim, tag). Supplying it checks one exact block.

Source code in gmshparser/mesh.py 
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
def has_element_entity(
    self,
    dim: int,
    tag: int,
    element_type: int | None = None,
) -> bool:
    """Return whether an element block exists for an entity.

    When ``element_type`` is omitted, this reports whether any element block
    exists for ``(dim, tag)``. Supplying it checks one exact block.
    """
    if element_type is not None:
        return (dim, tag, int(element_type)) in self.element_entities_
    return any(
        entity_dim == dim and entity_tag == tag
        for entity_dim, entity_tag, _ in self.element_entities_
    )

has_node_entity(dim, tag)

Return whether a node entity exists for (dim, tag).

Source code in gmshparser/mesh.py 
125
126
127
def has_node_entity(self, dim: int, tag: int) -> bool:
    """Return whether a node entity exists for ``(dim, tag)``."""
    return (dim, tag) in self.node_entities_

Return whether a periodic relation exists for one slave entity.

Source code in gmshparser/mesh.py 
341
342
343
def has_periodic_link(self, dimension: int, entity_tag: int) -> bool:
    """Return whether a periodic relation exists for one slave entity."""
    return (dimension, entity_tag) in self.periodic_links_

set_ascii(is_ascii)

Set whether the mesh uses the ASCII representation.

Source code in gmshparser/mesh.py 
77
78
79
def set_ascii(self, is_ascii: bool) -> None:
    """Set whether the mesh uses the ASCII representation."""
    self.ascii_ = is_ascii

set_element_physical_tags(element_tag, physical_tags)

Store physical tags carried directly by one legacy element record.

Source code in gmshparser/mesh.py 
329
330
331
332
333
334
335
def set_element_physical_tags(
    self,
    element_tag: int,
    physical_tags: Iterable[int],
) -> None:
    """Store physical tags carried directly by one legacy element record."""
    self.element_physical_tags_[element_tag] = self._normalize_tags(physical_tags)

set_entity_physical_tags(dimension, tag, physical_tags)

Replace physical tags assigned to one elementary entity.

Source code in gmshparser/mesh.py 
298
299
300
301
302
303
304
305
306
307
def set_entity_physical_tags(
    self,
    dimension: int,
    tag: int,
    physical_tags: Iterable[int],
) -> None:
    """Replace physical tags assigned to one elementary entity."""
    self.entity_physical_tags_[(dimension, tag)] = self._normalize_tags(
        physical_tags
    )

set_max_element_tag(max_element_tag)

Set the maximum element tag.

Source code in gmshparser/mesh.py 
190
191
192
def set_max_element_tag(self, max_element_tag: int) -> None:
    """Set the maximum element tag."""
    self.max_element_tag_ = max_element_tag

set_max_node_tag(max_node_tag)

Set the maximum node tag.

Source code in gmshparser/mesh.py 
117
118
119
def set_max_node_tag(self, max_node_tag: int) -> None:
    """Set the maximum node tag."""
    self.max_node_tag_ = max_node_tag

set_min_element_tag(min_element_tag)

Set the minimum element tag.

Source code in gmshparser/mesh.py 
182
183
184
def set_min_element_tag(self, min_element_tag: int) -> None:
    """Set the minimum element tag."""
    self.min_element_tag_ = min_element_tag

set_min_node_tag(min_node_tag)

Set the minimum node tag.

Source code in gmshparser/mesh.py 
109
110
111
def set_min_node_tag(self, min_node_tag: int) -> None:
    """Set the minimum node tag."""
    self.min_node_tag_ = min_node_tag

set_name(name)

Set the name of the mesh.

Source code in gmshparser/mesh.py 
49
50
51
def set_name(self, name: str) -> None:
    """Set the name of the mesh."""
    self.name_ = name

set_number_of_element_entities(number_of_element_entities)

Set the number of element entities.

Source code in gmshparser/mesh.py 
163
164
165
166
167
168
def set_number_of_element_entities(
    self,
    number_of_element_entities: int,
) -> None:
    """Set the number of element entities."""
    self.number_of_element_entities_ = number_of_element_entities

set_number_of_elements(number_of_elements)

Set the number of elements.

Source code in gmshparser/mesh.py 
174
175
176
def set_number_of_elements(self, number_of_elements: int) -> None:
    """Set the number of elements."""
    self.number_of_elements_ = number_of_elements

set_number_of_node_entities(number_of_node_entities)

Set the number of node entities.

Source code in gmshparser/mesh.py 
93
94
95
def set_number_of_node_entities(self, number_of_node_entities: int) -> None:
    """Set the number of node entities."""
    self.number_of_node_entities_ = number_of_node_entities

set_number_of_nodes(number_of_nodes)

Set the number of nodes.

Source code in gmshparser/mesh.py 
101
102
103
def set_number_of_nodes(self, number_of_nodes: int) -> None:
    """Set the number of nodes."""
    self.number_of_nodes_ = number_of_nodes

set_physical_name(dimension, tag, name)

Store a physical group name without changing the legacy object model.

Source code in gmshparser/mesh.py 
286
287
288
def set_physical_name(self, dimension: int, tag: int, name: str) -> None:
    """Store a physical group name without changing the legacy object model."""
    self.physical_names_[(dimension, tag)] = name

set_precision(precision)

Set the MSH data-size field.

Source code in gmshparser/mesh.py 
85
86
87
def set_precision(self, precision: int) -> None:
    """Set the MSH data-size field."""
    self.precision_ = precision

set_version(version)

Set the MSH format version.

Source code in gmshparser/mesh.py 
57
58
59
60
61
62
63
def set_version(self, version: float) -> None:
    """Set the MSH format version."""
    self.version_ = version
    major = int(version)
    minor = int(round((version - major) * 10))
    self.version_major_ = major
    self.version_minor_ = minor

The compatibility mesh mirrors MSH entity blocks and exposes explicit get_*, set_*, and add_* methods.

import gmshparser

mesh = gmshparser.parse("mesh.msh")

print(mesh.get_name())
print(mesh.get_version())
print(mesh.get_ascii())
print(mesh.get_number_of_nodes())
print(mesh.get_number_of_elements())

Node blocks and nodes

gmshparser.node_entity.NodeEntity

NodeEntity class holds nodes for one block.

Source code in gmshparser/node_entity.py 
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
class NodeEntity:
    """NodeEntity class holds nodes for one block."""

    def __init__(self) -> None:
        self.dimension_ = -1
        self.tag_ = -1
        self.number_of_parametric_coordinates_ = -1
        self.number_of_nodes_ = -1
        self.nodes_: dict[int, Node] = {}

    def set_dimension(self, dimension: int) -> None:
        """Set the dimension of the entity to `dimension`."""
        self.dimension_ = dimension

    def get_dimension(self) -> int:
        """Get the dimension of the entity."""
        return self.dimension_

    def set_tag(self, tag: int) -> None:
        """Set the tag of the entity."""
        self.tag_ = tag

    def get_tag(self) -> int:
        """Get the tag of the entity."""
        return self.tag_

    def set_number_of_parametric_coordinates(self, npar: int) -> None:
        """Set the number of parametric coordinates of the entity."""
        self.number_of_parametric_coordinates_ = npar

    def get_number_of_parametric_coordinates(self) -> int:
        """Get the number of parametric coordinates of the entity."""
        return self.number_of_parametric_coordinates_

    def set_number_of_nodes(self, number_of_nodes: int) -> None:
        """Set the number of nodes of the entity."""
        self.number_of_nodes_ = number_of_nodes

    def get_number_of_nodes(self) -> int:
        """Get the number of nodes of the entity."""
        return self.number_of_nodes_

    def add_node(self, node: Node) -> None:
        """Add new node to entity."""
        self.nodes_[node.get_tag()] = node

    def get_node(self, tag: int) -> Node:
        """Get node from entity by its tag."""
        return self.nodes_[tag]

    def get_nodes(self) -> ValuesView[Node]:
        """Get all nodes in this entity."""
        return self.nodes_.values()

dimension_ = -1 instance-attribute

nodes_ = {} instance-attribute

number_of_nodes_ = -1 instance-attribute

number_of_parametric_coordinates_ = -1 instance-attribute

tag_ = -1 instance-attribute

__init__()

Source code in gmshparser/node_entity.py 
 9
10
11
12
13
14
def __init__(self) -> None:
    self.dimension_ = -1
    self.tag_ = -1
    self.number_of_parametric_coordinates_ = -1
    self.number_of_nodes_ = -1
    self.nodes_: dict[int, Node] = {}

add_node(node)

Add new node to entity.

Source code in gmshparser/node_entity.py 
48
49
50
def add_node(self, node: Node) -> None:
    """Add new node to entity."""
    self.nodes_[node.get_tag()] = node

get_dimension()

Get the dimension of the entity.

Source code in gmshparser/node_entity.py 
20
21
22
def get_dimension(self) -> int:
    """Get the dimension of the entity."""
    return self.dimension_

get_node(tag)

Get node from entity by its tag.

Source code in gmshparser/node_entity.py 
52
53
54
def get_node(self, tag: int) -> Node:
    """Get node from entity by its tag."""
    return self.nodes_[tag]

get_nodes()

Get all nodes in this entity.

Source code in gmshparser/node_entity.py 
56
57
58
def get_nodes(self) -> ValuesView[Node]:
    """Get all nodes in this entity."""
    return self.nodes_.values()

get_number_of_nodes()

Get the number of nodes of the entity.

Source code in gmshparser/node_entity.py 
44
45
46
def get_number_of_nodes(self) -> int:
    """Get the number of nodes of the entity."""
    return self.number_of_nodes_

get_number_of_parametric_coordinates()

Get the number of parametric coordinates of the entity.

Source code in gmshparser/node_entity.py 
36
37
38
def get_number_of_parametric_coordinates(self) -> int:
    """Get the number of parametric coordinates of the entity."""
    return self.number_of_parametric_coordinates_

get_tag()

Get the tag of the entity.

Source code in gmshparser/node_entity.py 
28
29
30
def get_tag(self) -> int:
    """Get the tag of the entity."""
    return self.tag_

set_dimension(dimension)

Set the dimension of the entity to dimension.

Source code in gmshparser/node_entity.py 
16
17
18
def set_dimension(self, dimension: int) -> None:
    """Set the dimension of the entity to `dimension`."""
    self.dimension_ = dimension

set_number_of_nodes(number_of_nodes)

Set the number of nodes of the entity.

Source code in gmshparser/node_entity.py 
40
41
42
def set_number_of_nodes(self, number_of_nodes: int) -> None:
    """Set the number of nodes of the entity."""
    self.number_of_nodes_ = number_of_nodes

set_number_of_parametric_coordinates(npar)

Set the number of parametric coordinates of the entity.

Source code in gmshparser/node_entity.py 
32
33
34
def set_number_of_parametric_coordinates(self, npar: int) -> None:
    """Set the number of parametric coordinates of the entity."""
    self.number_of_parametric_coordinates_ = npar

set_tag(tag)

Set the tag of the entity.

Source code in gmshparser/node_entity.py 
24
25
26
def set_tag(self, tag: int) -> None:
    """Set the tag of the entity."""
    self.tag_ = tag

gmshparser.node.Node

Node.

Source code in gmshparser/node.py 
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Node:
    """Node."""

    def __init__(self) -> None:
        self.tag_ = -1
        self.coordinates_ = cast(tuple[float, ...], (None, None, None))

    def set_tag(self, tag: int) -> None:
        """Set node tag (node id)."""
        self.tag_ = tag

    def get_tag(self) -> int:
        """Get node tag (node id)."""
        return self.tag_

    def set_coordinates(self, coordinates: tuple[float, ...]) -> None:
        """Set Cartesian and optional parametric node coordinates."""
        self.coordinates_ = coordinates

    def get_coordinates(self) -> tuple[float, ...]:
        """Get Cartesian and optional parametric node coordinates."""
        return self.coordinates_

coordinates_ = cast(tuple[float, ...], (None, None, None)) instance-attribute

tag_ = -1 instance-attribute

__init__()

Source code in gmshparser/node.py 
7
8
9
def __init__(self) -> None:
    self.tag_ = -1
    self.coordinates_ = cast(tuple[float, ...], (None, None, None))

get_coordinates()

Get Cartesian and optional parametric node coordinates.

Source code in gmshparser/node.py 
23
24
25
def get_coordinates(self) -> tuple[float, ...]:
    """Get Cartesian and optional parametric node coordinates."""
    return self.coordinates_

get_tag()

Get node tag (node id).

Source code in gmshparser/node.py 
15
16
17
def get_tag(self) -> int:
    """Get node tag (node id)."""
    return self.tag_

set_coordinates(coordinates)

Set Cartesian and optional parametric node coordinates.

Source code in gmshparser/node.py 
19
20
21
def set_coordinates(self, coordinates: tuple[float, ...]) -> None:
    """Set Cartesian and optional parametric node coordinates."""
    self.coordinates_ = coordinates

set_tag(tag)

Set node tag (node id).

Source code in gmshparser/node.py 
11
12
13
def set_tag(self, tag: int) -> None:
    """Set node tag (node id)."""
    self.tag_ = tag

for entity in mesh.get_node_entities():
    print(entity.get_dimension(), entity.get_tag())
    for node in entity.get_nodes():
        print(node.get_tag(), node.get_coordinates())

Legacy node coordinate tuples may contain Cartesian coordinates followed by parametric coordinates.

Element blocks and elements

gmshparser.element_entity.ElementEntity

ElementEntity class holds elements for one block.

Source code in gmshparser/element_entity.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
class ElementEntity:
    """ElementEntity class holds elements for one block."""

    def __init__(self) -> None:
        self.dimension_ = -1
        self.tag_ = -1
        self.element_type_ = -1
        self.number_of_elements_ = -1
        self.elements_: dict[int, Element] = {}

    def set_dimension(self, dimension: int) -> None:
        """Set the dimension of element entity."""
        self.dimension_ = dimension

    def get_dimension(self) -> int:
        """Get the dimension of the element entity."""
        return self.dimension_

    def set_tag(self, tag: int) -> None:
        """Set the tag of the element entity."""
        self.tag_ = tag

    def get_tag(self) -> int:
        """Get the tag of the element entity."""
        return self.tag_

    def set_element_type(self, element_type: int) -> None:
        """Set element type in element entity."""
        self.element_type_ = element_type

    def get_element_type(self) -> int:
        """Get element type in element entity."""
        return self.element_type_

    def set_number_of_elements(self, number_of_elements: int) -> None:
        """Set the number of elements in entity."""
        self.number_of_elements_ = number_of_elements

    def get_number_of_elements(self) -> int:
        """Get the number of elements in entity."""
        return self.number_of_elements_

    def add_element(self, element: Element) -> None:
        """Add a new element to the entity."""
        self.elements_[element.get_tag()] = element

    def get_element(self, tag: int) -> Element:
        """Get an element from the entity."""
        return self.elements_[tag]

    def get_elements(self) -> ValuesView[Element]:
        """Return all the elements of this entity."""
        return self.elements_.values()

    def __str__(self) -> str:
        io = StringIO()
        io.write(f"---- Element entity # {self.get_tag()} ----\n")
        io.write(f"Dimension: {self.get_dimension()}\n")
        io.write(f"Element type: {self.get_element_type()}\n")
        io.write(f"Number of elements: {self.get_number_of_elements()}\n")
        return io.getvalue()

dimension_ = -1 instance-attribute

element_type_ = -1 instance-attribute

elements_ = {} instance-attribute

number_of_elements_ = -1 instance-attribute

tag_ = -1 instance-attribute

__init__()

Source code in gmshparser/element_entity.py 
10
11
12
13
14
15
def __init__(self) -> None:
    self.dimension_ = -1
    self.tag_ = -1
    self.element_type_ = -1
    self.number_of_elements_ = -1
    self.elements_: dict[int, Element] = {}

__str__()

Source code in gmshparser/element_entity.py 
61
62
63
64
65
66
67
def __str__(self) -> str:
    io = StringIO()
    io.write(f"---- Element entity # {self.get_tag()} ----\n")
    io.write(f"Dimension: {self.get_dimension()}\n")
    io.write(f"Element type: {self.get_element_type()}\n")
    io.write(f"Number of elements: {self.get_number_of_elements()}\n")
    return io.getvalue()

add_element(element)

Add a new element to the entity.

Source code in gmshparser/element_entity.py 
49
50
51
def add_element(self, element: Element) -> None:
    """Add a new element to the entity."""
    self.elements_[element.get_tag()] = element

get_dimension()

Get the dimension of the element entity.

Source code in gmshparser/element_entity.py 
21
22
23
def get_dimension(self) -> int:
    """Get the dimension of the element entity."""
    return self.dimension_

get_element(tag)

Get an element from the entity.

Source code in gmshparser/element_entity.py 
53
54
55
def get_element(self, tag: int) -> Element:
    """Get an element from the entity."""
    return self.elements_[tag]

get_element_type()

Get element type in element entity.

Source code in gmshparser/element_entity.py 
37
38
39
def get_element_type(self) -> int:
    """Get element type in element entity."""
    return self.element_type_

get_elements()

Return all the elements of this entity.

Source code in gmshparser/element_entity.py 
57
58
59
def get_elements(self) -> ValuesView[Element]:
    """Return all the elements of this entity."""
    return self.elements_.values()

get_number_of_elements()

Get the number of elements in entity.

Source code in gmshparser/element_entity.py 
45
46
47
def get_number_of_elements(self) -> int:
    """Get the number of elements in entity."""
    return self.number_of_elements_

get_tag()

Get the tag of the element entity.

Source code in gmshparser/element_entity.py 
29
30
31
def get_tag(self) -> int:
    """Get the tag of the element entity."""
    return self.tag_

set_dimension(dimension)

Set the dimension of element entity.

Source code in gmshparser/element_entity.py 
17
18
19
def set_dimension(self, dimension: int) -> None:
    """Set the dimension of element entity."""
    self.dimension_ = dimension

set_element_type(element_type)

Set element type in element entity.

Source code in gmshparser/element_entity.py 
33
34
35
def set_element_type(self, element_type: int) -> None:
    """Set element type in element entity."""
    self.element_type_ = element_type

set_number_of_elements(number_of_elements)

Set the number of elements in entity.

Source code in gmshparser/element_entity.py 
41
42
43
def set_number_of_elements(self, number_of_elements: int) -> None:
    """Set the number of elements in entity."""
    self.number_of_elements_ = number_of_elements

set_tag(tag)

Set the tag of the element entity.

Source code in gmshparser/element_entity.py 
25
26
27
def set_tag(self, tag: int) -> None:
    """Set the tag of the element entity."""
    self.tag_ = tag

gmshparser.element.Element

Element.

Source code in gmshparser/element.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Element:
    """Element."""

    def __init__(self) -> None:
        self.tag_ = -1
        self.connectivity_: list[int] = []

    def set_tag(self, tag: int) -> None:
        """Set element tag."""
        self.tag_ = tag

    def get_tag(self) -> int:
        """Get element tag."""
        return self.tag_

    def set_connectivity(self, connectivity: list[int]) -> None:
        """Set element connectivity."""
        self.connectivity_ = connectivity

    def get_connectivity(self) -> list[int]:
        """Get element connectivity."""
        return self.connectivity_

connectivity_ = [] instance-attribute

tag_ = -1 instance-attribute

__init__()

Source code in gmshparser/element.py 
4
5
6
def __init__(self) -> None:
    self.tag_ = -1
    self.connectivity_: list[int] = []

get_connectivity()

Get element connectivity.

Source code in gmshparser/element.py 
20
21
22
def get_connectivity(self) -> list[int]:
    """Get element connectivity."""
    return self.connectivity_

get_tag()

Get element tag.

Source code in gmshparser/element.py 
12
13
14
def get_tag(self) -> int:
    """Get element tag."""
    return self.tag_

set_connectivity(connectivity)

Set element connectivity.

Source code in gmshparser/element.py 
16
17
18
def set_connectivity(self, connectivity: list[int]) -> None:
    """Set element connectivity."""
    self.connectivity_ = connectivity

set_tag(tag)

Set element tag.

Source code in gmshparser/element.py 
 8
 9
10
def set_tag(self, tag: int) -> None:
    """Set element tag."""
    self.tag_ = tag

Element blocks are identified by dimension, elementary entity tag, and element type. Existing two-argument lookup remains available when an entity contains one element type:

entity = mesh.get_element_entity(2, 1)

For a mixed entity, provide the element type explicitly:

from gmshparser import ElementType

triangles = mesh.get_element_entity(2, 1, ElementType.TRIANGLE)
quadrangles = mesh.get_element_entity(2, 1, ElementType.QUADRANGLE)

The two-argument form raises KeyError for an ambiguous mixed entity rather than returning an arbitrary block.

Format versions

gmshparser.version_manager.MshFormatVersion

Bases: Enum

Enumeration of supported MSH format versions.

Source code in gmshparser/version_manager.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class MshFormatVersion(Enum):
    """Enumeration of supported MSH format versions."""

    MSH_1_0 = (1, 0)
    MSH_2_0 = (2, 0)
    MSH_2_1 = (2, 1)
    MSH_2_2 = (2, 2)
    MSH_4_0 = (4, 0)
    MSH_4_1 = (4, 1)

    def __init__(self, major: int, minor: int):
        self.major = major
        self.minor = minor

    @property
    def version_number(self) -> float:
        """Return version as float (e.g., 4.1)."""
        return float(f"{self.major}.{self.minor}")

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

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

MSH_1_0 = (1, 0) class-attribute instance-attribute

MSH_2_0 = (2, 0) class-attribute instance-attribute

MSH_2_1 = (2, 1) class-attribute instance-attribute

MSH_2_2 = (2, 2) class-attribute instance-attribute

MSH_4_0 = (4, 0) class-attribute instance-attribute

MSH_4_1 = (4, 1) class-attribute instance-attribute

major = major instance-attribute

minor = minor instance-attribute

version_number property

Return version as float (e.g., 4.1).

__init__(major, minor)

Source code in gmshparser/version_manager.py 
20
21
22
def __init__(self, major: int, minor: int):
    self.major = major
    self.minor = minor

__repr__()

Source code in gmshparser/version_manager.py 
32
33
def __repr__(self) -> str:
    return f"MshFormatVersion({self.major}.{self.minor})"

__str__()

Source code in gmshparser/version_manager.py 
29
30
def __str__(self) -> str:
    return f"{self.major}.{self.minor}"

gmshparser.version_manager.VersionManager

Manager for MSH format version detection and validation.

Source code in gmshparser/version_manager.py 
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
class VersionManager:
    """Manager for MSH format version detection and validation."""

    # Currently supported versions
    SUPPORTED_VERSIONS = [
        MshFormatVersion.MSH_1_0,
        MshFormatVersion.MSH_2_0,
        MshFormatVersion.MSH_2_1,
        MshFormatVersion.MSH_2_2,
        MshFormatVersion.MSH_4_0,
        MshFormatVersion.MSH_4_1,
    ]

    # Versions that are recognized but not fully implemented yet
    RECOGNIZED_VERSIONS = [
        MshFormatVersion.MSH_1_0,
        MshFormatVersion.MSH_2_0,
        MshFormatVersion.MSH_2_1,
        MshFormatVersion.MSH_2_2,
        MshFormatVersion.MSH_4_0,
        MshFormatVersion.MSH_4_1,
    ]

    @staticmethod
    def parse_version(version_str: str) -> tuple[int, int]:
        """Parse version string to major and minor version numbers.

        Parameters
        ----------
        version_str : str
            Version string (e.g., "4.1" or "2.2")

        Returns
        -------
        Tuple[int, int]
            Tuple of (major, minor) version numbers

        Raises
        ------
        ValueError
            If version string cannot be parsed
        """
        try:
            version_float = float(version_str)
            major = int(version_float)
            # Extract minor version from decimal part
            minor = int(round((version_float - major) * 10))
            return (major, minor)
        except (ValueError, TypeError) as e:
            raise ValueError(f"Invalid version string: {version_str}") from e

    @classmethod
    def get_version_enum(cls, major: int, minor: int) -> MshFormatVersion:
        """Get MshFormatVersion enum from major and minor version numbers.

        Parameters
        ----------
        major : int
            Major version number
        minor : int
            Minor version number

        Returns
        -------
        MshFormatVersion
            Version enum if found

        Raises
        ------
        ValueError
            If version is not recognized
        """
        for version in cls.RECOGNIZED_VERSIONS:
            if version.major == major and version.minor == minor:
                return version
        raise ValueError(f"Unrecognized MSH format version: {major}.{minor}")

    @classmethod
    def is_supported(cls, version: MshFormatVersion) -> bool:
        """Check if a version is supported.

        Parameters
        ----------
        version : MshFormatVersion
            Version to check

        Returns
        -------
        bool
            True if version is supported
        """
        return version in cls.SUPPORTED_VERSIONS

    @classmethod
    def validate_version(cls, version_str: str) -> MshFormatVersion:
        """Parse and validate a version string.

        Parameters
        ----------
        version_str : str
            Version string to validate

        Returns
        -------
        MshFormatVersion
            Validated version enum

        Raises
        ------
        ValueError
            If version is not recognized or not supported
        """
        major, minor = cls.parse_version(version_str)
        version_enum = cls.get_version_enum(major, minor)

        if not cls.is_supported(version_enum):
            supported = ", ".join(str(v) for v in cls.SUPPORTED_VERSIONS)
            raise ValueError(
                f"MSH format version {major}.{minor} is recognized but not "
                f"supported. Supported versions: {supported}"
            )

        return version_enum

    @classmethod
    def is_version_1(cls, version: MshFormatVersion) -> bool:
        """Check if version is in the 1.x series.

        Parameters
        ----------
        version : MshFormatVersion
            Version to check

        Returns
        -------
        bool
            True if version is 1.x
        """
        return version.major == 1

    @classmethod
    def is_version_2(cls, version: MshFormatVersion) -> bool:
        """Check if version is in the 2.x series.

        Parameters
        ----------
        version : MshFormatVersion
            Version to check

        Returns
        -------
        bool
            True if version is 2.x
        """
        return version.major == 2

    @classmethod
    def is_version_4(cls, version: MshFormatVersion) -> bool:
        """Check if version is in the 4.x series.

        Parameters
        ----------
        version : MshFormatVersion
            Version to check

        Returns
        -------
        bool
            True if version is 4.x
        """
        return version.major == 4

    @classmethod
    def get_supported_versions_list(cls) -> list[str]:
        """Get list of supported version strings.

        Returns
        -------
        List[str]
            List of supported version strings
        """
        return [str(v) for v in cls.SUPPORTED_VERSIONS]

RECOGNIZED_VERSIONS = [MshFormatVersion.MSH_1_0, MshFormatVersion.MSH_2_0, MshFormatVersion.MSH_2_1, MshFormatVersion.MSH_2_2, MshFormatVersion.MSH_4_0, MshFormatVersion.MSH_4_1] class-attribute instance-attribute

SUPPORTED_VERSIONS = [MshFormatVersion.MSH_1_0, MshFormatVersion.MSH_2_0, MshFormatVersion.MSH_2_1, MshFormatVersion.MSH_2_2, MshFormatVersion.MSH_4_0, MshFormatVersion.MSH_4_1] class-attribute instance-attribute

get_supported_versions_list() classmethod

Get list of supported version strings.

Returns:

Type Description
List[str]

List of supported version strings
Source code in gmshparser/version_manager.py 
208
209
210
211
212
213
214
215
216
217
@classmethod
def get_supported_versions_list(cls) -> list[str]:
    """Get list of supported version strings.

    Returns
    -------
    List[str]
        List of supported version strings
    """
    return [str(v) for v in cls.SUPPORTED_VERSIONS]

get_version_enum(major, minor) classmethod

Get MshFormatVersion enum from major and minor version numbers.

Parameters:

Name Type Description Default
major int

Major version number

 required
minor int

Minor version number

 required

Returns:

Type Description
MshFormatVersion

Version enum if found

Raises:

Type Description
ValueError

If version is not recognized
Source code in gmshparser/version_manager.py 
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
@classmethod
def get_version_enum(cls, major: int, minor: int) -> MshFormatVersion:
    """Get MshFormatVersion enum from major and minor version numbers.

    Parameters
    ----------
    major : int
        Major version number
    minor : int
        Minor version number

    Returns
    -------
    MshFormatVersion
        Version enum if found

    Raises
    ------
    ValueError
        If version is not recognized
    """
    for version in cls.RECOGNIZED_VERSIONS:
        if version.major == major and version.minor == minor:
            return version
    raise ValueError(f"Unrecognized MSH format version: {major}.{minor}")

is_supported(version) classmethod

Check if a version is supported.

Parameters:

Name Type Description Default
version MshFormatVersion

Version to check

 required

Returns:

Type Description
bool

True if version is supported
Source code in gmshparser/version_manager.py 
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
@classmethod
def is_supported(cls, version: MshFormatVersion) -> bool:
    """Check if a version is supported.

    Parameters
    ----------
    version : MshFormatVersion
        Version to check

    Returns
    -------
    bool
        True if version is supported
    """
    return version in cls.SUPPORTED_VERSIONS

is_version_1(version) classmethod

Check if version is in the 1.x series.

Parameters:

Name Type Description Default
version MshFormatVersion

Version to check

 required

Returns:

Type Description
bool

True if version is 1.x
Source code in gmshparser/version_manager.py 
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
@classmethod
def is_version_1(cls, version: MshFormatVersion) -> bool:
    """Check if version is in the 1.x series.

    Parameters
    ----------
    version : MshFormatVersion
        Version to check

    Returns
    -------
    bool
        True if version is 1.x
    """
    return version.major == 1

is_version_2(version) classmethod

Check if version is in the 2.x series.

Parameters:

Name Type Description Default
version MshFormatVersion

Version to check

 required

Returns:

Type Description
bool

True if version is 2.x
Source code in gmshparser/version_manager.py 
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
@classmethod
def is_version_2(cls, version: MshFormatVersion) -> bool:
    """Check if version is in the 2.x series.

    Parameters
    ----------
    version : MshFormatVersion
        Version to check

    Returns
    -------
    bool
        True if version is 2.x
    """
    return version.major == 2

is_version_4(version) classmethod

Check if version is in the 4.x series.

Parameters:

Name Type Description Default
version MshFormatVersion

Version to check

 required

Returns:

Type Description
bool

True if version is 4.x
Source code in gmshparser/version_manager.py 
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
@classmethod
def is_version_4(cls, version: MshFormatVersion) -> bool:
    """Check if version is in the 4.x series.

    Parameters
    ----------
    version : MshFormatVersion
        Version to check

    Returns
    -------
    bool
        True if version is 4.x
    """
    return version.major == 4

parse_version(version_str) staticmethod

Parse version string to major and minor version numbers.

Parameters:

Name Type Description Default
version_str str

Version string (e.g., "4.1" or "2.2")

 required

Returns:

Type Description
Tuple[int, int]

Tuple of (major, minor) version numbers

Raises:

Type Description
ValueError

If version string cannot be parsed
Source code in gmshparser/version_manager.py 
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
@staticmethod
def parse_version(version_str: str) -> tuple[int, int]:
    """Parse version string to major and minor version numbers.

    Parameters
    ----------
    version_str : str
        Version string (e.g., "4.1" or "2.2")

    Returns
    -------
    Tuple[int, int]
        Tuple of (major, minor) version numbers

    Raises
    ------
    ValueError
        If version string cannot be parsed
    """
    try:
        version_float = float(version_str)
        major = int(version_float)
        # Extract minor version from decimal part
        minor = int(round((version_float - major) * 10))
        return (major, minor)
    except (ValueError, TypeError) as e:
        raise ValueError(f"Invalid version string: {version_str}") from e

validate_version(version_str) classmethod

Parse and validate a version string.

Parameters:

Name Type Description Default
version_str str

Version string to validate

 required

Returns:

Type Description
MshFormatVersion

Validated version enum

Raises:

Type Description
ValueError

If version is not recognized or not supported
Source code in gmshparser/version_manager.py 
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
@classmethod
def validate_version(cls, version_str: str) -> MshFormatVersion:
    """Parse and validate a version string.

    Parameters
    ----------
    version_str : str
        Version string to validate

    Returns
    -------
    MshFormatVersion
        Validated version enum

    Raises
    ------
    ValueError
        If version is not recognized or not supported
    """
    major, minor = cls.parse_version(version_str)
    version_enum = cls.get_version_enum(major, minor)

    if not cls.is_supported(version_enum):
        supported = ", ".join(str(v) for v in cls.SUPPORTED_VERSIONS)
        raise ValueError(
            f"MSH format version {major}.{minor} is recognized but not "
            f"supported. Supported versions: {supported}"
        )

    return version_enum

These classes support parser version detection and validation. The modern application model exposes the smaller immutable gmshparser.api.Version value.

Migration

Equivalent modern access is flatter:

modern = gmshparser.read("mesh.msh")

print(modern.name)
print(modern.version)
print(len(modern.nodes))
print(len(modern.elements))

See Migrating from the Compatibility API for a method-by-method mapping.