ansh 0.1.1

A python package to define scalar and vector finite-element fields.

Ansh

Numerical approximation of finite-element scalar and vector fields in Python.

ansh is a thin wrapper around meshio, pyvista, and skfem. meshio is used for reading and writing meshes. skfem is used for finite-element field definition. pyvista is used for plotting both meshes and fields.

---

Table of Contents

• Installation
• Quick Start
  • Meshes
  • Scalar fields
  • Vector fields
• I/O
• License

Installation

pip install ansh

Quick Start

Meshes

Load a mesh from file and inspect its properties:

import ansh
import numpy as np

m = ansh.Mesh.from_file("tests/meshes/med/omega.med")
m.info = {"name": "shell", "about": "one of the unit test meshes"}

m.points          # float64 array of shape (n_points, 3)
m.cells           # list of CellBlock objects (type + connectivity)
m.cell_centres    # list of cell centre arrays per cell block
m.subregions      # dict mapping region names to cell index arrays
m.scale           # mesh scaling factor
m.info            # user-attached metadata dict

Subregions can be added via cell indices or selector functions:

def select_unit_cube(centres):
    return (
        ((centres[:, 0] < 1.) & (centres[:, 0] > -1.)) &
        ((centres[:, 1] < 1.) & (centres[:, 1] > -1.)) &
        ((centres[:, 2] < 1.) & (centres[:, 2] > -1.))
    )

m.add_subregion(
    subregion_name="cube",
    value=[np.array([], dtype=np.int_), select_unit_cube, np.array([], dtype=np.int_)],
)

Convert to PyVista or scikit-fem for further use:

m.to_pyvista()        # returns pyvista.MultiBlock with one block per subregion
m.to_meshio()         # returns meshio.Mesh
m.to_skfem()          # returns skfem MeshTet1
m.plot()              # interactive 3D plot via PyVista

See the full mesh demo for more details.

Scalar fields

Define a scalar field on a mesh by specifying the element type and initial value:

f = ansh.ScalarField(mesh=m, element_type=ansh.element_types.TetP1(), value=42.)

f.element_type     # skfem element (e.g. ElementTetP1)
f.value            # 1D float64 array of DOF values, shape (n_dofs,)
f.dof_locations    # coordinates of the DOF points, shape (n_dofs, 3)

The field is callable — evaluate it at arbitrary points inside the mesh:

f([0, 0, 0])                              # array([42.])
f(np.array([[0, 2., -1.], [0, 0, 0]]))   # array([42., 42.])

Update the value with a callable (receives DOF locations, returns values):

def norm_val(dofs):
    return np.linalg.norm(dofs, axis=-1)

f.value = norm_val

Set values on a specific subregion:

f.set_subregion_value(name="boundary", input_value=0.)

Export for matrix assembly or visualisation:

f.to_skfem()       # returns skfem DiscreteField
f.skfem_basis      # returns skfem CellBasis
f.to_pyvista()     # returns pyvista MultiBlock with field data attached
f.plot()           # interactive 3D plot with a clip widget

See the full scalar field demo for more details.

Vector fields

Define a vector field similarly, passing a 3-component value:

f = ansh.VectorField(
    mesh=m,
    element_type=ansh.element_types.TetP1(),
    value=[42., 42., 42.],
)

f.element_type     # skfem ElementVector (wrapping ElementTetP1)
f.value            # 2D float64 array of DOF values, shape (n_dofs, 3)
f.dof_locations    # coordinates of the DOF points, shape (n_dofs, 3)

Evaluate at arbitrary points:

f([0, 0, 0])                              # array([[42., 42., 42.]])
f(np.array([[0, 2., -1.], [0, 0, 0]]))   # array([[42., 42., 42.], ...])

Set value via callable (receives DOF locations, returns array of shape (n_dofs, 3)):

f.value = lambda dofs: dofs

Set subregion values:

f.set_subregion_value(name="shell", input_value=[0., 0., 0.])

Plot with glyphs coloured by component or magnitude:

f.plot(colour_with="z", factor=3e-3, cmap="RdBu")
f.plot(colour_with="magnitude", factor=3e-3, cmap="viridis")

See the full vector field demo for more details.

I/O

Mesh — read any format supported by meshio (.med, .vol, .vtk, .msh, etc.) and write to Abaqus .inp or Ansh HDF5 .h5:

m.to_file("mesh.inp")
m.to_file("mesh.h5")
ansh.Mesh.from_file("mesh.inp")
ansh.Mesh.from_file("mesh.h5")

Scalar/vector field — read/write HDF5 (.h5) or ParaView multiblock (.vtm):

f.to_file("field.h5")
f.to_file("field.vtm")
ansh.ScalarField.from_file("field.h5")
ansh.VectorField.from_file("field.h5")

License

ansh is distributed under the terms of the MIT license.