diff --git a/.gitignore b/.gitignore
index e9e1e9b..f3da140 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,7 +11,8 @@
 __pycache__/*
 .cache/*
 .*.swp
-*/.ipynb_checkpoints/*
+.ipynb_checkpoints/*
+examples/.ipynb_checkpoints/*
 .DS_Store
 
 # Project files
diff --git a/README.md b/README.md
index 544324a..bb8ce9d 100644
--- a/README.md
+++ b/README.md
@@ -9,11 +9,16 @@ Discrete Differential Geometry to provide a *mathematical language for building
 
 Features:
 - uses [`jax`](http://github.com/google/jax/) as a backend for numerical computations
-- manipulation of simplicial complexes of any dimension: computation of boundary/coboundary operators, circumcenters, dual/primal volumes
-- manipulation of (primal/dual) cochains: addition, multiplication by scalar, inner product, coboundary, Hodge star, codifferential, Laplace-de Rham
+- manipulation of simplicial complexes of any dimension: computation of
+  boundary/coboundary operators, circumcenters, dual/primal volumes
+- manipulation of (primal/dual) cochains: addition, multiplication by scalar, inner
+  product, coboundary, Hodge star, codifferential, Laplace-de Rham
+- manipulation of vector-valued and tensor-valued cochains: discrete vector and tensor
+  fields, sharp operator
 - interface to the [`pygmo`](https://github.com/esa/pygmo2) optimization library
-- interface for solving optimal control problems
-- implementation of discrete physical models: Dirichlet energy, Poisson, Euler's Elastica
+- routines for solving optimal control problems
+- implementation of discrete physical models: Dirichlet energy, Poisson, Euler's
+  Elastica, linear isotropic elasticity
 
 ## Installation
 
@@ -71,13 +76,11 @@ docs).
 
 ```python
 import dctkit as dt
-from dctkit import config, FloatDtype, Platform
-from dctkit.mesh import simplex, util
+from dctkit import config
+from dctkit.mesh import util
 from dctkit.dec import cochain as C
 from dctkit.math.opt import optctrl as oc
 import jax.numpy as jnp
-from jax import jit, grad
-from scipy.optimize import minimize
 from matplotlib.pyplot import plot
 
 # set backend for computations, precision and platform (CPU/GPU)
@@ -88,13 +91,10 @@ config()
 # generate mesh and create SimplicialComplex object
 num_nodes = 10
 L = 1.
-S_1, x = util.generate_1_D_mesh(num_nodes, L)
-S = simplex.SimplicialComplex(S_1, x, is_well_centered=True)
+mesh, _ = util.generate_line_mesh(num_nodes, L)
+S = util.build_complex_from_mesh(mesh)
 
-# perform some computations and cache results for later use
-S.get_circumcenters()
-S.get_primal_volumes()
-S.get_dual_volumes()
+# compute Hodge star operator for later use
 S.get_hodge_star()
 
 # initial guess for the solution vector (coefficients of a primal 0-chain)
@@ -113,10 +113,14 @@ def energy(u):
      du = C.coboundary(uc)
      return C.inner_product(du, du)-C.inner_product(uc, f)
 
-# minimization of the energy
+# set optimization problem
 prb = oc.OptimizationProblem(dim=num_nodes-1, state_dim=num_nodes-1, objfun=energy)
+# set additional arguments (empty dictionary) of the objective function, other than the state array
 prb.set_obj_args({})
-x = prb.run(x0=u, algo="lbfgs")
+
+x = prb.run(x0=u)
+
+# add boundary condition
 x = jnp.insert(x, 0, 0.)
 
 plot(x)
diff --git a/bench/bench_poisson.py b/bench/bench_poisson.py
index 7eb0fec..3669966 100644
--- a/bench/bench_poisson.py
+++ b/bench/bench_poisson.py
@@ -1,37 +1,17 @@
 import numpy as np
 from scipy.optimize import minimize
 import dctkit as dt
-from dctkit.mesh import simplex, util
-from dctkit.apps import poisson as p
-import os
+from dctkit.mesh import util
+from dctkit.physics import poisson as p
 import sys
-import matplotlib.tri as tri
 import time
 import jax.numpy as jnp
 import jaxopt
-import gmsh
 import jax
 import pygmo as pg
 from functools import partial
 
-from dctkit import config, FloatDtype, IntDtype, Backend, Platform
-
-cwd = os.path.dirname(simplex.__file__)
-
-
-def get_complex(S_p, node_coords):
-    bnodes, _ = gmsh.model.mesh.getNodesForPhysicalGroup(1, 1)
-    bnodes -= 1
-    bnodes = bnodes.astype(dt.int_dtype)
-    triang = tri.Triangulation(node_coords[:, 0], node_coords[:, 1])
-    # initialize simplicial complex
-    S = simplex.SimplicialComplex(S_p, node_coords, is_well_centered=True)
-    S.get_circumcenters()
-    S.get_primal_volumes()
-    S.get_dual_volumes()
-    S.get_hodge_star()
-
-    return S, bnodes, triang
+from dctkit import config, FloatDtype, Platform
 
 
 def bench_poisson(optimizer="scipy", platform="cpu", float_dtype="float32",
@@ -39,9 +19,9 @@ def bench_poisson(optimizer="scipy", platform="cpu", float_dtype="float32",
 
     # NOTE: NLOpt only works with float64
     if platform == "cpu":
-        config(FloatDtype.float64, IntDtype.int64, Backend.jax, Platform.cpu)
+        config(FloatDtype.float64, Platform.cpu)
     else:
-        config(FloatDtype.float64, IntDtype.int64, Backend.jax, Platform.gpu)
+        config(FloatDtype.float64, Platform.gpu)
 
     if jax.config.read("jax_enable_x64"):
         assert dt.float_dtype == "float64"
@@ -49,28 +29,33 @@ def bench_poisson(optimizer="scipy", platform="cpu", float_dtype="float32",
     np.random.seed(42)
     lc = 0.05
 
-    _, _, S_2, node_coord = util.generate_square_mesh(lc)
-    S, bnodes, _ = get_complex(S_2, node_coord)
+    mesh, _ = util.generate_square_mesh(lc)
+    S = util.build_complex_from_mesh(mesh)
+    node_coords = S.node_coords
+    S.get_hodge_star()
+    # extract the IDs of all the boundary nodes
+    S.get_complex_boundary_faces_indices()
+    bnodes = np.unique(S.S[1][S.bnd_faces_indices])
 
     gamma = 1000.
 
     # NOTE: exact solution of Delta u + f = 0
-    u_true = np.array(node_coord[:, 0]**2 + node_coord[:, 1]
+    u_true = np.array(node_coords[:, 0]**2 + node_coords[:, 1]
                       ** 2, dtype=dt.float_dtype)
     b_values = u_true[bnodes]
 
-    boundary_values = (np.array(bnodes, dtype=dt.int_dtype), b_values)
+    boundary_values = (bnodes, b_values)
 
     k = 1.
 
-    dim_0 = S.num_nodes
-    f_vec = -4.*np.ones(dim_0, dtype=dt.float_dtype)
+    num_nodes = S.num_nodes
+    f_vec = -4.*np.ones(num_nodes, dtype=dt.float_dtype)
 
-    mask = np.ones(dim_0, dtype=dt.float_dtype)
+    mask = np.ones(num_nodes, dtype=dt.float_dtype)
     mask[bnodes] = 0.
 
     # initial guess
-    u_0 = 0.01*np.random.rand(dim_0).astype(dt.float_dtype)
+    u_0 = np.zeros(num_nodes, dtype=dt.float_dtype)
 
     # Dirichlet energy and its gradient (computed using JAX's autodiff)
     energy = jax.jit(partial(p.energy_poisson, f=f_vec, S=S,
@@ -114,7 +99,7 @@ def gradient(self, dv):
                 return grad
 
             def get_bounds(self):
-                return ([-100]*dim_0, [100]*dim_0)
+                return ([-100]*num_nodes, [100]*num_nodes)
 
             def get_name(self):
                 return "Poisson problem"
@@ -125,8 +110,6 @@ def get_name(self):
         algo.extract(pg.nlopt).ftol_rel = 1e-5
         pop = pg.population(prb)
         pop.push_back(u_0)
-        print(algo)
-        # algo.set_verbosity(1)
         pop = algo.evolve(pop)
         u = pop.champion_x
         toc = time.time()
diff --git a/environment.yaml b/environment.yaml
index 014d56d..2315a3f 100644
--- a/environment.yaml
+++ b/environment.yaml
@@ -9,8 +9,15 @@ dependencies:
   - jaxopt
   - numpy=1.24.2
   - pygmo=2.19.5
-  - python=3.11.0
+  - python
   - python-gmsh
   - scipy=1.10.0
   - typeguard
-  - yaml=0.2.5
\ No newline at end of file
+  - yaml=0.2.5
+  - jupyterlab
+  - trame
+  - ipywidgets
+  - pyvista
+  - pip
+  - pip:
+    - pygmsh
\ No newline at end of file
diff --git a/examples/linear_elasticity.ipynb b/examples/linear_elasticity.ipynb
new file mode 100644
index 0000000..25c9c5e
--- /dev/null
+++ b/examples/linear_elasticity.ipynb
@@ -0,0 +1,378 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e6345158-0d14-4bb7-8625-ace70786dc16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "61af5e87-a006-4d84-b4e3-9d2d560c397b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%autoreload\n",
+    "import pygmsh\n",
+    "import numpy as np\n",
+    "import jax.numpy as jnp\n",
+    "from dctkit.mesh import util, simplex\n",
+    "from dctkit.math.opt import optctrl\n",
+    "from dctkit.physics.elasticity import LinearElasticity\n",
+    "import dctkit.dec.cochain as C\n",
+    "import dctkit as dt\n",
+    "from matplotlib.pyplot import triplot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "82bcfde1-8306-4144-8397-fcc34a4fa8ca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dt.config()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "01872adb-4880-496d-a43a-8d9c8535357b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lc = 0.5\n",
+    "L = 1.\n",
+    "with pygmsh.geo.Geometry() as geom:\n",
+    "    p = geom.add_polygon([[0., 0.], [L, 0.], [L, L], [0., L]], mesh_size=lc)\n",
+    "    # create a default physical group for the boundary lines\n",
+    "    geom.add_physical(p.lines, label=\"boundary\")\n",
+    "    geom.add_physical(p.lines[1], label=\"right\")\n",
+    "    geom.add_physical(p.lines[3], label=\"left\")\n",
+    "    mesh = geom.generate_mesh()\n",
+    "S = util.build_complex_from_mesh(mesh)\n",
+    "S.get_hodge_star()\n",
+    "S.get_flat_DPD_weights()\n",
+    "node_coords = S.node_coords"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "103b3be0-7114-4adc-a6a4-a6457cec650f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bnd_edges_idx = S.bnd_faces_indices\n",
+    "left_bnd_nodes_idx = util.get_nodes_for_physical_group(mesh, 1, \"left\")\n",
+    "right_bnd_nodes_idx = util.get_nodes_for_physical_group(mesh, 1, \"right\")\n",
+    "left_bnd_edges_idx = util.get_edges_for_physical_group(S, mesh, \"left\")\n",
+    "right_bnd_edges_idx = util.get_edges_for_physical_group(S, mesh, \"right\")\n",
+    "\n",
+    "bottom_left_corner = left_bnd_nodes_idx.pop(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "3031d712-8667-4986-b789-ba6d414f43f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# UNIAXIAL TENSION TEST: prescribe horizontal displacement of the right-end nodes and fix that of the left-hand nodes.\n",
+    "# All the other edges are traction-free.\n",
+    "\n",
+    "# Dirichlet bcs\n",
+    "applied_strain = 0.02\n",
+    "left_bnd_pos_components = [0]\n",
+    "right_bnd_pos_components = [0]\n",
+    "left_bnd_nodes_pos = S.node_coords[left_bnd_nodes_idx, :][:, left_bnd_pos_components]\n",
+    "right_bnd_nodes_pos = S.node_coords[right_bnd_nodes_idx, :][:, right_bnd_pos_components]*(1.+applied_strain)\n",
+    "bottom_left_corner_pos = S.node_coords[bottom_left_corner, :]\n",
+    "\n",
+    "# NOTE: without flatten it does not work properly when concatenating multiple bcs; \n",
+    "# fix this so that flatten is not needed (not intuitive)\n",
+    "boundary_values = {\"0\": (left_bnd_nodes_idx + right_bnd_nodes_idx, \n",
+    "                         np.vstack((left_bnd_nodes_pos, right_bnd_nodes_pos)).flatten()),\n",
+    "                    \":\": (bottom_left_corner, bottom_left_corner_pos)}\n",
+    "\n",
+    "# traction bcs\n",
+    "idx_free_edges = list(set(bnd_edges_idx) - set(right_bnd_edges_idx) - set(left_bnd_edges_idx))\n",
+    "bnd_tractions_free_values = np.zeros((len(idx_free_edges), 2), dtype=dt.float_dtype)\n",
+    "boundary_tractions = {':': (idx_free_edges, bnd_tractions_free_values)}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f460a000-f80d-4d90-aef1-298e39ddebea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mu_ = 1.\n",
+    "lambda_ = 10.\n",
+    "ni = lambda_/(2*(mu_ + lambda_))\n",
+    "E = mu_*(3*lambda_+2*mu_)/(mu_+lambda_)\n",
+    "ela = LinearElasticity(S=S, mu_=mu_, lambda_=lambda_)\n",
+    "gamma = 1000."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "b40774c6-674c-4fa5-ad43-ca982c83ba34",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Expected stress xx component =  0.07333333333333333\n",
+      "Expected strain xx component =  0.02\n",
+      "Expected strain yy component =  -0.016666666666666666\n"
+     ]
+    }
+   ],
+   "source": [
+    "# body force\n",
+    "num_faces = S.S[2].shape[0]\n",
+    "embedded_dim = S.space_dim\n",
+    "f = np.zeros((num_faces, (embedded_dim-1))).flatten()\n",
+    "\n",
+    "true_strain_yy = -(lambda_/(2*mu_+lambda_))*applied_strain # plane-strain, sigma_yy = 0\n",
+    "true_stress_xx = (2*mu_+lambda_)*applied_strain + lambda_*true_strain_yy\n",
+    "print(\"Expected stress xx component = \", true_stress_xx)\n",
+    "print(\"Expected strain xx component = \", applied_strain)\n",
+    "print(\"Expected strain yy component = \", true_strain_yy) \n",
+    "\n",
+    "node_coords_flattened = S.node_coords.flatten()\n",
+    "\n",
+    "obj_args = {'f': f, 'gamma': gamma, 'boundary_values': boundary_values, \n",
+    "            'boundary_tractions': boundary_tractions}\n",
+    "\n",
+    "prb = optctrl.OptimizationProblem(dim=S.node_coords.size,\n",
+    "                                  state_dim=S.node_coords.size,\n",
+    "                                  objfun=ela.obj_linear_elasticity)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "edff9f2b-8963-485b-ae3b-4badd068423b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n"
+     ]
+    }
+   ],
+   "source": [
+    "prb.set_obj_args(obj_args)\n",
+    "sol = prb.run(x0=node_coords_flattened)\n",
+    "curr_node_coords = sol.reshape(S.node_coords.shape)\n",
+    "print(prb.last_opt_result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "b167c662-fbd9-4c15-b2a1-2fec6b80f76e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "strain= [[[ 2.02000213e-02 -3.89468894e-09]\n",
+      "  [-3.89468888e-09 -1.68333168e-02]]\n",
+      "\n",
+      " [[ 2.01999878e-02  1.20120022e-08]\n",
+      "  [ 1.20120023e-08 -1.68333233e-02]]\n",
+      "\n",
+      " [[ 2.02000180e-02 -6.75360921e-09]\n",
+      "  [-6.75360920e-09 -1.68333160e-02]]\n",
+      "\n",
+      " [[ 2.01999937e-02  1.24049797e-08]\n",
+      "  [ 1.24049797e-08 -1.68333219e-02]]\n",
+      "\n",
+      " [[ 2.01999811e-02 -5.27162564e-09]\n",
+      "  [-5.27162542e-09 -1.68333200e-02]]\n",
+      "\n",
+      " [[ 2.02000162e-02  6.52484274e-09]\n",
+      "  [ 6.52484278e-09 -1.68333315e-02]]\n",
+      "\n",
+      " [[ 2.02000032e-02  2.32960544e-08]\n",
+      "  [ 2.32960544e-08 -1.68333290e-02]]\n",
+      "\n",
+      " [[ 2.01999763e-02  2.07164842e-08]\n",
+      "  [ 2.07164842e-08 -1.68333072e-02]]\n",
+      "\n",
+      " [[ 2.02000220e-02 -3.04773391e-09]\n",
+      "  [-3.04773378e-09 -1.68333164e-02]]\n",
+      "\n",
+      " [[ 2.01999847e-02  1.15145668e-08]\n",
+      "  [ 1.15145669e-08 -1.68332980e-02]]\n",
+      "\n",
+      " [[ 2.01999995e-02  1.12659728e-09]\n",
+      "  [ 1.12659736e-09 -1.68333040e-02]]\n",
+      "\n",
+      " [[ 2.01999919e-02 -1.17635582e-08]\n",
+      "  [-1.17635582e-08 -1.68333165e-02]]\n",
+      "\n",
+      " [[ 2.02000007e-02  4.74113131e-09]\n",
+      "  [ 4.74113124e-09 -1.68333125e-02]]\n",
+      "\n",
+      " [[ 2.02000054e-02  1.65090968e-08]\n",
+      "  [ 1.65090968e-08 -1.68333206e-02]]]\n",
+      "stress= [[[ 7.40670884e-02 -7.78937789e-09]\n",
+      "  [-7.78937775e-09  4.12148393e-07]]\n",
+      "\n",
+      " [[ 7.40666203e-02  2.40240045e-08]\n",
+      "  [ 2.40240046e-08 -1.92176719e-09]]\n",
+      "\n",
+      " [[ 7.40670561e-02 -1.35072184e-08]\n",
+      "  [-1.35072184e-08  3.87988299e-07]]\n",
+      "\n",
+      " [[ 7.40667044e-02  2.48099594e-08]\n",
+      "  [ 2.48099595e-08  7.31877731e-08]]\n",
+      "\n",
+      " [[ 7.40665734e-02 -1.05432513e-08]\n",
+      "  [-1.05432508e-08 -2.89424900e-08]]\n",
+      "\n",
+      " [[ 7.40668795e-02  1.30496855e-08]\n",
+      "  [ 1.30496856e-08  1.83996446e-07]]\n",
+      "\n",
+      " [[ 7.40667485e-02  4.65921087e-08]\n",
+      "  [ 4.65921087e-08  8.40919120e-08]]\n",
+      "\n",
+      " [[ 7.40666431e-02  4.14329684e-08]\n",
+      "  [ 4.14329684e-08  7.60712530e-08]]\n",
+      "\n",
+      " [[ 7.40670996e-02 -6.09546782e-09]\n",
+      "  [-6.09546756e-09  4.22860550e-07]]\n",
+      "\n",
+      " [[ 7.40668357e-02  2.30291336e-08]\n",
+      "  [ 2.30291338e-08  2.70409023e-07]]\n",
+      "\n",
+      " [[ 7.40669538e-02  2.25319457e-09]\n",
+      "  [ 2.25319472e-09  3.46870920e-07]]\n",
+      "\n",
+      " [[ 7.40667387e-02 -2.35271165e-08]\n",
+      "  [-2.35271164e-08  1.21857902e-07]]\n",
+      "\n",
+      " [[ 7.40668824e-02  9.48226262e-09]\n",
+      "  [ 9.48226247e-09  2.55991901e-07]]\n",
+      "\n",
+      " [[ 7.40668595e-02  3.30181936e-08]\n",
+      "  [ 3.30181937e-08  2.07501911e-07]]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "strain = ela.get_GreenLagrange_strain(curr_node_coords)\n",
+    "stress = ela.get_stress(strain)\n",
+    "\n",
+    "print(\"strain=\", strain)\n",
+    "print(\"stress=\", stress)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "6405e17e-f9df-49b6-bf86-4ae1094f19bd",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[7.40668345e-02 1.11592199e-08]\n",
+      " [1.11592200e-08 2.00865145e-07]]\n",
+      "[[0.07333333 0.        ]\n",
+      " [0.         0.        ]]\n",
+      "[[ 2.02000001e-02  5.57960997e-09]\n",
+      " [ 5.57961002e-09 -1.68333167e-02]]\n",
+      "[[ 0.02        0.        ]\n",
+      " [ 0.         -0.01666667]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "exact_stress = np.array([[true_stress_xx, 0.],[0.,0.]])\n",
+    "exact_strain = np.array([[applied_strain, 0.], [0., true_strain_yy]])\n",
+    "mean_stress = np.mean(stress, axis=0)\n",
+    "std_stress = np.std(stress,axis=0)\n",
+    "std_strain = np.std(strain,axis=0)\n",
+    "mean_strain = np.mean(strain, axis=0)\n",
+    "print(mean_stress) \n",
+    "print(exact_stress)\n",
+    "print(mean_strain)\n",
+    "print(exact_strain)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "d1c5d7dd-b15a-403f-a022-b65ab70a8a72",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f7afd923150>,\n",
+       " <matplotlib.lines.Line2D at 0x7f7afd918710>]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "triplot(node_coords[:,0], node_coords[:,1], triangles=S.S[2])\n",
+    "triplot(curr_node_coords[:,0], curr_node_coords[:,1], triangles=S.S[2])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/pacman_fracture.ipynb b/examples/pacman_fracture.ipynb
new file mode 100644
index 0000000..ea1dc18
--- /dev/null
+++ b/examples/pacman_fracture.ipynb
@@ -0,0 +1,419 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "483c6676-d99d-4fe6-bb41-8afe89ed8d5a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "7bca49c1-e9ed-47dd-8c15-b47505db0424",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%autoreload\n",
+    "import pygmsh\n",
+    "from math import sin, cos, pi\n",
+    "import pyvista as pv\n",
+    "from matplotlib.pyplot import triplot\n",
+    "import matplotlib.pyplot as plt\n",
+    "from dctkit import config\n",
+    "from dctkit.mesh import util\n",
+    "import numpy as np\n",
+    "import meshio\n",
+    "from dctkit.physics.elasticity import LinearElasticity\n",
+    "from dctkit.math.opt import optctrl\n",
+    "import dctkit as dt\n",
+    "from jax import jit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "fb715a2e-1f27-4622-8763-3187705113dc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "f0cdcc15-b320-4053-bd35-5a2832712ad6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "number of nodes =  868\n"
+     ]
+    }
+   ],
+   "source": [
+    "r = 1.\n",
+    "angle = 2*pi/4\n",
+    "lcar = 0.06\n",
+    "\n",
+    "with pygmsh.geo.Geometry() as geom:\n",
+    "    p1 = geom.add_point([0.0, 0.0, 0.0], lcar)\n",
+    "    p2 = geom.add_point([-r*cos(angle/2), r*sin(angle/2), 0.0], lcar)\n",
+    "    p3 = geom.add_point([r, 0.0, 0.0], lcar)\n",
+    "    p4 = geom.add_point([-r*cos(angle/2), -r*sin(angle/2), 0.0], lcar)\n",
+    "    \n",
+    "    c0 = geom.add_circle_arc(p2, p1, p3)\n",
+    "    c1 = geom.add_circle_arc(p3, p1, p4)\n",
+    "    l1 = geom.add_line(p1, p2)\n",
+    "    l2 = geom.add_line(p4, p1)\n",
+    "    ll = geom.add_curve_loop([l1, c0, c1, l2])\n",
+    "\n",
+    "    pacman = geom.add_plane_surface(ll)\n",
+    "    \n",
+    "    geom.add_physical([c0, c1], label=\"curved_boundary\")\n",
+    "    # WARNING: it seems that adding physical groups made of points messes up with the other groups\n",
+    "    #geom.add_physical([p3], label=\"right_point\")\n",
+    "    geom.add_physical([l1, l2], label=\"crack_faces\")\n",
+    "    \n",
+    "    mesh = geom.generate_mesh()\n",
+    "   \n",
+    "S = util.build_complex_from_mesh(mesh)\n",
+    "S.get_hodge_star()\n",
+    "S.get_flat_weights()\n",
+    "\n",
+    "curved_nodes = util.get_nodes_for_physical_group(mesh, 1, \"curved_boundary\")\n",
+    "crack_faces_nodes = util.get_nodes_for_physical_group(mesh, 1, \"crack_faces\")\n",
+    "crack_faces_edges = util.get_edges_for_physical_group(S, mesh, \"crack_faces\")\n",
+    "center_node = mesh.cells_dict[\"vertex\"][0]\n",
+    "right_node = mesh.cells_dict[\"vertex\"][2]\n",
+    "\n",
+    "x_curved_nodes = mesh.points[curved_nodes][:,0]\n",
+    "y_curved_nodes = mesh.points[curved_nodes][:,1]\n",
+    "x_crack_nodes = mesh.points[crack_faces_nodes][:,0]\n",
+    "y_crack_nodes = mesh.points[crack_faces_nodes][:,1]\n",
+    "\n",
+    "print(\"number of nodes = \", S.num_nodes)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "9890e2d9-d1fa-49c2-96ab-40a5b698cebb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f58544ee530>]"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig1, ax1 = plt.subplots()\n",
+    "ref_node_coords = S.node_coords.copy()\n",
+    "ax1.triplot(ref_node_coords[:,0], ref_node_coords[:,1], S.S[2])\n",
+    "ax1.axis('equal')\n",
+    "plt.plot(x_curved_nodes, y_curved_nodes, 'o')\n",
+    "plt.plot(x_crack_nodes, y_crack_nodes, 'o')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "8db1cf15-2473-4ae2-bf01-2cb24684b5cb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.5444837367824638\n"
+     ]
+    }
+   ],
+   "source": [
+    "from scipy.optimize import fsolve\n",
+    "import jax.numpy as jnp\n",
+    "from jax import grad, vmap\n",
+    "\n",
+    "# utility function for the calculation of the stress intensification factor vs opening angle of the V-notch\n",
+    "def compute_lam(omega):\n",
+    "    f = lambda x : jnp.sin(2*x*(pi-omega)) + x * jnp.sin(2*(pi-omega))\n",
+    "    return fsolve(f, 0.5)[0]\n",
+    "\n",
+    "lam = compute_lam(angle/2)\n",
+    "print(lam)\n",
+    "\n",
+    "def f(lam, omega):\n",
+    "    return (1+lam)*jnp.sin((1+lam)*(pi-omega))/((1-lam)*jnp.sin((1-lam)*(pi-omega)))\n",
+    "\n",
+    "def F(theta, lam, omega):\n",
+    "    return (2*pi**(lam-1))*(jnp.cos((1+lam)*theta)-f(lam, omega)*jnp.cos((1-lam)*theta))/(1-f(lam, omega))\n",
+    "\n",
+    "gradF = vmap(grad(F), in_axes=(0, None, None))\n",
+    "gradgradF = vmap(grad(grad(F)), in_axes=(0, None, None))\n",
+    "gradgradgradF = vmap(grad(grad(grad(F))), in_axes=(0, None, None))\n",
+    "\n",
+    "# polar displacement components for mode I, LEFM solution\n",
+    "def ur(theta, r, lam, omega, E, nu):\n",
+    "    return (r**lam)/E*((1-nu**2)*gradgradF(theta, lam, omega) \n",
+    "                       + (lam+1)*(1-nu*lam-nu**2*(lam+1))*F(theta, lam, omega))/(lam**2*(lam+1))\n",
+    "\n",
+    "def utheta(theta, r, lam, omega, E, nu):\n",
+    "    return (r**lam)/E*((1-nu**2)*gradgradgradF(theta, lam, omega) \n",
+    "                       + (2*(1+nu)*lam**2 + (lam + 1)*(1-nu*lam-nu**2*(lam+1)))*gradF(theta, lam, omega))/(lam**2*(1-lam**2))\n",
+    "\n",
+    "def ux(theta, r, lam, omega, E, nu):\n",
+    "    return ur(theta, r, lam, omega, E, nu)*jnp.cos(theta) - utheta(theta, r, lam, omega, E, nu)*jnp.sin(theta)\n",
+    "\n",
+    "def uy(theta, r, lam, omega, E, nu):\n",
+    "    return ur(theta, r, lam, omega, E, nu)*jnp.sin(theta) + utheta(theta, r, lam, omega, E, nu)*jnp.cos(theta)\n",
+    "\n",
+    "# compute angular positions of the boundary nodes\n",
+    "theta = jnp.arctan2(y_curved_nodes, x_curved_nodes)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "0ca520bc-ca92-42b1-92d0-82e737459db8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "E = 1.\n",
+    "nu = 0.3\n",
+    "omega = angle/2\n",
+    "\n",
+    "# displacement bcs\n",
+    "@jit\n",
+    "def update_boundary_disp(disp_mag):\n",
+    "    x_curved_nodes_curr = x_curved_nodes + disp_mag*ux(theta, r, lam, omega, E, nu)\n",
+    "    y_curved_nodes_curr = y_curved_nodes + disp_mag*uy(theta, r, lam, omega, E, nu)\n",
+    "    z_curved_nodes_curr = np.zeros(len(curved_nodes), dtype=dt.float_dtype)\n",
+    "    center_node_pos = jnp.zeros((1,3), dtype=dt.float_dtype)\n",
+    "    curved_nodes_pos = jnp.vstack([x_curved_nodes_curr, y_curved_nodes_curr, z_curved_nodes_curr]).T\n",
+    "    disp_nodes = list(center_node) + list(curved_nodes)\n",
+    "    disp_nodes_pos = jnp.vstack((center_node_pos, curved_nodes_pos))\n",
+    "    return {\":\": (disp_nodes, disp_nodes_pos)}\n",
+    "\n",
+    "# traction bcs\n",
+    "bnd_tractions_free_values = np.zeros((len(crack_faces_edges), 2), dtype=dt.float_dtype)\n",
+    "boundary_tractions = {':': (crack_faces_edges, bnd_tractions_free_values)}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "id": "a6ed035f-2d61-4f31-9e61-b8ee26f81279",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mu_ = E/(2*(1+nu))\n",
+    "lambda_ = E*nu/((1-2*nu)*(1+nu))\n",
+    "ela = LinearElasticity(S=S, mu_=mu_, lambda_=lambda_)\n",
+    "gamma = 10."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "id": "cbd1b3c1-6443-4152-a82e-2c1064e196e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# body force\n",
+    "num_faces = S.S[2].shape[0]\n",
+    "embedded_dim = S.space_dim\n",
+    "body_force = np.zeros((num_faces, (embedded_dim-1))).flatten()\n",
+    "\n",
+    "prb = optctrl.OptimizationProblem(dim=S.node_coords.size,\n",
+    "                                  state_dim=S.node_coords.size,\n",
+    "                                  objfun=ela.obj_linear_elasticity)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "id": "09718c72-3e7e-4154-83f5-9397c371459a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "load parameter =  0.05\n",
+      "convergence result =  3\n",
+      "Elapsed time =  19.41297435760498\n",
+      "3\n"
+     ]
+    }
+   ],
+   "source": [
+    "x0 = S.node_coords.flatten()\n",
+    "import time\n",
+    "tic = time.time()\n",
+    "for i in range(1,2):\n",
+    "    disp_mag = i*0.05\n",
+    "    print(\"load parameter = \", disp_mag)\n",
+    "    boundary_disp = update_boundary_disp(disp_mag)\n",
+    "    obj_args = {'f': body_force, 'gamma': gamma, 'boundary_values': boundary_disp, \n",
+    "                'boundary_tractions': boundary_tractions}\n",
+    "    prb.set_obj_args(obj_args)\n",
+    "    sol = prb.run(x0=x0, algo=\"lbfgs\", ftol_abs=1e-10, ftol_rel=1e-10, maxeval=1000)\n",
+    "    print(\"convergence result = \", prb.last_opt_result)\n",
+    "    x0 = sol.__array__()\n",
+    "\n",
+    "toc = time.time()\n",
+    "\n",
+    "print(\"Elapsed time = \", toc - tic)\n",
+    "\n",
+    "curr_node_coords = sol.reshape(S.node_coords.shape)\n",
+    "print(prb.last_opt_result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "id": "b82aaf60-b337-463d-8a2f-8885c1b546f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-0.7937013332327233,\n",
+       " 1.111378811783143,\n",
+       " -1.2075761430662326,\n",
+       " 1.2075775099384112)"
+      ]
+     },
+     "execution_count": 69,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig1, ax1 = plt.subplots()\n",
+    "ax1.triplot(ref_node_coords[:,0], ref_node_coords[:,1], S.S[2])\n",
+    "ax1.triplot(curr_node_coords[:,0], curr_node_coords[:,1], S.S[2])\n",
+    "ax1.axis('equal')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "id": "9d8f1c33-c9d5-49f5-a5ab-3bdf947f3bf0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1620 1620\n"
+     ]
+    }
+   ],
+   "source": [
+    "strains = ela.get_GreenLagrange_strain(curr_node_coords)\n",
+    "stresses = ela.get_stress(strains)\n",
+    "trace_stresses = jnp.trace(stresses, axis1=1, axis2=2)\n",
+    "# trace_stresses = stresses[:,1,1]\n",
+    "print(len(trace_stresses), len(S.S[2]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "id": "31e6a21d-6df3-44f7-8799-78be13f8bde9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-0.7924621202458749,\n",
+       " 1.0853553390593274,\n",
+       " -1.0997879644828619,\n",
+       " 1.0997879645731767)"
+      ]
+     },
+     "execution_count": 73,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig1, ax1 = plt.subplots()\n",
+    "ax1.tripcolor(ref_node_coords[:,0], ref_node_coords[:,1], trace_stresses, triangles=S.S[2], cmap=\"coolwarm\")\n",
+    "ax1.axis('equal')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2a368812",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/poisson_3D.ipynb b/examples/poisson_3D.ipynb
new file mode 100644
index 0000000..9bd86b5
--- /dev/null
+++ b/examples/poisson_3D.ipynb
@@ -0,0 +1,262 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4de97868-2f1e-4d44-8933-3e16d154cbdf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "9f92939f-6f36-4192-af7f-3f8a46170566",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%autoreload\n",
+    "import numpy as np\n",
+    "import jax.numpy as jnp\n",
+    "from dctkit.mesh import util, simplex\n",
+    "from dctkit.math.opt import optctrl as oc\n",
+    "import dctkit.dec.cochain as C\n",
+    "import dctkit as dt\n",
+    "import pygmsh\n",
+    "import pyvista as pv\n",
+    "from pyvista import themes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "82bcfde1-8306-4144-8397-fcc34a4fa8ca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dt.config()\n",
+    "pv.set_jupyter_backend('trame')\n",
+    "pv.global_theme = themes.ParaViewTheme()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "179ad2e2-7d27-46d9-88cd-9127ba3f74e2",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tetra\n",
+      "number of nodes =  237\n",
+      "number of tets =  741\n"
+     ]
+    }
+   ],
+   "source": [
+    "lc = 0.2\n",
+    "mesh, _ = util.generate_cube_mesh(lc)\n",
+    "#pv.plot(mesh)\n",
+    "S = util.build_complex_from_mesh(mesh)\n",
+    "num_nodes = S.num_nodes\n",
+    "print(\"number of nodes = \", num_nodes)\n",
+    "print(\"number of tets = \", S.S[3].shape[0])\n",
+    "S.get_hodge_star()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "18d95a59-6dbb-43af-9743-6e2ff45b390a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([  0,   1,   2,   3,   8,   9,  10,  11,  12,  13,  14,  15,  16,\n",
+       "         17,  18,  19,  20,  21,  22,  23,  56,  57,  58,  59,  60,  61,\n",
+       "         62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,\n",
+       "         75,  76,  77,  78,  79,   4,   5,   6,   7,  24,  25,  26,  27,\n",
+       "         28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39, 178,\n",
+       "        179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,\n",
+       "        192, 193, 194, 195, 196, 197, 198, 199, 200, 201]),\n",
+       " array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "        0., 0., 0.]))"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# boundary conditions\n",
+    "bottom_nodes = np.argwhere(S.node_coords[:,2]<1e-6).flatten()\n",
+    "top_nodes = np.argwhere(abs(S.node_coords[:,2]-1.)<1e-6).flatten()\n",
+    "values = np.zeros(len(bottom_nodes)+len(top_nodes), dtype=dt.float_dtype)\n",
+    "boundary_values = (np.hstack((bottom_nodes,top_nodes)), values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "c32ba0bf-2885-4c85-ad9a-f426463cab26",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from functools import partial\n",
+    "from dctkit.physics import poisson as p\n",
+    "\n",
+    "def disspot(u, u_prev, deltat):\n",
+    "    u_coch = C.CochainP0(S, u)\n",
+    "    u_prev_coch = C.CochainP0(S, u_prev)\n",
+    "    u_diff = C.sub(u_coch, u_prev_coch)\n",
+    "    return (1/2)*C.inner_product(u_diff, u_diff)/deltat\n",
+    "\n",
+    "energy = partial(p.energy_poisson, S=S)\n",
+    "\n",
+    "def obj(u, u_prev, f, k, boundary_values, gamma, deltat):\n",
+    "    en = energy(x=u, f=f, k=k, boundary_values=boundary_values, gamma=gamma)\n",
+    "    return en + disspot(u, u_prev, deltat)\n",
+    "\n",
+    "k = 1.\n",
+    "f_vec = np.ones(num_nodes, dtype=dt.float_dtype)\n",
+    "gamma = 1000.\n",
+    "deltat = 0.1\n",
+    "\n",
+    "u_0 = np.zeros(num_nodes, dt.float_dtype)\n",
+    "u_prev = u_0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "ff963044-5321-4516-86fc-37d2a4e66b92",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t =  0.1\n",
+      "t =  0.2\n",
+      "t =  0.30000000000000004\n",
+      "t =  0.4\n",
+      "t =  0.5\n",
+      "t =  0.6000000000000001\n",
+      "t =  0.7000000000000001\n",
+      "t =  0.8\n",
+      "t =  0.9\n",
+      "t =  1.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sols = []\n",
+    "prb = oc.OptimizationProblem(dim=num_nodes, state_dim=num_nodes, objfun=obj)\n",
+    "for i in range(10):\n",
+    "    print(\"t = \", (i+1)*deltat)\n",
+    "    args = {'u_prev': u_prev, 'f': f_vec, 'k': k, 'boundary_values': boundary_values,\n",
+    "        'gamma': gamma, 'deltat': deltat}\n",
+    "    prb.set_obj_args(args)\n",
+    "    u = prb.run(u_prev, ftol_abs=1e-8, ftol_rel=1e-8)\n",
+    "    u_prev = u.__array__()\n",
+    "    sols.append(u)\n",
+    "prb.last_opt_result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "e9a0d608-1c77-40fe-abd0-920b65601c75",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5e71fa1f4aac496a8e21c2d0f5e8a98c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Widget(value=\"<iframe src='http://localhost:33213/index.html?ui=P_0x7f3a706426b0_1&reconnect=auto' style='widt…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "p = pv.Plotter()\n",
+    "p.add_mesh(mesh, scalars=sols[-1])\n",
+    "p.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "247ab9e1-0ee5-495d-879e-f39183ef2f9c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import meshio\n",
+    "filename = \"timedata.xdmf\"\n",
+    "points = mesh.points\n",
+    "cells = {\"tetra\": mesh.cells_dict[\"tetra\"]}\n",
+    "with meshio.xdmf.TimeSeriesWriter(filename) as writer:\n",
+    "    writer.write_points_cells(points, cells)\n",
+    "    for i in range(10):\n",
+    "        writer.write_data(i, point_data={\"u\": sols[i]})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1de804fc-920f-4fbb-802a-cbfc00d58d4e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/dctkit/dec/cochain.py b/src/dctkit/dec/cochain.py
index fa55f6b..f3ac304 100644
--- a/src/dctkit/dec/cochain.py
+++ b/src/dctkit/dec/cochain.py
@@ -62,6 +62,13 @@ def __init__(self, complex: spx.SimplicialComplex, coeffs):
         super().__init__(2, complex, coeffs)
 
 
+class CochainP3(CochainP):
+    """Class for primal 3-cochains."""
+
+    def __init__(self, complex: spx.SimplicialComplex, coeffs):
+        super().__init__(3, complex, coeffs)
+
+
 class CochainD0(CochainD):
     """Class for dual 0-cochains."""
 
@@ -83,6 +90,13 @@ def __init__(self, complex: spx.SimplicialComplex, coeffs):
         super().__init__(2, complex, coeffs)
 
 
+class CochainD3(CochainD):
+    """Class for dual 3-cochains."""
+
+    def __init__(self, complex: spx.SimplicialComplex, coeffs):
+        super().__init__(3, complex, coeffs)
+
+
 def add(c1: Cochain, c2: Cochain) -> Cochain:
     """Adds two cochains.
 
@@ -293,11 +307,12 @@ def star(c: Cochain) -> Cochain:
                      coeffs=jnp.empty_like(c.coeffs, dtype=dt.float_dtype))
 
     if c.is_primal:
-        star_c.coeffs = c.complex.hodge_star[c.dim]*c.coeffs
+        star_c.coeffs = (c.complex.hodge_star[c.dim]*c.coeffs.T).T
     else:
         # NOTE: this step only works with well-centered meshes!
         assert c.complex.is_well_centered
-        star_c.coeffs = c.complex.hodge_star_inverse[c.complex.dim - c.dim]*c.coeffs
+        star_c.coeffs = (
+            c.complex.hodge_star_inverse[c.complex.dim - c.dim]*c.coeffs.T).T
 
     return star_c
 
diff --git a/src/dctkit/dec/vector.py b/src/dctkit/dec/vector.py
index 924de9c..ec75ae7 100644
--- a/src/dctkit/dec/vector.py
+++ b/src/dctkit/dec/vector.py
@@ -1,25 +1,34 @@
 import jax.numpy as jnp
 import numpy.typing as npt
-from .cochain import CochainD1
+from .cochain import CochainP1, CochainD1
 from dctkit.mesh import simplex as spx
 from jax import Array
 
 
-class DiscreteVectorField():
-    """Discrete vector fields class.
+class DiscreteTensorField():
+    """Discrete tensor fields class.
 
     Args:
-        S (SimplicialComplex): the simplicial complex where the discrete vector field
-        is defined.
-        is_primal (bool): True if the discrete vector field is primal, False otherwise.
-        coeffs (Array): array of the coefficients of the discrete vector fields.
+        S: the simplicial complex where the discrete vector field is defined.
+        is_primal: True if the discrete vector field is primal, False otherwise.
+        coeffs: array of the coefficients of the discrete vector fields.
+        rank: rank of the tensor.
     """
 
     def __init__(self, S: spx.SimplicialComplex, is_primal: bool,
-                 coeffs: npt.NDArray | Array):
+                 coeffs: npt.NDArray | Array, rank: int):
         self.S = S
         self.is_primal = is_primal
         self.coeffs = coeffs
+        self.rank = rank
+
+
+class DiscreteVectorField(DiscreteTensorField):
+    """Inherited class for discrete vector fields."""
+
+    def __init__(self, S: spx.SimplicialComplex, is_primal: bool,
+                 coeffs: npt.NDArray | Array):
+        super().__init__(S, is_primal, coeffs, 1)
 
 
 class DiscreteVectorFieldD(DiscreteVectorField):
@@ -29,18 +38,67 @@ def __init__(self, S: spx.SimplicialComplex, coeffs: npt.NDArray | Array):
         super().__init__(S, False, coeffs)
 
 
-def flat_DPD(v: DiscreteVectorFieldD) -> CochainD1:
-    """Implements the flat operator for dual discrete vector fields.
+class DiscreteTensorFieldD(DiscreteTensorField):
+    """Inherited class for dual discrete tensor fields."""
+
+    def __init__(self, S: spx.SimplicialComplex, coeffs: npt.NDArray | Array,
+                 rank: int):
+        super().__init__(S, False, coeffs, rank)
+
+
+def flat_DPD(v: DiscreteTensorFieldD) -> CochainD1:
+    """Implements the flat DPD operator for dual discrete vector fields.
 
     Args:
         v: a dual discrete vector field.
     Returns:
-        the dual cochain resulting from the application of the flat operator.
+        the dual 1-cochain resulting from the application of the flat operator.
     """
-    dedges = v.S.dual_edges_vectors
-    flat_matrix = v.S.flat_weights
+    dedges = v.S.dual_edges_vectors[:, :v.coeffs.shape[0]]
+    flat_matrix = v.S.flat_DPD_weights
     # multiply weights of each dual edge by the vectors associated to the dual nodes
-    # belonging to the edge and then perform dot product row-wise with the edge vectors
-    # of the dual edges (see definition of DPD in Hirani, pag. 54).
-    coch_coeffs = jnp.sum((v.coeffs @ flat_matrix).T * dedges, axis=1)
+    # belonging to the edge
+    weighted_v = v.coeffs @ flat_matrix
+    if v.rank == 1:
+        # vector field case
+        # perform dot product row-wise with the edge vectors
+        # of the dual edges (see definition of DPD in Hirani, pag. 54).
+        weighted_v_T = weighted_v.T
+        coch_coeffs = jnp.einsum("ij, ij -> i", weighted_v_T, dedges)
+    elif v.rank == 2:
+        # tensor field case
+        # apply each matrix (rows of the multiarray weighted_v_T fixing the first axis)
+        # to the edge vector of the corresponding dual edge
+        weighted_v_T = jnp.transpose(weighted_v, axes=(2, 0, 1))
+        coch_coeffs = jnp.einsum("ijk, ik -> ij", weighted_v_T, dedges)
     return CochainD1(v.S, coch_coeffs)
+
+
+def flat_DPP(v: DiscreteTensorFieldD) -> CochainP1:
+    """Implements the flat DPP operator for dual discrete vector fields.
+
+    Args:
+        v: a dual discrete vector field.
+    Returns:
+        the primal 1-cochain resulting from the application of the flat operator.
+    """
+    primal_edges = v.S.primal_edges_vectors[:, :v.coeffs.shape[0]]
+    flat_matrix = v.S.flat_DPP_weights
+    # multiply weights of each primal edge by the vectors associated to the dual nodes
+    # belonging to the corresponding dual edge
+    weighted_v = v.coeffs @ flat_matrix
+    if v.rank == 1:
+        # vector field case
+        # perform dot product row-wise with the edge vectors
+        # of the dual edges (see definition of DPD in Hirani, pag. 54).
+        weighted_v_T = weighted_v.T
+        coch_coeffs = jnp.einsum("ij, ij -> i", weighted_v_T,
+                                 primal_edges)
+    elif v.rank == 2:
+        # tensor field case
+        # apply each matrix (rows of the multiarray weighted_v_T fixing the first axis)
+        # to the edge vector of the corresponding dual edge
+        weighted_v_T = jnp.transpose(weighted_v, axes=(2, 0, 1))
+        coch_coeffs = jnp.einsum("ijk, ik -> ij", weighted_v_T,
+                                 primal_edges)
+    return CochainP1(v.S, coch_coeffs)
diff --git a/src/dctkit/math/circumcenter.py b/src/dctkit/math/circumcenter.py
deleted file mode 100644
index 3b80ba6..0000000
--- a/src/dctkit/math/circumcenter.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import numpy as np
-import dctkit
-
-
-def circumcenter(s, node_coord):
-    """Compute the circumcenter of a given simplex s. (References: Bell, Hirani,
-        PyDEC: Software and Algorithms for Discretization of Exterior Calculus,
-        2012, Section 10.1).
-
-        Args:
-            s (np.array): array containing the IDs of the nodes beloging to s.
-            node_coord (np.array): coordinates of every node of the cell complex
-                in which s is defined.
-        Returns:
-            np.array: coordinates of the circumcenter of s.
-    """
-    # get global data type
-    float_dtype = dctkit.float_dtype
-
-    # store the coordinates of the nodes in s
-    simplex_coord = node_coord[s[:]]
-    rows, cols = simplex_coord.shape
-
-    assert (rows <= cols + 1)
-
-    # construct the matrix A
-    A = np.bmat([[2*np.dot(simplex_coord, simplex_coord.T),
-                  np.ones((rows, 1), dtype=float_dtype)],
-                [np.ones((1, rows), dtype=float_dtype),
-                 np.zeros((1, 1), dtype=float_dtype)]])
-    b = np.hstack((np.sum(simplex_coord * simplex_coord, axis=1),
-                   np.ones((1), dtype=float_dtype)))
-
-    # barycentric coordinates x of the circumcenter are the solution
-    # of the linear sistem Ax = b
-    bary_coords = np.linalg.solve(A, b)
-    bary_coords = bary_coords[:-1]
-
-    # compute the coordinates of the circumcenter
-    circumcenter = np.dot(bary_coords, simplex_coord)
-
-    return circumcenter, bary_coords
diff --git a/src/dctkit/math/opt/optctrl.py b/src/dctkit/math/opt/optctrl.py
index 2c95493..3435314 100644
--- a/src/dctkit/math/opt/optctrl.py
+++ b/src/dctkit/math/opt/optctrl.py
@@ -88,7 +88,8 @@ def get_name(self) -> str:
         return "Optimization problem"
 
     def run(self, x0: npt.NDArray, algo: str = "tnewton", ftol_abs: float = 1e-5,
-            ftol_rel: float = 1e-5, maxeval: int = 500) -> npt.NDArray:
+            ftol_rel: float = 1e-5, maxeval: int = 500,
+            verbose: bool = False) -> npt.NDArray:
         prb = pg.problem(self)
 
         if self.constr_problem:
@@ -99,7 +100,7 @@ def run(self, x0: npt.NDArray, algo: str = "tnewton", ftol_abs: float = 1e-5,
         algo.extract(pg.nlopt).maxeval = maxeval  # type: ignore
         pop = pg.population(prb)
         pop.push_back(x0)
-        # algo.set_verbosity(1)
+        algo.set_verbosity(verbose)
         pop = algo.evolve(pop)  # type: ignore
         self.last_opt_result = algo.extract(  # type: ignore
             pg.nlopt).get_last_opt_result()
diff --git a/src/dctkit/mesh/circumcenter.py b/src/dctkit/mesh/circumcenter.py
new file mode 100644
index 0000000..30c8218
--- /dev/null
+++ b/src/dctkit/mesh/circumcenter.py
@@ -0,0 +1,59 @@
+import numpy as np
+import dctkit
+import numpy.typing as npt
+from typing import Tuple
+
+# FIXME: pass only the coordinates of the nodes of the simplex or consider making this a
+# method of the SimplicialComplex class.
+
+
+def circumcenter(S: npt.NDArray,
+                 node_coords: npt.NDArray) -> Tuple[npt.NDArray, npt.NDArray]:
+    """Compute the circumcenter of a set of simplices (arranged row-wise).
+        (Reference: Bell, Hirani, PyDEC: Software and Algorithms for Discretization
+        of Exterior Calculus, 2012, Section 10.1).
+
+        Args:
+            S: matrix containing the IDs of the nodes belonging to each simplex.
+            node_coords: coordinates (cols) of each node of the complex to which the
+                simplices belongs.
+        Returns:
+            a tuple consisting of the Cartesian coordinates of the circumcenter and the
+                barycentric coordinates.
+    """
+    # get global data type
+    float_dtype = dctkit.float_dtype
+
+    # store the coordinates of the nodes for each simplex in S
+    S_coord = node_coords[S]
+
+    transpose_S_coord = np.transpose(S_coord, [0, 2, 1])
+    # extract number of p-simplices and number of nodes per simplex
+    num_p, num_nodes_per_spx = S.shape
+
+    # construct for each simplex s the matrix
+    # A_s = [B_s | 1_{m-1,1};
+    #        1_{1, m-1} |  0]
+    # where m-1 is the number of nodes per simplex and B is the matrix (m-1)x(m-1)
+    # defined as B_ij = 2 <v_i, v_j>
+    A = np.zeros((num_p, num_nodes_per_spx+1, num_nodes_per_spx+1), dtype=float_dtype)
+    A[:, :num_nodes_per_spx, :num_nodes_per_spx] = 2 * S_coord @ transpose_S_coord
+    A[:, :, -1] = 1
+    A[:, -1, :] = 1
+    A[:, -1, -1] = 0
+
+    # the vector of constant terms b for a given p-simplex s = {v_0,...,v_p} is
+    # [<v_0,v_0>, ..., <v_p,v_p>, 1], where v_i is the coordinate of the
+    # i-th node in s
+    b = np.ones((num_p, num_nodes_per_spx+1), dtype=float_dtype)
+    b[:, range(num_nodes_per_spx)] = np.sum(S_coord * S_coord, axis=2)
+
+    # barycentric coordinates x of the circumcenter are the solution
+    # of the linear sistem Ax = b without the last component (i.e. x[:-1])
+    bary_coords_extended = np.linalg.solve(A, b)
+    bary_coords = bary_coords_extended[:, :-1]
+
+    # the circumcenter of a p-simplex {v0,...,vp} can be written in barycentric
+    # coordinates as c = sum_j x_j v_j
+    circumcenter = np.einsum("ij,ijk -> ik", bary_coords, S_coord)
+    return circumcenter, bary_coords
diff --git a/src/dctkit/mesh/simplex.py b/src/dctkit/mesh/simplex.py
index 68963a2..f302c1f 100644
--- a/src/dctkit/mesh/simplex.py
+++ b/src/dctkit/mesh/simplex.py
@@ -1,21 +1,24 @@
 import numpy as np
 import dctkit
-from dctkit.math import circumcenter as circ
+from dctkit.mesh import circumcenter as circ, volume
 from dctkit.math import shifted_list as sl
-from dctkit.math import volume, spmv
+from dctkit.math import spmv
+import numpy.typing as npt
+from jax import Array
+import jax.numpy as jnp
+from typing import Tuple, Any
 
 
 class SimplicialComplex:
     """Simplicial complex class.
 
     Args:
-        tet_node_tags (int32 np.array): matrix containing the IDs of the nodes
-            (cols) belonging to each tetrahedron or top-level simplex (rows).
-        node_coord (float np.array): Cartesian coordinates (columns) of all the
-        nodes (rows) of the simplicial complex.
-        bnd_faces_tags (float np.array): matrix containing the IDs of the nodes
-            (cols) belonging to each boundary (n-1)-simplex (rows).
-        is_well_centered (bool): True if the mesh is well-centered.
+        tet_node_tags: matrix containing the IDs of the nodes (cols) belonging to each
+            tetrahedron or top-level simplex (rows).
+        node_coords: Cartesian coordinates (columns) of all the nodes (rows) of the
+            simplicial complex.
+        is_well_centered: True if the mesh is well-centered.
+
     Attributes:
         dim (int32): dimension of the complex.
         S (list): list where each entry p is a matrix containing the IDs of the
@@ -23,63 +26,64 @@ class SimplicialComplex:
         circ (list): list where each entry p is a matrix containing the
             coordinates of the circumcenters (cols) of all the p-simplexes (rows).
         boundary (list): list of the boundary matrices at all dimensions (0..dim-1).
-        node_coord (float np.array): Cartesian coordinates (columns) of all the
+        node_coords (float np.array): Cartesian coordinates (cols) of the
             nodes (rows) of the simplicial complex.
         primal_volumes (list): list where each entry p is an array containing all the
             volumes of the primal p-simplices.
         dual_volumes (list): list where each entry p is an array containing all
             the volumes of the dual p-simplices.
-        B (list): list where each entry p is a matrix containing the IDs of the
-            (p-1)-simplices (cols) belonging to each p-simplex (rows).
+        boundary_connectivity (list): list where each entry p is a matrix containing
+            the IDs of the (p-1)-simplices (cols) belonging to each p-simplex (rows).
         hodge_star (list): list where each entry is an array containing the
             diagonal of the Hodge star matrix.
     """
 
-    def __init__(self, tet_node_tags, node_coord, bnd_faces_tags=None,
-                 is_well_centered=False):
+    def __init__(self, tet_node_tags: npt.NDArray, node_coords: npt.NDArray,
+                 is_well_centered: bool = False):
 
-        # store the coordinates of the nodes
-        node_coord = np.array(node_coord, dtype=dctkit.float_dtype)
-        tet_node_tags = np.array(tet_node_tags, dtype=dctkit.int_dtype)
-        self.node_coord = node_coord
-        self.num_nodes = node_coord.shape[0]
-        self.embedded_dim = node_coord.shape[1]
+        self.node_coords = node_coords.astype(dctkit.float_dtype)
+        tet_node_tags = tet_node_tags.astype(dctkit.int_dtype)
+        self.num_nodes = node_coords.shape[0]
+        self.space_dim = node_coords.shape[1]
         self.float_dtype = dctkit.float_dtype
         self.int_dtype = dctkit.int_dtype
         self.is_well_centered = is_well_centered
-        self.bnd_faces_tags = bnd_faces_tags
+        self.ref_covariant_basis = None
+        self.ref_metric_contravariant = None
 
         # compute complex dimension from top-level simplices
         self.dim = tet_node_tags.shape[1] - 1
 
-        self.S = [None] * (self.dim + 1)
+        self.S = [npt.NDArray[Any]] * (self.dim + 1)
         self.S[-1] = tet_node_tags
 
-        # populate boundary operators and boundary elements indices
-        self.__get_boundary_operators()
-        if bnd_faces_tags is not None:
-            self.__get_boundary_faces_indices()
+        self.get_boundary_operators()
+
+        # FIXME: maybe we don't want to compute the metric by default, in some
+        # applications is not needed...
+        if self.dim == 2:
+            self.reference_metric = self.get_current_metric_2D(self.node_coords)
 
-    def __get_boundary_operators(self):
+    def get_boundary_operators(self):
         """Compute all the COO representations of the boundary matrices."""
         self.boundary = sl.ShiftedList([None] * self.dim, -1)
-        self.B = sl.ShiftedList([None] * self.dim, -1)
+        self.boundary_connectivity = sl.ShiftedList([None] * self.dim, -1)
         for p in range(self.dim):
-            boundary, vals, B = compute_boundary_COO(self.S[self.dim - p])
+            boundary, vals, faces_ordered = compute_boundary_COO(self.S[self.dim - p])
+            boundary_connectivity_dim_m_p = compute_boundary_connectivity(
+                self.S[self.dim - p], faces_ordered)
 
             self.boundary[self.dim - p] = boundary
-            self.B[self.dim - p] = B
+            self.boundary_connectivity[self.dim - p] = boundary_connectivity_dim_m_p
             self.S[self.dim - p - 1] = vals
 
-    def __get_boundary_faces_indices(self):
-        """Compute the (sorted) indices of the boundary faces in the matrix S[dim-1]."""
-        faces = self.S[self.dim - 1]
-        num_bnd_faces = self.bnd_faces_tags.shape[0]
-        self.bnd_faces_indices = np.zeros(num_bnd_faces, dtype=dctkit.int_dtype)
-        # extract row indices of the faces matrix corresponding to the boundary faces
-        self.bnd_faces_indices = [int(np.argwhere(
-            np.all(faces == bnd_face, axis=1))) for bnd_face in self.bnd_faces_tags]
-        self.bnd_faces_indices = np.sort(self.bnd_faces_indices)
+    def get_complex_boundary_faces_indices(self):
+        """Find the IDs of the boundary faces of the complex, i.e. the row indices of
+        the boundary faces in the matrix S[dim-1]."""
+        # boundary faces IDs appear only once in the matrix B[dim]
+        unique_elements, counts = np.unique(
+            self.boundary_connectivity[self.dim], return_counts=True)
+        self.bnd_faces_indices = np.sort(unique_elements[counts == 1])
 
     def get_circumcenters(self):
         """Compute all the circumcenters."""
@@ -87,102 +91,97 @@ def get_circumcenters(self):
         self.bary_circ = sl.ShiftedList([None] * (self.dim), -1)
         for p in range(1, self.dim + 1):
             S = self.S[p]
-            C = np.empty((S.shape[0], self.embedded_dim), dtype=self.float_dtype)
-            B = np.empty((S.shape[0], S.shape[1]), dtype=self.float_dtype)
-            for i in range(S.shape[0]):
-                C[i, :], B[i, :] = circ.circumcenter(S[i, :], self.node_coord)
+            C, B = circ.circumcenter(S, self.node_coords)
             self.circ[p] = C
             self.bary_circ[p] = B
 
     def get_primal_volumes(self):
         """Compute all the primal volumes."""
-        # loop over all p-simplices (1..dim + 1)
-        # (volume of 0-simplices is 1, we do not store it)
-        self.primal_volumes = sl.ShiftedList([None] * (self.dim), -1)
+        self.primal_volumes = [None]*(self.dim + 1)
+        self.primal_volumes[0] = np.ones(self.num_nodes, dtype=self.float_dtype)
         for p in range(1, self.dim + 1):
             S = self.S[p]
-            num_p_simplices, _ = S.shape
-            primal_volumes = np.empty(num_p_simplices)
-            if p == self.embedded_dim:
-                primal_volumes = volume.signed_volume(S, self.node_coord)
+            if p == self.space_dim:
+                primal_volumes = volume.signed_volume(S, self.node_coords)
             else:
-                primal_volumes = volume.unsigned_volume(S, self.node_coord)
+                primal_volumes = volume.unsigned_volume(S, self.node_coords)
             self.primal_volumes[p] = primal_volumes
 
     def get_dual_volumes(self):
         """Compute all the dual volumes."""
-        self.dual_volumes = sl.ShiftedList([None] * (self.dim), -1)
-        self.dual_volumes[self.dim] = np.ones(self.S[self.embedded_dim - self.dim].
-                                              shape[0], dtype=self.float_dtype)
+
+        if not hasattr(self, "circ"):
+            self.get_circumcenters()
+
+        self.dual_volumes = [None] * (self.dim+1)
+        self.dual_volumes[self.dim] = np.ones(self.S[self.dim].shape[0],
+                                              dtype=self.float_dtype)
+
         # loop over simplices at all dimensions
         for p in range(self.dim, 0, -1):
-            num_p, num_bnd_simplices = self.B[p].shape
+            num_p, _ = self.boundary_connectivity[p].shape
             num_pm1, _ = self.S[p - 1].shape
             dv = np.zeros(num_pm1, dtype=self.float_dtype)
             if p == 1:
-                # circ_pm1 = circumcenters of the (p-1)-simplices and the
-                # circumcenters of the nodes (0-simplices) are the nodes itself.
-                circ_pm1 = self.node_coord
+                # circ_pm1 = circumcenters of the (p-1)-simplices and the circumcenters
+                # of the nodes (0-simplices) are the nodes itself.
+                circ_pm1 = self.node_coords
             else:
                 circ_pm1 = self.circ[p - 1]
             # Loop over p-simplices
             for i in range(num_p):
-                # Loop over boundary simplices of the p-simplex
-
-                for j in range(num_bnd_simplices):
-                    # ID of the boundary (p-1)-simplex
-                    index = self.B[p][i, j]
-
-                    # Distance between circumcenters of the p-simplex and the
-                    # boundary (p-1)-simplex
-                    length = np.linalg.norm(self.circ[p][i, :] -
-                                            circ_pm1[index, :])
-
-                    # Find opposite vertex to the (p-1)-simplex
-                    opp_vert = list(
-                        set(self.S[p][i]) - set(self.S[p - 1][index]))[0]
-                    opp_vert_index = list(self.S[p][i]).index(opp_vert)
-
-                    # Sign of the dual volume of the boundary (p-1)-simplex = sign
-                    # of the barycentric coordinate of the circumcenter of the
-                    # parent p-simplex relative to the opposite vertex
-                    sign = np.copysign(1, self.bary_circ[p][i, opp_vert_index])
-
-                    # Update dual volume of the boundary (p-1)-simplex
-                    dv[index] += sign * (length*self.dual_volumes[p][i] /
-                                         (self.dim - p + 1))
+                # indexes of the boundary simplices of the p-simplex
+                index = self.boundary_connectivity[p][i, :]
+                # Distance between circumcenters of the p-simplex and the boundary
+                # (p-1)-simplices
+                length = np.linalg.norm(self.circ[p][i, :] - circ_pm1[index, :], axis=1)
+
+                # Find opposite vertexes to the (p-1)-simplices
+                opp_vert = np.array(
+                    [list(set(self.S[p][i]) - set(self.S[p - 1][j])) for j in index])
+                opp_vert_index = [list(self.S[p][i]).index(j) for j in opp_vert]
+
+                # Sign of the dual volume of the boundary (p-1)-simplex = sign of
+                # the barycentric coordinate of the circumcenter of the parent
+                # p-simplex relative to the opposite vertex
+                sign = np.copysign(1, self.bary_circ[p][i, opp_vert_index])
+                # Update dual volume of the boundary (p-1)-simplex
+                dv[index] += sign * (length*self.dual_volumes[p][i] /
+                                     (self.dim - p + 1))
 
             self.dual_volumes[p - 1] = dv
 
     def get_hodge_star(self):
-        """Compute all the hodge stars and their inverse if the mesh is well-centered.
+        """Compute all the Hodge stars, and their inverses if the mesh is well-centered.
         """
         n = self.dim
-        self.hodge_star = [None]*(n + 1)
+
+        if not hasattr(self, "primal_volumes"):
+            self.get_primal_volumes()
+
+        if not hasattr(self, "dual_volumes"):
+            self.get_dual_volumes()
+
+        self.hodge_star = [self.dual_volumes[i]/self.primal_volumes[i]
+                           for i in range(n + 1)]
+
         if self.is_well_centered:
-            self.hodge_star_inverse = [None]*(n + 1)
-        for p in range(n + 1):
-            if p == 0:
-                # volumes of vertices are 1 by definition
-                pv = 1
-                dv = self.dual_volumes[n - p]
-            elif p == n:
-                pv = self.primal_volumes[p]
-                # volumes of vertices are 1 by definition
-                dv = 1
-            else:
-                pv = self.primal_volumes[p]
-                dv = self.dual_volumes[n - p]
-            self.hodge_star[p] = dv/pv
-            if self.is_well_centered:
-                self.hodge_star_inverse[p] = 1.0/self.hodge_star[p]
-                # adjust the sign in order to have star_inv*star = (-1)^(p*(n-p))
-                self.hodge_star_inverse[p] *= (-1)**(p*(n-p))
+            # adjust the sign in order to have star_inv*star = (-1)^(p*(n-p))
+            self.hodge_star_inverse = [(-1)**(i*(n-i))/self.hodge_star[i]
+                                       for i in range(n + 1)]
+
+    def get_primal_edge_vectors(self):
+        primal_edges = self.S[1]
+        node_coords = self.node_coords
+        self.primal_edges_vectors = node_coords[primal_edges[:, 1], :] - \
+            node_coords[primal_edges[:, 0], :]
 
     def get_dual_edge_vectors(self):
-        """Compute dual edges vectors taking into account their orientations."""
+        """Compute the dual edge vectors."""
         dim = self.dim
         # dual nodes == circumcenters of the n-simplices
+        if not hasattr(self, "circ"):
+            self.get_circumcenters()
         dual_nodes_coords = self.circ[dim]
         num_dual_edges = self.S[dim-1].shape[0]
 
@@ -197,8 +196,9 @@ def get_dual_edge_vectors(self):
         # separately, as described below
 
         # construct the array consisting of the positions of the circumcenters of the
-        # boundary faces arranged by rows, padded with zeros for the non-boundary
-        # edges
+        # boundary faces arranged by rows, padded with zeros for the non-boundary edges
+        if not hasattr(self, "bnd_faces_indices"):
+            self.get_complex_boundary_faces_indices()
         circ_faces = self.circ[dim-1]
         circ_bnd_faces = np.zeros(circ_faces.shape, dtype=dctkit.float_dtype)
         circ_bnd_faces[self.bnd_faces_indices] = circ_faces[self.bnd_faces_indices]
@@ -212,12 +212,12 @@ def get_dual_edge_vectors(self):
         _, idx, count = np.unique(rows, return_index=True, return_counts=True)
         boundary_rows_idx = idx[count == 1]
 
-        # the action of the dual coboundary on the collection of the
-        # coordinates of the dual nodes produces incomplete results on the dual edges
-        # having only one dual node as a boundary (i.e. those who are incident on the
-        # boundary faces). To compensate for this, add the coordinates of the
-        # circumcenters of the boundary faces with the appropriate sign, given by the
-        # orientation of the dual edge contained in the dual coboundary matrix.
+        # the action of the dual coboundary on the collection of the coordinates of the
+        # dual nodes produces incomplete results on the dual edges having only one dual
+        # node as a boundary (i.e. those who are incident on the boundary faces). To
+        # compensate for this, add the coordinates of the circumcenters of the boundary
+        # faces with the appropriate sign, given by the orientation of the dual edge
+        # contained in the dual coboundary matrix.
         # NOTE: vals must be a COLUMN vector
         # NOTE: the (-1)**dim factor accounts for the correct sign of the dual
         # coboundary matrix
@@ -229,16 +229,19 @@ def get_dual_edge_vectors(self):
 
         self.dual_edges_lengths = np.linalg.norm(self.dual_edges_vectors, axis=1)
 
-    def get_flat_weights(self):
-        """Compute the matrix where each non-negative entry (i,j) is the
-           ratio between the length of the j-th dual edge contained in the
-           i-th n-simplex and the total length of the j-th dual edge.
+    def get_flat_DPD_weights(self):
+        """Compute the matrix where each non-negative entry (i,j) is the ratio between
+           the length of the j-th dual edge contained in the i-th n-simplex and the
+           total length of the j-th dual edge.
 
-           This ratio appears as a weighitng factor in the computation of the
-           discrete flat operator.
+           This ratio appears as a weighting factor in the computation of the discrete
+           flat operator.
         """
+        if not hasattr(self, "dual_edges_lengths"):
+            self.get_dual_edge_vectors()
+
         dim = self.dim
-        B = self.B[dim]
+        B = self.boundary_connectivity[dim]
         num_n_simplices = self.S[dim].shape[0]
         num_nm1_simplices = self.S[dim-1].shape[0]
         self.dual_edges_fractions_lengths = np.zeros(
@@ -255,46 +258,109 @@ def get_flat_weights(self):
             self.dual_edges_fractions_lengths[i, :][
                 dual_edges_indices] = np.linalg.norm(diff_circs, axis=1)
 
-        self.flat_weights = self.dual_edges_fractions_lengths/self.dual_edges_lengths
-
-    def get_metric_2D(self):
-        """Compute the multiarray of shape (n, 2, 2) where n is the number of
-           2-simplices and any 2x2 matrix is the metric of the corresponding 2-simplex.
+        self.flat_DPD_weights = self.dual_edges_fractions_lengths / \
+            self.dual_edges_lengths
+        # in the case of non-well centered mesh an entry of the flat weights matrix
+        # can be NaN. In this case, the corresponding dual edge is the null vector,
+        # hence we shouldn't take in account dot product with it. We then replace
+        # any NaN with 0.
+        self.flat_DPD_weights = np.nan_to_num(self.flat_DPD_weights)
+
+    def get_flat_DPP_weights(self):
+        # FIXME: extend to 3D case.
+        # NOTATION:
+        # s^i: generic i-simplex of the simplicial complex self.
+        # s^j > s^i: s^i is a proper face of s^j (hence i<j)
+        if not hasattr(self, "primal_edge_vectors"):
+            self.get_primal_edge_vectors()
+
+        if self.dim == 2:
+            # in this case the entries of the flat_DPD matrix coincides
+            # with the entries of the flat_DPP matrix, since in this case
+            # n -1 = 1. Hence summing over s^n > s^1 is the same as summing
+            # over s^n > s^{n-1} and moreover |★s^{n-1} ∩ s^n| = |★s^1 ∩ s^n|
+            if not hasattr(self, "flat_DPD_weights"):
+                self.get_flat_DPD_weights()
+            self.flat_DPP_weights = self.flat_DPD_weights
+
+    def get_current_metric_2D(self, node_coords: npt.NDArray | Array) -> Array:
+        """Compute the current metric of a 2D simplicial complex.
+
+            Args:
+                node_coords: matrix of shape (n, space_dim) where the i-th row is the
+                    vector of coordinates of i-th node of the simplex in the current
+                    configuration.
+
+            Returns:
+                the multiarray of shape (n, 2, 2), where n is the number of 2-simplices
+                    and each 2x2 matrix is the current metric of the corresponding
+                    2-simplex.
         """
+        # NOTATION:
+        # a_i, reference covariant basis (pairs of edge vectors of a primal 2-simplex)
+        # a^i = a^(ik)a_k, reference contravariant basis
+        # G = current metric
+        # g_(ij), covariant components of the current metric
+        # g_i, current covariant basis
+        # (a_k)r, r-th Cartesian component of the basis vector a_k
+        # e_r, global Cartesian basis
+        # g^(ij)_p the contravariant components of the the pull-back of the current
+        # metric
+
         dim = self.dim
-        B = self.B[dim]
+        B = self.boundary_connectivity[dim]
         primal_edges = self.S[1]
-        node_coords = self.node_coord
         # construct the matrix in which the i-th row corresponds to the vector
         # of coordinates of the i-th primal edge
-        primal_edge_vectors = node_coords[primal_edges[:, 1], :] - \
-            node_coords[primal_edges[:, 0], :]
-        # construct the multiarray of shape (n, 3, 3) where any 3x3 matrix represents
-        # the coordinates of the edge vectors (arranged in rows) belonging to the
-        # corresponding 2-simplex
-        primal_edges_per_2_simplex = primal_edge_vectors[B]
-        # extract the first two rows, i.e. basis vectors, for each 3x3 matrix
-        basis_vectors = primal_edges_per_2_simplex[:, :-1, :]
-        self.metric = basis_vectors @ np.transpose(
-            basis_vectors, axes=(0, 2, 1))
-
-
-def __simplex_array_parity(s):
-    """Compute the number of transpositions needed to sort the array in
-       ascending order modulo 2. (Copied from PyDEC, dec/simplex_array.py)
+        primal_edge_vectors = node_coords[primal_edges[:, 1], :2] - \
+            node_coords[primal_edges[:, 0], :2]
+        # construct the multiarray of shape (n, 2, 2) where any 2x2 matrix represents
+        # the coordinates of the first two edge vectors (arranged in rows) belonging to
+        # corresponding primal 2-simplex i.e. the rows are the vectors g_i
+        current_covariant_basis = primal_edge_vectors[B][:, :2, :]
+
+        # compute the matrix (a_k)r and its transpose
+        if self.ref_covariant_basis is None:
+            self.ref_covariant_basis = current_covariant_basis
+            self.ref_covariant_basis_T = jnp.transpose(
+                self.ref_covariant_basis, axes=(0, 2, 1))
+
+        # compute g_(ij) = g_i dot g_j
+        current_metric_covariant = current_covariant_basis @ jnp.transpose(
+            current_covariant_basis, axes=(0, 2, 1))
+
+        # compute a^(ij)
+        if self.ref_metric_contravariant is None:
+            ref_metric_covariant = current_metric_covariant
+            self.ref_metric_contravariant = jnp.linalg.inv(ref_metric_covariant)
+
+        # compute g^(km)_p = g_(ij) a^(ik) a^(jm)
+        pullback_current_metric_contravariant = ((self.ref_metric_contravariant @
+                                                 current_metric_covariant) @
+                                                 self.ref_metric_contravariant)
+
+        # compute the components of G = g^(km)_p (a_k)r (a_m)s e_r x e_s
+        current_cartesian_metric = ((self.ref_covariant_basis_T @
+                                     pullback_current_metric_contravariant) @
+                                    self.ref_covariant_basis)
+        return current_cartesian_metric
+
+
+def __simplex_array_parity(s: npt.NDArray) -> npt.NDArray:
+    """Compute the number of transpositions needed to sort the array in ascending order
+       modulo 2. (Copied from PyDEC, dec/simplex_array.py)
 
         Args:
-            s (np.array): array of the simplices.
+            s: array of the simplices.
 
         Returns:
-            np.array: array of the transpositions needed modulo 2.
+            array of the transpositions modulo 2.
 
     """
     s = s.copy()
     M, N = s.shape
 
-    # number of transpositions used to sort the
-    # indices of each simplex (row of s)
+    # number of transpositions used to sort the indices of each simplex (row of s)
     trans = np.zeros_like(s[:, 0])
     seq = np.arange(M)
 
@@ -312,24 +378,24 @@ def __simplex_array_parity(s):
     return trans
 
 
-def compute_boundary_COO(S):
+def compute_boundary_COO(S: npt.NDArray) -> Tuple[list, npt.NDArray, npt.NDArray]:
     """Compute the COO representation of the boundary matrix of all p-simplices.
 
     Args:
-        S (np.array): matrix of the IDs of the nodes (cols) belonging to
-            each p-simplex (rows).
+        S: matrix of the IDs of the nodes (cols) belonging to each p-simplex (rows).
+
     Returns:
-        tuple: tuple with the COO representation of the boundary.
-        np.array: np.array matrix of node tags per (p-1)-face
-        ordered lexicographically.
+        a tuple containing a list with the COO representation of the boundary, the
+            matrix of node IDs belonging to each (p-1)-face ordered lexicographically,
+            and a matrix containing the IDs of the nodes (cols) belonging to
+            each p-simplex (rows) counted with repetition and ordered lexicographically.
+
     """
     # number of p-simplices
     num_simplices = S.shape[0]
     # nodes per p-simplex = p + 1
     nodes_per_simplex = S.shape[1]
 
-    dim = nodes_per_simplex - 1
-
     N = num_simplices * nodes_per_simplex
 
     # compute array of relative orientations of the (p-1)-faces wrt the
@@ -340,9 +406,6 @@ def compute_boundary_COO(S):
     # FIXME: avoid making a copy and sorting every time
     F = S.copy()
     F.sort(axis=1)
-    # ic(F)
-    # F_2 = S[np.lexsort(S.T[::-1])]
-    # ic(F_2)
 
     # S_(p-1) matrix with repeated (p-1)-simplices and with two extra columns
     S_pm1_ext = np.empty((N, nodes_per_simplex + 1), dtype=dctkit.int_dtype)
@@ -369,27 +432,52 @@ def compute_boundary_COO(S):
     column_index = faces_ordered[:, -1]
     faces = faces_ordered[:, :-2]
 
-    # FIXME: explain the meaming of vals and give a more descriptive name
-    # compute vals and rows_index
-    vals, rows_index = np.unique(faces, axis=0, return_inverse=True)
+    # compute the matrix obtained from faces removing the duplicate rows and mantaining
+    # the lexicographically order (unique faces) and the vector of occurences for each
+    # non-duplicate row (rows_index); e.g. if faces = [[1,2];[1,3];[1,3];[1,4]],
+    # then unique_faces = [[1,2]; [1,3]; [1,4]] and rows_index = [0; 1; 1; 2]
+    unique_faces, rows_index = np.unique(faces, axis=0, return_inverse=True)
     rows_index = rows_index.astype(dtype=dctkit.int_dtype)
     boundary_COO = [rows_index, column_index, values]
 
-    # for triangles and tets, compute B explicitly
-    if dim > 1:
+    return boundary_COO, unique_faces, faces_ordered
+
+
+def compute_boundary_connectivity(S: npt.NDArray, faces_ordered:
+                                  npt.NDArray) -> npt.NDArray:
+    """Compute the matrix containing the IDs of the (p-1)-simplices (cols) belonging
+    to each p-simplex (rows).
+
+    Args:
+        S: matrix of the IDs of the nodes (cols) belonging to each p-simplex (rows).
+
+    Returns:
+        a matrix containing the IDs of the (p-1)-simplices (cols) belonging
+            to each p-simplex (rows).
+
+    """
+
+    nodes_per_simplex = S.shape[1]
+    p = nodes_per_simplex - 1
+
+    # for triangles and tets, compute boundary_connectivity_p explicitly
+    if p > 1:
         # order faces_ordered w.r.t last column
         faces_ordered_last = faces_ordered[faces_ordered[:, -1].argsort()]
 
         # initialize the matrix of the boundary simplex as an array
-        B = np.empty(faces.shape[0], dtype=dctkit.int_dtype)
+        boundary_connectivity_p = np.empty(
+            faces_ordered.shape[0], dtype=dctkit.int_dtype)
 
-        # compute B
-        _, B = np.unique(faces_ordered_last[:, :-2], axis=0, return_inverse=True)
-        B = B.reshape(faces.shape[0] // nodes_per_simplex, nodes_per_simplex)
+        # compute boundary_connectivity_p
+        _, boundary_connectivity_p = np.unique(
+            faces_ordered_last[:, :-2], axis=0, return_inverse=True)
+        boundary_connectivity_p = boundary_connectivity_p.reshape(
+            faces_ordered.shape[0] // nodes_per_simplex, nodes_per_simplex)
 
-    # for edges, B_1 = S_1
+    # for edges p = 1 and boundary_connectivity_1 = S_1
     else:
-        B = S
-    B.astype(dtype=dctkit.int_dtype)
+        boundary_connectivity_p = S
+    boundary_connectivity_p.astype(dtype=dctkit.int_dtype)
 
-    return boundary_COO, vals, B
+    return boundary_connectivity_p
diff --git a/src/dctkit/mesh/util.py b/src/dctkit/mesh/util.py
index 4c9407c..98c2053 100644
--- a/src/dctkit/mesh/util.py
+++ b/src/dctkit/mesh/util.py
@@ -1,136 +1,185 @@
-from dctkit import int_dtype, float_dtype
-import gmsh  # type: ignore
+from dctkit.mesh.simplex import SimplicialComplex
 import numpy as np
-import numpy.typing as npt
-from typing import Tuple
+from typing import Tuple, List
+from pygmsh.geo import Geometry
+from meshio import Mesh
 
 
-def read_mesh(filename=None, format="gmsh"):
-    """Reads a mesh from file.
+def build_complex_from_mesh(mesh: Mesh, is_well_centered=True) -> SimplicialComplex:
+    """Build a SimplicialComplex object from a meshio.Mesh object.
 
     Args:
-        filename: name of the file containing the mesh.
+        mesh: a meshio.Mesh object.
+        is_well_centered: True if the mesh is well centered.
+
     Returns:
-        numNodes: number of mesh points.
+        a SimplicialComplex object.
     """
-    assert format == "gmsh"
-
-    if not gmsh.is_initialized():
-        gmsh.initialize()
+    node_coords = mesh.points
+    cell_types = mesh.cells_dict.keys()
 
-    if filename is not None:
-        gmsh.open(filename)
+    if "tetra" in cell_types:
+        tet_node_tags = mesh.cells_dict["tetra"]
+    elif "triangle" in cell_types:
+        tet_node_tags = mesh.cells_dict["triangle"]
+    elif "line" in cell_types:
+        tet_node_tags = mesh.cells_dict["line"]
 
-    # Get nodes and corresponding coordinates
-    nodeTags, coords, _ = gmsh.model.mesh.getNodes()
-    numNodes = len(nodeTags)
-    # print("# nodes = ", numNodes)
+    S = SimplicialComplex(tet_node_tags, node_coords, is_well_centered=is_well_centered)
+    return S
 
-    coords = np.array(coords, dtype=float_dtype)
-    # Get 2D elements and associated node tags
-    # NOTE: ONLY GET TRIANGLES
-    elemTags, nodeTagsPerElem = gmsh.model.mesh.getElementsByType(2)
 
-    # Decrease element IDs by 1 to have node indices starting from 0
-    nodeTagsPerElem = np.array(nodeTagsPerElem, dtype=int_dtype) - 1
-    nodeTagsPerElem = nodeTagsPerElem.reshape(len(nodeTagsPerElem) // 3, 3)
-    # Get number of TRIANGLES
-    numElements = len(elemTags)
-    # print("# elements = ", numElements)
+def generate_square_mesh(lc: float, L: float = 1.) -> Tuple[Mesh, Geometry]:
+    """Generate the mesh of a square.
 
-    # physicalGrps = gmsh.model.getPhysicalGroups()
-    # print("physical groups: ", physicalGrps)
+    Args:
+        lc: target mesh size.
+        L: side length.
 
-    # edgeNodesTags = gmsh.model.mesh.getElementEdgeNodes(2)
-    # print("edge nodes tags: ", edgeNodesTags)
+    Returns:
+        a tuple containing a meshio Mesh and a pygmsh Geometry objects.
+    """
+    with Geometry() as geom:
+        p = geom.add_polygon([[0., 0.], [L, 0.], [L, L], [0., L]], mesh_size=lc)
+        # create a default physical group for the boundary lines
+        geom.add_physical(p.lines, label="boundary")
+        mesh = geom.generate_mesh()
 
-    # Position vectors of mesh points
-    node_coords = coords.reshape(len(coords)//3, 3)
+    return mesh, geom
 
-    # get node tags per boundary elements
-    _, nodeTagsPerBElem = gmsh.model.mesh.getElementsByType(1)
-    nodeTagsPerBElem = np.array(nodeTagsPerBElem, dtype=int_dtype) - 1
-    nodeTagsPerBElem = nodeTagsPerBElem.reshape(len(nodeTagsPerBElem) // 2, 2)
-    # we sort every row to get the orientation used for our simulations
-    nodeTagsPerBElem = np.sort(nodeTagsPerBElem)
 
-    return numNodes, numElements, nodeTagsPerElem, node_coords, nodeTagsPerBElem
+def generate_hexagon_mesh(a: float, lc: float) -> Tuple[Mesh, Geometry]:
+    """Generate the mesh of a regular hexagon.
 
+    Args:
+        a: edge length.
+        lc: target mesh size.
 
-def generate_square_mesh(lc):
-    if not gmsh.is_initialized():
-        gmsh.initialize()
+    Returns:
+        a tuple containing a meshio Mesh and a pygmsh Geometry objects.
+    """
+    with Geometry() as geom:
+        geom.add_polygon([[2*a, np.sqrt(3)/2*a], [3/2*a, np.sqrt(3)*a],
+                          [a/2, np.sqrt(3)*a], [0., np.sqrt(3)/2*a], [a/2, 0.],
+                          [3/2*a, 0.]], mesh_size=lc)
+        mesh = geom.generate_mesh()
 
-    gmsh.model.add("t1")
-    gmsh.model.geo.addPoint(1, 0, 0, lc, 1)
-    gmsh.model.geo.addPoint(0, 0, 0, lc, 2)
-    gmsh.model.geo.addPoint(1, 1, 0, lc, 3)
-    gmsh.model.geo.addPoint(0, 1, 0, lc, 4)
+    return mesh, geom
 
-    gmsh.model.geo.addLine(1, 2, 1)
-    gmsh.model.geo.addLine(2, 4, 2)
-    gmsh.model.geo.addLine(4, 3, 3)
-    gmsh.model.geo.addLine(3, 1, 4)
-    gmsh.model.geo.addCurveLoop([1, 2, 3, 4], 1)
-    gmsh.model.geo.addPlaneSurface([1], 1)
-    gmsh.model.geo.synchronize()
-    gmsh.model.addPhysicalGroup(1, [1, 2, 3, 4], 1)
-    gmsh.model.mesh.generate(2)
 
-    numNodes, numElements, nodeTagsPerElem, node_coords, nodeTagsPerBElem = read_mesh()
+def generate_tet_mesh(lc: float) -> Tuple[Mesh, Geometry]:
+    """Generate the mesh of a tetrahedron.
 
-    return numNodes, numElements, nodeTagsPerElem, node_coords, nodeTagsPerBElem
+    Args:
+        lc: target mesh size.
 
+    Returns:
+        a tuple containing a meshio Mesh and a pygmsh Geometry objects.
+    """
+    nodes = np.array([[0, 0, 0], [1, 0, 0], [1/2, 1, 0], [0, 0, 1]])
+    lines = [[0, 1], [0, 2], [0, 3], [1, 2], [1, 3], [2, 3]]
+    curve_loops = []
+    with Geometry() as geom:
+        points = np.array([geom.add_point(node, lc) for node in nodes])
+        edges = [geom.add_line(*points[line_idx]) for line_idx in lines]
+        curve_loops.append(geom.add_curve_loop([edges[0], edges[3], -edges[1]]))
+        curve_loops.append(geom.add_curve_loop([edges[0], edges[4], -edges[2]]))
+        curve_loops.append(geom.add_curve_loop([edges[1], edges[5], -edges[2]]))
+        curve_loops.append(geom.add_curve_loop([edges[3], edges[5], -edges[4]]))
+        surfaces = [geom.add_surface(curve_loops[i]) for i in range(len(curve_loops))]
+        surface_loop = geom.add_surface_loop(surfaces)
+        geom.add_volume(surface_loop)
+        mesh = geom.generate_mesh()
+
+    return mesh, geom
+
+
+def generate_cube_mesh(lc: float, L: float = 1.) -> Tuple[Mesh, Geometry]:
+    """Generate the mesh of a cube.
 
-def generate_hexagon_mesh(a, lc):
-    """Generate a regular hexagonal mesh
+    Args:
+        lc: target mesh size.
+        L: side length.
 
-       Args:
-            a (float): length of the hexagonal edges.
+    Returns:
+        a tuple containing a meshio Mesh and a pygmsh Geometry objects.
     """
-    if not gmsh.is_initialized():
-        gmsh.initialize()
+    with Geometry() as geom:
+        poly = geom.add_polygon([[0.0, 0.0], [L, 0.0], [L, L], [0.0, L]], lc)
+        geom.extrude(poly, [0, 0, L])
+        mesh = geom.generate_mesh()
+
+    return mesh, geom
 
-    gmsh.model.add("hexagon")
-    gmsh.model.geo.addPoint(2*a, np.sqrt(3)/2 * a, 0, lc, 1)
-    gmsh.model.geo.addPoint(3/2 * a, np.sqrt(3)*a, 0, lc, 2)
-    gmsh.model.geo.addPoint(a/2, np.sqrt(3)*a, 0, lc, 3)
-    gmsh.model.geo.addPoint(0, np.sqrt(3)/2 * a, 0, lc, 4)
-    gmsh.model.geo.addPoint(a/2, 0, 0, lc, 5)
-    gmsh.model.geo.addPoint(3/2 * a, 0, 0, lc, 6)
 
-    gmsh.model.geo.addLine(1, 2, 1)
-    gmsh.model.geo.addLine(2, 3, 2)
-    gmsh.model.geo.addLine(3, 4, 3)
-    gmsh.model.geo.addLine(4, 5, 4)
-    gmsh.model.geo.addLine(5, 6, 5)
-    gmsh.model.geo.addLine(6, 1, 6)
-    gmsh.model.geo.addCurveLoop([1, 2, 3, 4, 5, 6], 1)
-    gmsh.model.geo.addPlaneSurface([1], 1)
-    gmsh.model.geo.synchronize()
-    gmsh.model.addPhysicalGroup(1, [1, 2, 3, 4, 5, 6], 1)
-    gmsh.model.mesh.generate(2)
+def generate_line_mesh(num_nodes: int, L: float = 1.) -> Tuple[Mesh, Geometry]:
+    """Generate a uniform mesh in an interval of given length.
 
-    numNodes, numElements, nodeTagsPerElem, node_coords, nodeTagsPerBElem = read_mesh()
+    Args:
+        num_nodes: number of nodes.
+        L: length of the interval.
+
+    Returns:
+        a tuple containing a meshio Mesh and a pygmsh Geometry objects.
+    """
+    lc = L/(num_nodes-1)
+    points = [None]*num_nodes
+    with Geometry() as g:
+        points[0] = g.add_point([0., 0.], lc)
+        # we have to add one line for each element of the mesh, otherwise if we mesh one
+        # line for the whole interval [0, L] the end nodes are going to be the first two
+        # items in the mesh.points matrix.
+        for i in range(1, num_nodes):
+            points[i] = g.add_point([i*lc, 0.], lc)
+            # see also test_hex in pygmsh library's tests
+            new_line_points = [points[i-1], points[i]]
+            g.add_line(*new_line_points)
+            mesh = g.generate_mesh()
+
+    return mesh, g
+
+
+def get_nodes_for_physical_group(mesh: Mesh, dim: int, group_name: str) -> List[int]:
+    """Find the IDs of the nodes belonging to a physical group within the mesh object.
+
+    Args:
+        mesh: a meshio object.
+        dim: dimension of the cells belonging to the physical group.
+        group_name: name of the physical group.
+
+    Returns:
+        list of the node IDs belonging to the physical group.
+    """
+    if dim == 1:
+        cell_type = "line"
+    elif dim == 2:
+        cell_type = "triangle"
+    elif dim == 3:
+        cell_type = "tetra"
+    else:
+        raise NotImplementedError
 
-    return numNodes, numElements, nodeTagsPerElem, node_coords, nodeTagsPerBElem
+    group_cells = mesh.cell_sets_dict[group_name].get(cell_type)
+    nodes_ids = list(set(mesh.cells_dict[cell_type][group_cells].flatten()))
+    return nodes_ids
 
 
-def generate_1_D_mesh(num_nodes: int, L: float) -> Tuple[npt.NDArray, npt.NDArray]:
-    """Generate a uniform 1D mesh.
+def get_edges_for_physical_group(S: SimplicialComplex, mesh: Mesh,
+                                 group_name: str) -> List[int]:
+    """Find the IDs of the edges belonging to a physical group within the mesh object.
 
     Args:
-        num_nodes: number of nodes.
-        L: length of the interval.
+        S: SimplicialComplex object associated to the mesh.
+        mesh: a meshio object.
+        group_name: name of the physical group.
+
     Returns:
-        a tuple consisting of the matrix of node coordinates (rows = node IDs, cols =
-            x,y coords) and a matrix containing the IDs of the nodes belonging to
-            each 1-simplex.
+        list of the node IDs belonging to the physical group.
     """
-    node_coords = np.linspace(0, L, num=num_nodes)
-    x = np.zeros((num_nodes, 2))
-    x[:, 0] = node_coords
-    S_1 = np.empty((num_nodes - 1, 2))
-    S_1[:, 0] = np.arange(num_nodes-1)
-    S_1[:, 1] = np.arange(1, num_nodes)
-    return S_1, x
+    edges_ids_in_mesh = mesh.cell_sets_dict[group_name]["line"]
+    edges_nodes_ids = mesh.cells_dict["line"][edges_ids_in_mesh]
+    # nodes ids for edges in S[1] are sorted lexicographycally
+    edges_nodes_ids.sort()
+    edges_ids = [int(np.argwhere(np.all(S.S[1] == edge_nodes, axis=1)))
+                 for edge_nodes in edges_nodes_ids]
+    return edges_ids
diff --git a/src/dctkit/math/volume.py b/src/dctkit/mesh/volume.py
similarity index 63%
rename from src/dctkit/math/volume.py
rename to src/dctkit/mesh/volume.py
index 951f968..a987bc6 100644
--- a/src/dctkit/math/volume.py
+++ b/src/dctkit/mesh/volume.py
@@ -4,20 +4,21 @@
 from scipy.special import factorial
 
 
-def unsigned_volume(S: npt.NDArray, node_coord: npt.NDArray) -> float:
-    """Compute the unsigned volume of a set of simplices S.
+def unsigned_volume(S: npt.NDArray, node_coords: npt.NDArray) -> float:
+    """Compute the unsigned volume of a set of simplices.
 
     Args:
-        S (np.array): matrix containing the IDs of the nodes belonging to each simplex.
-        node_coord (np.array): coordinates of every node of the cell complex in
-            which s is defined.
+        S: matrix containing the IDs of the nodes belonging to each simplex.
+        node_coords: coordinates of the points of the cell complex to which the set of
+            simplices belongs.
+
     Returns:
-        float: unsigned volume of the simplex.
+        unsigned volume of the simplex.
     """
     int_dtype = dctkit.int_dtype
 
     # store the coordinates of the nodes of every simplex in S
-    S_coord = node_coord[S]
+    S_coord = node_coords[S]
     rows = S_coord.shape[1]
 
     # indices to extract the matrix with rows equal to the rows of S with indices
@@ -36,19 +37,19 @@ def unsigned_volume(S: npt.NDArray, node_coord: npt.NDArray) -> float:
     return vol
 
 
-def signed_volume(S: npt.NDArray, node_coord: npt.NDArray) -> float:
-    """Compute the signed volume of a set of n-simplices.
+def signed_volume(S: npt.NDArray, node_coords: npt.NDArray) -> float:
+    """Compute the signed volume of a set of simplices.
 
     Args:
-        S (np.array): matrix containing the IDs (cols) of the nodes belonging to each
-        simplex (rows).
-        node_coord (np.array): coordinates of every node of the cell complex.
+        S: matrix containing the IDs (cols) of the nodes belonging to each simplex
+            (rows).
+        node_coords: coordinates of every node of the cell complex.
     Returns:
-        float: signed volume of the simplex.
+        signed volume of the simplex.
     """
     int_dtype = dctkit.int_dtype
 
-    S_coord = node_coord[S]
+    S_coord = node_coords[S]
     _, rows, cols = S_coord.shape
 
     assert (rows == cols + 1)
diff --git a/src/dctkit/apps/elastica.py b/src/dctkit/physics/elastica.py
similarity index 91%
rename from src/dctkit/apps/elastica.py
rename to src/dctkit/physics/elastica.py
index 41ffa77..7fccc36 100644
--- a/src/dctkit/apps/elastica.py
+++ b/src/dctkit/physics/elastica.py
@@ -1,7 +1,6 @@
 import numpy as np
 import jax.numpy as jnp
 from dctkit.dec import cochain as C
-from dctkit.mesh import simplex as sim
 import dctkit as dt
 from dctkit.mesh import util
 import numpy.typing as npt
@@ -23,12 +22,10 @@ def __init__(self, num_elements: float, L: float) -> None:
 
     def get_elastica_mesh(self):
         """Constructs the normalized simplicial complex in the interval [0,1]."""
+
         num_nodes = self.num_elements + 1
-        S_1, x = util.generate_1_D_mesh(num_nodes, 1)
-        self.S = sim.SimplicialComplex(S_1, x, is_well_centered=True)
-        self.S.get_circumcenters()
-        self.S.get_primal_volumes()
-        self.S.get_dual_volumes()
+        mesh, _ = util.generate_line_mesh(num_nodes, 1.)
+        self.S = util.build_complex_from_mesh(mesh)
         self.S.get_hodge_star()
 
         # define internal cochain to compute the energy only in the interior points
diff --git a/src/dctkit/physics/elasticity.py b/src/dctkit/physics/elasticity.py
new file mode 100644
index 0000000..6bcc13c
--- /dev/null
+++ b/src/dctkit/physics/elasticity.py
@@ -0,0 +1,189 @@
+import numpy.typing as npt
+from dctkit.mesh.simplex import SimplicialComplex
+import dctkit.dec.cochain as C
+import dctkit.dec.vector as V
+from jax import Array
+import jax.numpy as jnp
+from typing import Tuple, Dict
+
+
+class LinearElasticity():
+    """Linear elasticity class.
+
+    Args:
+        S: reference configuration simplicial complex.
+        mu_: Lamé modulus.
+        lambda_: Lamé modulus.
+    """
+
+    def __init__(self, S: SimplicialComplex, mu_: float, lambda_: float):
+        self.S = S
+        self.mu_ = mu_
+        self.lambda_ = lambda_
+
+    def get_GreenLagrange_strain(self, node_coords:
+                                 npt.NDArray | Array) -> npt.NDArray | Array:
+        """Compute the discrete strain tensor given the current node coordinates.
+
+        Args:
+            node_coords: current node coordinates.
+
+        Returns:
+            the discrete strain tensor.
+
+        """
+        current_metric = self.S.get_current_metric_2D(node_coords=node_coords)
+        # define the infinitesimal strain and its trace
+        epsilon = 1/2 * (current_metric - self.S.reference_metric)
+        return epsilon
+
+    def get_stress(self, strain: npt.NDArray | Array) -> Array:
+        """Compute the discrete stress tensor from strains using the consistutive
+        equation for isotropic linear elastic materials.
+
+        Args:
+            strain: discrete strain tensor.
+
+        Returns:
+            the discrete stress tensor.
+
+        """
+        num_faces = self.S.S[2].shape[0]
+        tr_strain = jnp.trace(strain, axis1=1, axis2=2)
+        # get the stress via the consistutive equation for isotropic linear
+        # elastic materials
+        stress = 2.*self.mu_*strain + self.lambda_*tr_strain[:, None, None] * \
+            jnp.stack([jnp.identity(2)]*num_faces)
+        return stress
+
+    def set_boundary_tractions(self, forces: C.CochainP1,
+                               boundary_tractions:
+                               Dict[str, Tuple[Array, Array]]) -> C.CochainP1:
+        """Set the boundary tractions on primal edges.
+
+        Args:
+            forces: vector-valued primal 1-cochain containing forces acting on primal
+                edges.
+            boundary_tractions: a dictionary of tuples. Each key represent the type
+                of coordinate to manipulate (x,y, or both), while each tuple consists
+                of two jax arrays, in which the first encordes the indices where we
+                want to impose the boundary tractions, while the last encodes the
+                boundary traction values themselves.
+
+        Returns:
+            the updated force 1-cochain.
+
+        """
+        for key in boundary_tractions:
+            idx, values = boundary_tractions[key]
+            if key == ":":
+                forces.coeffs = forces.coeffs.at[idx, :].set(values)
+            else:
+                forces.coeffs = forces.coeffs.at[idx, int(key)].set(values)
+        return forces
+
+    def force_balance_residual_primal(self, node_coords: C.CochainP0, f: C.CochainP2,
+                                      boundary_tractions:
+                                      Dict[str, Tuple[Array, Array]]) -> C.CochainP2:
+        """Compute the residual of the discrete balance equation in the case
+          of isotropic linear elastic materials in 2D using DEC framework.
+
+        Args:
+            node_coords: primal vector valued 0-cochain of
+            node coordinates of the current configuration.
+            f: primal vector-valued 2-cochain of sources.
+            boundary_tractions: a dictionary of tuples. Each key represent the type
+                of coordinate to manipulate (x,y, or both), while each tuple consists
+                of two jax arrays, in which the first encordes the indices where we
+                want to impose the boundary tractions, while the last encodes the
+                boundary traction values themselves.
+
+        Returns:
+            the residual vector-valued cochain.
+
+        """
+        strain = self.get_GreenLagrange_strain(node_coords=node_coords.coeffs)
+        stress = self.get_stress(strain=strain)
+        stress_tensor = V.DiscreteTensorFieldD(S=self.S, coeffs=stress.T, rank=2)
+        stress_integrated = V.flat_DPD(stress_tensor)
+        forces = C.star(stress_integrated)
+        # set tractions on given sub-portions of the boundary
+        forces_bnd_update = self.set_boundary_tractions(forces, boundary_tractions)
+        residual = C.add(C.coboundary(forces_bnd_update), f)
+        return residual
+
+    def force_balance_residual_dual(self, node_coords: C.CochainP0,
+                                    f: C.CochainD2) -> C.CochainD2:
+        """Compute the residual of the discrete balance equation in the case
+          of isotropic linear elastic materials in 2D using DEC framework.
+
+        Args:
+            node_coords: primal vector valued 0-cochain of
+            node coordinates of the current configuration.
+            f: dual vector-valued 2-cochain of sources.
+
+        Returns:
+            the residual vector-valued cochain.
+
+        """
+        strain = self.get_GreenLagrange_strain(node_coords=node_coords.coeffs)
+        stress = self.get_stress(strain=strain)
+        stress_tensor = V.DiscreteTensorFieldD(S=self.S, coeffs=stress.T, rank=2)
+        stress_integrated = V.flat_DPP(stress_tensor)
+        forces = C.star(stress_integrated)
+        print(forces.coeffs)
+        print(C.coboundary(forces).coeffs)
+        residual = C.add(C.coboundary(forces), f)
+        return residual
+
+    def obj_linear_elasticity(self, node_coords: npt.NDArray | Array,
+                              f: npt.NDArray | Array, gamma: float, boundary_values:
+                              Dict[str, Tuple[Array, Array]],
+                              boundary_tractions: Dict[str, Tuple[Array,
+                                                                  Array]]) -> float:
+        """Objective function of the optimization problem associated to linear
+           elasticity balance equation with Dirichlet boundary conditions on a portion
+           of the boundary.
+
+        Args:
+            node_coords: 1-dimensional array obtained after flattening
+            the matrix with node coordinates arranged row-wise.
+            f: 1-dimensional array obtained after flattening the
+            matrix of external sources (constant term of the system).
+            gamma: penalty factor.
+            boundary_values: a dictionary of tuples. Each key represent the type of
+                coordinate to manipulate (x,y, or both), while each tuple consists of
+                two np.arrays in which the first encodes the indices of boundary
+                values, while the last encodes the boundary values themselves.
+            boundary_tractions: a dictionary of tuples. Each key represent the type
+                of coordinate to manipulate (x,y, or both), while each tuple consists
+                of two jax arrays, in which the first encordes the indices where we want
+                to impose the boundary tractions, while the last encodes the boundary
+                traction values themselves. It is None when we perform the force balance
+                on dual cells.
+
+        Returns:
+            the value of the objective function at node_coords.
+
+        """
+        node_coords_reshaped = node_coords.reshape(self.S.node_coords.shape)
+        node_coords_coch = C.CochainP0(complex=self.S, coeffs=node_coords_reshaped)
+        if boundary_tractions is None:
+            f = f.reshape((self.S.num_nodes, self.S.space_dim-1))
+            f_coch = C.CochainD2(complex=self.S, coeffs=f)
+            residual = self.force_balance_residual_dual(node_coords_coch, f_coch).coeffs
+        else:
+            f = f.reshape((self.S.S[2].shape[0], self.S.space_dim-1))
+            f_coch = C.CochainP2(complex=self.S, coeffs=f)
+            residual = self.force_balance_residual_primal(
+                node_coords_coch, f_coch, boundary_tractions).coeffs
+        penalty = 0.
+        for key in boundary_values:
+            idx, values = boundary_values[key]
+            if key == ":":
+                penalty += jnp.sum((node_coords_reshaped[idx, :] - values)**2)
+            else:
+                penalty += jnp.sum((node_coords_reshaped[idx, :]
+                                   [:, int(key)] - values)**2)
+        energy = 1/2*(jnp.sum(residual**2) + gamma*penalty)
+        return energy
diff --git a/src/dctkit/apps/poisson.py b/src/dctkit/physics/poisson.py
similarity index 100%
rename from src/dctkit/apps/poisson.py
rename to src/dctkit/physics/poisson.py
diff --git a/tests/conftest.py b/tests/conftest.py
index 63dab7e..a02291d 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,12 +1,3 @@
-"""
-    Dummy conftest.py for dctkit.
-
-    If you don't know what this is for, just leave it empty.
-    Read more about conftest.py under:
-    - https://docs.pytest.org/en/stable/fixture.html
-    - https://docs.pytest.org/en/stable/writing_plugins.html
-"""
-
 import pytest
 from dctkit import config, FloatDtype, Platform
 import dctkit
diff --git a/tests/data/test1.geo b/tests/data/test1.geo
deleted file mode 100644
index d3e54d7..0000000
--- a/tests/data/test1.geo
+++ /dev/null
@@ -1,62 +0,0 @@
-
-lc = 1.0;
-
-// This variable can then be used in the definition of Gmsh's simplest
-// `elementary entity', a `Point'. A Point is uniquely identified by a tag (a
-// strictly positive integer; here `1') and defined by a list of four numbers:
-// three coordinates (X, Y and Z), and a characteristic length (lc) that sets
-// the target element size at the point:
-
-Point(1) = {1., 0,  0, lc};
-Point(2) = {0, 0, 0, lc};
-Point(3) = {1., 1., 0, lc};
-Point(4) = {0,  1., 0, lc};
-
-Line(1) = {1, 2};
-Line(2) = {2, 4};
-Line(3) = {4, 3};
-Line(4) = {3, 1};
-
-// The third elementary entity is the surface. In order to define a simple
-// rectangular surface from the four curves defined above, a curve loop has
-// first to be defined. A curve loop is also identified by a tag (unique amongst
-// curve loops) and defined by an ordered list of connected curves, a sign being
-// associated with each curve (depending on the orientation of the curve to form
-// a loop):
-
-Curve Loop(1) = {1, 2, 3, 4};
-
-Plane Surface(1) = {1};
-
-// Such groups are called "Physical Groups" in Gmsh. By default, if physical
-// groups are defined, Gmsh will export in output files only mesh elements that
-// belong to at least one physical group. (To force Gmsh to save all elements,
-// whether they belong to physical groups or not, set `Mesh.SaveAll=1;', or
-// specify `-save_all' on the command line.) Physical groups are also identified
-// by tags, i.e. strictly positive integers, that should be unique per dimension
-// (0D, 1D, 2D or 3D). Physical groups can also be given names.
-//
-// Here we define a physical curve that groups the left, bottom and right curves
-// in a single group (with prescribed tag 5); and a physical surface with name
-// "My surface" (with an automatic tag) containing the geometrical surface 1:
-
-Physical Curve(1) = {1, 2, 3, 4};
-
-Mesh 2;
-Mesh.SaveAll=1;
-Save "test1.msh";
-
-// Now that the geometry is complete, you can
-// - either open this file with Gmsh and select `2D' in the `Mesh' module to
-//   create a mesh; then select `Save' to save it to disk in the default format
-//   (or use `File->Export' to export in other formats);
-// - or run `gmsh t1.geo -2` to mesh in batch mode on the command line.
-
-// You could also uncomment the following lines in this script:
-//
-//   Mesh 2;
-//   Save "t1.msh";
-//
-// which would lead Gmsh to mesh and save the mesh every time the file is
-// parsed. (To simply parse the file from the command line, you can use `gmsh
-// t1.geo -')
diff --git a/tests/data/test1.msh b/tests/data/test1.msh
deleted file mode 100644
index e6c5a16..0000000
--- a/tests/data/test1.msh
+++ /dev/null
@@ -1,61 +0,0 @@
-$MeshFormat
-4.1 0 8
-$EndMeshFormat
-$Entities
-4 4 1 0
-1 1 0 0 0 
-2 0 0 0 0 
-3 1 1 0 0 
-4 0 1 0 0 
-1 0 0 0 1 0 0 1 1 2 1 -2 
-2 0 0 0 0 1 0 1 1 2 2 -4 
-3 0 1 0 1 1 0 1 1 2 4 -3 
-4 1 0 0 1 1 0 1 1 2 3 -1 
-1 0 0 0 1 1 0 0 4 1 2 3 4 
-$EndEntities
-$Nodes
-9 5 1 5
-0 1 0 1
-1
-1 0 0
-0 2 0 1
-2
-0 0 0
-0 3 0 1
-3
-1 1 0
-0 4 0 1
-4
-0 1 0
-1 1 0 0
-1 2 0 0
-1 3 0 0
-1 4 0 0
-2 1 0 1
-5
-0.5 0.5 0
-$EndNodes
-$Elements
-9 12 1 12
-0 1 15 1
-1 1 
-0 2 15 1
-2 2 
-0 3 15 1
-3 3 
-0 4 15 1
-4 4 
-1 1 1 1
-5 1 2 
-1 2 1 1
-6 2 4 
-1 3 1 1
-7 4 3 
-1 4 1 1
-8 3 1 
-2 1 2 4
-9 1 2 5 
-10 3 1 5 
-11 2 4 5 
-12 4 3 5 
-$EndElements
diff --git a/tests/data/test2.geo b/tests/data/test2.geo
deleted file mode 100644
index 0e948ed..0000000
--- a/tests/data/test2.geo
+++ /dev/null
@@ -1,62 +0,0 @@
-
-lc = 0.08;
-
-// This variable can then be used in the definition of Gmsh's simplest
-// `elementary entity', a `Point'. A Point is uniquely identified by a tag (a
-// strictly positive integer; here `1') and defined by a list of four numbers:
-// three coordinates (X, Y and Z), and a characteristic length (lc) that sets
-// the target element size at the point:
-
-Point(1) = {0, 0, 0, lc};
-Point(2) = {1., 0,  0, lc};
-Point(3) = {1., 1., 0, lc};
-Point(4) = {0,  1., 0, lc};
-
-Line(1) = {1, 2};
-Line(2) = {2, 3};
-Line(3) = {3, 4};
-Line(4) = {4, 1};
-
-// The third elementary entity is the surface. In order to define a simple
-// rectangular surface from the four curves defined above, a curve loop has
-// first to be defined. A curve loop is also identified by a tag (unique amongst
-// curve loops) and defined by an ordered list of connected curves, a sign being
-// associated with each curve (depending on the orientation of the curve to form
-// a loop):
-
-Curve Loop(1) = {1, 2, 3, 4};
-
-Plane Surface(1) = {1};
-
-// Such groups are called "Physical Groups" in Gmsh. By default, if physical
-// groups are defined, Gmsh will export in output files only mesh elements that
-// belong to at least one physical group. (To force Gmsh to save all elements,
-// whether they belong to physical groups or not, set `Mesh.SaveAll=1;', or
-// specify `-save_all' on the command line.) Physical groups are also identified
-// by tags, i.e. strictly positive integers, that should be unique per dimension
-// (0D, 1D, 2D or 3D). Physical groups can also be given names.
-//
-// Here we define a physical curve that groups the left, bottom and right curves
-// in a single group (with prescribed tag 5); and a physical surface with name
-// "My surface" (with an automatic tag) containing the geometrical surface 1:
-
-Physical Curve(1) = {1, 2, 3, 4};
-
-Mesh 2;
-Mesh.SaveAll=1;
-Save "test2.msh";
-
-// Now that the geometry is complete, you can
-// - either open this file with Gmsh and select `2D' in the `Mesh' module to
-//   create a mesh; then select `Save' to save it to disk in the default format
-//   (or use `File->Export' to export in other formats);
-// - or run `gmsh t1.geo -2` to mesh in batch mode on the command line.
-
-// You could also uncomment the following lines in this script:
-//
-//   Mesh 2;
-//   Save "t1.msh";
-//
-// which would lead Gmsh to mesh and save the mesh every time the file is
-// parsed. (To simply parse the file from the command line, you can use `gmsh
-// t1.geo -')
diff --git a/tests/data/test2.msh b/tests/data/test2.msh
deleted file mode 100644
index e965403..0000000
--- a/tests/data/test2.msh
+++ /dev/null
@@ -1,961 +0,0 @@
-$MeshFormat
-4.1 0 8
-$EndMeshFormat
-$Entities
-4 4 1 0
-1 0 0 0 0 
-2 1 0 0 0 
-3 1 1 0 0 
-4 0 1 0 0 
-1 0 0 0 1 0 0 1 1 2 1 -2 
-2 1 0 0 1 1 0 1 1 2 2 -3 
-3 0 1 0 1 1 0 1 1 2 3 -4 
-4 0 0 0 0 1 0 1 1 2 4 -1 
-1 0 0 0 1 1 0 0 4 1 2 3 4 
-$EndEntities
-$Nodes
-9 230 1 230
-0 1 0 1
-1
-0 0 0
-0 2 0 1
-2
-1 0 0
-0 3 0 1
-3
-1 1 0
-0 4 0 1
-4
-0 1 0
-1 1 0 12
-5
-6
-7
-8
-9
-10
-11
-12
-13
-14
-15
-16
-0.0769230769229268 0 0
-0.1538461538458463 0 0
-0.230769230768699 0 0
-0.3076923076915516 0 0
-0.3846153846144044 0 0
-0.4615384615372571 0 0
-0.5384615384603233 0 0
-0.6153846153836027 0 0
-0.6923076923068823 0 0
-0.7692307692301616 0 0
-0.8461538461534411 0 0
-0.9230769230767206 0 0
-1 2 0 12
-17
-18
-19
-20
-21
-22
-23
-24
-25
-26
-27
-28
-1 0.0769230769229268 0
-1 0.1538461538458463 0
-1 0.230769230768699 0
-1 0.3076923076915516 0
-1 0.3846153846144044 0
-1 0.4615384615372571 0
-1 0.5384615384603233 0
-1 0.6153846153836027 0
-1 0.6923076923068823 0
-1 0.7692307692301616 0
-1 0.8461538461534411 0
-1 0.9230769230767206 0
-1 3 0 12
-29
-30
-31
-32
-33
-34
-35
-36
-37
-38
-39
-40
-0.9230769230766027 1 0
-0.8461538461535256 1 0
-0.7692307692309824 1 0
-0.6923076923084392 1 0
-0.6153846153858957 1 0
-0.5384615384633524 1 0
-0.4615384615403821 1 0
-0.3846153846169851 1 0
-0.307692307693588 1 0
-0.230769230770191 1 0
-0.1538461538467939 1 0
-0.07692307692339706 1 0
-1 4 0 12
-41
-42
-43
-44
-45
-46
-47
-48
-49
-50
-51
-52
-0 0.9230769230766027 0
-0 0.8461538461535256 0
-0 0.7692307692309824 0
-0 0.6923076923084392 0
-0 0.6153846153858957 0
-0 0.5384615384633524 0
-0 0.4615384615403821 0
-0 0.3846153846169851 0
-0 0.307692307693588 0
-0 0.230769230770191 0
-0 0.1538461538467939 0
-0 0.07692307692339706 0
-2 1 0 178
-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
-188
-189
-190
-191
-192
-193
-194
-195
-196
-197
-198
-199
-200
-201
-202
-203
-204
-205
-206
-207
-208
-209
-210
-211
-212
-213
-214
-215
-216
-217
-218
-219
-220
-221
-222
-223
-224
-225
-226
-227
-228
-229
-230
-0.06661733875239605 0.5000000000018321 0
-0.9333826612474474 0.4999999999987852 0
-0.4999999999987902 0.0666173387525474 0
-0.5000000000018673 0.9333826612476281 0
-0.2665028614154953 0.9268297401207103 0
-0.9333826612472742 0.730769230768203 0
-0.06138339780811351 0.2740595184268933 0
-0.7317770412402804 0.06839461886529155 0
-0.7334971385852043 0.9268297401198493 0
-0.06661733875208123 0.7307692307699731 0
-0.9333826612475358 0.2692307692300863 0
-0.2692307692301253 0.0666173387524549 0
-0.8775518754568693 0.9303309809656659 0
-0.06489971572367467 0.8816403742616667 0
-0.0636671873713789 0.1144499824692462 0
-0.8775518754570641 0.06966901903362174 0
-0.5769230769246689 0.9333826612476851 0
-0.5384615384634056 0.8667653224951989 0
-0.4615384615404561 0.866765322495053 0
-0.500000000002058 0.8001479837425696 0
-0.423076923079061 0.8001479837424146 0
-0.461538461540676 0.7335306449899091 0
-0.5384615384636725 0.7335306449900431 0
-0.5015072493618555 0.6672582787367589 0
-0.4213564666713661 0.6646738967044628 0
-0.461709121130705 0.5998611817612488 0
-0.538541429255351 0.6008329897600173 0
-0.5000417583993841 0.533695668157478 0
-0.4233185201751456 0.5334899581311301 0
-0.4615856874565321 0.4670326847835973 0
-0.5334009996249363 0.4683900229108018 0
-0.3846635217866083 0.4670250773465996 0
-0.4230928169270385 0.400433148255414 0
-0.3486818534180099 0.5329157441251611 0
-0.3461645179926485 0.4004361152927044 0
-0.3846198122321898 0.3338235059899335 0
-0.4615418484515593 0.3338242942316717 0
-0.307694824270214 0.3338247887376776 0
-0.2717793468195917 0.3989721883816976 0
-0.3461550035216832 0.2672084520180336 0
-0.2692312066075769 0.267208958788038 0
-0.6153846153863253 0.8667653224954398 0
-0.307692573485197 0.2014502165064336 0
-0.2307693479662572 0.2015934003798119 0
-0.3846156218109308 0.2007348449412661 0
-0.3870459302876097 0.8681685986918168 0
-0.3384666772085007 0.8033122933228554 0
-0.1946298304967129 0.2660354983907207 0
-0.1567882423615004 0.1989680686361193 0
-0.346153846157085 0.1339745962161837 0
-0.2000941737683757 0.1343704226362046 0
-0.4230769230801192 0.1339745962163199 0
-0.4600080309721953 0.1996631788944614 0
-0.9333826612473648 0.5769230769218534 0
-0.866765322494835 0.5384615384602465 0
-0.8667653224949137 0.4615384615372542 0
-0.8001479837423007 0.4999999999986933 0
-0.8001479837423709 0.4230769230757069 0
-0.8001479837422281 0.5769230769216803 0
-0.7335306449896902 0.5384615384601337 0
-0.7335306449896126 0.6153846153831317 0
-0.8001479837421381 0.6538461538446911 0
-0.7369227436939499 0.6923076923061571 0
-0.8007133335261242 0.7307692307677561 0
-0.7375823184419787 0.7692307692291848 0
-0.8009174876147558 0.8076923076907661 0
-0.6633836314764081 0.6609335382215723 0
-0.8667653224949824 0.3846153846142628 0
-0.8001479837424206 0.3461538461527098 0
-0.7335306449897872 0.3846153846141448 0
-0.733530644989858 0.3076923076910995 0
-0.667828475466993 0.3461538461525677 0
-0.6679810036720222 0.2692307692294972 0
-0.733708594562419 0.2307692307680181 0
-0.666913306237322 0.1923076923064046 0
-0.6684043144755216 0.4230769230756055 0
-0.6059385193190634 0.2312973239553025 0
-0.6042597266039651 0.1535264322106511 0
-0.6070561310393005 0.3810398156596558 0
-0.733268035960488 0.1519101334447368 0
-0.8001338738331418 0.1919850222399163 0
-0.8028647427797035 0.1145556063799986 0
-0.8693764992986388 0.1530738913481396 0
-0.736130442151171 0.845207581503759 0
-0.8037590956657918 0.8841142942631937 0
-0.8696561604096648 0.8466506470800659 0
-0.6650011595286925 0.1155613885859158 0
-0.5899982749626942 0.0718270355749912 0
-0.6654991853621068 0.8035487929553199 0
-0.9333826612473289 0.6538461538449988 0
-0.07689201031188631 0.195998596953012 0
-0.06661733875231977 0.5769230769246627 0
-0.133234677504809 0.5384615384634037 0
-0.133234677504559 0.6153846153863234 0
-0.131509904969954 0.4599787997999767 0
-0.1998520162572009 0.576923076925059 0
-0.1998520162569887 0.6538461538479324 0
-0.2649707171552775 0.6178765876746554 0
-0.2639241681968528 0.692723021024322 0
-0.1994278184546622 0.7308384522232886 0
-0.3377326233176593 0.6615757117135284 0
-0.2645757076443904 0.7685815251985371 0
-0.1994657087287262 0.8075956372634387 0
-0.2651897588282377 0.844353260033142 0
-0.198322562714831 0.8827467859660212 0
-0.2701701836137408 0.5349845688484618 0
-0.5779535479097233 0.80046928422054 0
-0.6197550624596608 0.7330391053981469 0
-0.5859665730826966 0.668983141233763 0
-0.9333826612474816 0.4230769230758236 0
-0.1331381887745 0.7692275014963347 0
-0.06000674468757087 0.3486433156733322 0
-0.3846153846176661 0.7335306449897842 0
-0.422823386165262 0.2670772582995048 0
-0.4962481099517336 0.266516394093358 0
-0.5404021645288886 0.3394095477548273 0
-0.5885343390609025 0.5351445067077659 0
-0.1955203304221915 0.4948387179739108 0
-0.6669133062370708 0.5769230769215665 0
-0.4955920240449204 0.4038400734939296 0
-0.3112511552512494 0.4654290110957764 0
-0.8001752903529937 0.2691769908852935 0
-0.7337791463628048 0.4615384615371466 0
-0.2315815090589412 0.3333853329997623 0
-0.1633126088945164 0.3269076690168317 0
-0.9341808338367589 0.1928076755534667 0
-0.9333826612475323 0.3461538461529629 0
-0.6669133062371584 0.499999999998596 0
-0.8667653224947454 0.6153846153832861 0
-0.1951488743143069 0.4094957540860588 0
-0.4234820140237274 0.9336165406136165 0
-0.3486023466255997 0.9339666431837659 0
-0.06407081676132957 0.4248205265804511 0
-0.866769873596769 0.3076833446339903 0
-0.6518702594794551 0.9336937839235687 0
-0.06661733875220484 0.6538461538472624 0
-0.8668595474586925 0.692307692306408 0
-0.9339860775147424 0.8073023837572232 0
-0.867336505360973 0.2306596156484821 0
-0.8675858779618755 0.769248582061737 0
-0.1331478964158327 0.6923186845951856 0
-0.06631498679242315 0.8071959280111174 0
-0.132562640039651 0.8452471916790485 0
-0.1250247774484508 0.9288277229247605 0
-0.385852549205096 0.5995816901771489 0
-0.5385469406049599 0.196621119169931 0
-0.9365400601935346 0.8818758624877623 0
-0.9365328403988425 0.1181100726935795 0
-0.1126994625599063 0.06194986746832241 0
-0.4197396383978168 0.06264805038885661 0
-0.3454863892181966 0.05264799707149904 0
-0.2707881421214081 0.1476011948982177 0
-0.1886562097413984 0.06358448572619613 0
-0.6057869828633966 0.3076923076909832 0
-0.4946148651231503 0.1426556034511118 0
-0.6029729529530643 0.4536003352299485 0
-0.6056027259875254 0.6046313276687681 0
-0.1217733283587825 0.3838176074250918 0
-0.1314058735010903 0.1317949561568089 0
-0.3178629121970139 0.7319446392498056 0
-0.807692307692254 0.9484713091468218 0
-0.8055156549721302 0.05052384885578239 0
-0.19362678666087 0.9480680135639004 0
-0.129316889936081 0.2591654712601344 0
-0.3219855809761096 0.8752217162950503 0
-0.6791284539528584 0.8751972574953513 0
-0.6554384538037996 0.05068230525352498 0
-0.2487739780842161 0.4607440480771811 0
-0.3240948666362729 0.5918749106529827 0
-0.5484023955000059 0.1214261319822723 0
-0.6859203320467575 0.7313012454892923 0
-0.9436883994176642 0.9436883994176962 0
-0.05631160058231526 0.9436883994176843 0
-0.9436883994175705 0.05631160058233515 0
-0.05591994342713055 0.05591994342725896 0
-0.5586534521129379 0.2723993283538435 0
-0.5552116466788921 0.4105973258719565 0
-0.1062625856349864 0.3120040412318129 0
-$EndNodes
-$Elements
-9 462 1 462
-0 1 15 1
-53 1 
-0 2 15 1
-54 2 
-0 3 15 1
-55 3 
-0 4 15 1
-56 4 
-1 1 1 13
-1 1 5 
-2 5 6 
-3 6 7 
-4 7 8 
-5 8 9 
-6 9 10 
-7 10 11 
-8 11 12 
-9 12 13 
-10 13 14 
-11 14 15 
-12 15 16 
-13 16 2 
-1 2 1 13
-14 2 17 
-15 17 18 
-16 18 19 
-17 19 20 
-18 20 21 
-19 21 22 
-20 22 23 
-21 23 24 
-22 24 25 
-23 25 26 
-24 26 27 
-25 27 28 
-26 28 3 
-1 3 1 13
-27 3 29 
-28 29 30 
-29 30 31 
-30 31 32 
-31 32 33 
-32 33 34 
-33 34 35 
-34 35 36 
-35 36 37 
-36 37 38 
-37 38 39 
-38 39 40 
-39 40 4 
-1 4 1 13
-40 4 41 
-41 41 42 
-42 42 43 
-43 43 44 
-44 44 45 
-45 45 46 
-46 46 47 
-47 47 48 
-48 48 49 
-49 49 50 
-50 50 51 
-51 51 52 
-52 52 1 
-2 1 2 406
-57 171 169 180 
-58 55 11 140 
-59 202 102 203 
-60 104 102 202 
-61 201 205 211 
-62 205 103 211 
-63 170 147 182 
-64 65 137 138 
-65 134 68 135 
-66 102 64 203 
-67 64 102 204 
-68 103 64 204 
-69 64 103 205 
-70 55 104 202 
-71 104 55 207 
-72 153 77 165 
-73 169 171 209 
-74 170 182 220 
-75 11 12 140 
-76 55 140 222 
-77 119 160 161 
-78 154 99 156 
-79 39 40 196 
-80 137 65 213 
-81 68 134 214 
-82 180 169 208 
-83 141 159 160 
-84 160 75 161 
-85 61 136 137 
-86 156 57 157 
-87 132 60 134 
-88 143 101 216 
-89 153 165 212 
-90 196 40 225 
-91 159 75 160 
-92 141 94 159 
-93 76 79 161 
-94 77 153 197 
-95 60 132 139 
-96 75 76 161 
-97 160 119 223 
-98 156 99 217 
-99 65 138 199 
-100 135 68 200 
-101 59 143 216 
-102 86 158 173 
-103 101 143 211 
-104 167 105 198 
-105 127 130 139 
-106 132 127 139 
-107 136 61 218 
-108 57 156 217 
-109 139 130 140 
-110 173 158 220 
-111 61 137 213 
-112 157 57 215 
-113 134 60 214 
-114 210 164 230 
-115 167 198 228 
-116 133 135 191 
-117 25 58 142 
-118 183 36 184 
-119 152 163 193 
-120 98 183 184 
-121 142 58 189 
-122 29 30 65 
-123 41 42 66 
-124 163 62 193 
-125 51 67 143 
-126 135 178 191 
-127 24 25 142 
-128 49 59 164 
-129 117 118 136 
-130 136 118 137 
-131 22 23 54 
-132 89 167 168 
-133 51 52 67 
-134 108 120 162 
-135 89 168 172 
-136 72 75 159 
-137 48 49 164 
-138 15 16 68 
-139 59 50 143 
-140 89 166 167 
-141 97 105 166 
-142 34 35 56 
-143 46 47 53 
-144 92 97 166 
-145 54 108 162 
-146 133 134 135 
-147 50 51 143 
-148 37 38 57 
-149 73 99 165 
-150 117 116 118 
-151 22 54 162 
-152 23 24 106 
-153 189 58 192 
-154 10 11 55 
-155 25 26 58 
-156 117 136 141 
-157 92 95 97 
-158 115 116 117 
-159 49 50 59 
-160 97 95 102 
-161 96 101 103 
-162 166 105 167 
-163 13 14 60 
-164 92 93 95 
-165 77 74 165 
-166 106 24 142 
-167 88 92 166 
-168 35 36 183 
-169 158 148 170 
-170 148 145 170 
-171 54 107 108 
-172 113 115 119 
-173 124 122 128 
-174 149 151 152 
-175 74 73 165 
-176 152 155 163 
-177 127 125 129 
-178 97 102 104 
-179 54 106 107 
-180 124 128 131 
-181 128 122 175 
-182 84 81 86 
-183 127 129 130 
-184 73 98 99 
-185 76 74 77 
-186 80 83 169 
-187 72 73 74 
-188 80 82 83 
-189 126 132 133 
-190 146 148 149 
-191 79 80 169 
-192 80 78 81 
-193 152 154 155 
-194 79 78 80 
-195 76 78 79 
-196 85 88 89 
-197 70 72 159 
-198 80 81 82 
-199 88 90 92 
-200 108 110 120 
-201 113 119 171 
-202 82 81 84 
-203 89 88 166 
-204 152 151 154 
-205 121 123 174 
-206 76 77 78 
-207 109 111 112 
-208 108 107 109 
-209 133 132 134 
-210 115 114 116 
-211 112 113 171 
-212 83 82 172 
-213 82 84 85 
-214 126 133 174 
-215 112 111 113 
-216 85 89 172 
-217 84 86 173 
-218 72 71 73 
-219 109 107 111 
-220 97 104 105 
-221 144 145 146 
-222 149 150 151 
-223 69 70 94 
-224 146 145 148 
-225 90 87 91 
-226 113 114 115 
-227 82 85 172 
-228 95 93 96 
-229 123 122 124 
-230 75 74 76 
-231 128 175 180 
-232 123 124 125 
-233 108 109 110 
-234 147 53 185 
-235 109 112 175 
-236 149 148 150 
-237 72 74 75 
-238 92 90 93 
-239 151 150 153 
-240 94 70 159 
-241 123 126 174 
-242 126 125 127 
-243 48 164 185 
-244 91 87 173 
-245 121 110 122 
-246 120 110 121 
-247 116 189 192 
-248 137 118 138 
-249 150 148 158 
-250 85 87 88 
-251 85 84 87 
-252 21 22 162 
-253 121 122 123 
-254 70 71 72 
-255 123 125 126 
-256 145 147 170 
-257 90 91 176 
-258 110 109 175 
-259 54 23 106 
-260 175 112 180 
-261 112 171 180 
-262 122 110 175 
-263 36 37 184 
-264 20 21 179 
-265 113 111 114 
-266 190 138 192 
-267 162 120 179 
-268 87 84 173 
-269 126 127 132 
-270 19 20 63 
-271 18 19 178 
-272 88 87 90 
-273 73 71 98 
-274 176 91 182 
-275 96 100 101 
-276 106 142 181 
-277 71 56 183 
-278 63 179 186 
-279 7 8 64 
-280 47 48 185 
-281 53 47 185 
-282 179 120 186 
-283 93 90 176 
-284 107 106 181 
-285 96 93 100 
-286 21 162 179 
-287 111 107 181 
-288 100 176 177 
-289 145 53 147 
-290 70 56 71 
-291 63 20 179 
-292 177 176 182 
-293 114 111 181 
-294 100 93 176 
-295 31 32 61 
-296 174 133 191 
-297 19 63 178 
-298 121 174 186 
-299 155 154 156 
-300 26 27 190 
-301 43 44 62 
-302 56 35 183 
-303 37 57 184 
-304 32 33 187 
-305 44 45 188 
-306 155 156 157 
-307 118 116 192 
-308 98 71 183 
-309 144 53 145 
-310 120 121 186 
-311 34 56 69 
-312 58 190 192 
-313 69 56 70 
-314 46 53 144 
-315 114 181 189 
-316 149 152 193 
-317 66 42 194 
-318 33 34 69 
-319 62 188 193 
-320 45 46 144 
-321 61 32 187 
-322 66 194 195 
-323 181 142 189 
-324 116 114 189 
-325 62 44 188 
-326 178 63 191 
-327 63 186 191 
-328 58 26 190 
-329 69 94 187 
-330 188 146 193 
-331 144 146 188 
-332 33 69 187 
-333 45 144 188 
-334 138 118 192 
-335 186 174 191 
-336 146 149 193 
-337 62 163 194 
-338 43 62 194 
-339 155 157 195 
-340 42 43 194 
-341 194 163 195 
-342 163 155 195 
-343 195 157 196 
-344 66 195 196 
-345 119 161 209 
-346 131 168 206 
-347 177 210 230 
-348 99 154 212 
-349 86 81 197 
-350 78 77 197 
-351 81 78 197 
-352 27 28 199 
-353 138 190 199 
-354 17 18 200 
-355 178 135 200 
-356 130 129 198 
-357 10 55 202 
-358 102 95 204 
-359 96 103 204 
-360 64 8 203 
-361 7 64 205 
-362 129 125 206 
-363 124 131 206 
-364 169 83 208 
-365 158 170 220 
-366 182 147 210 
-367 131 128 208 
-368 141 160 223 
-369 171 119 209 
-370 143 67 211 
-371 158 86 221 
-372 190 27 199 
-373 18 178 200 
-374 168 131 229 
-375 198 129 228 
-376 161 79 209 
-377 5 6 201 
-378 201 6 205 
-379 9 10 202 
-380 8 9 203 
-381 9 202 203 
-382 95 96 204 
-383 6 7 205 
-384 151 153 212 
-385 79 169 209 
-386 125 124 206 
-387 65 30 213 
-388 31 61 213 
-389 15 68 214 
-390 60 14 214 
-391 57 38 215 
-392 100 177 216 
-393 184 57 217 
-394 99 98 217 
-395 61 187 218 
-396 185 164 210 
-397 182 91 220 
-398 60 139 219 
-399 150 158 221 
-400 67 201 211 
-401 119 115 223 
-402 117 141 223 
-403 16 2 226 
-404 2 17 226 
-405 3 29 224 
-406 4 41 225 
-407 28 3 224 
-408 40 4 225 
-409 66 196 225 
-410 172 168 229 
-411 52 1 227 
-412 1 5 227 
-413 105 104 207 
-414 13 60 219 
-415 165 99 212 
-416 128 180 208 
-417 198 105 207 
-418 130 198 222 
-419 39 196 215 
-420 94 141 218 
-421 147 185 210 
-422 198 207 222 
-423 177 182 210 
-424 141 136 218 
-425 103 101 211 
-426 131 208 229 
-427 154 151 212 
-428 140 12 219 
-429 30 31 213 
-430 14 15 214 
-431 196 157 215 
-432 38 39 215 
-433 12 13 219 
-434 101 100 216 
-435 139 140 219 
-436 98 184 217 
-437 187 94 218 
-438 153 150 221 
-439 91 173 220 
-440 86 197 221 
-441 140 130 222 
-442 168 167 228 
-443 199 28 224 
-444 17 200 226 
-445 207 55 222 
-446 216 177 230 
-447 197 153 221 
-448 115 117 223 
-449 67 52 227 
-450 68 16 226 
-451 29 65 224 
-452 41 66 225 
-453 129 206 228 
-454 208 83 229 
-455 83 172 229 
-456 164 59 230 
-457 65 199 224 
-458 200 68 226 
-459 206 168 228 
-460 201 67 227 
-461 5 201 227 
-462 59 216 230 
-$EndElements
diff --git a/tests/data/test3.geo b/tests/data/test3.geo
deleted file mode 100644
index f37822b..0000000
--- a/tests/data/test3.geo
+++ /dev/null
@@ -1,62 +0,0 @@
-
-lc = 0.1;
-
-// This variable can then be used in the definition of Gmsh's simplest
-// `elementary entity', a `Point'. A Point is uniquely identified by a tag (a
-// strictly positive integer; here `1') and defined by a list of four numbers:
-// three coordinates (X, Y and Z), and a characteristic length (lc) that sets
-// the target element size at the point:
-
-Point(1) = {0, 0, 0, lc};
-Point(2) = {1., 0,  0, lc};
-Point(3) = {1., 1., 0, lc};
-Point(4) = {0,  1., 0, lc};
-
-Line(1) = {1, 2};
-Line(2) = {2, 3};
-Line(3) = {3, 4};
-Line(4) = {4, 1};
-
-// The third elementary entity is the surface. In order to define a simple
-// rectangular surface from the four curves defined above, a curve loop has
-// first to be defined. A curve loop is also identified by a tag (unique amongst
-// curve loops) and defined by an ordered list of connected curves, a sign being
-// associated with each curve (depending on the orientation of the curve to form
-// a loop):
-
-Curve Loop(1) = {1, 2, 3, 4};
-
-Plane Surface(1) = {1};
-
-// Such groups are called "Physical Groups" in Gmsh. By default, if physical
-// groups are defined, Gmsh will export in output files only mesh elements that
-// belong to at least one physical group. (To force Gmsh to save all elements,
-// whether they belong to physical groups or not, set `Mesh.SaveAll=1;', or
-// specify `-save_all' on the command line.) Physical groups are also identified
-// by tags, i.e. strictly positive integers, that should be unique per dimension
-// (0D, 1D, 2D or 3D). Physical groups can also be given names.
-//
-// Here we define a physical curve that groups the left, bottom and right curves
-// in a single group (with prescribed tag 5); and a physical surface with name
-// "My surface" (with an automatic tag) containing the geometrical surface 1:
-
-Physical Curve(1) = {1, 2, 3, 4};
-
-Mesh 2;
-Mesh.SaveAll=1;
-Save "test3.msh";
-
-// Now that the geometry is complete, you can
-// - either open this file with Gmsh and select `2D' in the `Mesh' module to
-//   create a mesh; then select `Save' to save it to disk in the default format
-//   (or use `File->Export' to export in other formats);
-// - or run `gmsh t1.geo -2` to mesh in batch mode on the command line.
-
-// You could also uncomment the following lines in this script:
-//
-//   Mesh 2;
-//   Save "t1.msh";
-//
-// which would lead Gmsh to mesh and save the mesh every time the file is
-// parsed. (To simply parse the file from the command line, you can use `gmsh
-// t1.geo -')
diff --git a/tests/data/test3.msh b/tests/data/test3.msh
deleted file mode 100644
index 3768183..0000000
--- a/tests/data/test3.msh
+++ /dev/null
@@ -1,609 +0,0 @@
-$MeshFormat
-4.1 0 8
-$EndMeshFormat
-$Entities
-4 4 1 0
-1 0 0 0 0 
-2 1 0 0 0 
-3 1 1 0 0 
-4 0 1 0 0 
-1 0 0 0 1 0 0 1 1 2 1 -2 
-2 1 0 0 1 1 0 1 1 2 2 -3 
-3 0 1 0 1 1 0 1 1 2 3 -4 
-4 0 0 0 0 1 0 1 1 2 4 -1 
-1 0 0 0 1 1 0 0 4 1 2 3 4 
-$EndEntities
-$Nodes
-9 142 1 142
-0 1 0 1
-1
-0 0 0
-0 2 0 1
-2
-1 0 0
-0 3 0 1
-3
-1 1 0
-0 4 0 1
-4
-0 1 0
-1 1 0 9
-5
-6
-7
-8
-9
-10
-11
-12
-13
-0.09999999999981467 0 0
-0.1999999999995579 0 0
-0.2999999999992664 0 0
-0.3999999999989749 0 0
-0.4999999999986943 0 0
-0.5999999999989468 0 0
-0.69999999999921 0 0
-0.7999999999994734 0 0
-0.8999999999997368 0 0
-1 2 0 9
-14
-15
-16
-17
-18
-19
-20
-21
-22
-1 0.09999999999981467 0
-1 0.1999999999995579 0
-1 0.2999999999992664 0
-1 0.3999999999989749 0
-1 0.4999999999986943 0
-1 0.5999999999989468 0
-1 0.69999999999921 0
-1 0.7999999999994734 0
-1 0.8999999999997368 0
-1 3 0 9
-23
-24
-25
-26
-27
-28
-29
-30
-31
-0.8999999999995836 1 0
-0.7999999999999998 1 0
-0.7000000000006934 1 0
-0.6000000000013869 1 0
-0.5000000000020587 1 0
-0.4000000000016644 1 0
-0.3000000000012483 1 0
-0.2000000000008322 1 0
-0.100000000000416 1 0
-1 4 0 9
-32
-33
-34
-35
-36
-37
-38
-39
-40
-0 0.8999999999995836 0
-0 0.7999999999999998 0
-0 0.7000000000006934 0
-0 0.6000000000013869 0
-0 0.5000000000020587 0
-0 0.4000000000016644 0
-0 0.3000000000012483 0
-0 0.2000000000008322 0
-0 0.100000000000416 0
-2 1 0 102
-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
-0.4500000000018615 0.9133974596216763 0
-0.09236792741065167 0.4605742807381243 0
-0.5499999999988205 0.08660254037843171 0
-0.9152217186777625 0.5468402906274979 0
-0.6500000000008003 0.9133974596219512 0
-0.08885430207258711 0.6509201999022065 0
-0.9133974596218086 0.3499999999991206 0
-0.3475303635242555 0.08190748804974735 0
-0.9103703875043376 0.758672565470732 0
-0.250817301762687 0.9138693290130382 0
-0.7459788032314766 0.07959225689678906 0
-0.0866025403788042 0.2500000000010402 0
-0.09056972474474843 0.8408174380938657 0
-0.8495762630717529 0.9153227954948183 0
-0.1504237369277891 0.08467720450543256 0
-0.9170502595852439 0.1505932316990231 0
-0.3501362169619658 0.9134761045201359 0
-0.4000227028286922 0.8268080267265114 0
-0.5000037838059687 0.8267971038241901 0
-0.4500044144404199 0.7401949275428535 0
-0.5500013663751488 0.7401931677420538 0
-0.5000009634704363 0.6535903947466357 0
-0.3996660322685219 0.6539624100660317 0
-0.4492890262150219 0.5674132367139486 0
-0.5498816649485163 0.5670583805869821 0
-0.4998617818618978 0.4804675945786106 0
-0.5999572411359392 0.4804104109524933 0
-0.3992029949383343 0.480833304271524 0
-0.4498441294682414 0.3938707812513986 0
-0.3508014145113756 0.3944261231392706 0
-0.6499731510146841 0.5670034207262449 0
-0.7044542185661735 0.4836609274158977 0
-0.6507352432846276 0.3943325211712257 0
-0.2989417123120311 0.4807819782420579 0
-0.4001075906650127 0.3073017552560431 0
-0.3000000000029337 0.3071796769753513 0
-0.4999919533568901 0.3072147840053007 0
-0.4500000000024976 0.2205771365973904 0
-0.7516124797967325 0.5701303236396063 0
-0.7002642718023641 0.6541163631790488 0
-0.7535358109397499 0.398725467089393 0
-0.7000000000012374 0.3071796769756582 0
-0.8000000000003885 0.6535898384882729 0
-0.7471434102059782 0.7386054505286097 0
-0.5500000000021417 0.2205771365975503 0
-0.8109810542586335 0.3047536098154713 0
-0.7487737367126552 0.2215627586077864 0
-0.3001627035935244 0.8268888562051477 0
-0.1994089234458856 0.8296981761685946 0
-0.2499286045088541 0.7410578833522045 0
-0.1494939110587462 0.7431601482469266 0
-0.1967429917984388 0.6534863612147316 0
-0.147506470839524 0.5596891567283323 0
-0.2461396475416213 0.5647585225755515 0
-0.2006125504552568 0.4738835212418007 0
-0.1629581819743502 0.3803886475363467 0
-0.3488732355465844 0.5672558538991083 0
-0.6000008583640311 0.8267954148199791 0
-0.8994183955992581 0.6528983889292931 0
-0.6499999999991334 0.08660254037864022 0
-0.9157740970141776 0.4494733817703521 0
-0.816795611873832 0.4899817334731327 0
-0.4498499977837827 0.0839345655930238 0
-0.5500007736960177 0.9133979063146327 0
-0.2471893802660855 0.08407329706072982 0
-0.1856343100128922 0.1794039491425673 0
-0.9132469817449553 0.250891140252 0
-0.600020236268652 0.6536923509744803 0
-0.7499293771789073 0.9137183489341745 0
-0.349200695495715 0.228832737024256 0
-0.5500650581848783 0.3939126281557886 0
-0.6495716905027346 0.740032944414692 0
-0.6994408893754027 0.8265574229272838 0
-0.6001320424719062 0.3072989805838409 0
-0.8150407418201517 0.8183024367054094 0
-0.6500000000016627 0.2205771365975219 0
-0.3499640762739982 0.7407829625697141 0
-0.2985524313230031 0.6535506656128902 0
-0.1530678781041704 0.9178724624824317 0
-0.9167537064254057 0.8508718537559957 0
-0.08296629115975593 0.1498875452108657 0
-0.1890575670468488 0.2940842362157939 0
-0.8440933898604551 0.09385434397709348 0
-0.2503952377171327 0.3884573638917701 0
-0.07972803913531304 0.3493512757062616 0
-0.8380531170040471 0.1999999999995611 0
-0.8406928938275633 0.3992789991981977 0
-0.289826115351807 0.1633999302292044 0
-0.06578358757521634 0.7469795572487383 0
-0.6999999999992164 0.1535898384871371 0
-0.5999999999988372 0.1535898384867516 0
-0.4999999999989004 0.1535898384865984 0
-0.3977345286928263 0.1553736159967034 0
-0.8325961894321559 0.730144284150142 0
-0.06525626353167149 0.5500000000017229 0
-0.8366096411895946 0.5826881150315606 0
-0.261387261226549 0.2359890604552144 0
-0.926794919243098 0.9267949192431389 0
-0.07320508075687601 0.9267949192431241 0
-0.9267949192432314 0.07320508075664824 0
-0.07320508075662228 0.07320508075678341 0
-0.7753798093615701 0.1497198395936734 0
-$EndNodes
-$Elements
-9 286 1 286
-0 1 15 1
-1 1 
-0 2 15 1
-2 2 
-0 3 15 1
-3 3 
-0 4 15 1
-4 4 
-1 1 1 10
-5 1 5 
-6 5 6 
-7 6 7 
-8 7 8 
-9 8 9 
-10 9 10 
-11 10 11 
-12 11 12 
-13 12 13 
-14 13 2 
-1 2 1 10
-15 2 14 
-16 14 15 
-17 15 16 
-18 16 17 
-19 17 18 
-20 18 19 
-21 19 20 
-22 20 21 
-23 21 22 
-24 22 3 
-1 3 1 10
-25 3 23 
-26 23 24 
-27 24 25 
-28 25 26 
-29 26 27 
-30 27 28 
-31 28 29 
-32 29 30 
-33 30 31 
-34 31 4 
-1 4 1 10
-35 4 32 
-36 32 33 
-37 33 34 
-38 34 35 
-39 35 36 
-40 36 37 
-41 37 38 
-42 38 39 
-43 39 40 
-44 40 1 
-2 1 2 242
-45 72 81 102 
-46 122 76 124 
-47 115 49 120 
-48 106 52 121 
-49 52 106 122 
-50 49 115 134 
-51 96 122 124 
-52 47 86 107 
-53 52 122 125 
-54 93 42 95 
-55 89 53 91 
-56 122 96 125 
-57 102 81 127 
-58 107 86 126 
-59 79 72 102 
-60 42 93 135 
-61 91 53 129 
-62 91 46 92 
-63 92 46 93 
-64 86 47 127 
-65 95 42 96 
-66 54 115 120 
-67 55 106 121 
-68 83 99 134 
-69 53 89 119 
-70 123 56 126 
-71 86 87 126 
-72 128 48 133 
-73 68 64 97 
-74 92 94 118 
-75 99 83 136 
-76 74 94 95 
-77 99 49 134 
-78 94 97 118 
-79 64 63 97 
-80 74 68 97 
-81 92 93 94 
-82 123 126 142 
-83 46 91 129 
-84 74 95 124 
-85 110 128 133 
-86 76 122 137 
-87 94 93 95 
-88 94 74 97 
-89 41 57 58 
-90 41 28 57 
-91 27 28 41 
-92 88 50 89 
-93 36 37 42 
-94 98 45 104 
-95 44 19 99 
-96 45 26 104 
-97 57 50 88 
-98 88 89 90 
-99 43 10 100 
-100 27 41 104 
-101 29 50 57 
-102 18 19 44 
-103 9 10 43 
-104 41 58 59 
-105 28 29 57 
-106 26 27 104 
-107 18 44 101 
-108 48 8 103 
-109 9 43 103 
-110 47 17 101 
-111 90 89 91 
-112 20 49 99 
-113 41 59 104 
-114 45 98 113 
-115 8 9 103 
-116 11 51 100 
-117 17 18 101 
-118 90 91 92 
-119 19 20 99 
-120 59 98 104 
-121 10 11 100 
-122 29 30 50 
-123 109 113 115 
-124 20 21 49 
-125 38 39 52 
-126 101 44 102 
-127 109 45 113 
-128 11 12 51 
-129 59 58 60 
-130 23 24 54 
-131 7 8 48 
-132 70 68 74 
-133 32 33 53 
-134 16 17 47 
-135 62 60 63 
-136 66 64 68 
-137 58 57 88 
-138 7 48 105 
-139 80 84 112 
-140 34 35 46 
-141 66 68 69 
-142 69 75 77 
-143 16 47 107 
-144 65 67 71 
-145 25 26 45 
-146 80 83 84 
-147 71 79 80 
-148 15 16 107 
-149 71 72 79 
-150 62 63 64 
-151 6 7 105 
-152 71 67 72 
-153 65 64 66 
-154 65 66 67 
-155 77 75 78 
-156 62 64 65 
-157 71 80 108 
-158 77 78 85 
-159 59 61 98 
-160 62 65 108 
-161 65 71 108 
-162 14 15 56 
-163 78 75 110 
-164 98 61 112 
-165 72 73 81 
-166 69 70 75 
-167 81 82 86 
-168 66 69 111 
-169 61 60 62 
-170 5 6 55 
-171 72 67 73 
-172 67 66 111 
-173 61 62 108 
-174 59 60 61 
-175 54 24 109 
-176 69 68 70 
-177 24 25 109 
-178 56 15 107 
-179 69 77 111 
-180 61 108 112 
-181 80 79 83 
-182 81 73 82 
-183 73 67 111 
-184 75 76 110 
-185 55 6 105 
-186 86 82 87 
-187 25 45 109 
-188 75 70 76 
-189 112 84 113 
-190 55 105 106 
-191 108 80 112 
-192 98 112 113 
-193 111 77 114 
-194 88 90 117 
-195 73 111 114 
-196 113 84 115 
-197 77 85 114 
-198 114 85 116 
-199 82 73 114 
-200 82 114 116 
-201 60 58 117 
-202 54 109 115 
-203 63 60 117 
-204 87 82 116 
-205 58 88 117 
-206 95 96 124 
-207 97 63 118 
-208 90 92 118 
-209 63 117 118 
-210 96 42 125 
-211 117 90 118 
-212 89 50 119 
-213 30 31 119 
-214 21 22 120 
-215 39 40 121 
-216 12 13 123 
-217 76 70 124 
-218 42 37 125 
-219 38 52 125 
-220 93 46 135 
-221 101 102 127 
-222 81 86 127 
-223 50 30 119 
-224 49 21 120 
-225 52 39 121 
-226 51 12 123 
-227 105 48 128 
-228 70 74 124 
-229 53 33 129 
-230 34 46 129 
-231 115 84 134 
-232 36 42 135 
-233 46 35 135 
-234 44 99 136 
-235 3 23 138 
-236 4 32 139 
-237 22 3 138 
-238 2 14 140 
-239 13 2 140 
-240 1 5 141 
-241 40 1 141 
-242 31 4 139 
-243 37 38 125 
-244 56 107 126 
-245 122 106 137 
-246 47 101 127 
-247 110 76 137 
-248 79 102 136 
-249 106 105 128 
-250 83 79 136 
-251 130 116 131 
-252 48 103 133 
-253 131 85 132 
-254 85 78 132 
-255 116 85 131 
-256 33 34 129 
-257 87 116 130 
-258 43 100 131 
-259 100 130 131 
-260 100 51 130 
-261 43 131 132 
-262 103 43 132 
-263 78 110 133 
-264 132 78 133 
-265 103 132 133 
-266 84 83 134 
-267 35 36 135 
-268 102 44 136 
-269 51 123 142 
-270 119 31 139 
-271 121 40 141 
-272 120 22 138 
-273 123 13 140 
-274 23 54 138 
-275 32 53 139 
-276 14 56 140 
-277 5 55 141 
-278 128 110 137 
-279 53 119 139 
-280 54 120 138 
-281 55 121 141 
-282 56 123 140 
-283 106 128 137 
-284 126 87 142 
-285 87 130 142 
-286 130 51 142 
-$EndElements
diff --git a/tests/test_circumcenter.py b/tests/test_circumcenter.py
index 2f827ff..57382b0 100644
--- a/tests/test_circumcenter.py
+++ b/tests/test_circumcenter.py
@@ -1,29 +1,22 @@
 import numpy as np
 import dctkit
 from dctkit.mesh import util
-from dctkit.math import circumcenter as circ
+from dctkit.mesh import circumcenter as circ
 import os
 
 cwd = os.path.dirname(__file__)
 
 
 def test_circumcenter(setup_test):
+    mesh, _ = util.generate_square_mesh(1.0)
+    S2 = mesh.cells_dict["triangle"]
+    node_coords = mesh.points
 
-    filename = "data/test1.msh"
-    full_path = os.path.join(cwd, filename)
-    numNodes, numElements, S_2, node_coord, _ = util.read_mesh(full_path)
-
-    print(f"The number of nodes in the mesh is {numNodes}")
-    print(f"The number of faces in the mesh is {numElements}")
-    print(f"The vectorization of the face matrix is \n {S_2}")
-    print(f"The coordinates of the nodes are \n {node_coord}")
-
-    circ_true = np.empty((numElements, S_2.shape[1]), dtype=dctkit.float_dtype)
-    circ_true[0, :] = np.array([0.5, 0, 0], dtype=dctkit.float_dtype)
-    circ_true[1, :] = np.array([1, 0.5, 0], dtype=dctkit.float_dtype)
-    circ_true[2, :] = np.array([0, 0.5, 0], dtype=dctkit.float_dtype)
-    circ_true[3, :] = np.array([0.5, 1, 0], dtype=dctkit.float_dtype)
-    for i in range(numElements):
-        circ_i = circ.circumcenter(S_2[i, :], node_coord)[0]
-        assert circ_i.dtype == dctkit.float_dtype
-        assert np.allclose(circ_i, circ_true[i, :])
+    circs_true = np.array([[0.5, 0, 0], [0, 0.5, 0], [1, 0.5, 0], [0.5, 1, 0]],
+                          dtype=dctkit.float_dtype)
+    bary_true = np.array([[0.5, 0.5, 0], [0.5, 0.5, 0], [0.5, 0.5, 0], [0.5, 0.5, 0]],
+                         dtype=dctkit.float_dtype)
+    circs, bary = circ.circumcenter(S2, node_coords)
+    assert circs.dtype == dctkit.float_dtype
+    assert np.allclose(circs, circs_true)
+    assert np.allclose(bary, bary_true)
diff --git a/tests/test_cochain.py b/tests/test_cochain.py
index 056048c..d65deba 100644
--- a/tests/test_cochain.py
+++ b/tests/test_cochain.py
@@ -1,125 +1,527 @@
 import numpy as np
 import dctkit
-from dctkit.mesh import simplex, util
-from dctkit.dec import cochain
-import os
-import matplotlib.tri as tri
-import matplotlib.pyplot as plt
-
-cwd = os.path.dirname(__file__)
-
-# FIXME: tests should involve different dimensions (of cochains and complex)
-
-
-def test_cochain(setup_test):
-    filename = "data/test1.msh"
-    full_path = os.path.join(cwd, filename)
-    numNodes, numElements, S_2, node_coord, _ = util.read_mesh(full_path)
-
-    print(f"The number of nodes in the mesh is {numNodes}")
-    print(f"The number of faces in the mesh is {numElements}")
-    print(f"The vectorization of the face matrix is \n {S_2}")
-
-    v_0 = np.array([1, 2, 3, 4, 5], dtype=dctkit.float_dtype)
-    v_1 = np.array([1, 2, 3, 4, 5, 6, 7, 8], dtype=dctkit.float_dtype)
-    cpx = simplex.SimplicialComplex(S_2, node_coord)
-    c_0 = cochain.Cochain(dim=0, is_primal=True, complex=cpx, coeffs=v_0)
-    c_1 = cochain.Cochain(dim=1, is_primal=True, complex=cpx, coeffs=v_1)
-
-    # coboundary test
-    dc_0 = cochain.coboundary(c_0)
-    dc_1 = cochain.coboundary(c_1)
-    dc_v_0_true = np.array([1, 2, 4, 2, 3, 1, 2, 1], dtype=dctkit.float_dtype)
-    dc_v_1_true = np.array([3, -6, 7, -7], dtype=dctkit.float_dtype)
-    dc_0_true = cochain.Cochain(dim=0, is_primal=True, complex=cpx, coeffs=dc_v_0_true)
-    dc_1_true = cochain.Cochain(dim=1, is_primal=True, complex=cpx, coeffs=dc_v_1_true)
-
-    assert dc_0.coeffs.dtype == dctkit.float_dtype
-
-    assert np.allclose(dc_0.coeffs, dc_0_true.coeffs)
-    assert np.allclose(dc_1.coeffs, dc_1_true.coeffs)
-
-    # hodge star test
-    cpx.get_circumcenters()
-    cpx.get_primal_volumes()
-    cpx.get_dual_volumes()
-    cpx.get_hodge_star()
-    star_c_0 = cochain.star(c_0)
-    coeffs_0 = star_c_0.coeffs
-    coeffs_0_true = np.array([1/8, 1/4, 3/8, 1/2, 5/2], dtype=dctkit.float_dtype)
-    star_c_1 = cochain.star(c_1)
-    coeffs_1 = star_c_1.coeffs
-    coeffs_1_true = np.array([0, 0, 3, 0, 5, 0, 7, 8], dtype=dctkit.float_dtype)
-
-    assert coeffs_0.dtype == dctkit.float_dtype
-    assert coeffs_1.dtype == dctkit.float_dtype
-
-    assert np.allclose(coeffs_0, coeffs_0_true)
-    assert np.allclose(coeffs_1, coeffs_1_true)
-
-    # primal codifferential test (we need a well-centered mesh)
-
-    _, _, S_2_new, node_coords_new, _ = util.generate_square_mesh(0.4)
-    triang = tri.Triangulation(node_coords_new[:, 0], node_coords_new[:, 1])
-
-    plt.triplot(triang, 'ko-')
-    plt.show()
-
-    cpx_new = simplex.SimplicialComplex(S_2_new, node_coords_new, is_well_centered=True)
-    cpx_new.get_circumcenters()
-    cpx_new.get_primal_volumes()
-    cpx_new.get_dual_volumes()
-    cpx_new.get_hodge_star()
-
-    num_0 = cpx_new.num_nodes
-    num_1 = cpx_new.S[1].shape[0]
-    num_2 = cpx_new.S[2].shape[0]
-    v = np.random.rand(num_1).astype(dtype=dctkit.float_dtype)
-    w = np.random.rand(num_2).astype(dtype=dctkit.float_dtype)
-    c = cochain.Cochain(dim=1, is_primal=True, complex=cpx_new, coeffs=v)
-    d = cochain.Cochain(dim=2, is_primal=True, complex=cpx_new, coeffs=w)
-    inner_product_standard = cochain.inner_product(cochain.coboundary(c), d)
-    inner_product_codiff = cochain.inner_product(c, cochain.codifferential(d))
-
-    assert inner_product_standard.dtype == dctkit.float_dtype
-    assert np.allclose(inner_product_standard, inner_product_codiff)
-
-    # dual codifferential test 1D
-    S_1, x = util.generate_1_D_mesh(10, 1)
-    S = simplex.SimplicialComplex(S_1, x, is_well_centered=True)
-    S.get_circumcenters()
-    S.get_primal_volumes()
-    S.get_dual_volumes()
-    S.get_hodge_star()
-    n_0 = S.num_nodes
-    n_1 = S.S[1].shape[0]
-    a_vec = np.arange(n_1, dtype=dctkit.float_dtype)
-    b_vec = np.arange(n_0, dtype=dctkit.float_dtype)
-    a = cochain.Cochain(dim=0, is_primal=False, complex=S, coeffs=a_vec)
-    b = cochain.Cochain(dim=1, is_primal=False, complex=S, coeffs=b_vec)
-    dual_inner = cochain.inner_product(cochain.coboundary(a), b)
-    dual_cod_inner = cochain.inner_product(a, cochain.codifferential(b))
-    assert np.allclose(dual_inner, dual_cod_inner)
-
-    # dual codifferential test 2D
-    alpha0_vec = np.arange(num_2, dtype=dctkit.float_dtype)
-    alpha1_vec = np.arange(num_1, dtype=dctkit.float_dtype)
-    alpha2_vec = np.arange(num_0, dtype=dctkit.float_dtype)
-    alpha0 = cochain.Cochain(dim=0, is_primal=False, complex=cpx_new, coeffs=alpha0_vec)
-    alpha1 = cochain.Cochain(dim=1, is_primal=False, complex=cpx_new, coeffs=alpha1_vec)
-    alpha2 = cochain.Cochain(dim=2, is_primal=False, complex=cpx_new, coeffs=alpha2_vec)
-    dual_inner_1 = cochain.inner_product(cochain.coboundary(alpha0), alpha1)
-    dual_inner_2 = cochain.inner_product(cochain.coboundary(alpha1), alpha2)
-    dual_cod_inner_1 = cochain.inner_product(alpha0, cochain.codifferential(alpha1))
-    dual_cod_inner_2 = cochain.inner_product(alpha1, cochain.codifferential(alpha2))
-    assert np.allclose(dual_inner_1, dual_cod_inner_1)
-    assert np.allclose(dual_inner_2, dual_cod_inner_2)
-
-    # inner product test
-    v_0_2 = np.array([5, 6, 7, 8, 9], dtype=dctkit.float_dtype)
-    c_0_2 = cochain.Cochain(dim=0, is_primal=True, complex=cpx, coeffs=v_0_2)
-    inner_product = cochain.inner_product(c_0, c_0_2)
-    inner_product_true = 5/8 + 3/2 + 21/8 + 4 + 45/2
-
-    assert inner_product.dtype == dctkit.float_dtype
-    assert np.allclose(inner_product, inner_product_true)
+from dctkit.mesh import util
+from dctkit.dec import cochain as C
+
+
+def test_coboundary(setup_test):
+    mesh_1, _ = util.generate_line_mesh(5, 1.)
+    mesh_2, _ = util.generate_square_mesh(1.0)
+    mesh_3, _ = util.generate_tet_mesh(2.0)
+    S_1 = util.build_complex_from_mesh(mesh_1)
+    S_2 = util.build_complex_from_mesh(mesh_2, is_well_centered=False)
+    S_3 = util.build_complex_from_mesh(mesh_3)
+
+    # 1D test
+    vP0 = np.array([1, 2, 3, 4, 5], dtype=dctkit.float_dtype)
+    vD0 = np.array([1, 2, 3, 4], dtype=dctkit.float_dtype)
+    cP0 = C.CochainP0(complex=S_1, coeffs=vP0)
+    cD0 = C.CochainD0(complex=S_1, coeffs=vD0)
+    dcP0 = C.coboundary(cP0)
+    dcD0 = C.coboundary(cD0)
+    dc_all = [dcP0, dcD0]
+    dcP0_true = np.array([1., 1., 1., 1.], dtype=dctkit.float_dtype)
+    dcD0_true = np.array([1.,  1.,  1.,  1., -4.], dtype=dctkit.float_dtype)
+    dc_true_all = [dcP0_true, dcD0_true]
+
+    for i in range(2):
+        assert np.allclose(dc_all[i].coeffs, dc_true_all[i])
+
+    # 2D test
+    vP0 = np.array([1, 2, 3, 4, 5], dtype=dctkit.float_dtype)
+    vP1 = np.array([1, 2, 3, 4, 5, 6, 7, 8], dtype=dctkit.float_dtype)
+    vD0 = np.array([1, 2, 3, 4], dtype=dctkit.float_dtype)
+    vD1 = np.array([1, 2, 3, 4, 5, 6, 7, 8], dtype=dctkit.float_dtype)
+    cP0 = C.CochainP0(complex=S_2, coeffs=vP0)
+    cP1 = C.CochainP1(complex=S_2, coeffs=vP1)
+    cD0 = C.CochainD0(complex=S_2, coeffs=vD0)
+    cD1 = C.CochainD1(complex=S_2, coeffs=vD1)
+
+    dcP0 = C.coboundary(cP0)
+    dcP1 = C.coboundary(cP1)
+    dcD0 = C.coboundary(cD0)
+    dcD1 = C.coboundary(cD1)
+    dc_all = [dcP0, dcP1, dcD0, dcD1]
+    dcP0_true = np.array([1, 3, 4, 1, 3, 1, 2, 1], dtype=dctkit.float_dtype)
+    dcP1_true = np.array([3, -7, 6, 7], dtype=dctkit.float_dtype)
+    dcD0_true = np.array([1, -2, 1, 3, -2, 4, -1, 2], dtype=dctkit.float_dtype)
+    dcD1_true = np.array([6,   8,   9,  -0, -23], dtype=dctkit.float_dtype)
+    dc_true_all = [dcP0_true, dcP1_true, dcD0_true, dcD1_true]
+
+    for i in range(4):
+        assert np.allclose(dc_all[i].coeffs, dc_true_all[i])
+
+    # 3D test
+    vP0 = np.array([1, 2, 3, 4], dtype=dctkit.float_dtype)
+    vP1 = np.array([1, 2, 3, 4, 5, 6], dtype=dctkit.float_dtype)
+    vP2 = np.array([1, 2, 3, 4], dtype=dctkit.float_dtype)
+    vD0 = np.array([1], dtype=dctkit.float_dtype)
+    vD1 = np.array([1, 2, 3, 4], dtype=dctkit.float_dtype)
+    vD2 = np.array([1, 2, 3, 4, 5, 6], dtype=dctkit.float_dtype)
+
+    cP0 = C.CochainP0(complex=S_3, coeffs=vP0)
+    cP1 = C.CochainP1(complex=S_3, coeffs=vP1)
+    cP2 = C.CochainP2(complex=S_3, coeffs=vP2)
+    cD0 = C.CochainD0(complex=S_3, coeffs=vD0)
+    cD1 = C.CochainD1(complex=S_3, coeffs=vD1)
+    cD2 = C.CochainD2(complex=S_3, coeffs=vD2)
+
+    dcP0 = C.coboundary(cP0)
+    dcP1 = C.coboundary(cP1)
+    dcP2 = C.coboundary(cP2)
+    dcD0 = C.coboundary(cD0)
+    dcD1 = C.coboundary(cD1)
+    dcD2 = C.coboundary(cD2)
+    dc_all = [dcP0, dcP1, dcP2, dcD0, dcD1, dcD2]
+    dcP0_true = np.array([1, 2, 3, 1, 2, 1], dtype=dctkit.float_dtype)
+    dcP1_true = np.array([3, 3, 5, 5], dtype=dctkit.float_dtype)
+    dcP2_true = np.array([2], dtype=dctkit.float_dtype)
+    dcD0_true = np.array([1, -1,  1, -1], dtype=dctkit.float_dtype)
+    dcD1_true = np.array([3,  2, -5,  5, -2,  7], dtype=dctkit.float_dtype)
+    dcD2_true = np.array([6,   8,  -0, -14], dtype=dctkit.float_dtype)
+    dc_true_all = [dcP0_true, dcP1_true, dcP2_true, dcD0_true, dcD1_true, dcD2_true]
+
+    for i in range(6):
+        assert np.allclose(dc_all[i].coeffs, dc_true_all[i])
+
+    # vector-valued test
+    cP0_v_coeffs = np.arange(15, dtype=dctkit.float_dtype).reshape((5, 3))
+    cP1_v_coeffs = np.arange(24, dtype=dctkit.float_dtype).reshape((8, 3))
+    cD0_v_coeffs = np.arange(12, dtype=dctkit.float_dtype).reshape((4, 3))
+    cD1_v_coeffs = np.arange(24, dtype=dctkit.float_dtype).reshape((8, 3))
+    cP0_v = C.CochainP0(S_2, cP0_v_coeffs)
+    cP1_v = C.CochainP1(S_2, cP1_v_coeffs)
+    cD0_v = C.CochainD0(S_2, cD0_v_coeffs)
+    cD1_v = C.CochainD1(S_2, cD1_v_coeffs)
+    dcP0_v = C.coboundary(cP0_v)
+    dcP1_v = C.coboundary(cP1_v)
+    dcD0_v = C.coboundary(cD0_v)
+    dcD1_v = C.coboundary(cD1_v)
+    dc_all = [dcP0_v, dcP1_v, dcD0_v, dcD1_v]
+    dcP0_v_true = np.array([[3, 3, 3],
+                           [9,  9,  9],
+                           [12, 12, 12],
+                           [3, 3, 3],
+                           [9, 9, 9],
+                           [3, 3, 3],
+                           [6, 6, 6],
+                           [3, 3, 3]], dtype=dctkit.float_dtype)
+    dcP1_v_true = np.array([[6, 7, 8],
+                           [-18, -19, -20],
+                           [15, 16, 17],
+                           [18, 19, 20]], dtype=dctkit.float_dtype)
+    dcD0_v_true = np.array([[0,  1,  2],
+                            [-3, -4, -5],
+                            [3,  3,  3],
+                            [6,  7,  8],
+                            [-6, -6, -6],
+                            [9, 10, 11],
+                            [-3, -3, -3],
+                            [6,  6,  6]], dtype=dctkit.float_dtype)
+    dcD1_v_true = np.array([[9,  12,  15],
+                            [21,  22,  23],
+                            [24,  25,  26],
+                            [3,   2,   1],
+                            [-57, -61, -65]], dtype=dctkit.float_dtype)
+    dc_true_all = [dcP0_v_true, dcP1_v_true, dcD0_v_true, dcD1_v_true]
+
+    for i in range(4):
+        assert np.allclose(dc_all[i].coeffs, dc_true_all[i])
+
+
+def test_hodge_star(setup_test):
+    mesh_1, _ = util.generate_line_mesh(5, 1.)
+    mesh_2, _ = util.generate_square_mesh(0.8)
+    mesh_3, _ = util.generate_tet_mesh(2.0)
+    S_1 = util.build_complex_from_mesh(mesh_1)
+    S_2 = util.build_complex_from_mesh(mesh_2)
+    S_3 = util.build_complex_from_mesh(mesh_3)
+    S_1.get_hodge_star()
+    S_2.get_hodge_star()
+    S_3.get_hodge_star()
+
+    # 1D test
+    vP0 = np.array([1, 2, 3, 4, 5], dtype=dctkit.float_dtype)
+    vP1 = np.array([1, 2, 3, 4], dtype=dctkit.float_dtype)
+
+    cP0 = C.CochainP0(complex=S_1, coeffs=vP0)
+    cP1 = C.CochainP1(complex=S_1, coeffs=vP1)
+    c_all = [cP0, cP1]
+
+    star_cP0 = C.star(cP0)
+    star_cP1 = C.star(cP1)
+    star_invP0 = C.star(star_cP0)
+    star_invP1 = C.star(star_cP1)
+    star_all = [star_cP0, star_cP1]
+    star_inv_all = [star_invP0, star_invP1]
+    star_cP0_true = np.array([0.125, 0.5, 0.75, 1., 0.625], dtype=dctkit.float_dtype)
+    star_cP1_true = np.array([4.,  8., 12., 16.], dtype=dctkit.float_dtype)
+    star_true_all = [star_cP0_true, star_cP1_true]
+
+    for i in range(2):
+        assert np.allclose(star_all[i].coeffs, star_true_all[i])
+        assert np.allclose(star_inv_all[i].coeffs, (-1)
+                           ** (i*(S_1.dim-i))*c_all[i].coeffs)
+
+    # 2D test
+    vP0 = np.arange(1, 13, dtype=dctkit.float_dtype)
+    vP1 = np.arange(1, 26, dtype=dctkit.float_dtype)
+    vP2 = np.arange(1, 15, dtype=dctkit.float_dtype)
+
+    cP0 = C.CochainP0(complex=S_2, coeffs=vP0)
+    cP1 = C.CochainP1(complex=S_2, coeffs=vP1)
+    cP2 = C.CochainP2(complex=S_2, coeffs=vP2)
+    c_all = [cP0, cP1, cP2]
+
+    star_cP0 = C.star(cP0)
+    star_cP1 = C.star(cP1)
+    star_cP2 = C.star(cP2)
+    star_invP0 = C.star(star_cP0)
+    star_invP1 = C.star(star_cP1)
+    star_invP2 = C.star(star_cP2)
+    star_all = [star_cP0, star_cP1, star_cP2]
+    star_inv_all = [star_invP0, star_invP1, star_invP2]
+    star_cP0_true = np.array([0.0546875, 0.07714844, 0.15560322, 0.16492188,
+                              0.36824544, 0.42319261, 0.50444237, 0.59590218,
+                              1.11520924, 1.37589165, 1.50811261, 1.49166558],
+                             dtype=dctkit.float_dtype)
+    star_cP1_true = np.array([0.25,  0.5,  1.,  0.25,  0.3125,
+                              4.66666667,  1.44642505,  1.68050682,  3.70569916,
+                              0.875, 0.9625,  8.42553191,  9.20833333, 11.66666667,
+                              11.38033168, 13.24818921, 13.92687454, 13.10409096,
+                              15.48630137, 13.89726027, 15.23812097, 13.52634108,
+                              10.75613978, 15.94348786, 14.46332164],
+                             dtype=dctkit.float_dtype)
+    star_cP2_true = np.array([11.36094675,  21.33333333,  32.,  44.9122807,
+                              71.11111111,  85.33333333,  95.31914894, 108.93617021,
+                              153.2594235, 175.34246575, 196.00928074, 204.8,
+                              220.39735099, 239.46547884], dtype=dctkit.float_dtype)
+    star_true_all = [star_cP0_true, star_cP1_true, star_cP2_true]
+
+    for i in range(3):
+        assert np.allclose(star_all[i].coeffs, star_true_all[i])
+        assert np.allclose(star_inv_all[i].coeffs, (-1)
+                           ** (i*(S_2.dim-i))*c_all[i].coeffs)
+
+    # 3D test
+    vP0 = np.array([1, 2, 3, 4], dtype=dctkit.float_dtype)
+    vP1 = np.array([1, 2, 3, 4, 5, 6], dtype=dctkit.float_dtype)
+    vP2 = np.array([1, 2, 3, 4], dtype=dctkit.float_dtype)
+    vP3 = np.array([1], dtype=dctkit.float_dtype)
+
+    cP0 = C.CochainP0(complex=S_3, coeffs=vP0)
+    cP1 = C.CochainP1(complex=S_3, coeffs=vP1)
+    cP2 = C.CochainP2(complex=S_3, coeffs=vP2)
+    cP3 = C.CochainP3(complex=S_3, coeffs=vP3)
+    c_all = [cP0, cP1, cP2, cP3]
+
+    star_cP0 = C.star(cP0)
+    star_cP1 = C.star(cP1)
+    star_cP2 = C.star(cP2)
+    star_cP3 = C.star(cP3)
+    star_invP0 = C.star(star_cP0)
+    star_invP1 = C.star(star_cP1)
+    star_invP2 = C.star(star_cP2)
+    star_invP3 = C.star(star_cP3)
+    star_all = [star_cP0, star_cP1, star_cP2, star_cP3]
+    star_inv_all = [star_invP0, star_invP1, star_invP2, star_invP3]
+
+    star_cP0_true = np.array([0.0859375, 0.06510417, 0.0859375, 0.078125],
+                             dtype=dctkit.float_dtype)
+    star_cP1_true = np.array([0.1875,  0.25,  0.515625,  0.125, -0.078125, -0.0625],
+                             dtype=dctkit.float_dtype)
+    star_cP2_true = np.array([1.,  1.5,  1.5, -0.66666667], dtype=dctkit.float_dtype)
+    star_cP3_true = np.array([6.], dtype=dctkit.float_dtype)
+    star_true_all = [star_cP0_true, star_cP1_true, star_cP2_true, star_cP3_true]
+
+    for i in range(4):
+        assert np.allclose(star_all[i].coeffs, star_true_all[i])
+        assert np.allclose(star_inv_all[i].coeffs, (-1)
+                           ** (i*(S_3.dim-i))*c_all[i].coeffs)
+
+    # vector-valued test
+    cP0_v_coeffs = np.arange(36, dtype=dctkit.float_dtype).reshape((12, 3))
+    cP1_v_coeffs = np.arange(75, dtype=dctkit.float_dtype).reshape((25, 3))
+    cP2_v_coeffs = np.arange(42, dtype=dctkit.float_dtype).reshape((14, 3))
+
+    cP0_v = C.CochainP0(S_2, cP0_v_coeffs)
+    cP1_v = C.CochainP1(S_2, cP1_v_coeffs)
+    cP2_v = C.CochainP2(S_2, cP2_v_coeffs)
+    c_all = [cP0_v, cP1_v, cP2_v]
+
+    star_cP0_v = C.star(cP0_v)
+    star_cP1_v = C.star(cP1_v)
+    star_cP2_v = C.star(cP2_v)
+    star_invP0_v = C.star(star_cP0_v)
+    star_invP1_v = C.star(star_cP1_v)
+    star_invP2_v = C.star(star_cP2_v)
+    star_all = [star_cP0_v, star_cP1_v, star_cP2_v]
+    star_inv_all = [star_invP0_v, star_invP1_v, star_invP2_v]
+    star_cP0_v_true = np.array([[0., 0.0546875, 0.109375],
+                                [0.11572266, 0.15429688, 0.19287109],
+                                [0.31120643, 0.36307417, 0.41494191],
+                                [0.37107422, 0.41230469, 0.45353516],
+                                [0.88378906, 0.95743815, 1.03108724],
+                                [1.05798153, 1.12851363, 1.19904573],
+                                [1.29713753, 1.36920072, 1.44126392],
+                                [1.56424323, 1.638731, 1.71321878],
+                                [2.9738913, 3.09780344, 3.22171557],
+                                [3.71490746, 3.85249663, 3.99008579],
+                                [4.1130344, 4.25013555, 4.38723669],
+                                [4.10208035, 4.22638582, 4.35069128]],
+                               dtype=dctkit.float_dtype)
+    star_cP1_v_true = np.array([[0.,  0.25,  0.5],
+                                [0.75,  1.,  1.25],
+                                [2.,  2.33333333,  2.66666667],
+                                [0.5625,  0.625,  0.6875],
+                                [0.75,  0.8125,  0.875],
+                                [11.66666667, 12.44444444, 13.22222222],
+                                [3.7193787,  3.92601085,  4.132643],
+                                [4.41133041,  4.62139376,  4.83145712],
+                                [9.88186442, 10.29360878, 10.70535313],
+                                [2.3625,  2.45,  2.5375],
+                                [2.625,  2.7125,  2.8],
+                                [23.17021277, 23.87234043, 24.57446809],
+                                [25.5, 26.20833333, 26.91666667],
+                                [32.5, 33.33333333, 34.16666667],
+                                [31.86492869, 32.62361747, 33.38230625],
+                                [37.26053215, 38.08854398, 38.9165558],
+                                [39.32293987, 40.14216778, 40.96139569],
+                                [37.12825773, 37.85626278, 38.58426783],
+                                [44.01369863, 44.82876712, 45.64383562],
+                                [39.60719178, 40.30205479, 40.99691781],
+                                [43.53748848, 44.26311329, 44.98873809],
+                                [38.73452219, 39.34935588, 39.96418956],
+                                [30.8654446, 31.33310285, 31.8007611],
+                                [45.83752759, 46.50183959, 47.16615158],
+                                [41.65436631, 42.23289917, 42.81143204]],
+                               dtype=dctkit.float_dtype)
+    star_cP2_v_true = np.array([[0.,  11.36094675,  22.72189349],
+                                [32.,  42.66666667,  53.33333333],
+                                [64.,  74.66666667,  85.33333333],
+                                [101.05263158, 112.28070175, 123.50877193],
+                                [170.66666667, 184.88888889, 199.11111111],
+                                [213.33333333, 227.55555556, 241.77777778],
+                                [245.10638298, 258.72340425, 272.34042553],
+                                [285.95744681, 299.57446809, 313.19148936],
+                                [408.69179601, 425.72062084, 442.74944568],
+                                [473.42465753, 490.95890411, 508.49315069],
+                                [534.57076566, 552.38979118, 570.20881671],
+                                [563.2, 580.26666667, 597.33333333],
+                                [610.33112583, 627.28476821, 644.2384106],
+                                [667.08240535, 684.18708241, 701.29175947]],
+                               dtype=dctkit.float_dtype)
+    star_true_all = [star_cP0_v_true, star_cP1_v_true, star_cP2_v_true]
+
+    for i in range(3):
+        assert np.allclose(star_all[i].coeffs, star_true_all[i])
+        assert np.allclose(star_inv_all[i].coeffs, (-1)
+                           ** (i*(S_2.dim-i))*c_all[i].coeffs)
+
+
+def test_inner_product(setup_test):
+    mesh_1, _ = util.generate_line_mesh(5, 1.)
+    mesh_2, _ = util.generate_square_mesh(1.0)
+    mesh_3, _ = util.generate_tet_mesh(2.0)
+    S_1 = util.build_complex_from_mesh(mesh_1)
+    S_2 = util.build_complex_from_mesh(mesh_2, is_well_centered=False)
+    S_3 = util.build_complex_from_mesh(mesh_3)
+    S_1.get_hodge_star()
+    S_2.get_hodge_star()
+    S_3.get_hodge_star()
+
+    # 1D test
+    vP0_1 = np.array([1, 2, 3, 4, 5], dtype=dctkit.float_dtype)
+    vP0_2 = np.array([6, 7, 8, 9, 10], dtype=dctkit.float_dtype)
+    vP1_1 = np.array([1, 2, 3, 4], dtype=dctkit.float_dtype)
+    vP1_2 = np.array([5, 6, 7, 8], dtype=dctkit.float_dtype)
+
+    cP0_1 = C.CochainP0(complex=S_1, coeffs=vP0_1)
+    cP0_2 = C.CochainP0(complex=S_1, coeffs=vP0_2)
+    cP1_1 = C.CochainP1(complex=S_1, coeffs=vP1_1)
+    cP1_2 = C.CochainP1(complex=S_1, coeffs=vP1_2)
+
+    inner_productP0 = C.inner_product(cP0_1, cP0_2)
+    inner_productP1 = C.inner_product(cP1_1, cP1_2)
+    inner_product_all = [inner_productP0, inner_productP1]
+    inner_productP0_true = np.dot(vP0_1, S_1.hodge_star[0]*vP0_2)
+    inner_productP1_true = np.dot(vP1_1, S_1.hodge_star[1]*vP1_2)
+    inner_product_true_all = [inner_productP0_true, inner_productP1_true]
+
+    for i in range(2):
+        assert np.allclose(inner_product_all[i], inner_product_true_all[i])
+
+    # 2D test
+    vP0_1 = np.array([1, 2, 3, 4, 5], dtype=dctkit.float_dtype)
+    vP0_2 = np.array([6, 7, 8, 9, 10], dtype=dctkit.float_dtype)
+    vP1_1 = np.array([1, 2, 3, 4, 5, 6, 7, 8], dtype=dctkit.float_dtype)
+    vP1_2 = np.array([9, 10, 11, 12, 13, 14, 15, 16], dtype=dctkit.float_dtype)
+    vP2_1 = np.array([1, 2, 3, 4], dtype=dctkit.float_dtype)
+    vP2_2 = np.array([5, 6, 7, 8], dtype=dctkit.float_dtype)
+
+    cP0_1 = C.CochainP0(complex=S_2, coeffs=vP0_1)
+    cP0_2 = C.CochainP0(complex=S_2, coeffs=vP0_2)
+    cP1_1 = C.CochainP1(complex=S_2, coeffs=vP1_1)
+    cP1_2 = C.CochainP1(complex=S_2, coeffs=vP1_2)
+    cP2_1 = C.CochainP2(complex=S_2, coeffs=vP2_1)
+    cP2_2 = C.CochainP2(complex=S_2, coeffs=vP2_2)
+
+    inner_productP0 = C.inner_product(cP0_1, cP0_2)
+    inner_productP1 = C.inner_product(cP1_1, cP1_2)
+    inner_productP2 = C.inner_product(cP2_1, cP2_2)
+    inner_product_all = [inner_productP0, inner_productP1, inner_productP2]
+    inner_productP0_true = np.dot(vP0_1, S_2.hodge_star[0]*vP0_2)
+    inner_productP1_true = np.dot(vP1_1, S_2.hodge_star[1]*vP1_2)
+    inner_productP2_true = np.dot(vP2_1, S_2.hodge_star[2]*vP2_2)
+    inner_product_true_all = [inner_productP0_true,
+                              inner_productP1_true, inner_productP2_true]
+
+    for i in range(3):
+        assert np.allclose(inner_product_all[i], inner_product_true_all[i])
+
+    # 3D test
+
+    vP0_1 = np.array([1, 2, 3, 4], dtype=dctkit.float_dtype)
+    vP0_2 = np.array([5, 6, 7, 8], dtype=dctkit.float_dtype)
+    vP1_1 = np.array([1, 2, 3, 4, 5, 6], dtype=dctkit.float_dtype)
+    vP1_2 = np.array([7, 8, 9, 10, 11, 12], dtype=dctkit.float_dtype)
+    vP2_1 = np.array([1, 2, 3, 4], dtype=dctkit.float_dtype)
+    vP2_2 = np.array([5, 6, 7, 8], dtype=dctkit.float_dtype)
+    vP3_1 = np.array([1], dtype=dctkit.float_dtype)
+    vP3_2 = np.array([2], dtype=dctkit.float_dtype)
+
+    cP0_1 = C.CochainP0(complex=S_3, coeffs=vP0_1)
+    cP0_2 = C.CochainP0(complex=S_3, coeffs=vP0_2)
+    cP1_1 = C.CochainP1(complex=S_3, coeffs=vP1_1)
+    cP1_2 = C.CochainP1(complex=S_3, coeffs=vP1_2)
+    cP2_1 = C.CochainP2(complex=S_3, coeffs=vP2_1)
+    cP2_2 = C.CochainP2(complex=S_3, coeffs=vP2_2)
+    cP3_1 = C.CochainP3(complex=S_3, coeffs=vP3_1)
+    cP3_2 = C.CochainP3(complex=S_3, coeffs=vP3_2)
+
+    inner_productP0 = C.inner_product(cP0_1, cP0_2)
+    inner_productP1 = C.inner_product(cP1_1, cP1_2)
+    inner_productP2 = C.inner_product(cP2_1, cP2_2)
+    inner_productP3 = C.inner_product(cP3_1, cP3_2)
+    inner_product_all = [inner_productP0,
+                         inner_productP1, inner_productP2, inner_productP3]
+    inner_productP0_true = np.dot(vP0_1, S_3.hodge_star[0]*vP0_2)
+    inner_productP1_true = np.dot(vP1_1, S_3.hodge_star[1]*vP1_2)
+    inner_productP2_true = np.dot(vP2_1, S_3.hodge_star[2]*vP2_2)
+    inner_productP3_true = np.dot(vP3_1, S_3.hodge_star[3]*vP3_2)
+    inner_product_true_all = [inner_productP0_true,
+                              inner_productP1_true,
+                              inner_productP2_true,
+                              inner_productP3_true]
+
+    for i in range(4):
+        assert np.allclose(inner_product_all[i], inner_product_true_all[i])
+
+
+def test_codifferential(setup_test):
+    mesh_1, _ = util.generate_line_mesh(5, 1.)
+    mesh_2, _ = util.generate_square_mesh(0.8)
+    mesh_3, _ = util.generate_tet_mesh(2.0)
+    S_1 = util.build_complex_from_mesh(mesh_1)
+    S_2 = util.build_complex_from_mesh(mesh_2)
+    S_3 = util.build_complex_from_mesh(mesh_3)
+    S_1.get_hodge_star()
+    S_2.get_hodge_star()
+    S_3.get_hodge_star()
+
+    # 1D test
+    n_0 = S_1.num_nodes
+    n_1 = S_1.S[1].shape[0]
+    vP0 = np.arange(n_0, dtype=dctkit.float_dtype)
+    vP1 = np.arange(n_1, dtype=dctkit.float_dtype)
+    vD0 = np.arange(n_1, dtype=dctkit.float_dtype)
+    vD1 = np.arange(n_0, dtype=dctkit.float_dtype)
+
+    cP0 = C.CochainP0(complex=S_1, coeffs=vP0)
+    cP1 = C.CochainP1(complex=S_1, coeffs=vP1)
+    cD0 = C.CochainD0(complex=S_1, coeffs=vD0)
+    cD1 = C.CochainD1(complex=S_1, coeffs=vD1)
+
+    innerP0P1 = C.inner_product(C.coboundary(cP0), cP1)
+    innerD0D1 = C.inner_product(C.coboundary(cD0), cD1)
+    inner_all = [innerP0P1, innerD0D1]
+    cod_innerP0P1 = C.inner_product(cP0, C.codifferential(cP1))
+    cod_innerD0D1 = C.inner_product(cD0, C.codifferential(cD1))
+    cod_inner_all = [cod_innerP0P1, cod_innerD0D1]
+
+    for i in range(2):
+        assert np.allclose(inner_all[i], cod_inner_all[i])
+
+    # 2D test
+    n_0 = S_2.num_nodes
+    n_1 = S_2.S[1].shape[0]
+    n_2 = S_2.S[2].shape[0]
+    vP0 = np.arange(n_0, dtype=dctkit.float_dtype)
+    vP1 = np.arange(n_1, dtype=dctkit.float_dtype)
+    vP2 = np.arange(n_2, dtype=dctkit.float_dtype)
+    vD0 = np.arange(n_2, dtype=dctkit.float_dtype)
+    vD1 = np.arange(n_1, dtype=dctkit.float_dtype)
+    vD2 = np.arange(n_0, dtype=dctkit.float_dtype)
+
+    cP0 = C.CochainP0(complex=S_2, coeffs=vP0)
+    cP1 = C.CochainP1(complex=S_2, coeffs=vP1)
+    cP2 = C.CochainP2(complex=S_2, coeffs=vP2)
+    cD0 = C.CochainD0(complex=S_2, coeffs=vD0)
+    cD1 = C.CochainD1(complex=S_2, coeffs=vD1)
+    cD2 = C.CochainD2(complex=S_2, coeffs=vD2)
+
+    innerP0P1 = C.inner_product(C.coboundary(cP0), cP1)
+    innerP1P2 = C.inner_product(C.coboundary(cP1), cP2)
+    innerD0D1 = C.inner_product(C.coboundary(cD0), cD1)
+    innerD1D2 = C.inner_product(C.coboundary(cD1), cD2)
+    inner_all = [innerP0P1, innerP1P2, innerD0D1, innerD1D2]
+    cod_innerP0P1 = C.inner_product(cP0, C.codifferential(cP1))
+    cod_innerP1P2 = C.inner_product(cP1, C.codifferential(cP2))
+    cod_innerD0D1 = C.inner_product(cD0, C.codifferential(cD1))
+    cod_innerD1D2 = C.inner_product(cD1, C.codifferential(cD2))
+    cod_inner_all = [cod_innerP0P1, cod_innerP1P2, cod_innerD0D1, cod_innerD1D2]
+
+    for i in range(4):
+        assert np.allclose(inner_all[i], cod_inner_all[i])
+
+    # 3D test
+    n_0 = S_3.num_nodes
+    n_1 = S_3.S[1].shape[0]
+    n_2 = S_3.S[2].shape[0]
+    n_3 = S_3.S[3].shape[0]
+    vP0 = np.arange(n_0, dtype=dctkit.float_dtype)
+    vP1 = np.arange(n_1, dtype=dctkit.float_dtype)
+    vP2 = np.arange(n_2, dtype=dctkit.float_dtype)
+    vP3 = np.arange(n_3, dtype=dctkit.float_dtype)
+    vD0 = np.arange(n_3, dtype=dctkit.float_dtype)
+    vD1 = np.arange(n_2, dtype=dctkit.float_dtype)
+    vD2 = np.arange(n_1, dtype=dctkit.float_dtype)
+    vD3 = np.arange(n_0, dtype=dctkit.float_dtype)
+
+    cP0 = C.CochainP0(complex=S_3, coeffs=vP0)
+    cP1 = C.CochainP1(complex=S_3, coeffs=vP1)
+    cP2 = C.CochainP2(complex=S_3, coeffs=vP2)
+    cP3 = C.CochainP3(complex=S_3, coeffs=vP3)
+    cD0 = C.CochainD0(complex=S_3, coeffs=vD0)
+    cD1 = C.CochainD1(complex=S_3, coeffs=vD1)
+    cD2 = C.CochainD2(complex=S_3, coeffs=vD2)
+    cD3 = C.CochainD3(complex=S_3, coeffs=vD3)
+
+    innerP0P1 = C.inner_product(C.coboundary(cP0), cP1)
+    innerP1P2 = C.inner_product(C.coboundary(cP1), cP2)
+    innerP2P3 = C.inner_product(C.coboundary(cP2), cP3)
+    innerD0D1 = C.inner_product(C.coboundary(cD0), cD1)
+    innerD1D2 = C.inner_product(C.coboundary(cD1), cD2)
+    innerD2D3 = C.inner_product(C.coboundary(cD2), cD3)
+    inner_all = [innerP0P1, innerP1P2, innerP2P3, innerD0D1, innerD1D2, innerD2D3]
+    cod_innerP0P1 = C.inner_product(cP0, C.codifferential(cP1))
+    cod_innerP1P2 = C.inner_product(cP1, C.codifferential(cP2))
+    cod_innerP2P3 = C.inner_product(cP2, C.codifferential(cP3))
+    cod_innerD0D1 = C.inner_product(cD0, C.codifferential(cD1))
+    cod_innerD1D2 = C.inner_product(cD1, C.codifferential(cD2))
+    cod_innerD2D3 = C.inner_product(cD2, C.codifferential(cD3))
+    cod_inner_all = [cod_innerP0P1, cod_innerP1P2,
+                     cod_innerP2P3, cod_innerD0D1, cod_innerD1D2, cod_innerD2D3]
+
+    for i in range(6):
+        assert np.allclose(inner_all[i], cod_inner_all[i])
diff --git a/tests/test_elastica.py b/tests/test_elastica.py
index c8452a2..c16db27 100644
--- a/tests/test_elastica.py
+++ b/tests/test_elastica.py
@@ -5,7 +5,7 @@
 from dctkit.math.opt import optctrl
 from scipy import sparse
 import os
-from dctkit.apps import elastica as el
+from dctkit.physics import elastica as el
 import numpy.typing as npt
 from dctkit.dec import cochain as C
 from typing import Tuple
@@ -107,14 +107,13 @@ def obj(x: npt.NDArray, theta_true: npt.NDArray) -> Array:
     theta = x[:-1]
     theta = np.insert(theta, 0, theta_true[0])
 
-    # reconstruct x, y
     x, y = reconstruct_xy(theta, h, num_nodes)
 
     error = np.linalg.norm(x - x_true) + np.linalg.norm(y - y_true)
     assert error <= 2e-2
 
 
-def test_elastica_equation(setup_test):
+def test_elastica_residual(setup_test):
     data = "data/xy_F_35.txt"
     F = -35.
     np.random.seed(42)
@@ -169,9 +168,7 @@ def obj(x: npt.NDArray) -> Array:
         moment = curv
 
         residual = C.sub(C.codifferential(C.star(moment)), load)
-        # mask_residual = C.cochain_mul(mask_coch, residual)
 
-        # return C.inner_product(mask_residual, mask_residual)
         return jnp.linalg.norm(residual.coeffs[1:])
 
     prb = optctrl.OptimizationProblem(
@@ -181,14 +178,13 @@ def obj(x: npt.NDArray) -> Array:
     sol = prb.run(x0=theta_0)
     theta = jnp.insert(sol, 0, theta_true[0])
 
-    # reconstruct x, y
     x, y = reconstruct_xy(theta, h, num_nodes)
 
     error = np.linalg.norm(x - x_true) + np.linalg.norm(y - y_true)
     assert error <= 2e-2
 
 
-def test_elastica_equation_tuneB(setup_test):
+def test_elastica_residual_tuneB(setup_test):
     data = "data/xy_F_35.txt"
     F = -35.
     np.random.seed(42)
@@ -245,9 +241,7 @@ def energy(theta: npt.NDArray, B, theta_0, F) -> Array:
         moment = curv
 
         residual = C.sub(C.codifferential(C.star(moment)), load)
-        # mask_residual = C.cochain_mul(mask_coch, residual)
 
-        # return jnp.linalg.norm(residual.coeffs[1:])
         return residual.coeffs[1:]
 
     energy_grad = energy
@@ -285,10 +279,7 @@ def obj(x: npt.NDArray, theta_true: npt.NDArray) -> Array:
     theta = x[:-1]
     theta = np.insert(theta, 0, theta_true[0])
 
-    # reconstruct x, y
     x, y = reconstruct_xy(theta, h, num_nodes)
 
     error = np.linalg.norm(x - x_true) + np.linalg.norm(y - y_true)
-    print(jnp.sum(jnp.square(theta-theta_true)))
-    # assert False
     assert error <= 2e-2
diff --git a/tests/test_linear_elasticity.py b/tests/test_linear_elasticity.py
new file mode 100644
index 0000000..3c925b9
--- /dev/null
+++ b/tests/test_linear_elasticity.py
@@ -0,0 +1,151 @@
+import numpy as np
+from dctkit.mesh import util
+from dctkit.math.opt import optctrl
+from dctkit.physics.elasticity import LinearElasticity
+import dctkit as dt
+import pygmsh
+
+
+def test_linear_elasticity_primal(setup_test):
+    lc = 0.5
+    L = 1.
+    with pygmsh.geo.Geometry() as geom:
+        p = geom.add_polygon([[0., 0.], [L, 0.], [L, L], [0., L]], mesh_size=lc)
+        # create a default physical group for the boundary lines
+        geom.add_physical(p.lines, label="boundary")
+        geom.add_physical(p.lines[1], label="right")
+        geom.add_physical(p.lines[3], label="left")
+        mesh = geom.generate_mesh()
+
+    S = util.build_complex_from_mesh(mesh)
+    S.get_hodge_star()
+    S.get_flat_DPD_weights()
+
+    ref_node_coords = S.node_coords
+
+    bnd_edges_idx = S.bnd_faces_indices
+    left_bnd_nodes_idx = util.get_nodes_for_physical_group(mesh, 1, "left")
+    right_bnd_nodes_idx = util.get_nodes_for_physical_group(mesh, 1, "right")
+    left_bnd_edges_idx = util.get_edges_for_physical_group(S, mesh, "left")
+    right_bnd_edges_idx = util.get_edges_for_physical_group(S, mesh, "right")
+
+    bottom_left_corner = left_bnd_nodes_idx.pop(0)
+
+    mu_ = 1.
+    lambda_ = 10.
+    true_strain_xx = 0.02
+    true_strain_yy = -(lambda_/(2*mu_+lambda_))*true_strain_xx
+    true_curr_node_coords = S.node_coords.copy()
+    true_curr_node_coords[:, 0] *= 1 + true_strain_xx
+    true_curr_node_coords[:, 1] *= 1 + true_strain_yy
+    left_bnd_pos_components = [0]
+    right_bnd_pos_components = [0]
+
+    left_bnd_nodes_pos = ref_node_coords[left_bnd_nodes_idx,
+                                         :][:, left_bnd_pos_components]
+    right_bnd_nodes_pos = true_curr_node_coords[right_bnd_nodes_idx,
+                                                :][:, right_bnd_pos_components]
+    bottom_left_corner_pos = ref_node_coords[bottom_left_corner, :]
+
+    # NOTE: without flatten it does not work properly when concatenating multiple bcs;
+    # fix this so that flatten is not needed (not intuitive)
+    boundary_values = {"0": (left_bnd_nodes_idx + right_bnd_nodes_idx,
+                             np.vstack((left_bnd_nodes_pos,
+                                        right_bnd_nodes_pos)).flatten()),
+                       ":": (bottom_left_corner, bottom_left_corner_pos)}
+
+    idx_free_edges = list(set(bnd_edges_idx) -
+                          set(right_bnd_edges_idx) - set(left_bnd_edges_idx))
+    bnd_tractions_free_values = np.zeros((len(idx_free_edges), 2), dtype=dt.float_dtype)
+    boundary_tractions = {':': (idx_free_edges, bnd_tractions_free_values)}
+
+    ela = LinearElasticity(S=S, mu_=mu_, lambda_=lambda_)
+    gamma = 1000.
+
+    num_faces = S.S[2].shape[0]
+    embedded_dim = S.space_dim
+    f = np.zeros((num_faces, (embedded_dim-1))).flatten()
+
+    obj_args = {'f': f, 'gamma': gamma, 'boundary_values': boundary_values,
+                'boundary_tractions': boundary_tractions}
+
+    prb = optctrl.OptimizationProblem(dim=S.node_coords.size,
+                                      state_dim=S.node_coords.size,
+                                      objfun=ela.obj_linear_elasticity)
+
+    prb.set_obj_args(obj_args)
+    node_coords_flattened = S.node_coords.flatten()
+    sol = prb.run(x0=node_coords_flattened)
+    curr_node_coords = sol.reshape(S.node_coords.shape)
+
+    assert np.sum((true_curr_node_coords - curr_node_coords)**2) < 1e-6
+
+
+def test_linear_elasticity_dual(setup_test):
+    lc = 0.5
+    L = 1.
+    with pygmsh.geo.Geometry() as geom:
+        p = geom.add_polygon([[0., 0.], [L, 0.], [L, L], [0., L]], mesh_size=lc)
+        # create a default physical group for the boundary lines
+        geom.add_physical(p.lines, label="boundary")
+        geom.add_physical(p.lines[1], label="right")
+        geom.add_physical(p.lines[3], label="left")
+        mesh = geom.generate_mesh()
+
+    S = util.build_complex_from_mesh(mesh)
+    S.get_hodge_star()
+    S.get_flat_DPP_weights()
+
+    ref_node_coords = S.node_coords
+
+    left_bnd_nodes_idx = util.get_nodes_for_physical_group(mesh, 1, "left")
+    right_bnd_nodes_idx = util.get_nodes_for_physical_group(mesh, 1, "right")
+
+    bottom_left_corner = left_bnd_nodes_idx.pop(0)
+
+    mu_ = 1.
+    lambda_ = 10.
+    true_strain_xx = 0.02
+    true_strain_yy = -(lambda_/(2*mu_+lambda_))*true_strain_xx
+    true_curr_node_coords = S.node_coords.copy()
+    true_curr_node_coords[:, 0] *= 1 + true_strain_xx
+    true_curr_node_coords[:, 1] *= 1 + true_strain_yy
+    left_bnd_pos_components = [0]
+    right_bnd_pos_components = [0]
+
+    left_bnd_nodes_pos = ref_node_coords[left_bnd_nodes_idx,
+                                         :][:, left_bnd_pos_components]
+    right_bnd_nodes_pos = true_curr_node_coords[right_bnd_nodes_idx,
+                                                :][:, right_bnd_pos_components]
+    bottom_left_corner_pos = ref_node_coords[bottom_left_corner, :]
+
+    # NOTE: without flatten it does not work properly when concatenating multiple bcs;
+    # fix this so that flatten is not needed (not intuitive)
+    boundary_values = {"0": (left_bnd_nodes_idx + right_bnd_nodes_idx,
+                             np.vstack((left_bnd_nodes_pos,
+                                        right_bnd_nodes_pos)).flatten()),
+                       ":": (bottom_left_corner, bottom_left_corner_pos)}
+
+    ela = LinearElasticity(S=S, mu_=mu_, lambda_=lambda_)
+    gamma = 1000.
+
+    embedded_dim = S.space_dim
+    f = np.zeros((S.num_nodes, (embedded_dim-1))).flatten()
+
+    obj_args = {'f': f, 'gamma': gamma, 'boundary_values': boundary_values,
+                'boundary_tractions': None}
+
+    prb = optctrl.OptimizationProblem(dim=S.node_coords.size,
+                                      state_dim=S.node_coords.size,
+                                      objfun=ela.obj_linear_elasticity)
+
+    prb.set_obj_args(obj_args)
+    node_coords_flattened = S.node_coords.flatten()
+    sol = prb.run(x0=node_coords_flattened)
+    curr_node_coords = sol.reshape(S.node_coords.shape)
+
+    print(ela.obj_linear_elasticity(
+        true_curr_node_coords.flatten(), f, gamma, boundary_values, None))
+    print(S.node_coords)
+
+    assert np.sum((true_curr_node_coords - curr_node_coords)**2) < 1e-6
diff --git a/tests/test_optctrl.py b/tests/test_optctrl.py
index 9209d00..5d1b89d 100644
--- a/tests/test_optctrl.py
+++ b/tests/test_optctrl.py
@@ -3,31 +3,11 @@
 import jax.numpy as jnp
 import numpy as np
 import dctkit as dt
-from dctkit.mesh import simplex, util
+from dctkit.mesh import util
 from dctkit.dec import cochain as C
-import gmsh
-import matplotlib.tri as tri
-from dctkit import config, FloatDtype, Platform
 import numpy.typing as npt
 from jax import grad
 
-config(FloatDtype.float32, Platform.cpu)
-
-
-def get_complex(S_p, node_coords):
-    bnodes, _ = gmsh.model.mesh.getNodesForPhysicalGroup(1, 1)
-    bnodes -= 1
-    bnodes = bnodes.astype(dt.int_dtype)
-    triang = tri.Triangulation(node_coords[:, 0], node_coords[:, 1])
-    # initialize simplicial complex
-    S = simplex.SimplicialComplex(S_p, node_coords, is_well_centered=True)
-    S.get_circumcenters()
-    S.get_primal_volumes()
-    S.get_dual_volumes()
-    S.get_hodge_star()
-
-    return S, bnodes, triang
-
 
 def test_optimal_control_toy(setup_test):
     # target state
@@ -88,9 +68,11 @@ def test_optimal_control_poisson(setup_test):
 
     lc = 0.5
 
-    _, _, S_2, node_coord, _ = util.generate_square_mesh(lc)
-
-    S, bnodes, _ = get_complex(S_2, node_coord)
+    mesh, _ = util.generate_square_mesh(lc)
+    S = util.build_complex_from_mesh(mesh)
+    S.get_hodge_star()
+    bnodes = mesh.cell_sets_dict["boundary"]["line"]
+    node_coord = S.node_coords
 
     k = 1.
 
diff --git a/tests/test_poisson.py b/tests/test_poisson.py
index 13043d5..da10099 100644
--- a/tests/test_poisson.py
+++ b/tests/test_poisson.py
@@ -3,32 +3,15 @@
 import jax
 import dctkit as dt
 from scipy.optimize import minimize
-from dctkit.mesh import simplex, util
-from dctkit.apps import poisson as p
+from dctkit.mesh import util
+from dctkit.physics import poisson as p
 from dctkit.dec import cochain as C
 from dctkit.math.opt import optctrl as oc
-import matplotlib.tri as tri
 import jaxopt
-import gmsh
 import pytest
 from functools import partial
 
 
-def get_complex(S_p, node_coords):
-    bnodes, _ = gmsh.model.mesh.getNodesForPhysicalGroup(1, 1)
-    bnodes -= 1
-    bnodes = bnodes.astype(dt.int_dtype)
-    triang = tri.Triangulation(node_coords[:, 0], node_coords[:, 1])
-    # initialize simplicial complex
-    S = simplex.SimplicialComplex(S_p, node_coords, is_well_centered=True)
-    S.get_circumcenters()
-    S.get_primal_volumes()
-    S.get_dual_volumes()
-    S.get_hodge_star()
-
-    return S, bnodes, triang
-
-
 cases = [["jaxopt", False], ["jaxopt", True], ["pygmo", True],
          ["pygmo", False], ["scipy", False], ["scipy", True]]
 
@@ -43,9 +26,11 @@ def test_poisson(setup_test, optimizer, energy_formulation):
 
     lc = 0.5
 
-    _, _, S_2, node_coord, _ = util.generate_square_mesh(lc)
-
-    S, bnodes, _ = get_complex(S_2, node_coord)
+    mesh, _ = util.generate_square_mesh(lc)
+    S = util.build_complex_from_mesh(mesh)
+    S.get_hodge_star()
+    bnodes = mesh.cell_sets_dict["boundary"]["line"]
+    node_coord = S.node_coords
 
     k = 1.
 
diff --git a/tests/test_simplex.py b/tests/test_simplex.py
index 5e04dea..f3e034b 100644
--- a/tests/test_simplex.py
+++ b/tests/test_simplex.py
@@ -2,31 +2,20 @@
 import dctkit
 from dctkit.mesh import simplex, util
 from dctkit.math import shifted_list as sl
-import os
-
-cwd = os.path.dirname(__file__)
 
 
 def test_boundary_COO(setup_test):
-    filename = "data/test1.msh"
-    full_path = os.path.join(cwd, filename)
-    numNodes, numElements, S_2, _, _ = util.read_mesh(full_path)
-
-    print(f"The number of nodes in the mesh is {numNodes}")
-    print(f"The number of faces in the mesh is {numElements}")
-    print(f"The face matrix is \n {S_2}")
-
-    boundary_tuple, _, _ = simplex.compute_boundary_COO(
-        S_2)
-    print(f"The row index vector is \n {boundary_tuple[0]}")
-    print(f"The column index vector is \n {boundary_tuple[1]}")
-    print(f"The values vector is \n {boundary_tuple[2]}")
+    mesh, _ = util.generate_square_mesh(1.0)
+    S2 = mesh.cells_dict["triangle"]
+
+    boundary_tuple, _, _ = simplex.compute_boundary_COO(S2)
+
     rows_index_true = np.array(
         [0, 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 7], dtype=dctkit.int_dtype)
     column_index_true = np.array(
-        [0, 1, 0, 1, 2, 0, 2, 3, 1, 3, 2, 3], dtype=dctkit.int_dtype)
-    values_true = np.array([1, -1, -1, 1, 1, 1, -1, -1, -1,
-                           1, 1, -1], dtype=dctkit.int_dtype)
+        [0, 1, 0, 1, 2, 0, 2, 3, 2, 3, 1, 3], dtype=dctkit.int_dtype)
+    values_true = np.array(
+        [1, -1, -1, 1, 1, 1, -1, 1, 1, -1, -1, 1], dtype=dctkit.int_dtype)
 
     assert boundary_tuple[0].dtype == dctkit.int_dtype
     boundary_true = (rows_index_true, column_index_true, values_true)
@@ -36,19 +25,9 @@ def test_boundary_COO(setup_test):
 
 
 def test_simplicial_complex_1(setup_test):
-    # define node_coords
     num_nodes = 5
-    node_coords = np.linspace(0, 1, num=num_nodes)
-    x = np.zeros((num_nodes, 2))
-    x[:, 0] = node_coords
-    # define S_1
-    S_1 = np.empty((num_nodes - 1, 2))
-    S_1[:, 0] = np.arange(num_nodes-1)
-    S_1[:, 1] = np.arange(1, num_nodes)
-    S = simplex.SimplicialComplex(S_1, x, is_well_centered=True)
-    S.get_circumcenters()
-    S.get_primal_volumes()
-    S.get_dual_volumes()
+    mesh, _ = util.generate_line_mesh(num_nodes)
+    S = util.build_complex_from_mesh(mesh)
     S.get_hodge_star()
 
     # define true boundary values
@@ -60,17 +39,19 @@ def test_simplicial_complex_1(setup_test):
 
     # define true circumcenters
     circ_true = sl.ShiftedList([], -1)
-    circ_true_1 = np.zeros((num_nodes - 1, 2))
+    circ_true_1 = np.zeros((num_nodes - 1, 3))
     circ_true_1[:, 0] = np.array([1/8, 3/8, 5/8, 7/8], dtype=dctkit.float_dtype)
     circ_true.append(circ_true_1)
 
     # define true primal volumes
-    pv_true = sl.ShiftedList([], -1)
-    pv_true.append(1/4*np.ones(num_nodes-1, dtype=dctkit.float_dtype))
+    pv_true = [None]*2
+    pv_true[0] = np.ones(num_nodes, dtype=dctkit.float_dtype)
+    pv_true[1] = 1/4*np.ones(num_nodes-1, dtype=dctkit.float_dtype)
 
     # define true dual volumes values
-    dv_true = sl.ShiftedList([], -1)
-    dv_true.append(np.array([0.125, 0.25, 0.25, 0.25, 0.125], dtype=dctkit.float_dtype))
+    dv_true = [None]*2
+    dv_true[0] = np.array([0.125, 0.25, 0.25, 0.25, 0.125], dtype=dctkit.float_dtype)
+    dv_true[1] = np.ones(4, dtype=dctkit.float_dtype)
 
     # define true hodge star values
     hodge_true = []
@@ -87,87 +68,76 @@ def test_simplicial_complex_1(setup_test):
     hodge_inv_true.append(hodge_inv_true_0)
     hodge_inv_true.append(hodge_inv_true_1)
 
-    # test boundary
     for i in range(3):
         assert np.alltrue(S.boundary[1][i] == boundary_true[1][i])
 
-    # test circumcenters
-    assert np.allclose(S.circ[1], circ_true[1])
-
-    # test primal volumes
-    assert np.allclose(S.primal_volumes[1], pv_true[1])
-
-    # test dual volumes
-    assert np.allclose(S.dual_volumes[1], dv_true[1])
-
-    # test hodge star
     for i in range(2):
+        assert np.allclose(S.circ[i], circ_true[i])
+        assert np.allclose(S.primal_volumes[i], pv_true[i])
+        assert np.allclose(S.dual_volumes[i], dv_true[i])
         assert np.allclose(S.hodge_star[i], hodge_true[i])
-
-    # test hodge star inverse
-    for i in range(2):
         assert np.allclose(S.hodge_star_inverse[i], hodge_inv_true[i])
 
 
 def test_simplicial_complex_2(setup_test):
-    filename = "data/test1.msh"
-    full_path = os.path.join(cwd, filename)
-    numNodes, numElements, S_2, x, bnd_faces_tags = util.read_mesh(full_path)
-
-    print(f"The number of nodes in the mesh is {numNodes}")
-    print(f"The number of faces in the mesh is {numElements}")
-    print(f"The face matrix is \n {S_2}")
-
-    S = simplex.SimplicialComplex(S_2, x, bnd_faces_tags=bnd_faces_tags)
-    S.get_circumcenters()
-    S.get_primal_volumes()
-    S.get_dual_volumes()
+    mesh, _ = util.generate_square_mesh(1.0)
+    S = util.build_complex_from_mesh(mesh, is_well_centered=False)
     S.get_hodge_star()
-    S.get_dual_edge_vectors()
-    S.get_flat_weights()
-    S.get_metric_2D()
+    S.get_flat_DPD_weights()
+    S.get_flat_DPP_weights()
 
     # define true boundary values
     boundary_true = sl.ShiftedList([], -1)
     rows_1_true = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3,
                            4, 4, 4, 4], dtype=dctkit.int_dtype)
-    cols_1_true = np.array([0, 1, 2, 0, 3, 4, 1, 5, 6, 3, 5, 7,
-                           2, 4, 6, 7], dtype=dctkit.int_dtype)
+    cols_1_true = np.array([0, 1, 2, 0, 3, 4, 3, 5, 6, 1, 5, 7, 2, 4, 6, 7],
+                           dtype=dctkit.int_dtype)
     values_1_true = np.array([-1, -1, -1, 1, -1, -1, 1, -1, -1,
                              1, 1, -1, 1, 1, 1, 1], dtype=dctkit.int_dtype)
     rows_2_true = np.array([0, 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 7], dtype=dctkit.int_dtype)
-    cols_2_true = np.array([0, 1, 0, 1, 2, 0, 2, 3, 1, 3, 2, 3], dtype=dctkit.int_dtype)
-    values_2_true = np.array([1, -1, -1, 1, 1, 1, -1, -1, -1,
-                             1, 1, -1], dtype=dctkit.int_dtype)
+    cols_2_true = np.array([0, 1, 0, 1, 2, 0, 2, 3, 2, 3, 1, 3],
+                           dtype=dctkit.int_dtype)
+    values_2_true = np.array([1, -1, -1, 1, 1, 1, -1, 1, 1, -1, -1, 1],
+                             dtype=dctkit.int_dtype)
     boundary_true.append((rows_1_true, cols_1_true, values_1_true))
     boundary_true.append((rows_2_true, cols_2_true, values_2_true))
 
     # define true circumcenters
 
     circ_true = sl.ShiftedList([], -1)
-    circ_1_true = np.array([[0.5, 0, 0], [1, 0.5, 0], [0.75, 0.25, 0], [0, 0.5, 0],
-                           [0.25, 0.25, 0], [0.5, 1, 0], [0.75, 0.75, 0],
-                           [0.25, 0.75, 0]], dtype=dctkit.float_dtype)
-    circ_2_true = np.array([[0.5, 0, 0], [1, 0.5, 0], [0, 0.5, 0], [
-                           0.5, 1, 0]], dtype=dctkit.float_dtype)
+    circ_1_true = np.array([[0.5, 0., 0.],
+                            [0.,  0.5,  0.],
+                            [0.25, 0.25, 0.],
+                            [1.,   0.5,  0.],
+                            [0.75, 0.25, 0.],
+                            [0.5,  1.,   0.],
+                            [0.75, 0.75, 0.],
+                            [0.25, 0.75, 0.]], dtype=dctkit.float_dtype)
+    circ_2_true = np.array([[0.5, 0.,  0.],
+                            [0.,  0.5, 0.],
+                            [1.,  0.5, 0.],
+                            [0.5, 1.,  0.]],
+                           dtype=dctkit.float_dtype)
     circ_true.append(circ_1_true)
     circ_true.append(circ_2_true)
 
     # define true primal volumes values
-    pv_true = sl.ShiftedList([], -1)
+    pv_true = [None]*3
     pv_1_true = np.array([1, 1, np.sqrt(2)/2, 1, np.sqrt(2)/2, 1, np.sqrt(2)/2,
                           np.sqrt(2)/2], dtype=dctkit.float_dtype)
     pv_2_true = np.array([0.25, 0.25, 0.25, 0.25], dtype=dctkit.float_dtype)
-    pv_true.append(pv_1_true)
-    pv_true.append(pv_2_true)
+    pv_true[0] = np.ones(S.num_nodes, dtype=dctkit.float_dtype)
+    pv_true[1] = pv_1_true
+    pv_true[2] = pv_2_true
 
     # define true dual volumes values
-    dv_true = sl.ShiftedList([], -1)
-    dv_1_true = np.array([0, 0, np.sqrt(2)/2, 0, np.sqrt(2)/2, 0, np.sqrt(2)/2,
+    dv_true = [None]*3
+    dv_1_true = np.array([1/8, 1/8, 1/8, 1/8, 1/2], dtype=dctkit.float_dtype)
+    dv_2_true = np.array([0, 0, np.sqrt(2)/2, 0, np.sqrt(2)/2, 0, np.sqrt(2)/2,
                           np.sqrt(2)/2], dtype=dctkit.float_dtype)
-    dv_2_true = np.array([1/8, 1/8, 1/8, 1/8, 1/2], dtype=dctkit.float_dtype)
-    dv_true.append(dv_1_true)
-    dv_true.append(dv_2_true)
+    dv_true[0] = dv_1_true
+    dv_true[1] = dv_2_true
+    dv_true[2] = np.ones(S.S[2].shape[0], dtype=dctkit.float_dtype)
 
     # define true hodge star values
     hodge_true = []
@@ -178,75 +148,175 @@ def test_simplicial_complex_2(setup_test):
     hodge_true.append(hodge_1_true)
     hodge_true.append(hodge_2_true)
 
-    # define true dual edges
-    dedges_true = np.array([[0, 0, 0], [0, 0, 0], [0.5, 0.5, 0],
-                            [0, 0, 0], [0.5, -0.5, 0], [0, 0, 0],
-                            [-0.5, 0.5, 0], [-0.5, -0.5, 0]])
+    # define true primal edge vectors
+    primal_edges_vectors_true = np.array([[1.,  0.,  0.],
+                                          [0.,  1.,  0.],
+                                          [0.5,  0.5,  0.],
+                                          [0.,  1.,  0.],
+                                          [-0.5,  0.5,  0.],
+                                          [-1.,  0.,  0.],
+                                          [-0.5, -0.5,  0.],
+                                          [0.5, -0.5,  0.]], dtype=dctkit.float_dtype)
+
+    # define true dual edge vectors
+    dual_edges_vectors_true = np.array([[0., 0., 0.],
+                                        [0.,   0.,   0.],
+                                        [-0.5,  0.5,  0.],
+                                        [0.,   0.,   0.],
+                                        [-0.5, -0.5,  0.],
+                                        [0.,   0.,   0.],
+                                        [0.5, -0.5,  0.],
+                                        [0.5,  0.5,  0.]], dtype=dctkit.float_dtype)
 
     # define true dual edges lengths
     num_n_simplices = S.S[S.dim].shape[0]
     num_nm1_simplices = S.S[S.dim-1].shape[0]
     dedges_lengths_true = np.zeros(
         (num_n_simplices, num_nm1_simplices), dtype=dctkit.float_dtype)
-    dedges_lengths_true[0, 0] = 0
     dedges_lengths_true[0, [2, 4]] = np.sqrt(2)/4
-    dedges_lengths_true[1, 1] = 0
-    dedges_lengths_true[1, [2, 6]] = np.sqrt(2)/4
-    dedges_lengths_true[2, 3] = 0
-    dedges_lengths_true[2, [4, 7]] = np.sqrt(2)/4
-    dedges_lengths_true[3, 5] = 0
+    dedges_lengths_true[1, [2, 7]] = np.sqrt(2)/4
+    dedges_lengths_true[2, [4, 6]] = np.sqrt(2)/4
     dedges_lengths_true[3, [6, 7]] = np.sqrt(2)/4
 
-    metric_true = np.zeros((4, 2, 2), dtype=dctkit.float_dtype)
-    for i in range(4):
-        metric_true[i] = np.array([[1., 0.5], [0.5, 0.5]])
+    # define true flat DPD and DPP matrices
+    flat_DPD_weigths_true = np.array([[0., 0., 0.5, 0., 0.5, 0., 0., 0.],
+                                      [0., 0., 0.5, 0., 0., 0., 0., 0.5],
+                                      [0., 0., 0., 0., 0.5, 0., 0.5, 0.],
+                                      [0., 0., 0., 0., 0., 0., 0.5, 0.5]],
+                                     dtype=dctkit.float_dtype)
+    flat_DPP_weigths_true = flat_DPD_weigths_true
 
-    assert S.boundary[1][0].dtype == dctkit.int_dtype
-    assert S.circ[1].dtype == dctkit.float_dtype
-    assert S.primal_volumes[1].dtype == dctkit.float_dtype
-    assert S.dual_volumes[1].dtype == dctkit.float_dtype
-    assert S.hodge_star[0].dtype == dctkit.float_dtype
+    # define true reference metric
+    metric_true = np.stack([np.identity(2)]*4)
 
-    # test boundary
     for i in range(3):
         assert np.alltrue(S.boundary[1][i] == boundary_true[1][i])
         assert np.alltrue(S.boundary[2][i] == boundary_true[2][i])
+        assert np.allclose(S.primal_volumes[i], pv_true[i])
+        assert np.allclose(S.dual_volumes[i], dv_true[i])
+        assert np.allclose(S.hodge_star[i], hodge_true[i])
 
     # test circumcenters
-    assert np.allclose(S.circ[1], circ_true[1])
-    assert np.allclose(S.circ[2], circ_true[2])
-
-    # test primal volumes
-    assert np.allclose(S.primal_volumes[1], pv_true[1])
-    assert np.allclose(S.primal_volumes[2], pv_true[2])
+    for i in range(1, 3):
+        assert np.allclose(S.circ[i], circ_true[i])
 
-    # test dual volumes
-    assert np.allclose(S.dual_volumes[1], dv_true[1])
-    assert np.allclose(S.dual_volumes[2], dv_true[2])
-
-    # test hodge star
-    for i in range(3):
-        assert np.allclose(S.hodge_star[i], hodge_true[i])
+    # test primal edge
+    assert np.allclose(S.primal_edges_vectors, primal_edges_vectors_true)
 
     # test dual edge and dual edge lengths
-    assert np.allclose(S.dual_edges_vectors, dedges_true)
+    assert np.allclose(S.dual_edges_vectors, dual_edges_vectors_true)
     assert np.allclose(S.dual_edges_fractions_lengths, dedges_lengths_true)
 
+    # test flat DPD and flat DPP
+    # FIXME: after extending flat DPP to other dimensions, test it!
+    assert np.allclose(S.flat_DPD_weights, flat_DPD_weigths_true)
+    assert np.allclose(S.flat_DPP_weights, flat_DPP_weigths_true)
+
     # test metric
-    assert np.allclose(S.metric, metric_true)
+    assert np.allclose(S.reference_metric, metric_true)
 
     # test hodge star inverse
-    _, _, S_2_new, node_coords_new, _ = util.generate_square_mesh(0.4)
-
-    # FIXME: make this part of the test more clear (remove long instructions between
-    # paretheses)
-    cpx_new = simplex.SimplicialComplex(S_2_new, node_coords_new, is_well_centered=True)
-    cpx_new.get_circumcenters()
-    cpx_new.get_primal_volumes()
-    cpx_new.get_dual_volumes()
-    cpx_new.get_hodge_star()
-    n = cpx_new. dim
-    for p in range(3):
-        assert np.allclose(
-            cpx_new.hodge_star[p]*cpx_new.hodge_star_inverse[p], (-1)**(
-                p*(n-p))*np.ones(cpx_new.S[p].shape[0]))
+    mesh, _ = util.generate_square_mesh(0.4)
+    S = util.build_complex_from_mesh(mesh)
+    S.get_hodge_star()
+
+    n = S.dim
+    signed_identity = [S.hodge_star[i]*S.hodge_star_inverse[i] for i in range(3)]
+    signed_identity_true = [(-1)**(i*(n-i))*np.ones(S.S[i].shape[0]) for i in range(3)]
+    for i in range(3):
+        assert np.allclose(signed_identity[i], signed_identity_true[i])
+
+
+def test_simplicial_complex_3(setup_test):
+    # FIXME: generate mesh and complex after defining appropriate functions in util
+    mesh, _ = util.generate_tet_mesh(2.0)
+    S = util.build_complex_from_mesh(mesh)
+    S.get_hodge_star()
+
+    # test boundary
+    boundary_true = sl.ShiftedList([], -1)
+    rows_1_true = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3], dtype=dctkit.int_dtype)
+    cols_1_true = np.array([0, 1, 2, 0, 3, 4, 1, 3, 5, 2, 4, 5], dtype=dctkit.int_dtype)
+    values_1_true = np.array([-1, -1, -1,  1, -1, -1,  1,  1, -1,
+                             1,  1,  1], dtype=dctkit.int_dtype)
+    rows_2_true = np.array([0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5], dtype=dctkit.int_dtype)
+    cols_2_true = np.array([0, 1, 0, 2, 1, 2, 0, 3, 1, 3, 2, 3], dtype=dctkit.int_dtype)
+    values_2_true = np.array([1,  1, -1,  1, -1, -1,  1,  1,  1, -
+                             1,  1,  1], dtype=dctkit.int_dtype)
+    rows_3_true = np.array([0, 1, 2, 3], dtype=dctkit.int_dtype)
+    cols_3_true = np.array([0, 0, 0, 0], dtype=dctkit.int_dtype)
+    values_3_true = np.array([-1,  1, -1,  1], dtype=dctkit.int_dtype)
+    boundary_true.append((rows_1_true, cols_1_true, values_1_true))
+    boundary_true.append((rows_2_true, cols_2_true, values_2_true))
+    boundary_true.append((rows_3_true, cols_3_true, values_3_true))
+
+    assert S.boundary[1][0].dtype == dctkit.int_dtype
+    for i in range(3):
+        assert np.alltrue(S.boundary[1][i] == boundary_true[1][i])
+        assert np.alltrue(S.boundary[2][i] == boundary_true[2][i])
+        assert np.alltrue(S.boundary[3][i] == boundary_true[3][i])
+
+    # test circumcenter
+    circ_true = sl.ShiftedList([], -1)
+    circ_1_true = np.array([[0.5, 0., 0.],
+                            [0.25, 0.5, 0.],
+                            [0., 0., 0.5],
+                            [0.75, 0.5, 0.],
+                            [0.5, 0., 0.5],
+                            [0.25, 0.5, 0.5]], dtype=dctkit.float_dtype)
+    circ_2_true = np.array([[0.5, 0.375, 0.],
+                            [0.5, 0., 0.5],
+                            [0.25, 0.5, 0.5],
+                            [0.41666667, 0.33333333, 0.41666667]],
+                           dtype=dctkit.float_dtype)
+    circ_3_true = np.array([[0.5, 0.375, 0.5]], dtype=dctkit.float_dtype)
+    circ_true.append(circ_1_true)
+    circ_true.append(circ_2_true)
+    circ_true.append(circ_3_true)
+
+    for i in range(1, 4):
+        assert np.allclose(S.circ[i], circ_true[i])
+    assert S.circ[1].dtype == dctkit.float_dtype
+
+    # test primal volumes
+    pv_true = sl.ShiftedList([], -1)
+    pv_1_true = np.array([1., np.sqrt(5)/2, 1., np.sqrt(5)/2,
+                         np.sqrt(2), 1.5], dtype=dctkit.float_dtype)
+    pv_2_true = np.array([0.5, 0.5, 0.55901699, 0.75], dtype=dctkit.float_dtype)
+    pv_3_true = np.array([5/30], dtype=dctkit.float_dtype)
+    pv_true.append(pv_1_true)
+    pv_true.append(pv_2_true)
+    pv_true.append(pv_3_true)
+
+    assert S.primal_volumes[1].dtype == dctkit.float_dtype
+    for i in range(1, 4):
+        assert np.allclose(S.primal_volumes[i], pv_true[i])
+
+    # define true dual volumes values
+    dv_true = []
+    dv_0_true = np.array([0.0859375, 0.03255208, 0.02864583,
+                         0.01953125], dtype=dctkit.float_dtype)
+    dv_1_true = np.array([0.1875,  0.13975425,  0.171875,  0.03493856, -0.02209709,
+                          -0.015625], dtype=dctkit.float_dtype)
+    dv_2_true = np.array([0.5,  0.375,  0.2795085, -0.125], dtype=dctkit.float_dtype)
+    dv_true.append(dv_0_true)
+    dv_true.append(dv_1_true)
+    dv_true.append(dv_2_true)
+
+    assert S.dual_volumes[1].dtype == dctkit.float_dtype
+    for i in range(3):
+        assert np.allclose(S.dual_volumes[i], dv_true[i])
+
+    # test hodge star
+    hodge_true = [dv_0_true] + [dv_true[i]/pv_true[i]
+                                for i in range(1, 3)] + [1/pv_3_true]
+    for i in range(4):
+        assert np.allclose(S.hodge_star[i], hodge_true[i])
+
+    # test hodge star inverse
+    n = S.dim
+    signed_identity = [S.hodge_star[i]*S.hodge_star_inverse[i] for i in range(4)]
+    signed_identity_true = [(-1)**(i*(n-i))*np.ones(S.S[i].shape[0]) for i in range(4)]
+
+    for i in range(4):
+        assert np.allclose(signed_identity[i], signed_identity_true[i])
diff --git a/tests/test_vector.py b/tests/test_vector.py
index 0af4580..8792fe0 100644
--- a/tests/test_vector.py
+++ b/tests/test_vector.py
@@ -1,23 +1,36 @@
 import numpy as np
-from dctkit.mesh import simplex, util
+import dctkit as dt
+from dctkit.mesh import util
 import dctkit.dec.vector as V
-import jax.numpy as jnp
 
 
-def test_vector_cochain(setup_test):
-    _, _, S_2, node_coords, bnd_faces_tags = util.generate_hexagon_mesh(1, 1)
-    S = simplex.SimplicialComplex(S_2, node_coords, bnd_faces_tags=bnd_faces_tags)
-    S.get_circumcenters()
-    S.get_primal_volumes()
-    S.get_dual_volumes()
+def test_vector(setup_test):
+    mesh, _ = util.generate_hexagon_mesh(1., 1.)
+    S = util.build_complex_from_mesh(mesh)
     S.get_hodge_star()
-    S.get_dual_edge_vectors()
-    S.get_flat_weights()
+    S.get_flat_DPP_weights()
+    S.get_flat_DPD_weights()
 
-    # test flat operator
-    v_coeffs = np.ones((S.embedded_dim, S.S[2].shape[0]))
+    # test flat operators
+    v_coeffs = np.ones((S.space_dim, S.S[2].shape[0]), dtype=dt.float_dtype)
+    T_coeffs = np.ones((S.space_dim, S.space_dim,
+                       S.S[2].shape[0]), dtype=dt.float_dtype)
     v = V.DiscreteVectorFieldD(S, v_coeffs)
-    c = V.flat_DPD(v)
-    c_true_coeffs = S.dual_edges_vectors.sum(axis=1)
+    T = V.DiscreteTensorFieldD(S, T_coeffs, 2)
 
-    assert jnp.allclose(c.coeffs, c_true_coeffs)
+    c_v_DPD = V.flat_DPD(v)
+    c_T_DPD = V.flat_DPD(T)
+    c_v_DPP = V.flat_DPP(v)
+    c_T_DPP = V.flat_DPP(T)
+
+    c_v_DPD_true_coeffs = S.dual_edges_vectors.sum(axis=1)
+    c_T_DPD_true_coeffs = np.ones((12, 3), dtype=dt.float_dtype)
+    c_T_DPD_true_coeffs = c_v_DPD_true_coeffs[:, None]*c_T_DPD_true_coeffs
+    c_v_DPP_true_coeffs = S.primal_edges_vectors.sum(axis=1)
+    c_T_DPP_true_coeffs = np.ones((12, 3), dtype=dt.float_dtype)
+    c_T_DPP_true_coeffs = c_v_DPP_true_coeffs[:, None]*c_T_DPP_true_coeffs
+
+    assert np.allclose(c_v_DPD.coeffs, c_v_DPD_true_coeffs)
+    assert np.allclose(c_T_DPD.coeffs, c_T_DPD_true_coeffs)
+    assert np.allclose(c_v_DPP.coeffs, c_v_DPP_true_coeffs)
+    assert np.allclose(c_T_DPP.coeffs, c_T_DPP_true_coeffs)