# Geometry package

Currently the geometry classes is implemented very simplistic. The only module
is the `meshClasses`

module.

The required import is

```
import pyva.geometry.meshClasses as meshC
```

## Mesh classes

The only yet implemented mesh is a regular two-dimensional meshClass that provides methods for regular meshes, used for example for the discrete radiation stiffness.

The mesh is created with

```
# Dimensions
Lx = 1.2
Ly = 1.5
Nx = 3
Ny = 7
my_mesh = meshC.RegMesh2D(0., 0., Lx, Ly, Nx, Ny)
```

There are many properties that can be found in the API description of `RegMesh2D`

.
An important method that gives the X and Y positions is the nodes method

```
X,Y = my_mesh.nodes()
>>> X
array([[0. , 0.24, 0.48, 0.72, 0.96, 1.2 ],
[0. , 0.24, 0.48, 0.72, 0.96, 1.2 ],
[0. , 0.24, 0.48, 0.72, 0.96, 1.2 ],
[0. , 0.24, 0.48, 0.72, 0.96, 1.2 ],
[0. , 0.24, 0.48, 0.72, 0.96, 1.2 ],
[0. , 0.24, 0.48, 0.72, 0.96, 1.2 ],
[0. , 0.24, 0.48, 0.72, 0.96, 1.2 ]])
>>> Y
array([[0. , 0. , 0. , 0. , 0. , 0. ],
[0.25, 0.25, 0.25, 0.25, 0.25, 0.25],
[0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 ],
[0.75, 0.75, 0.75, 0.75, 0.75, 0.75],
[1. , 1. , 1. , 1. , 1. , 1. ],
[1.25, 1.25, 1.25, 1.25, 1.25, 1.25],
[1.5 , 1.5 , 1.5 , 1.5 , 1.5 , 1.5 ]])
```

The radiation efficiency required the distance between all nodes. This means for a mesh of N nodes N*(N+1)/2 distances of the upper triangular matrix because the distances are symmetric. The good thing with regular meshes is that that most distances have similar values. The distance method has two outputs

```
dist,index = my_mesh.distance()
```

The number of mesh nodes is

```
>>> my_mesh.Nmesh
42
```

And the size of the distance is also 42

```
>>> dist.size
42
>>> dist
array([0. , 0.24 , 0.48 , 0.72 , 0.96 ,
1.2 , 0.25 , 0.34655446, 0.54120237, 0.762168 ,
0.99201816, 1.2257651 , 0.5 , 0.554617 , 0.6931089 ,
0.8765843 , 1.0824047 , 1.3000001 , 0.75 , 0.7874643 ,
0.89044935, 1.0396634 , 1.2182364 , 1.4150972 , 1. ,
1.0283968 , 1.109234 , 1.2322338 , 1.3862178 , 1.56205 ,
1.25 , 1.2728314 , 1.3389921 , 1.4425324 , 1.5761029 ,
1.7327724 , 1.5 , 1.5190787 , 1.5749286 , 1.6638509 ,
1.7808987 , 1.9209373 ], dtype=float32)
```

With the index we can reconstruct all distances

```
>>> index.size
903
>>> index
array([ 0, 1, 2, 3, 4, 5, 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, 0, 1, 2, 3, 4, 7, 6, 7, 8,
9, 10, 13, 12, 13, 14, 15, 16, 19, 18, 19, 20, 21, 22, 25, 24, 25,
26, 27, 28, 31, 30, 31, 32, 33, 34, 37, 36, 37, 38, 39, 40, 0, 1 ... ])
```

The upper trangle can be reconstructed by

```
dist_triu = dist[index]
```

Thus, with the indexing trick the number of data is tremendously reduced. As the distance is used in many stiffness matrix formulas this increases the calculation speed also. Finally, the mesh can be plotted with

```
my_mesh.plot3D(1)
```