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)

3D plot of RegMesh2D