Skip to content

Mesh API

gmshparser.mesh.Mesh

Bases: object

Mesh is the main class of the package.

Source code in gmshparser/mesh.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
 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
class Mesh(object):
    """Mesh is the main class of the package."""

    def __init__(self):
        self.name_ = "New Mesh"
        self.version_ = None  # Will be set when parsing MeshFormat
        self.version_major_ = None
        self.version_minor_ = None
        self.ascii_ = True
        self.precision_ = 8  # t_size
        self.number_of_node_entities_ = 0
        self.number_of_nodes_ = 0
        self.min_node_tag_ = 0
        self.max_node_tag_ = 0
        self.node_entities_ = {}
        self.number_of_element_entities_ = 0
        self.number_of_elements_ = 0
        self.min_element_tag_ = 0
        self.max_element_tag_ = 0
        self.element_entities_ = {}

    def set_name(self, name: str):
        """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):
        """Set the version of the Mesh object"""
        self.version_ = version
        # Parse major and minor version numbers
        major = int(version)
        minor = int(round((version - major) * 10))
        self.version_major_ = major
        self.version_minor_ = minor

    def get_version(self) -> Optional[float]:
        """Get the version of the Mesh object"""
        return self.version_

    def get_version_major(self) -> Optional[int]:
        """Get the major version number."""
        return self.version_major_

    def get_version_minor(self) -> Optional[int]:
        """Get the minor version number."""
        return self.version_minor_

    def set_ascii(self, is_ascii: bool):
        """Set a boolean flag whether this mesh is ASCII or binary"""
        self.ascii_ = is_ascii

    def get_ascii(self) -> bool:
        """Get a boolean flag whether this mesh is ASCII of binary"""
        return self.ascii_

    def set_precision(self, precision: int):
        """Set the precision of the mesh (8)"""
        self.precision_ = precision

    def get_precision(self) -> int:
        """Get the precision of the mesh"""
        return self.precision_

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

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

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

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

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

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

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

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

    def has_node_entity(self, dim: int, tag: int) -> bool:
        """Test does mesh have node entity of dimension `dim` and tag `tag`."""
        return (dim, tag) in self.node_entities_

    def add_node_entity(self, node_entity: NodeEntity):
        """Add node entity to 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):
        """Get node entity based on dimension and tag."""
        return self.node_entities_[(dim, tag)]

    def get_node_entities(self) -> List[NodeEntity]:
        """Get all node entities of mesh."""
        return self.node_entities_.values()

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

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

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

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

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

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

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

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

    def has_element_entity(self, dim: int, tag: int) -> bool:
        """Test does mesh have element entity with `(dim, tag)`."""
        return (dim, tag) in self.element_entities_

    def add_element_entity(self, element_entity: ElementEntity):
        """Add element entity to mesh."""
        dim = element_entity.get_dimension()
        tag = element_entity.get_tag()
        self.element_entities_[(dim, tag)] = element_entity

    def get_element_entity(self, dim: int, tag: int) -> ElementEntity:
        """Get element entity based on dimension `dim` and tag `tag`."""
        return self.element_entities_[(dim, tag)]

    def get_element_entities(self) -> List[ElementEntity]:
        """Get all element entities as dictionary."""
        return self.element_entities_.values()

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

add_element_entity(element_entity)

Add element entity to mesh.

Source code in gmshparser/mesh.py 
159
160
161
162
163
def add_element_entity(self, element_entity: ElementEntity):
    """Add element entity to mesh."""
    dim = element_entity.get_dimension()
    tag = element_entity.get_tag()
    self.element_entities_[(dim, tag)] = element_entity

add_node_entity(node_entity)

Add node entity to mesh.

Source code in gmshparser/mesh.py 
109
110
111
112
113
def add_node_entity(self, node_entity: NodeEntity):
    """Add node entity to mesh."""
    dim = node_entity.get_dimension()
    tag = node_entity.get_tag()
    self.node_entities_[(dim, tag)] = node_entity

get_ascii()

Get a boolean flag whether this mesh is ASCII of binary

Source code in gmshparser/mesh.py 
61
62
63
def get_ascii(self) -> bool:
    """Get a boolean flag whether this mesh is ASCII of binary"""
    return self.ascii_

