# discretize.CurvilinearMesh.average_edge_to_cell_vector#

property CurvilinearMesh.average_edge_to_cell_vector#

Averaging operator from edges to cell centers (vector quantities).

This property constructs the averaging operator that independently maps the Cartesian components of vector quantities from edges to cell centers. This averaging operators is used when a discrete vector quantity defined on mesh edges must be approximated at cell centers. Once constructed, the operator is stored permanently as a property of the mesh.

Be aware that the Cartesian components of the original vector are defined on their respective edges; e.g. the x-component lives on x-edges. However, the x, y and z components are being averaged separately to cell centers. The operation is implemented as a matrix vector product, i.e.:

u_c = Aec @ u_e

Returns
(dim * n_cells, n_edges) scipy.sparse.csr_matrix

The vector averaging operator from edges to cell centers. Since we are averaging a vector quantity to cell centers, the first dimension of the operator is the mesh dimension times the number of cells.

Notes

Let $$\mathbf{u_e}$$ be the discrete representation of a vector quantity whose Cartesian components are defined on their respective edges; e.g. $$u_x$$ is defined on x-edges. average_edge_to_cell_vector constructs a discrete linear operator $$\mathbf{A_{ec}}$$ that projects each Cartesian component of $$\mathbf{u_e}$$ independently to cell centers, i.e.:

$\mathbf{u_c} = \mathbf{A_{ec}} \, \mathbf{u_e}$

where $$\mathbf{u_c}$$ is a discrete vector quantity whose Cartesian components defined at the cell centers and organized into a 1D array of the form np.r_[ux, uy, uz]. For each cell, and for each Cartesian component, we are simply taking the average of the values defined on the cell’s corresponding edges and placing the result at the cell’s center.

Examples

Here we compute the values of a vector function discretized to the edges. We then create an averaging operator to approximate the function at cell centers.

We start by importing the necessary packages and defining a mesh.

>>> from discretize import TensorMesh
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> h = 0.5 * np.ones(40)
>>> mesh = TensorMesh([h, h], x0="CC")


Then we create a discrete vector on mesh edges

>>> edges_x = mesh.edges_x
>>> edges_y = mesh.edges_y
>>> u_ex = -(edges_x[:, 1] / np.sqrt(np.sum(edges_x ** 2, axis=1))) * np.exp(
...     -(edges_x[:, 0] ** 2 + edges_x[:, 1] ** 2) / 6 ** 2
... )
>>> u_ey = (edges_y[:, 0] / np.sqrt(np.sum(edges_y ** 2, axis=1))) * np.exp(
...     -(edges_y[:, 0] ** 2 + edges_y[:, 1] ** 2) / 6 ** 2
... )
>>> u_e = np.r_[u_ex, u_ey]


Next, we construct the averaging operator and apply it to the discrete vector quantity to approximate the value at cell centers.

>>> Aec = mesh.average_edge_to_cell_vector
>>> u_c = Aec @ u_e


And plot the results:

Expand to show scripting for plot
>>> fig = plt.figure(figsize=(11, 5))
>>> mesh.plot_image(u_e, ax=ax1, v_type="E", view='vec')
>>> ax1.set_title("Variable at edges", fontsize=16)
>>> mesh.plot_image(u_c, ax=ax2, v_type="CCv", view='vec')
>>> ax2.set_title("Averaged to cell centers", fontsize=16)
>>> plt.show()


Below, we show a spy plot illustrating the sparsity and mapping of the operator

Expand to show scripting for plot
>>> fig = plt.figure(figsize=(9, 9))