def basisDerivatives(basisrules, meshes, structuredpoints, k):
# Tests that we get the correct directional derivatives
N = 5
h = 1E-5
for mesh in meshes:
ei = pcbu.ElementInfo(mesh, k)
for e in range(mesh.nelements):
_, points = pug.elementToStructuredPoints(structuredpoints, mesh, e)
# generate some random normals
if points is not None and len(points):
nn = nr.random((len(points),2))
n = nn / np.sqrt(np.sum(nn**2, axis=1)).reshape(-1,1)
for basisrule in basisrules:
basis = basisrule.populate(ei.info(e))[0]
vd = basis.derivs(points)
vl = basis.laplacian(points)
vp = basis.values(points)
vph = [basis.values(points + dx) for dx in [[h,0],[0,h], [-h,0], [0,-h]]]
vdh = np.dstack([vph[0] - vph[2], vph[1] - vph[3]])/(2*h)
vlh = (sum(vph) - 4*vp) / (h**2)
vdn = basis.derivs(points, n)
vdnh = (basis.values(points + n * h) - basis.values(points - n * h)) / (2*h) # compute the derivatives in mesh coordinates using finite differences
np.testing.assert_allclose(vdnh, vdn, rtol=1E-5, atol=1E-5)
np.testing.assert_allclose(vdh, vd, rtol=1E-5, atol=1E-5)
np.testing.assert_allclose(vlh, vl, rtol=1E-3, atol=1E-4)
def outputMeshPartition(bounds, npoints, mesh, nparts = 0):
''' Show the mesh partitions'''
bounds=np.array(bounds,dtype='d')
points = pug.StructuredPoints(bounds.transpose(), npoints)
parts = getPartitions(mesh) if nparts==0 else mesh.basicinfo.partition(nparts)
v = np.ones(points.length)*-1
for i,p in enumerate(parts):
for eid in p:
epoints, _ = pug.elementToStructuredPoints(points, mesh, eid)
v[np.array(epoints)] += (i+1)
image(v, npoints, bounds, colorbar=False)
showmesh(mesh)
def evaluate(self, structuredpoints):
outputshape = structuredpoints.length if len(self.x.shape) == 1 else (structuredpoints.length, self.x.shape[1])
vals = numpy.zeros(outputshape, dtype=numpy.complex128)
pointcount = numpy.zeros(structuredpoints.length, dtype=int)
for e in self.mesh.partition:
pointidxs, points = elementToStructuredPoints(structuredpoints, self.mesh, e)
if len(pointidxs):
v = self.elttobasis.getValues(e, points)
(vidx0,vidx1) = self.elttobasis.getIndices()[e:e+2]
vals[pointidxs] += numpy.dot(v, self.x[vidx0: vidx1])
pointcount[pointidxs]+=1
return self.filter(vals), pointcount
def compareStructuredAndUnstructured(self, meshes, dim):
""" Compare the structured and unstructured element-to-point routines
Since the unstructured routine picks an arbitrary element for points that lie on boundaries
but the structured routine will say that such points lie in both elements, this routine
can at best say that the two routines are compatible.
"""
vertices = np.array([[0] * dim, [1] * dim])
sp = pug.StructuredPoints(vertices, np.array([5] * dim))
for mesh in meshes:
points = sp.getPoints(vertices)[1]
# print points
etopunstructured = pug.pointsToElement(points, mesh)
pointscheck = etopunstructured == -1
for e in range(mesh.nelements):
ps = pug.elementToStructuredPoints(sp, mesh, e)[0]
self.assertFalse((etopunstructured[ps] == -1).any())
pointscheck[ps] |= etopunstructured[ps] == e
self.assertTrue(pointscheck.all())
