# iota.mesh

**Description**

This module provides functionalities to operate with data from the meshes.

* [CFDMesh](#class_CFDmesh)
  * [add\_cell\_faces](#add_cell_faces)
  * [add\_face](#add_face)
  * [add\_vertex](#add_vertex)
  * [add\_vertices](#add_vertices)
  * [cell](#cell)
  * [cell\_center](#cell_center)
  * [cell\_centers](#cell_centers)
  * [cell\_faces](#cell_faces)
  * [cell\_ids](#cell_ids)
  * [cell\_neighbours](#cell_neighbours)
  * [cell\_owners](#cell_owners)
  * [cell\_size](#cell_size)
  * [cell\_type](#cell_type)
  * [cell\_volume](#cell_volume)
  * [cells\_around\_vertex](#cells_around_vertex)
  * [check\_consistency](#check_consistency)
  * [dimension](#dimension)
  * [edge](#edge)
  * [edge\_ids](#edge_ids)
  * [edge\_size](#edge_size)
  * [edges](#edges)
  * [face](#face)
  * [face\_area](#face_area)
  * [face\_cell\_neighbours](#face_cell_neighbours)
  * [face\_centroid](#face_centroid)
  * [face\_centroids](#face_centroids)
  * [face\_ids](#face_ids)
  * [face\_neighbours](#face_neighbours)
  * [face\_size](#face_size)
  * [is\_valid](#is_valid)
  * [isosurface](#isosurface)
  * [reserve\_faces](#reserve_faces)
  * [reserve\_vertices](#reserve_vertices)
  * [skin](#skin)
  * [slice](#slice)
  * [vertex](#vertex)
  * [vertex\_ids](#vertex_ids)
  * [vertex\_size](#vertex_size)
  * [vertices](#vertices)
  * [vertices\_bytes](#vertices_bytes)
  * [vertices\_weight](#vertices_weigth)
  * [volume](#volume)
* Package
  * [mesh\_load](#mesh_load)
  * [mesh\_export](#mesh_export)
  * [mesh\_create\_line](#mesh_create_line)
  * [mesh\_create\_circle](#mesh_create_circle)
  * [mesh\_create\_rectangle](#mesh_create_rectangle)
  * [mesh\_create\_cuboid](#mesh_create_cuboid)
  * [mesh\_create\_cylinder](#mesh_create_cylinder)

## [class CFDMesh](#class_dataset) <a href="#class_cfdmesh" id="class_cfdmesh"></a>

#### [iota.mesh.**CFDMesh**(id, name](#CFDMesh_ctor) <a href="#cfdmesh_ctor" id="cfdmesh_ctor"></a>

_CFD mesh class object. This object is returned when getting a mesh from a CFD dataset using_ [_Dataset.get\_mesh_](https://github.com/particle-analytics/iota-user-manual/tree/c25e767c006a77f3660728a528545cf848dbef52/datasets.md#dataset_get_mesh) _method._

**Parameters**

* `id`: (int) id for the mesh
* `name`: (str) name for the mesh

**Example**

```python
my_mesh = iota.mesh.CFDMesh(0,'my_mesh')
```

### Methods

#### [CFDMesh.add\_cell\_faces(type, faces)](#add_cell_faces) <a href="#add_cell_faces" id="add_cell_faces"></a>

_Add a new cell defined by a list of faces_

**Parameters**

* `type` : (CFDMesh.CellType) the type of the cell
* `faces` : (list of FaceHandle) a list of faces&#x20;

**Examples**

_Adding a cell of type hexahedron defined by a list of faces_

```python
my_mesh.add_cell_faces(iota.mesh.CellType.HEXAHEDRON,list_of_faces)
```

_Adding a cell of type polyhedron defined by a list of faces_

```python
my_mesh.add_cell_faces(iota.mesh.CellType.POLYHEDRON,list_of_faces)
```

#### [CFDMesh.add\_face(vertices,id)](#add_face) <a href="#add_face" id="add_face"></a>

_Add a new face defined by a list of vertices_

**Parameters**

* `vertices` : (list of VertexHandle) a list of vertices&#x20;
* `id` : (int) identifier of the face

**Examples**

_Adding a cell of type hexahedron defined by a list of faces_

```python
my_mesh.add_cell_faces(iota.mesh.CellType.HEXAHEDRON,list_of_faces)
```

_Adding a cell of type polyhedron defined by a list of faces_

```python
my_mesh.add_cell_faces(iota.mesh.CellType.POLYHEDRON,list_of_faces)
```

#### [CFDMesh.add\_vertex(vertex,id)](#add_vertex) <a href="#add_vertex" id="add_vertex"></a>

_Add a single new vertex to the mesh_

**Parameters**

* `vertex` : (iota.Vector3) vertex position (x,y,z)
* `id` : (int) id for the vertex

**Example**

```python
my_mesh.add_vertex(iota.Vector3(0,0,0), 1)
```

#### [CFDMesh.add\_vertices(vertices)](#add_vertices) <a href="#add_vertices" id="add_vertices"></a>

_Add a set of new vertices to the mesh_

**Parameters**

* `vertices` : (numpy.ndarray of floats) An array with the position (x,y,z) of the vertices

**Example**

_Adding two new vertices to the mesh_

```python
ArrayOfVertices = numpy.array([(0.5,0.5,0.5), (1.3,2.8, 2.9)])
my_mesh.add_vertices(ArrayOfVertices)
```

#### [CFDMesh.cell(id)](#cell) <a href="#cell" id="cell"></a>

_Get the id of the vertices of a cell given its id_

**Parameters**

* `id` : (int) index of cell

**Returns**

* A **numpy.ndarray of integers** that contains the id of the vertices of the cell

**Example**

_Getting the ids of the vertices of the cell with id = 5_

```python
vertices = my_mesh.cell(id=5)
print(vertices)
```

#### [CFDMesh.cell\_center(id)](#cell_center) <a href="#cell_center" id="cell_center"></a>

_Get the coordinates of the centre of a cell given its id_

**Parameters**

* `id` : (int) index of cell

**Returns**

* A **numpy.ndarray of floats** that contains the position (x,y,z) of the centre of the cell

**Example**

_Getting the coordinates of the centre of the cell with id = 5_

```python
cell_centre = my_mesh.cell_center(id=5)
print(cell_centre)
```

#### [CFDMesh.cell\_centers()](#cell_centers) <a href="#cell_centers" id="cell_centers"></a>

_Get the coordinates of the centres of all cells_

**Returns**

* A **numpy.ndarray of floats** that contains, per row, the position (x,y,z) of the cells

**Example**

```python
cell_centres = my_mesh.cell_centers()
print(cell_centres)
```

#### [CFDMesh.cell\_faces(id)](#cell_faces) <a href="#cell_faces" id="cell_faces"></a>

_Get the id of the faces of a cell given its id_

**Parameters**

* `id` : (int) index of cell

**Returns**

* A **numpy.ndarray of integers** that contains the id of the faces of the cell

**Example**

_Getting the id of the faces of the cell with id = 5_

```python
faces = my_mesh.cell_face(id=5)
print(faces)
```

#### [CFDMesh.cell\_ids()](#cell_ids) <a href="#cell_ids" id="cell_ids"></a>

_Get the id of the cells in the mesh_

**Returns**

* A **numpy.ndarray of integers** that contains the id of cells

**Example**

```python
id_cells = my_mesh.cell_ids()
print(id_cells)
```

#### [CFDMesh.cell\_neighbours(id)](#cell_neighbours) <a href="#cell_neighbours" id="cell_neighbours"></a>

_Get the id of the cells that are neighbors of a cell given its id_

**Parameters**

* `id` : (int) index of cell

**Returns**

* A **numpy.ndarray of integers** that contains the id of the cells

**Example**

_Getting the id of the cells that are neighbors of the cell with id = 5_

```python
cells_neighbors = my_mesh.cell_neighbours(id=5)
print(cells_neighbors)
```

#### [CFDMesh.cell\_owners(point\_coordinates, \[cell\_list\])](#cell_owners) <a href="#cell_owners" id="cell_owners"></a>

_Get a list of the cells occupying a particular point in space_

**Parameters**

* `point_coordinates` : (iota.Vector3d) coordinates (x,y,z) of the point
* `cell_list` : (list of integers) handles of the cells to interrogate (default: all cells)

**Returns**

* A **list of integers** containing the handles of the cells that occupy that point in space

```python
cell_owners = my_mesh.cell_owners(point_coordinates=iota.Vector3d(0.1, 0.2, 0.3))
print(cell_owners)
```

#### [CFDMesh.cell\_size(id)](#cell_size) <a href="#cell_size" id="cell_size"></a>

_Get the number of cells in the mesh_

**Parameters**

* `id` : (int) index of cell

**Returns**

* A **integer** that represents number of cells in the mesh

**Example**

_Getting the size of the cells with id = 5_

```python
size_of_cell = my_mesh.cell_size(id=5)
print(size_of_cell)
```

#### [CFDMesh.cell\_type(id)](#cell_type) <a href="#cell_type" id="cell_type"></a>

_Get the type of a cell given its id_

**Parameters**

* `id` : (int) index of cell

**Returns**

* A **iota.mesh.CellType** that represents the type of the cell

**Example**

_Getting the type of the cell with id = 5_

```python
type_of_cell = my_mesh.cell_type(id=5)
print(type_of_cell)
```

#### [CFDMesh.cell\_volume(id)](#cell_volume) <a href="#cell_volume" id="cell_volume"></a>

_Get the volume of a cell given its id_

**Parameters**

* `id` : (int) index of cell

**Returns**

* A **float** that represents the volume of the cell

**Example**

_Getting the volume of the cell with id = 5_

```python
volume_of_cell = my_mesh.cell_volume(id=5)
print(volume_of_cell)
```

#### [CFDMesh.cells\_around\_vertex(id)](#cells_around_vertex) <a href="#cells_arround_vertex" id="cells_arround_vertex"></a>

_Get the id of the cells around a vertex given its id_

**Parameters**

* `id` : (int) index of the vertex

**Returns**

* A **numpy.ndarray of integers** with the id of the cells

**Example**

_Getting the id of the cells around the vertex with id = 5_

```python
id_cells = my_mesh.cells_around_vertex(id=5)
print(id_cells)
```

#### [CFDMesh.check\_consistency()](#check_consistency) <a href="#check_consistency" id="check_consistency"></a>

_Check if the faces of the boundary of the mesh have consistent pointing normal vectors_

**Returns**

* A **tuple** of
  * A **bool** that is True if the faces have consistent pointing normal vectors
  * A **bool**  that is True if the normal vectors point inwards

**Example**

_Getting the id of the cells around the vertex with id = 5_

```python
id_cells = my_mesh.cells_around_vertex(id=5)
print(id_cells)
```

#### [CFDMesh.dimension()](#dimension) <a href="#dimension" id="dimension"></a>

_Get the dimension of the mesh_

**Returns**

* A **integer** that represents the dimension of the mesh:
  * **0**: point mesh&#x20;
  * **1** : line segments
  * **2** : surface mesh&#x20;
  * **3** : volume mesh

**Example**

```python
mesh_dimension = my_mesh.dimension()
print(mesh_dimension)
```

#### [CFDMesh.edge(id)](#edge) <a href="#edge" id="edge"></a>

_Get the id of the vertices of an edge given its id_

**Parameters**

* `id` : (int) index of edge

**Returns**

* A **numpy.ndarray of integers** that contains the id of the vertices of the edge

**Example**

_Getting the ids of the vertices of the edge with id = 5_

```python
vertices_edge = my_mesh.edge(5)
print(vertices_edge)
```

#### [CFDMesh.edge\_ids()](#edge_ids) <a href="#edge_ids" id="edge_ids"></a>

_Get the id of the edges in the mesh_

**Returns**

* A **numpy.ndarray of integers** that contains the id of the edges

**Example**

```python
id_edges = my_mesh.edge_ids()
print(id_edges)
```

#### [CFDMesh.edge\_size()](#edge_size) <a href="#edge_size" id="edge_size"></a>

_Get the number of edges in the mesh_

**Returns**

* An **integer** the corresponds to the number of edges

**Example**

```python
number_edges = my_mesh.edge_size()
print(number_edges)
```

#### [CFDMesh.edge\_size()](#edge_size) <a href="#edge_size" id="edge_size"></a>

_Get the number of edges in the mesh_

**Returns**

* An **integer** the corresponds to the number of edges

**Example**

```python
number_edges = my_mesh.edge_size()
print(number_edges)
```

#### [CFDMesh.edges()](#edges) <a href="#edges" id="edges"></a>

_Get the pair of vertices id for all the edges in the mesh_

**Returns**

* A **numpy.ndarray of integers** that contains a pair of vertices id for each edge&#x20;

**Example**

```python
id_vertices_edges = my_mesh.edges()
print(id_vertices_edges)
```

#### [CFDMesh.face(id)](#face) <a href="#face" id="face"></a>

_Get the id of the vertices of a face given its id_

**Parameters**

* `id` : (int) index of the face

**Returns**

* A **numpy.ndarray of integers** that contains the id of the vertices of the face

**Example**

_Getting the ids of the vertices of the face with id = 5_

```python
vertices_face = my_mesh.face(5)
print(vertices_face)
```

#### [CFDMesh.face\_area(id)](#face_area) <a href="#face_area" id="face_area"></a>

_Get the area of a face given its id_

**Parameters**

* `id` : (int) index of the face

**Returns**

* A **float** that represents the area of the face

**Example**

_Getting the area of the face with id = 5_

```python
area_face = my_mesh.face_area(5)
print(area_face)
```

#### [CFDMesh.face\_cell\_neighbours(id)](#face_cell_neighbours) <a href="#face_cell_neighbours" id="face_cell_neighbours"></a>

_Get the cell(s) that limit with a face given its id_

**Parameters**

* `id` : (int) index of the face

**Returns**

* A **list of integers** that contains the id of the cells that limit with the face

**Example**

_Getting the cells that limit with the face with id = 5_

```python
cell_neighbours = my_mesh.face_cell_neighbour(5)
print(cell_neighbours)
```

#### [CFDMesh.face\_centroid(id)](#face_centroid) <a href="#face_centroid" id="face_centroid"></a>

_Get the centroid of a face given its id_&#x20;

**Parameters**

* `id` : (int) index of the face

**Returns**

* A **numpy.ndarray of floats** that contains the position (x,y,z) of the centroid of the face

**Example**

_Getting the coordinates of the centroid of the face with id = 5_

```python
face_centroid = my_mesh.face_centroid(5)
print(face_centroid)
```

#### [CFDMesh.face\_centroids()](#face_centroids) <a href="#face_centroids" id="face_centroids"></a>

_Get the centroids of all faces_

**Returns**

* A **numpy.ndarray of floats** that contains, per row, the position (x,y,z) of the centroids of all the faces

**Example**

```python
face_centroids = mesh.face_centroids()
print(face_centroids)
```

#### [CFDMesh.face\_ids()](#face_ids) <a href="#face_ids" id="face_ids"></a>

_Get the id of the faces in the mesh_

**Returns**

* A **numpy.ndarray of integers** that contains the id of the faces

**Example**

```python
id_faces = my_mesh.face_ids()
print(id_faces)
```

#### [CFDMesh.face\_neighbours(id)](#face_neighbours) <a href="#face_neighbours" id="face_neighbours"></a>

_Get the id of the faces that are neighbors of a face given its id_

**Parameters**

* `id` : (int) index of the face

**Returns**

* A **numpy.ndarray of integers** that contains the id of the faces

**Example**

_Getting the id of the faces that are neighbors of the face with id = 5_

```python
neighbours_face = my_mesh.face_neighbours(5)
print(neighbours_face)
```

#### [CFDMesh.face\_size()](#face_size) <a href="#face_size" id="face_size"></a>

_Get the number the faces in the mesh_

**Returns**

* A **integer** that represents the number of faces

**Example**

```python
number_faces = my_mesh.face_size()
print(number_faces)
```

#### [CFDMesh.isosurface(variable, value)](#isosurface) <a href="#isosurface" id="isosurface"></a>

_Get the mesh that represents the isosurface for a constant value of a given an array of values of a variable_

**Parameters**

* `variable` : (numpy.ndarray of floats) array of values. Note the that the size of the values of the variable must be equal to the number of vertices of the input CFDMesh.
* `value`: (float) constant value of variable for the calculation of the isosurface

**Returns**

* A **iota.CFDMesh** object that contains the mesh that represents the isosurface

**Example**

_Getting the isosurface mesh from the mesh called 'my\_mesh' and based on the values of the result-analysis 'PRESSURE'-'phase-1' and a constant value of result equal to 0.0_

```python
my_cfd_mesh = my_dataset.get_mesh('my_mesh')
variable_values = my_dataset.get_result(step=0, mesh='my_mesh', result='PRESSURE', analysis='phase-1')
my_cfd_mesh.isosurface(varaibale=variable_values, value=0.0)
```

#### [CFDMesh.skin()](#skin) <a href="#skin" id="skin"></a>

_Get the mesh that represents the skin of a volume mesh_

**Returns**

* A **iota.CFDMesh** object that contains the mesh representing the skin of the volume mesh

**Example**

_Getting the skin of the volume mesh_

```python
skin_mesh = my_mesh.skin()
```

#### [CFDMesh.slice(normal, origin)](#slice) <a href="#slice" id="slice"></a>

_Get a mesh that represents a slice of a volume mesh given the normal vector (nx,ny,nz ) and the position (x,y,z) of the origin that define the slice_

**Parameters**

* `normal`: (list of floats) normal vector (nx,ny,nz ) of the slice
* `origin`: (list of float) position (x,y,z) of the slice

**Returns**

* A **iota.CFDMesh** object that contains the mesh representing the slice

**Example**

_Getting a slice with normal vector pointing the z-axis and centered at position (0,0,0)_

```python
new_slice = my_mesh.slice(normal=[0,0,1], origin=[0,0,0])
print(new_slice)
```

#### [CFDMesh.vertex(id)](#vertex) <a href="#vertex" id="vertex"></a>

_Get the position (x,y,z) of a vertex given its id_

**Parameters**

* `id`: (int) index of the vertex

**Returns**

* A **numpy.ndarray of floats** with the position (x,y,z) of the vertex

**Example**

_Getting the position of the vertex with id=5_

```python
vertex_position = my_mesh.vertex(id=5)
print(vertex_position)
```

#### [CFDMesh.vertex\_ids()](#vertex_ids) <a href="#vertex_ids" id="vertex_ids"></a>

_Get the id of the all the vertices in the mesh_

**Returns**

* A **numpy.ndarray of integers** with the id of the vertices

**Example**

_Getting the id of the vertices of the mesh_

```python
vertices_ids = my_mesh.vertex_ids()
print(vertices_ids)
```

#### [CFDMesh.vertex\_size()](#vertex_size) <a href="#vertex_size" id="vertex_size"></a>

_Get the number of vertices in the mesh_

**Returns**

* An **integer** that represents the number of vertices in the mesh

**Example**

_Getting the number of the vertices in the mesh_

```python
number_vertices = my_mesh.vertex_size()
print(number_vertices)
```

#### [CFDMesh.vertices()](#vertices) <a href="#vertices" id="vertices"></a>

_Get the positions (x,y,z) of all the vertices in the mesh_

**Returns**

* An **numpy.ndarray of floats** that contains the positions (x,y,z) of the vertices

**Example**

_Getting the positions of the vertices in 'my\_mesh'_

```python
vertices_positions = my_mesh.vertices()
print(vertices_positions)
```

#### [CFDMesh.volume()](#volume) <a href="#volume" id="volume"></a>

_Get the volume/area of a volume/surface mesh._

**Returns**

* A **float** that represents the volume/area of the volume/surface mesh

**Example**

_Getting the volume of a volume mesh_

```python
volume = my_volume_mesh.volume()
print(volume)
```

_Getting the area of a surface mesh_

```python
area = my_surface_mesh.volume()
print(area)
```

### [load(filename, \[split\])](#mesh_load) <a href="#mesh_load" id="mesh_load"></a>

_Load a mesh list from file_

\*Returns a list of meshes

**Arguments**

* `filename`: (str) file containing the meshes to me readed
* `split`: (bool) split meshes by connectivities (default: True)

**Example**

```python
meshes = iota.mesh.load(
    filename = 'my_username',
    split = True
)
print(meshes)
```

### [export(mesh, filename, \[format\])](#mesh_export) <a href="#mesh_export" id="mesh_export"></a>

_Export a mesh to file_

**Arguments**

* `mesh`: (iota.mesh.Mesh) mesh object to be exported
* `filename`: (str) file to write the mesh
* `format`: (iota.mesh.export\_format) mesh format for to written (default: P4S)

**Example**

```python
status = iota.mesh.export(
    mesh = myMesh,
    filename = '/file/to/write/the/mesh/mesh.meta',
    format = iota.mesh.export_format.P4S
)
print('mesh is ok: ',status)
```

### [create\_line(start, end, element\_size, \[name\])](#mesh_create_line) <a href="#mesh_create_line" id="mesh_create_line"></a>

_Create a linear mesh of edges_

**Arguments**

* `start`: (iota.Vector3d) point representing the origin of the line
* `end`: (iota.Vector3d) point representing the end of the line
* `element_size`: (float) size of the triangular elements
* `name`: (str) name of the mesh (default: 'line')

**Example**

```python
line = iota.mesh.create_line(
    start = iota.Vector3d(0,0,0),
    end = iota.Vector3d(1,1,0),
    element_size = 0.1,
    name = 'my_linear_mesh'
)
```

### [create\_circle(centre, radius, normal, element\_size, \[name\])](#mesh_create_circle) <a href="#mesh_create_circle" id="mesh_create_circle"></a>

_Create a circular mesh of triangles_

**Arguments**

* `centre`: (iota.Vector3d) point representing the centre of the circle
* `radius`: (float) radius of the circle
* `normal`: (iota.Vector3d) normal vector representing the plane of the circle
* `element_size`: (float) size of the triangular elements
* `name`: (str) name of the mesh (default: 'circle')

**Example**

```python
circle = iota.mesh.create_circle(
    centre = iota.Vector3d(0,0,0),
    radius = 1.0,
    normal = iota.Vector3d(0,0,1),
    element_size = 0.1,
    name = 'my_circle'
)
```

### [create\_rectangle(origin, normal, lenght, width, element\_size, \[name\])](#mesh_create_circle) <a href="#mesh_create_rectangle" id="mesh_create_rectangle"></a>

_Create a rectangular mesh of triangles_

**Arguments**

* `origin`: (iota.Vector3d) point representing the origin of the rectangle
* `normal`: (iota.Vector3d) normal vector representing the plane of the rectangle
* `length`: (float) length of the rectangle
* `width`: (float) width of the rectangle
* `element_size`: (float) size of the triangular elements
* `name`: (str) name of the mesh (default: 'rectangle')

**Example**

```python
rectangle = iota.mesh.create_rectangle(
    origin = iota.Vector3d(0,0,0),
    normal = iota.Vector3d(0,0,1),
    length = 1.0,
    width = 1.0,
    element_size = 0.1,
    name = 'my_rectangle'
)
```

### [create\_cuboid(origin, up, lenght, width, height, element\_size, \[name\], \[skin\])](#mesh_create_cuboid) <a href="#mesh_create_cuboid" id="mesh_create_cuboid"></a>

_Create a cuboid mesh of tetrahedra_

**Arguments**

* `origin`: (iota.Vector3d) point representing the origin of the cuboid
* `up`: (iota.Vector3d) vector representing the up direction of the cuboid
* `length`: (float) length of the cuboid
* `width`: (float) width of the cuboid
* `height`: (float) height of the cuboid
* `element_size`: (float) size of the elements
* `name`: (str) name of the mesh (default: 'cuboid')
* `skin`: (bool) generate the surface instead of volume (default: False)

**Example**

```python
cuboid = iota.mesh.create_cuboid(
    origin = iota.Vector3d(0,0,0),
    up = iota.Vector3d(0,0,1),
    length = 1.0,
    width = 1.0,
    height = 1.0,
    element_size = 0.1,
    name = 'my_cuboid'
)
```

### [create\_cylinder(origin, up, radius, element\_size, \[name\], \[skin\])](#mesh_create_cylinder) <a href="#mesh_create_cylinder" id="mesh_create_cylinder"></a>

_Create a cylinder mesh of tetrahedra_

**Arguments**

* `origin`: (iota.Vector3d) point representing the origin of the cylinder
* `up`: (iota.Vector3d) vector representing the up direction of the cylinder
* `radius`: (float) radius of the cylinder
* `height`: (float) height of the cylinder
* `element_size`: (float) size of the elements
* `name`: (str) name of the mesh (default: 'cylinder')
* `skin`: (bool) generate the surface instead of volume (default: False)

**Example**

```python
cylinder = iota.mesh.create_cylinder(
    origin = iota.Vector3d(0,0,0),
    up = iota.Vector3d(0,0,1),
    radius = 1.0,
    height = 1.0,
    element_size = 0.1,
    name = 'my_cylinder'
)
```
