Global evaluation rewrite

[lmoresi]

This branch is to provide the global evaluation of variables by using a swarm to scatter points from the local process to the places we wish to sample.

1. Need to fix up the storage of data / evaluation of functions. The evaluate methods should return data that is of the same shape as the evaluated function. We also need to be able to store this on a swarm and pass it around, then retrieve it safely.

2. Decide on the interface we present to the user. Everything needs to look like a sympy matrix. Scalars are (X,1,1) in shape, vectors are (X,1,dim), tensors are (X,dim.dim) even if symmetric. We can squeeze arrays to remove extra dimensions but there should be a consistent pattern behind the scenes.

3. Simplify the access methods - there are many redundant operations: variables are switched between readable and writable but the readable versions are never seen in the user space. There is a lot of room to reduce the footprint of this awkward pattern

[lmoresi]

Don't merge - this branch is still for testing

[jcgraciosa]

I am testing out the changes in this pull request. I found the following issues so far:

1. uw.function.evaluate() produces errors when evaluating a matrix with a constant inside:

meshbox = uw.meshing.UnstructuredSimplexBox(minCoords  = (0., 0.),
                                            maxCoords  = (1., 1.),
                                            cellSize = 1. / 16,
                                            regular = False)

x, y = meshbox.N.x, meshbox.N.y
vector_fn2 = sympy.Matrix((x*x, 0)) 
uw.function.evaluate(vector_fn2, meshbox.data, rbf = False)

2. The pack/unpack results to mismatches if an asymmetrical tensor is used:

meshbox = uw.meshing.UnstructuredSimplexBox(minCoords   = (0., 0.),
                                            maxCoords   = (1., 1.),
                                            cellSize    = 1. / 16,
                                            regular     = False)

swarm = uw.swarm.Swarm(meshbox)

t = uw.swarm.SwarmVariable(
    "T",
    swarm,
    vtype=uw.VarType.SYM_TENSOR,
    proxy_degree=1,
    proxy_continuous=True,
    varsymbol=r"\mathbf{T}",
)

swarm.populate(0)

x, y = meshbox.N.x, meshbox.N.y
tensor_fn = sympy.Matrix(((x*x, x*x*y), (x*y, y*y))) # FIXME: this produces mismatch between packed and unpacked 

with swarm.access(t):
    t_data = uw.function.evaluate(tensor_fn, swarm.particle_coordinates.data, rbf=False)

t.pack(t_data)

print(f"mismatches: {(t_data != t.unpack()).sum()}")

Perhaps this is due to the vtype of t set as uw.VarType.SYM_TENSOR.
Changing the vtype to uw.VarType.TENSOR results to some array size mismatches.

[lmoresi]

@jcgraciosa - your point (1) above is (perhaps) fixed - go ahead and try again to break it ! Your point (2) is intentional / expected. If you pass a non-symmetric tensor to set a symmetric tensor, the non-symmetric part is ignored and the lower-triangular section takes precedence. We probably need to introduce the operator to split into symmetric / anti-symmetric parts, but here I am assuming that the input is a mistake. Sympy knows about symmetric matrices, so we could introduce a warning or error if the input is non-symmetric.

[lmoresi]

This has become an extensive re-write. I am going to close this off and re-open for a holistic review as a "release candidate"