def test_cube():
points, cells = meshzoo.cube()
assert len(points) == 1331
assert len(cells) == 5000
points, cells = meshzoo.cube(nx=3, ny=3, nz=3)
assert len(points) == 27
assert all(numpy.sum(points, axis=0) == [13.5, 13.5, 13.5])
assert len(cells) == 40
def test_cube():
points, cells = meshzoo.cube()
assert len(points) == 1331
assert len(cells) == 5000
points, cells = meshzoo.cube(nx=3, ny=3, nz=3)
assert len(points) == 27
assert all(numpy.sum(points, axis=0) == [13.5, 13.5, 13.5])
assert len(cells) == 40
return
def write(filename, f):
import meshio
import meshzoo
points, cells = meshzoo.cube(-1, +1, -1, +1, -1, +1, 50, 50, 50)
vals = f(points)
meshio.write(filename, points, {'tetra': cells}, point_data={'f': vals})
return
def test():
class Gamma0(Subdomain):
def is_inside(self, x):
return x[1] < 0.5
is_boundary_only = True
class Gamma1(Subdomain):
def is_inside(self, x):
return x[1] >= 0.5
is_boundary_only = True
class Poisson(object):
def apply(self, u):
return integrate(lambda x: -n_dot_grad(u(x)), dS) - integrate(
lambda x: 50 * sin(2 * pi * x[0]), dV)
def dirichlet(self, u):
return [(lambda x: u(x) - 0.0, Gamma0()),
(lambda x: u(x) - 1.0, Gamma1())]
# # Read the mesh from file
# mesh, _, _ = pyfvm.reader.read('circle.vtu')
# Create mesh using meshzoo
import meshzoo
vertices, cells = meshzoo.cube(0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 30, 30, 30)
mesh = meshplex.MeshTetra(vertices, cells)
# vertices, cells = meshzoo.rectangle(0.0, 2.0, 0.0, 1.0, 401, 201)
# mesh = meshplex.MeshTri(vertices, cells)
print(len(vertices))
# import mshr
# import dolfin
# # h = 2.5e-3
# h = 1.e-1
# # cell_size = 2 * pi / num_boundary_points
# c = mshr.Circle(dolfin.Point(0., 0., 0.), 1, int(2*pi / h))
# # cell_size = 2 * bounding_box_radius / res
# m = mshr.generate_mesh(c, 2.0 / h)
# coords = m.coordinates()
# coords = numpy.c_[coords, numpy.zeros(len(coords))]
# cells = m.cells().copy()
# mesh = meshplex.MeshTri(coords, cells)
# # mesh = meshplex.lloyd_smoothing(mesh, 1.0e-4)
matrix, rhs = pyfvm.discretize_linear(Poisson(), mesh)
# ml = pyamg.smoothed_aggregation_solver(matrix)
ml = pyamg.ruge_stuben_solver(matrix)
u = ml.solve(rhs, tol=1e-10)
# from scipy.sparse import linalg
# u = linalg.spsolve(matrix, rhs)
mesh.write("out.vtk", point_data={"u": u})
return
def test():
class Gamma0(Subdomain):
def is_inside(self, x):
return x[1] < 0.5
is_boundary_only = True
class Gamma1(Subdomain):
def is_inside(self, x):
return x[1] >= 0.5
is_boundary_only = True
class Poisson(object):
def apply(self, u):
return integrate(lambda x: -n_dot_grad(u(x)), dS) - integrate(
lambda x: 50 * sin(2 * pi * x[0]), dV
)
def dirichlet(self, u):
return [(lambda x: u(x) - 0.0, Gamma0()), (lambda x: u(x) - 1.0, Gamma1())]
# # Read the mesh from file
# mesh, _, _ = pyfvm.reader.read('circle.vtu')
# Create mesh using meshzoo
import meshzoo
vertices, cells = meshzoo.cube(0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 30, 30, 30)
mesh = meshplex.MeshTetra(vertices, cells)
# vertices, cells = meshzoo.rectangle(0.0, 2.0, 0.0, 1.0, 401, 201)
# mesh = meshplex.MeshTri(vertices, cells)
print(len(vertices))
# import mshr
# import dolfin
# # h = 2.5e-3
# h = 1.e-1
# # cell_size = 2 * pi / num_boundary_points
# c = mshr.Circle(dolfin.Point(0., 0., 0.), 1, int(2*pi / h))
# # cell_size = 2 * bounding_box_radius / res
# m = mshr.generate_mesh(c, 2.0 / h)
# coords = m.coordinates()
# coords = numpy.c_[coords, numpy.zeros(len(coords))]
# cells = m.cells().copy()
# mesh = meshplex.MeshTri(coords, cells)
# # mesh = meshplex.lloyd_smoothing(mesh, 1.0e-4)
matrix, rhs = pyfvm.discretize_linear(Poisson(), mesh)
# ml = pyamg.smoothed_aggregation_solver(matrix)
ml = pyamg.ruge_stuben_solver(matrix)
u = ml.solve(rhs, tol=1e-10)
# from scipy.sparse import linalg
# u = linalg.spsolve(matrix, rhs)
mesh.write("out.vtk", point_data={"u": u})
return
def show_srgb_gamut(colorspace, filename, n=50, cut_000=False):
import meshio
import meshzoo
points, cells = meshzoo.cube(nx=n, ny=n, nz=n)
if cut_000:
# cut off [0, 0, 0] to avoid division by 0 in the xyz conversion
points = points[1:]
cells = cells[~numpy.any(cells == 0, axis=1)]
cells -= 1
srgb_linear = SrgbLinear()
pts = colorspace.from_xyz100(srgb_linear.to_xyz100(points.T)).T
rgb = srgb_linear.to_srgb1(points)
meshio.write(filename, pts, {'tetra': cells}, point_data={'srgb': rgb})
return
def save_hdr_gamut(self, filename, n=50, cut_000=False):
import meshio
import meshzoo
points, cells = meshzoo.cube(nx=n, ny=n, nz=n)
if cut_000:
# cut off [0, 0, 0] to avoid division by 0 in the xyz conversion
points = points[1:]
cells = cells[~numpy.any(cells == 0, axis=1)]
cells -= 1
hdr = HdrLinear()
pts = self.from_xyz100(hdr.to_xyz100(points.T)).T
rgb = hdr.to_hdr1(points)
meshio.write_points_cells(
filename, pts, {"tetra": cells}, point_data={"hdr-rgb": rgb}
)
def save_srgb_gamut(self, filename, n=50, cut_000=False):
import meshio
import meshzoo
points, cells = meshzoo.cube(nx=n, ny=n, nz=n)
if cut_000:
# cut off [0, 0, 0] to avoid division by 0 in the xyz conversion
points = points[1:]
cells = cells[~numpy.any(cells == 0, axis=1)]
cells -= 1
srgb_linear = SrgbLinear()
pts = self.from_xyz100(srgb_linear.to_xyz100(points.T)).T
assert pts.shape[1] == 3
rgb = srgb_linear.to_srgb1(points)
meshio.write_points_cells(
filename, pts, {"tetra": cells}, point_data={"srgb": rgb}
)
def write_tree_3d(filename, n, *args, res=20, alpha=2.0, **kwargs):
import meshio
import meshzoo
points, cells = meshzoo.cube(-alpha, alpha, -alpha, alpha, -alpha, alpha,
res, res, res)
evaluator = EvalWithDegrees(points.T, *args, **kwargs)
meshes = []
corners = numpy.array(
[[numpy.cos(k * 2 * numpy.pi / 3),
numpy.sin(k * 2 * numpy.pi / 3)] for k in range(3)])
for L, (values, degrees) in enumerate(itertools.islice(evaluator, n)):
for vals, degs in zip(values, degrees):
offset = sum([corner * d for corner, d in zip(corners, degs)])
pts = points.copy()
pts[:, 0] += alpha * 2.0 * offset[0]
pts[:, 1] += alpha * 2.0 * offset[1]
pts[:, 2] -= alpha * 3.0 * L
meshes.append(
meshio.Mesh(pts, {"tetra": cells}, point_data={"f": vals}))
# merge meshes
points = numpy.concatenate([mesh.points for mesh in meshes])
f_vals = numpy.concatenate([mesh.point_data["f"] for mesh in meshes])
#
cells = []
k = 0
for mesh in meshes:
cells.append(mesh.cells[0].data + k)
k += mesh.points.shape[0]
cells = numpy.concatenate(cells)
meshio.write_points_cells(filename,
points, {"tetra": cells},
point_data={"f": f_vals})
def get_mesh(self, k):
n = 2**(k + 1)
vertices, cells = meshzoo.cube(0.0, 1.0, 0.0, 1.0, 0.0, 1.0, n + 1,
n + 1, n + 1)
return meshplex.MeshTetra(vertices, cells)
def get_mesh(self, k):
n = 2 ** (k + 1)
vertices, cells = meshzoo.cube(
0.0, 1.0, 0.0, 1.0, 0.0, 1.0, n + 1, n + 1, n + 1
)
return meshplex.MeshTetra(vertices, cells)
if pp is None:
plt.show()
else:
plt.savefig(pp, format='pdf')
plt.close()
def testInterpolation2D():
delta = .1
n_start = 12
layers = list(range(3))
N = [n_start * 2**(l) for l in layers]
N_fine = N[-1] * 2
print("Interpolating Linear Function")
ufunc = lambda x: 3 * x[0] + 4 * x[1]
mesh_exact = RegMesh2D(delta, N_fine, ufunc)
pp = PdfPages("testplot.pdf")
for n in N:
mesh = RegMesh2D(delta, n, ufunc)
mesh.plot_ud(pp)
mesh = RegMesh2D(delta, N_fine, coarseMesh=mesh)
print("L2 Error: ", l2dist(mesh_exact.ud, mesh.ud))
pp.close()
if __name__ == "__main__":
n = 12
M = meshzoo.cube(-0.1, 1.1, -.1, 1.1, nx=n + 1, ny=n + 1, nz=n + 1)
print(M)