get_element_entities()

Get all element entities as dictionary.

Source code in gmshparser/mesh.py 
169
170
171
def get_element_entities(self) -> List[ElementEntity]:
    """Get all element entities as dictionary."""
    return self.element_entities_.values()

get_element_entity(dim, tag)

Get element entity based on dimension dim and tag tag.

Source code in gmshparser/mesh.py 
165
166
167
def get_element_entity(self, dim: int, tag: int) -> ElementEntity:
    """Get element entity based on dimension `dim` and tag `tag`."""
    return self.element_entities_[(dim, tag)]

get_max_element_tag()

Get element maximum tag.

Source code in gmshparser/mesh.py 
151
152
153
def get_max_element_tag(self) -> int:
    """Get element maximum tag."""
    return self.max_element_tag_

get_max_node_tag()

Get node maximum tag.

Source code in gmshparser/mesh.py 
101
102
103
def get_max_node_tag(self) -> int:
    """Get node maximum tag."""
    return self.max_node_tag_

get_min_element_tag()

Get element minimum tag.

Source code in gmshparser/mesh.py 
143
144
145
def get_min_element_tag(self) -> int:
    """Get element minimum tag."""
    return self.min_element_tag_

get_min_node_tag()

Get node minimum tag.

Source code in gmshparser/mesh.py 
93
94
95
def get_min_node_tag(self) -> int:
    """Get node minimum tag."""
    return self.min_node_tag_

get_name()

Get the name of the mesh.

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

get_node_entities()

Get all node entities of mesh.

Source code in gmshparser/mesh.py 
119
120
121
def get_node_entities(self) -> List[NodeEntity]:
    """Get all node entities of mesh."""
    return self.node_entities_.values()

get_node_entity(dim, tag)

Get node entity based on dimension and tag.

Source code in gmshparser/mesh.py 
115
116
117
def get_node_entity(self, dim: int, tag: int):
    """Get node entity based on dimension and tag."""
    return self.node_entities_[(dim, tag)]

get_number_of_element_entities()

Get number of element entities.

Source code in gmshparser/mesh.py 
127
128
129
def get_number_of_element_entities(self) -> int:
    """Get number of element entities."""
    return self.number_of_element_entities_

get_number_of_elements()

Get number of elements.

Source code in gmshparser/mesh.py 
135
136
137
def get_number_of_elements(self) -> int:
    """Get number of elements."""
    return self.number_of_elements_

get_number_of_node_entities()

Get number of node entities.

Source code in gmshparser/mesh.py 
77
78
79
def get_number_of_node_entities(self) -> int:
    """Get number of node entities."""
    return self.number_of_node_entities_

get_number_of_nodes()

Get number of nodes.

Source code in gmshparser/mesh.py 
85
86
87
def get_number_of_nodes(self) -> int:
    """Get number of nodes."""
    return self.number_of_nodes_

get_precision()

Get the precision of the mesh

Source code in gmshparser/mesh.py 
69
70
71
def get_precision(self) -> int:
    """Get the precision of the mesh"""
    return self.precision_

get_version()

Get the version of the Mesh object

Source code in gmshparser/mesh.py 
45
46
47
def get_version(self) -> Optional[float]:
    """Get the version of the Mesh object"""
    return self.version_

get_version_major()

Get the major version number.

Source code in gmshparser/mesh.py 
49
50
51
def get_version_major(self) -> Optional[int]:
    """Get the major version number."""
    return self.version_major_

get_version_minor()

Get the minor version number.

Source code in gmshparser/mesh.py 
53
54
55
def get_version_minor(self) -> Optional[int]:
    """Get the minor version number."""
    return self.version_minor_

has_element_entity(dim, tag)

Test does mesh have element entity with (dim, tag).

Source code in gmshparser/mesh.py 
155
156
157
def has_element_entity(self, dim: int, tag: int) -> bool:
    """Test does mesh have element entity with `(dim, tag)`."""
    return (dim, tag) in self.element_entities_

has_node_entity(dim, tag)

Test does mesh have node entity of dimension dim and tag tag.

Source code in gmshparser/mesh.py 
105
106
107
def has_node_entity(self, dim: int, tag: int) -> bool:
    """Test does mesh have node entity of dimension `dim` and tag `tag`."""
    return (dim, tag) in self.node_entities_

set_ascii(is_ascii)

Set a boolean flag whether this mesh is ASCII or binary

Source code in gmshparser/mesh.py 
57
58
59
def set_ascii(self, is_ascii: bool):
    """Set a boolean flag whether this mesh is ASCII or binary"""
    self.ascii_ = is_ascii

set_max_element_tag(max_element_tag)

Set element maximum tag.

Source code in gmshparser/mesh.py 
147
148
149
def set_max_element_tag(self, max_element_tag: int):
    """Set element maximum tag."""
    self.max_element_tag_ = max_element_tag

set_max_node_tag(max_node_tag)

Set node maximum tag.

Source code in gmshparser/mesh.py 
97
98
99
def set_max_node_tag(self, max_node_tag: int):
    """Set node maximum tag."""
    self.max_node_tag_ = max_node_tag

set_min_element_tag(min_element_tag)

Set element minimum tag.

Source code in gmshparser/mesh.py 
139
140
141
def set_min_element_tag(self, min_element_tag: int):
    """Set element minimum tag."""
    self.min_element_tag_ = min_element_tag

set_min_node_tag(min_node_tag)

Set node minimum tag.

Source code in gmshparser/mesh.py 
89
90
91
def set_min_node_tag(self, min_node_tag: int):
    """Set node minimum tag."""
    self.min_node_tag_ = min_node_tag

set_name(name)

Set the name of the mesh.

Source code in gmshparser/mesh.py 
28
29
30
def set_name(self, name: str):
    """Set the name of the mesh."""
    self.name_ = name

set_number_of_element_entities(number_of_element_entities)

Set number of element entities.

Source code in gmshparser/mesh.py 
123
124
125
def set_number_of_element_entities(self, number_of_element_entities: int):
    """Set number of element entities."""
    self.number_of_element_entities_ = number_of_element_entities

set_number_of_elements(number_of_elements)

Set number of elements.

Source code in gmshparser/mesh.py 
131
132
133
def set_number_of_elements(self, number_of_elements: int):
    """Set number of elements."""
    self.number_of_elements_ = number_of_elements

set_number_of_node_entities(number_of_node_entities)

Set number of node entities.

Source code in gmshparser/mesh.py 
73
74
75
def set_number_of_node_entities(self, number_of_node_entities: int):
    """Set number of node entities."""
    self.number_of_node_entities_ = number_of_node_entities

set_number_of_nodes(number_of_nodes)

Set number of nodes.

Source code in gmshparser/mesh.py 
81
82
83
def set_number_of_nodes(self, number_of_nodes: int):
    """Set number of nodes."""
    self.number_of_nodes_ = number_of_nodes

set_precision(precision)

Set the precision of the mesh (8)

Source code in gmshparser/mesh.py 
65
66
67
def set_precision(self, precision: int):
    """Set the precision of the mesh (8)"""
    self.precision_ = precision

set_version(version)

Set the version of the Mesh object

Source code in gmshparser/mesh.py 
36
37
38
39
40
41
42
43
def set_version(self, version: float):
    """Set the version of the Mesh object"""
    self.version_ = version
    # Parse major and minor version numbers
    major = int(version)
    minor = int(round((version - major) * 10))
    self.version_major_ = major
    self.version_minor_ = minor

Usage Examples

Basic Information

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

# Version info
version = mesh.get_version()
is_ascii = mesh.is_ascii()

# Counts
num_nodes = mesh.get_number_of_nodes()
num_elements = mesh.get_number_of_elements()
num_node_entities = mesh.get_number_of_node_entities()
num_element_entities = mesh.get_number_of_element_entities()

# Tag ranges
min_node_tag = mesh.get_min_node_tag()
max_node_tag = mesh.get_max_node_tag()
min_element_tag = mesh.get_min_element_tag()
max_element_tag = mesh.get_max_element_tag()

Accessing Data

# Get all node entities
node_entities = mesh.get_node_entities()

# Get all element entities
element_entities = mesh.get_element_entities()

# Get mesh name (filename)
name = mesh.get_name()