def test_interpolation(self):
from sfepy import data_dir
from sfepy.discrete.fem import Mesh
from sfepy.linalg import make_axis_rotation_matrix
fname = in_dir(self.options.out_dir)
meshes = {
'tp' : Mesh.from_file(data_dir + '/meshes/3d/block.mesh'),
'si' : Mesh.from_file(data_dir + '/meshes/3d/cylinder.mesh'),
}
datas = gen_datas(meshes)
for field_name in ['scalar_si', 'vector_si', 'scalar_tp', 'vector_tp']:
m1 = meshes[field_name[-2:]]
for ia, angle in enumerate(nm.linspace(0.0, nm.pi, 11)):
self.report('%s: %d. angle: %f' % (field_name, ia, angle))
shift = [0.0, 0.0, 0.0]
mtx = make_axis_rotation_matrix([0, 1, 0], angle)
m2 = m1.copy('rotated mesh')
m2.transform_coors(mtx)
data = datas[field_name]
u1, u2 = do_interpolation(m2, m1, data, field_name)
if ia == 0:
u1.save_as_mesh(fname('test_mesh_interp_%s_u1.vtk'
% field_name))
u2.save_as_mesh(fname('test_mesh_interp_%s_u2.%03d.vtk'
% (field_name, ia)))
return True
def test_write_read_meshes(self):
"""
Try to write and then read all supported formats.
"""
from sfepy.discrete.fem import Mesh
from sfepy.discrete.fem.meshio import (supported_formats,
supported_capabilities)
conf_dir = op.dirname(__file__)
mesh0 = Mesh.from_file(data_dir
+ '/meshes/various_formats/small3d.mesh',
prefix_dir=conf_dir)
oks = []
for suffix, format_ in six.iteritems(supported_formats):
if isinstance(format_, tuple):
continue
if 'w' not in supported_capabilities[format_]: continue
filename = op.join(self.options.out_dir, 'test_mesh_wr' + suffix)
self.report('%s format: %s' % (suffix, filename))
mesh0.write(filename, io='auto')
mesh1 = Mesh.from_file(filename)
oks.extend(self._compare_meshes(mesh0, mesh1))
return sum(oks) == len(oks)
def test_write_read_meshes(self):
"""
Try to write and then read all supported formats.
"""
from sfepy.discrete.fem import Mesh
from sfepy.discrete.fem.meshio import (supported_formats,
supported_capabilities)
conf_dir = op.dirname(__file__)
mesh0 = Mesh.from_file(data_dir +
'/meshes/various_formats/small3d.mesh',
prefix_dir=conf_dir)
oks = []
for suffix, format_ in supported_formats.iteritems():
if isinstance(format_, tuple):
continue
if 'w' not in supported_capabilities[format_]: continue
filename = op.join(self.options.out_dir, 'test_mesh_wr' + suffix)
self.report('%s format: %s' % (suffix, filename))
mesh0.write(filename, io='auto')
mesh1 = Mesh.from_file(filename)
oks.extend(self._compare_meshes(mesh0, mesh1))
return sum(oks) == len(oks)
def main():
parser = ArgumentParser(description=__doc__.rstrip(),
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('filename', help=helps['filename'])
parser.add_argument('-d', '--detailed',
action='store_true', dest='detailed',
default=False, help=helps['detailed'])
options = parser.parse_args()
mesh = Mesh.from_file(options.filename)
output(mesh.cmesh)
output('element types:', mesh.descs)
output('nodal BCs:', sorted(mesh.nodal_bcs.keys()))
bbox = mesh.get_bounding_box()
output('bounding box:\n%s'
% '\n'.join('%s: [%14.7e, %14.7e]' % (name, bbox[0, ii], bbox[1, ii])
for ii, name in enumerate('xyz'[:mesh.dim])))
output('centre: [%s]'
% ', '.join('%14.7e' % ii for ii in 0.5 * (bbox[0] + bbox[1])))
output('coordinates mean: [%s]'
% ', '.join('%14.7e' % ii for ii in mesh.coors.mean(0)))
if not options.detailed: return
domain = FEDomain(mesh.name, mesh)
for dim in range(1, mesh.cmesh.tdim + 1):
volumes = mesh.cmesh.get_volumes(dim)
output('volumes of %d %dD entities:\nmin: %.7e mean: %.7e median:'
' %.7e max: %.7e'
% (mesh.cmesh.num[dim], dim, volumes.min(), volumes.mean(),
nm.median(volumes), volumes.max()))
euler = lambda mesh: nm.dot(mesh.cmesh.num, [1, -1, 1, -1])
ec = euler(mesh)
output('Euler characteristic:', ec)
graph = mesh.create_conn_graph(verbose=False)
n_comp, _ = graph_components(graph.shape[0], graph.indptr, graph.indices)
output('number of connected components:', n_comp)
if mesh.dim > 1:
region = domain.create_region('surf', 'vertices of surface', 'facet')
surf_mesh = Mesh.from_region(region, mesh,
localize=True, is_surface=True)
FEDomain(surf_mesh.name, surf_mesh) # Calls CMesh.setup_entities().
sec = euler(surf_mesh)
output('surface Euler characteristic:', sec)
if mesh.dim == 3:
output('surface genus:', (2.0 - sec) / 2.0)
surf_graph = surf_mesh.create_conn_graph(verbose=False)
n_comp, _ = graph_components(surf_graph.shape[0],
surf_graph.indptr, surf_graph.indices)
output('number of connected surface components:', n_comp)
def refine_region(domain0, region0, region1):
"""
Coarse cell sub_cells[ii, 0] in mesh0 is split into sub_cells[ii, 1:] in
mesh1.
The new fine cells are interleaved among the original coarse cells so that
the indices of the coarse cells do not change.
The cell groups are preserved. The vertex groups are preserved only in the
coarse (non-refined) cells.
"""
if region1 is None:
return domain0, None
mesh0 = domain0.mesh
mesh1 = Mesh.from_region(region1, mesh0)
domain1 = FEDomain('d', mesh1)
domain1r = domain1.refine()
mesh1r = domain1r.mesh
n_cell = region1.shape.n_cell
n_sub = 4 if mesh0.cmesh.tdim == 2 else 8
sub_cells = nm.empty((n_cell, n_sub + 1), dtype=nm.uint32)
sub_cells[:, 0] = region1.cells
sub_cells[:, 1] = region1.cells
aux = nm.arange((n_sub - 1) * n_cell, dtype=nm.uint32)
sub_cells[:, 2:] = mesh0.n_el + aux.reshape((n_cell, -1))
coors0, vgs0, conns0, mat_ids0, descs0 = mesh0._get_io_data()
coors, vgs, _conns, _mat_ids, descs = mesh1r._get_io_data()
# Preserve vertex groups of non-refined cells.
vgs[:len(vgs0)] = vgs0
def _interleave_refined(c0, c1):
if c1.ndim == 1:
c0 = c0[:, None]
c1 = c1[:, None]
n_row, n_col = c1.shape
n_new = region0.shape.n_cell + n_row
out = nm.empty((n_new, n_col), dtype=c0.dtype)
out[region0.cells] = c0[region0.cells]
out[region1.cells] = c1[::n_sub]
aux = c1.reshape((-1, n_col * n_sub))
out[mesh0.n_el:] = aux[:, n_col:].reshape((-1, n_col))
return out
conn = _interleave_refined(conns0[0], _conns[0])
mat_id = _interleave_refined(mat_ids0[0], _mat_ids[0]).squeeze()
mesh = Mesh.from_data('a', coors, vgs, [conn], [mat_id], descs)
domain = FEDomain('d', mesh)
return domain, sub_cells
def refine_region(domain0, region0, region1):
"""
Coarse cell sub_cells[ii, 0] in mesh0 is split into sub_cells[ii, 1:] in
mesh1.
The new fine cells are interleaved among the original coarse cells so that
the indices of the coarse cells do not change.
The cell groups are preserved. The vertex groups are preserved only in the
coarse (non-refined) cells.
"""
if region1 is None:
return domain0, None
mesh0 = domain0.mesh
mesh1 = Mesh.from_region(region1, mesh0)
domain1 = FEDomain('d', mesh1)
domain1r = domain1.refine()
mesh1r = domain1r.mesh
n_cell = region1.shape.n_cell
n_sub = 4 if mesh0.cmesh.tdim == 2 else 8
sub_cells = nm.empty((n_cell, n_sub + 1), dtype=nm.uint32)
sub_cells[:, 0] = region1.cells
sub_cells[:, 1] = region1.cells
aux = nm.arange((n_sub - 1) * n_cell, dtype=nm.uint32)
sub_cells[:, 2:] = mesh0.n_el + aux.reshape((n_cell, -1))
coors0, vgs0, conns0, mat_ids0, descs0 = mesh0._get_io_data()
coors, vgs, _conns, _mat_ids, descs = mesh1r._get_io_data()
# Preserve vertex groups of non-refined cells.
vgs[:len(vgs0)] = vgs0
def _interleave_refined(c0, c1):
if c1.ndim == 1:
c0 = c0[:, None]
c1 = c1[:, None]
n_row, n_col = c1.shape
n_new = region0.shape.n_cell + n_row
out = nm.empty((n_new, n_col), dtype=c0.dtype)
out[region0.cells] = c0[region0.cells]
out[region1.cells] = c1[::n_sub]
aux = c1.reshape((-1, n_col * n_sub))
out[mesh0.n_el:] = aux[:, n_col:].reshape((-1, n_col))
return out
conn = _interleave_refined(conns0[0], _conns[0])
mat_id = _interleave_refined(mat_ids0[0], _mat_ids[0]).squeeze()
mesh = Mesh.from_data('a', coors, vgs, [conn], [mat_id], descs)
domain = FEDomain('d', mesh)
return domain, sub_cells
def __init__(self, name, nurbs, bmesh, regions=None, **kwargs):
"""
Create an IGA domain.
Parameters
----------
name : str
The domain name.
"""
Domain.__init__(self,
name,
nurbs=nurbs,
bmesh=bmesh,
regions=regions,
**kwargs)
from sfepy.discrete.fem.geometry_element import create_geometry_elements
from sfepy.discrete.fem import Mesh
from sfepy.discrete.fem.utils import prepare_remap
tconn = iga.get_bezier_topology(bmesh.conn, nurbs.degrees)
itc = nm.unique(tconn)
remap = prepare_remap(itc, bmesh.conn.max() + 1)
ltcoors = bmesh.cps[itc]
ltconn = remap[tconn]
n_nod, dim = ltcoors.shape
n_el = ltconn.shape[0]
self.shape = Struct(n_nod=n_nod, dim=dim, tdim=0, n_el=n_el)
desc = '%d_%d' % (dim, bmesh.conn.shape[1])
mat_id = nm.zeros(bmesh.conn.shape[0], dtype=nm.int32)
eval_mesh = Mesh.from_data(self.name + '_eval', nurbs.cps, None,
[nurbs.conn], [mat_id], [desc])
self.eval_mesh = eval_mesh
desc = '%d_%d' % (dim, 2**dim)
mat_id = nm.zeros(ltconn.shape[0], dtype=nm.int32)
self.mesh = Mesh.from_data(self.name + '_topo', ltcoors, None,
[ltconn], [mat_id], [desc])
self.cmesh = self.mesh.cmesh
gels = create_geometry_elements()
self.cmesh.set_local_entities(gels)
self.cmesh.setup_entities()
self.shape.tdim = self.cmesh.tdim
self.gel = gels[desc]
if regions is not None:
self.vertex_set_bcs = {}
for key, val in six.iteritems(self.regions):
self.vertex_set_bcs[key] = remap[val]
self.reset_regions()
def test_interpolation_two_meshes(self):
from sfepy import data_dir
from sfepy.discrete import Variables
from sfepy.discrete.fem import Mesh, FEDomain, Field
m1 = Mesh.from_file(data_dir + '/meshes/3d/block.mesh')
m2 = Mesh.from_file(data_dir + '/meshes/3d/cube_medium_tetra.mesh')
m2.coors[:] *= 2.0
bbox = m1.get_bounding_box()
dd = bbox[1, :] - bbox[0, :]
data = nm.sin(4.0 * nm.pi * m1.coors[:,0:1] / dd[0]) \
* nm.cos(4.0 * nm.pi * m1.coors[:,1:2] / dd[1])
variables1 = {
'u': ('unknown field', 'scalar_tp', 0),
'v': ('test field', 'scalar_tp', 'u'),
}
variables2 = {
'u': ('unknown field', 'scalar_si', 0),
'v': ('test field', 'scalar_si', 'u'),
}
d1 = FEDomain('d1', m1)
omega1 = d1.create_region('Omega', 'all')
field1 = Field.from_args('scalar_tp',
nm.float64, (1, 1),
omega1,
approx_order=1)
ff1 = {field1.name: field1}
d2 = FEDomain('d2', m2)
omega2 = d2.create_region('Omega', 'all')
field2 = Field.from_args('scalar_si',
nm.float64, (1, 1),
omega2,
approx_order=0)
ff2 = {field2.name: field2}
vv1 = Variables.from_conf(transform_variables(variables1), ff1)
u1 = vv1['u']
u1.set_from_mesh_vertices(data)
vv2 = Variables.from_conf(transform_variables(variables2), ff2)
u2 = vv2['u']
# Performs interpolation, if other field differs from self.field
# or, in particular, is defined on a different mesh.
u2.set_from_other(u1, strategy='interpolation', close_limit=0.1)
fname = in_dir(self.options.out_dir)
u1.save_as_mesh(fname('test_mesh_interp_block_scalar.vtk'))
u2.save_as_mesh(fname('test_mesh_interp_cube_scalar.vtk'))
return True
def __init__(self, name, nurbs, bmesh, regions=None, **kwargs):
"""
Create an IGA domain.
Parameters
----------
name : str
The domain name.
"""
Domain.__init__(self, name, nurbs=nurbs, bmesh=bmesh, regions=regions,
**kwargs)
from sfepy.discrete.fem.geometry_element import create_geometry_elements
from sfepy.discrete.fem import Mesh
from sfepy.discrete.fem.utils import prepare_remap
tconn = iga.get_bezier_topology(bmesh.conn, nurbs.degrees)
itc = nm.unique(tconn)
remap = prepare_remap(itc, bmesh.conn.max() + 1)
ltcoors = bmesh.cps[itc]
ltconn = remap[tconn]
n_nod, dim = ltcoors.shape
n_el = ltconn.shape[0]
self.shape = Struct(n_nod=n_nod, dim=dim, tdim=0, n_el=n_el)
desc = '%d_%d' % (dim, bmesh.conn.shape[1])
mat_id = nm.zeros(bmesh.conn.shape[0], dtype=nm.int32)
eval_mesh = Mesh.from_data(self.name + '_eval', nurbs.cps, None,
[nurbs.conn], [mat_id], [desc])
self.eval_mesh = eval_mesh
desc = '%d_%d' % (dim, 2**dim)
mat_id = nm.zeros(ltconn.shape[0], dtype=nm.int32)
self.mesh = Mesh.from_data(self.name + '_topo', ltcoors, None, [ltconn],
[mat_id], [desc])
self.cmesh = self.mesh.cmesh
gels = create_geometry_elements()
self.cmesh.set_local_entities(gels)
self.cmesh.setup_entities()
self.shape.tdim = self.cmesh.tdim
self.gel = gels[desc]
if regions is not None:
self.vertex_set_bcs = {}
for key, val in self.regions.iteritems():
self.vertex_set_bcs[key] = remap[val]
self.reset_regions()
def test_interpolation_two_meshes(self):
from sfepy import data_dir
from sfepy.discrete import Variables
from sfepy.discrete.fem import Mesh, FEDomain, Field
m1 = Mesh.from_file(data_dir + '/meshes/3d/block.mesh')
m2 = Mesh.from_file(data_dir + '/meshes/3d/cube_medium_tetra.mesh')
m2.coors[:] *= 2.0
bbox = m1.get_bounding_box()
dd = bbox[1,:] - bbox[0,:]
data = nm.sin(4.0 * nm.pi * m1.coors[:,0:1] / dd[0]) \
* nm.cos(4.0 * nm.pi * m1.coors[:,1:2] / dd[1])
variables1 = {
'u' : ('unknown field', 'scalar_tp', 0),
'v' : ('test field', 'scalar_tp', 'u'),
}
variables2 = {
'u' : ('unknown field', 'scalar_si', 0),
'v' : ('test field', 'scalar_si', 'u'),
}
d1 = FEDomain('d1', m1)
omega1 = d1.create_region('Omega', 'all')
field1 = Field.from_args('scalar_tp', nm.float64, (1,1), omega1,
approx_order=1)
ff1 = {field1.name : field1}
d2 = FEDomain('d2', m2)
omega2 = d2.create_region('Omega', 'all')
field2 = Field.from_args('scalar_si', nm.float64, (1,1), omega2,
approx_order=0)
ff2 = {field2.name : field2}
vv1 = Variables.from_conf(transform_variables(variables1), ff1)
u1 = vv1['u']
u1.set_from_mesh_vertices(data)
vv2 = Variables.from_conf(transform_variables(variables2), ff2)
u2 = vv2['u']
# Performs interpolation, if other field differs from self.field
# or, in particular, is defined on a different mesh.
u2.set_from_other(u1, strategy='interpolation', close_limit=0.1)
fname = in_dir(self.options.out_dir)
u1.save_as_mesh(fname('test_mesh_interp_block_scalar.vtk'))
u2.save_as_mesh(fname('test_mesh_interp_cube_scalar.vtk'))
return True
def test_write_read_meshes(self):
"""
Try to write and then read all supported formats.
"""
import numpy as nm
from sfepy.discrete.fem import Mesh
from sfepy.discrete.fem.meshio import supported_formats
conf_dir = op.dirname(__file__)
mesh0 = Mesh.from_file(data_dir +
'/meshes/various_formats/small3d.mesh',
prefix_dir=conf_dir)
mesh0.cmesh.vertex_groups[:] =\
nm.random.randint(1, 10, size=mesh0.cmesh.n_coor)
mesh0.cmesh.cell_groups[:] =\
nm.random.randint(1, 10, size=mesh0.cmesh.n_el)
oks = []
for name, (cls, suffix, flag) in six.iteritems(supported_formats):
if 'w' not in flag: continue
suffix = suffix[0] # only the first of possible suffixes
filename = op.join(self.options.out_dir, 'test_mesh_wr' + suffix)
self.report('%s format: %s' % (suffix, filename))
try:
mesh0.write(filename, io='auto')
except RuntimeError:
if cls == 'meshio':
import traceback
self.report('-> cannot write "%s" format into "%s",'
' skipping' % (name, filename))
tb = traceback.format_exc()
self.report('reason:\n', tb)
continue
else:
raise
else:
mesh1 = Mesh.from_file(filename)
ok = self._compare_meshes(mesh0, mesh1, flag)
self.report('->', sum(ok) == len(ok))
oks.extend(ok)
return sum(oks) == len(oks)
def from_conf(conf, options):
from sfepy import data_dir
from sfepy.discrete.fem import Mesh, FEDomain
from sfepy.discrete import Functions
mesh = Mesh("test mesh", data_dir + "/meshes/various_formats/abaqus_tet.inp")
mesh.nodal_bcs["set0"] = [0, 7]
domain = FEDomain("test domain", mesh)
conf_functions = {"get_vertices": (get_vertices,), "get_cells": (get_cells,)}
functions = Functions.from_conf(transform_functions(conf_functions))
test = Test(conf=conf, options=options, domain=domain, functions=functions)
return test
def refine_mesh(filename, level):
"""
Uniformly refine `level`-times a mesh given by `filename`.
The refined mesh is saved to a file with name constructed from base
name of `filename` and `level`-times appended `'_r'` suffix.
Parameters
----------
filename : str
The mesh file name.
level : int
The refinement level.
"""
import os
from sfepy.base.base import output
from sfepy.discrete.fem import Mesh, FEDomain
if level > 0:
mesh = Mesh.from_file(filename)
domain = FEDomain(mesh.name, mesh)
for ii in range(level):
output('refine %d...' % ii)
domain = domain.refine()
output('... %d nodes %d elements' %
(domain.shape.n_nod, domain.shape.n_el))
suffix = os.path.splitext(filename)[1]
filename = domain.name + suffix
domain.mesh.write(filename, io='auto')
return filename
def main():
parser = OptionParser(usage=usage)
(options, args) = parser.parse_args()
if len(args) != 1:
parser.print_help()
sys.exit(1)
mesh_dir = args[0]
mesh_files = []
for (dirpath, dirnames, filenames) in os.walk(mesh_dir):
for ii in filenames:
_, ext = os.path.splitext(ii)
if ext.lower() in ['.mesh', '.vtk']:
mesh_files.append(dirpath + os.path.sep + ii)
for ii in mesh_files:
base, ext = os.path.splitext(ii)
fname_out = base + '.png'
if ext == '.mesh':
fname_in = 'aux.vtk'
mesh = Mesh.from_file(ii)
mesh.write(fname_in, io='auto')
else:
fname_in = ii
print('writing %s...' % fname_out)
gen_shot(fname_in, fname_out)
def test_rcm(self):
from sfepy import data_dir
from sfepy.linalg import rcm, permute_in_place, save_sparse_txt
from sfepy.discrete.fem import Mesh
filename = data_dir + '/meshes/2d/special/square_triquad.mesh'
self.report('testing reversed Cuthill-McKee permutation')
conf_dir = op.dirname(__file__)
mesh = Mesh.from_file(filename, prefix_dir=conf_dir)
graph = mesh.create_conn_graph()
graph0 = graph.copy()
save_sparse_txt(op.join(self.options.out_dir, 'test_rcm_graph_orig'),
graph, fmt='%d %d %d\n')
perm = rcm(graph)
permute_in_place(graph, perm)
save_sparse_txt(op.join(self.options.out_dir, 'test_rcm_graph_rcm'),
graph, fmt='%d %d %d\n')
assert_((graph0.indptr != graph.indptr).any())
assert_((graph0.indices != graph.indices).any())
permute_in_place(graph, perm, inverse=True)
save_sparse_txt(op.join(self.options.out_dir, 'test_rcm_graph_rcm_inv'),
graph, fmt='%d %d %d\n')
assert_((graph0.indptr == graph.indptr).all())
assert_((graph0.indices == graph.indices).all())
return True
def triangulate(mesh, verbose=False):
"""
Triangulate a 2D or 3D tensor product mesh: quadrilaterals->triangles,
hexahedrons->tetrahedrons.
Parameters
----------
mesh : Mesh
The input mesh.
Returns
-------
mesh : Mesh
The triangulated mesh.
"""
conns = None
for k, new_desc in [('3_8', '3_4'), ('2_4', '2_3')]:
if k in mesh.descs:
conns = mesh.get_conn(k)
break
if conns is not None:
nelo = conns.shape[0]
output('initial mesh: %d elements' % nelo, verbose=verbose)
new_conns = elems_q2t(conns)
nn = new_conns.shape[0] // nelo
new_cgroups = nm.repeat(mesh.cmesh.cell_groups, nn)
output('new mesh: %d elements' % new_conns.shape[0], verbose=verbose)
mesh = Mesh.from_data(mesh.name, mesh.coors, mesh.cmesh.vertex_groups,
[new_conns], [new_cgroups], [new_desc])
return mesh
def test_spbox_2d(self):
"""
Check position of a given vertex in the deformed mesh.
"""
mesh = Mesh.from_file(data_dir + '/meshes/2d/square_tri1.mesh')
spb = SplineBox([[-1, 1], [-1, 0.6]], mesh.coors, nsg=[2, 1])
spb.move_control_point(1, [0.1, -0.2])
spb.move_control_point(2, [0.2, -0.3])
spb.move_control_point(3, [0.0, -0.1])
pt0 = mesh.coors[175, :].copy()
mesh.cmesh.coors[:] = spb.evaluate()
pt1 = mesh.coors[175, :]
expected_distance = 0.165892726387
actual_distance = nm.linalg.norm(pt0 - pt1)
ok = nm.fabs(actual_distance - expected_distance)\
/ expected_distance < tolerance
if not ok:
self.report('expected distance:')
self.report(expected_distance)
self.report('actual distance:')
self.report(actual_distance)
return ok
def from_conf(conf, options):
from sfepy.discrete import FieldVariable, Variables, Problem
from sfepy.discrete.fem import Mesh, FEDomain, Field
mesh = Mesh.from_file(data_dir + '/meshes/2d/square_unit_tri.mesh')
domain = FEDomain('domain', mesh)
omega = domain.create_region('Omega', 'all')
domain.create_region('Left', 'vertices in (x < -0.499)', 'facet')
domain.create_region(
'LeftStrip', 'vertices in (x < -0.499)'
' & (y > -0.199) & (y < 0.199)', 'facet')
domain.create_region('LeftFix', 'r.Left -v r.LeftStrip', 'facet')
domain.create_region('Right', 'vertices in (x > 0.499)', 'facet')
domain.create_region(
'RightStrip', 'vertices in (x > 0.499)'
' & (y > -0.199) & (y < 0.199)', 'facet')
domain.create_region('RightFix', 'r.Right -v r.RightStrip', 'facet')
fu = Field.from_args('fu', nm.float64, 'vector', omega, approx_order=2)
u = FieldVariable('u', 'unknown', fu)
fp = Field.from_args('fp', nm.float64, 'scalar', omega, approx_order=2)
p = FieldVariable('p', 'unknown', fp)
pb = Problem('test', domain=domain, fields=[fu, fp], auto_conf=False)
test = Test(problem=pb,
variables=Variables([u, p]),
conf=conf,
options=options)
return test
def from_conf(conf, options):
import sfepy
from sfepy.discrete.fem import Mesh, FEDomain, Field
mesh = Mesh.from_file('meshes/2d/rectangle_tri.mesh',
prefix_dir=sfepy.data_dir)
domain = FEDomain('domain', mesh)
dim = domain.shape.dim
min_x, max_x = domain.get_mesh_bounding_box()[:,0]
eps = 1e-8 * (max_x - min_x)
omega = domain.create_region('Omega', 'all')
gamma1 = domain.create_region('Gamma1',
'vertices in x < %.10f' % (min_x + eps),
'facet')
gamma2 = domain.create_region('Gamma2',
'vertices in x > %.10f' % (max_x - eps),
'facet')
field = Field.from_args('fu', nm.float64, 'vector', omega,
approx_order=2)
test = Test(conf=conf, options=options, dim=dim,
omega=omega, gamma1=gamma1, gamma2=gamma2,
field=field)
return test
def save_basis(nurbs, pars):
"""
Save a NURBS object basis on a FE mesh corresponding to the given
parametrization in VTK files.
Parameters
----------
nurbs : igakit.nurbs.NURBS instance
The NURBS object.
pars : sequence of array, optional
The values of parameters in each parametric dimension.
"""
coors, conn, desc = create_linear_fe_mesh(nurbs, pars)
mat_id = nm.zeros(conn.shape[0], dtype=nm.int32)
mesh = Mesh.from_data('nurbs', coors, None, [conn], [mat_id], [desc])
n_dof = nurbs.weights.ravel().shape[0]
variable = nm.zeros(n_dof, dtype=nm.float64)
field = variable.reshape(nurbs.weights.shape)
for ic in xrange(n_dof):
variable[ic - 1] = 0.0
variable[ic] = 1.0
vals = nurbs.evaluate(field, *pars).reshape((-1))
out = {}
out['bf'] = Struct(name='output_data', mode='vertex',
data=vals[:, None])
mesh.write('iga_basis_%03d.vtk' % ic, io='auto', out=out)
def gen_two_bodies(dims0, shape0, centre0, dims1, shape1, centre1, shift1):
from sfepy.discrete.fem import Mesh
from sfepy.mesh.mesh_generators import gen_block_mesh
m0 = gen_block_mesh(dims0, shape0, centre0)
m1 = gen_block_mesh(dims1, shape1, centre1)
coors = nm.concatenate((m0.coors, m1.coors + shift1), axis=0)
desc = m0.descs[0]
c0 = m0.get_conn(desc)
c1 = m1.get_conn(desc)
conn = nm.concatenate((c0, c1 + m0.n_nod), axis=0)
ngroups = nm.zeros(coors.shape[0], dtype=nm.int32)
ngroups[m0.n_nod:] = 1
mat_id = nm.zeros(conn.shape[0], dtype=nm.int32)
mat_id[m0.n_el:] = 1
name = 'two_bodies.mesh'
mesh = Mesh.from_data(name, coors, ngroups, [conn], [mat_id], m0.descs)
mesh.write(name, io='auto')
return mesh
def test_refine_3_8(self):
mesh = Mesh.from_file(data_dir + '/meshes/elements/3_8_1.mesh')
domain = refine(FEDomain('domain', mesh), self.options.out_dir, 1)
ok = compare_mesh('3_8', domain.mesh.coors, domain.mesh.get_conn('3_8'))
return ok
def main():
parser = ArgumentParser(description=__doc__)
parser.add_argument('--version', action='version', version='%(prog)s')
parser.add_argument('--eps', action='store', dest='eps',
default=1e-12, help=helps['eps'])
parser.add_argument('-o', '--filename-out',
action='store', dest='filename_out',
default=None, help=helps['filename-out'])
parser.add_argument('filename')
options = parser.parse_args()
filename = options.filename
mesh = Mesh.from_file(filename)
mesh_out = extract_edges(mesh, eps=float(options.eps))
mesh_out = merge_lines(mesh_out)
filename_out = options.filename_out
if filename_out is None:
filename_out = edit_filename(filename, prefix='edge_', new_ext='.vtk')
output('Outline mesh - vertices: %d, edges: %d, output filename: %s'
% (mesh_out[0].shape[0], mesh_out[2][0].shape[0], filename_out))
# hack to write '3_2' elements - edges
io = VTKMeshIO(None)
aux_mesh = Struct()
aux_mesh._get_io_data = lambda: mesh_out
aux_mesh.n_el = mesh_out[2][0].shape[0]
io.write(filename_out, aux_mesh)
def test_rcm(self):
from sfepy import data_dir
from sfepy.linalg import rcm, permute_in_place, save_sparse_txt
from sfepy.discrete.fem import Mesh
filename = data_dir + '/meshes/2d/special/square_triquad.mesh'
self.report('testing reversed Cuthill-McKee permutation')
conf_dir = op.dirname(__file__)
mesh = Mesh.from_file(filename, prefix_dir=conf_dir)
graph = mesh.create_conn_graph()
graph0 = graph.copy()
save_sparse_txt(op.join(self.options.out_dir, 'test_rcm_graph_orig'),
graph, fmt='%d %d %d\n')
perm = rcm(graph)
permute_in_place(graph, perm)
save_sparse_txt(op.join(self.options.out_dir, 'test_rcm_graph_rcm'),
graph, fmt='%d %d %d\n')
assert_((graph0.indptr != graph.indptr).any())
assert_((graph0.indices != graph.indices).any())
permute_in_place(graph, perm, inverse=True)
save_sparse_txt(op.join(self.options.out_dir, 'test_rcm_graph_rcm_inv'),
graph, fmt='%d %d %d\n')
assert_((graph0.indptr == graph.indptr).all())
assert_((graph0.indices == graph.indices).all())
return True
def _get_bqp(geometry, order):
from sfepy.discrete import Integral
from sfepy.discrete.fem.geometry_element import GeometryElement
from sfepy.discrete.fem import Mesh, FEDomain, Field
gel = GeometryElement(geometry)
mesh = Mesh.from_data('aux', gel.coors, None,
[gel.conn[None, :]], [[0]], [geometry])
domain = FEDomain('domain', mesh)
omega = domain.create_region('Omega', 'all')
surf = domain.create_region('Surf', 'vertices of surface', 'facet')
field = Field.from_args('f', nm.float64, shape=1,
region=omega, approx_order=1)
field.setup_surface_data(surf)
integral = Integral('aux', order=order)
field.create_bqp('Surf', integral)
sd = field.surface_data['Surf']
qp = field.qp_coors[(integral.order, sd.bkey)]
output('geometry:', geometry, 'order:', order, 'num. points:',
qp.vals.shape[1], 'true_order:',
integral.qps[gel.surface_facet_name].order)
output('min. weight:', qp.weights.min())
output('max. weight:', qp.weights.max())
return (gel, qp.vals.reshape((-1, mesh.dim)),
nm.tile(qp.weights, qp.vals.shape[0]))
def test_read_meshes(self):
"""Try to read all listed meshes."""
from sfepy.discrete.fem import Mesh
conf_dir = op.dirname(__file__)
meshes = {}
for ii, filename in enumerate(filename_meshes):
self.report("%d. mesh: %s" % (ii + 1, filename))
mesh = Mesh.from_file(filename, prefix_dir=conf_dir)
assert_(mesh.dim == (mesh.coors.shape[1]))
assert_(mesh.n_nod == (mesh.coors.shape[0]))
assert_(mesh.n_nod == (mesh.ngroups.shape[0]))
assert_(mesh.n_el == sum(mesh.n_els))
for ig, conn in enumerate(mesh.conns):
assert_(conn.shape[0] == len(mesh.mat_ids[ig]))
assert_(conn.shape[0] == mesh.n_els[ig])
assert_(conn.shape[1] == mesh.n_e_ps[ig])
self.report("read ok")
meshes[filename] = mesh
self.meshes = meshes
return True
def main():
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('mesh_dir')
options = parser.parse_args()
mesh_dir = options.mesh_dir
mesh_files = []
for (dirpath, dirnames, filenames) in os.walk(mesh_dir):
for ii in filenames:
_, ext = os.path.splitext(ii)
if ext.lower() in ['.mesh', '.vtk']:
mesh_files.append(dirpath + os.path.sep + ii)
for ii in mesh_files:
base, ext = os.path.splitext(ii)
fname_out = base + '.png'
if ext == '.mesh':
fname_in = 'aux.vtk'
mesh = Mesh.from_file(ii)
mesh.write(fname_in, io='auto')
else:
fname_in = ii
print(('writing %s...' % fname_out))
gen_shot(fname_in, fname_out)
def main():
parser = ArgumentParser(description=__doc__,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('mesh_dir')
options = parser.parse_args()
mesh_dir = options.mesh_dir
mesh_files = []
for (dirpath, dirnames, filenames) in os.walk(mesh_dir):
for ii in filenames:
_, ext = os.path.splitext(ii)
if ext.lower() in ['.mesh', '.vtk']:
mesh_files.append(dirpath + os.path.sep + ii)
for ii in mesh_files:
base, ext = os.path.splitext(ii)
fname_out = base + '.png'
if ext == '.mesh':
fname_in = 'aux.vtk'
mesh = Mesh.from_file(ii)
mesh.write(fname_in, io='auto')
else:
fname_in = ii
print(('writing %s...' % fname_out))
gen_shot(fname_in, fname_out)
def main():
parser = ArgumentParser(description=__doc__)
parser.add_argument('--version', action='version', version='%(prog)s')
parser.add_argument('filename')
options = parser.parse_args()
filename = options.filename
mesh = Mesh.from_file(filename)
output('Mesh:')
output(' dimension: %d, vertices: %d, elements: %d'
% (mesh.dim, mesh.n_nod, mesh.n_el))
domain = FEDomain('domain', mesh)
output(domain.cmesh)
domain.cmesh.cprint(1)
dim = domain.cmesh.dim
entities_opts = [
{'color' : 'k', 'label_global' : 12, 'label_local' : 8},
{'color' : 'b', 'label_global' : 12, 'label_local' : 8},
{'color' : 'g', 'label_global' : 12, 'label_local' : 8},
{'color' : 'r', 'label_global' : 12},
]
if dim == 2: entities_opts.pop(2)
pc.plot_cmesh(None, domain.cmesh,
wireframe_opts = {'color' : 'k'},
entities_opts=entities_opts)
plt.show()
def test_refine_3_8(self):
mesh = Mesh('3_8', data_dir + '/meshes/elements/3_8_1.mesh')
domain = refine(FEDomain('domain', mesh), self.options.out_dir, 1)
ok = compare_mesh('3_8', domain.mesh.coors, domain.mesh.conns[0])
return ok
def main():
parser = OptionParser(usage=usage)
(options, args) = parser.parse_args()
if len(args) != 1:
parser.print_help()
sys.exit(1)
mesh_dir = args[0]
mesh_files = []
for (dirpath, dirnames, filenames) in os.walk(mesh_dir):
for ii in filenames:
_, ext = os.path.splitext(ii)
if ext.lower() in ['.mesh', '.vtk']:
mesh_files.append(dirpath + os.path.sep + ii)
for ii in mesh_files:
base, ext = os.path.splitext(ii)
fname_out = base + '.png'
if ext == '.mesh':
fname_in = 'aux.vtk'
mesh = Mesh.from_file(ii)
mesh.write(fname_in, io='auto')
else:
fname_in = ii
print('writing %s...' % fname_out)
gen_shot(fname_in, fname_out)
def save_basis(nurbs, pars):
"""
Save a NURBS object basis on a FE mesh corresponding to the given
parametrization in VTK files.
Parameters
----------
nurbs : igakit.nurbs.NURBS instance
The NURBS object.
pars : sequence of array, optional
The values of parameters in each parametric dimension.
"""
coors, conn, desc = create_linear_fe_mesh(nurbs, pars)
mat_id = nm.zeros(conn.shape[0], dtype=nm.int32)
mesh = Mesh.from_data('nurbs', coors, None, [conn], [mat_id], [desc])
n_dof = nurbs.weights.ravel().shape[0]
variable = nm.zeros(n_dof, dtype=nm.float64)
field = variable.reshape(nurbs.weights.shape)
for ic in xrange(n_dof):
variable[ic - 1] = 0.0
variable[ic] = 1.0
vals = nurbs.evaluate(field, *pars).reshape((-1))
out = {}
out['bf'] = Struct(name='output_data',
mode='vertex',
data=vals[:, None])
mesh.write('iga_basis_%03d.vtk' % ic, io='auto', out=out)
def test_read_meshes(self):
"""Try to read all listed meshes."""
from sfepy.discrete.fem import Mesh
ok = True
conf_dir = op.dirname(__file__)
self.meshes = {}
for ii, filename in enumerate(filename_meshes):
self.report('%d. mesh: %s' % (ii + 1, filename))
try:
mesh = Mesh.from_file(filename, prefix_dir=conf_dir)
except Exception as exc:
self.report(exc)
self.report('read failed!')
ok = False
continue
try:
assert_(mesh.dim == (mesh.coors.shape[1]))
assert_(mesh.n_nod == (mesh.coors.shape[0]))
assert_(mesh.n_nod == (mesh.cmesh.vertex_groups.shape[0]))
assert_(mesh.n_el == mesh.cmesh.num[mesh.cmesh.tdim])
except ValueError as exc:
self.report(exc)
self.report('read assertion failed!')
ok = False
continue
self.report('read ok')
self.meshes[filename] = mesh
return ok
def main():
parser = ArgumentParser(description=__doc__.rstrip(),
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('filename', help=helps['filename'])
parser.add_argument('-d', '--detailed',
action='store_true', dest='detailed',
default=False, help=helps['detailed'])
options = parser.parse_args()
mesh = Mesh.from_file(options.filename)
output(mesh.cmesh)
output('element types:', mesh.descs)
output('nodal BCs:', sorted(mesh.nodal_bcs.keys()))
bbox = mesh.get_bounding_box()
output('bounding box: %s'
% ', '.join('%s: [%s, %s]' % (name, bbox[0, ii], bbox[1, ii])
for ii, name in enumerate('xyz'[:mesh.dim])))
output('centre:', mesh.coors.mean(0))
if not options.detailed: return
from sfepy.discrete.fem.geometry_element import create_geometry_elements
gels = create_geometry_elements()
mesh.cmesh.set_local_entities(gels)
mesh.cmesh.setup_entities()
for dim in range(1, mesh.cmesh.tdim + 1):
volumes = mesh.cmesh.get_volumes(dim)
output('volumes of %d %dD entities: min: %s mean: %s max: %s'
% (mesh.cmesh.num[dim],
dim, volumes.min(), volumes.mean(), volumes.max()))
def triangulate(mesh, verbose=False):
"""
Triangulate a 2D or 3D tensor product mesh: quadrilaterals->triangles,
hexahedrons->tetrahedrons.
Parameters
----------
mesh : Mesh
The input mesh.
Returns
-------
mesh : Mesh
The triangulated mesh.
"""
conns = None
for k, new_desc in [('3_8', '3_4'), ('2_4', '2_3')]:
if k in mesh.descs:
conns = mesh.get_conn(k)
break
if conns is not None:
nelo = conns.shape[0]
output('initial mesh: %d elements' % nelo, verbose=verbose)
new_conns = elems_q2t(conns)
nn = new_conns.shape[0] // nelo
new_cgroups = nm.repeat(mesh.cmesh.cell_groups, nn)
output('new mesh: %d elements' % new_conns.shape[0], verbose=verbose)
mesh = Mesh.from_data(mesh.name, mesh.coors,
mesh.cmesh.vertex_groups,
[new_conns], [new_cgroups], [new_desc])
return mesh
def refine_mesh(filename, level):
"""
Uniformly refine `level`-times a mesh given by `filename`.
The refined mesh is saved to a file with name constructed from base
name of `filename` and `level`-times appended `'_r'` suffix.
Parameters
----------
filename : str
The mesh file name.
level : int
The refinement level.
"""
import os
from sfepy.base.base import output
from sfepy.discrete.fem import Mesh, FEDomain
if level > 0:
mesh = Mesh.from_file(filename)
domain = FEDomain(mesh.name, mesh)
for ii in range(level):
output('refine %d...' % ii)
domain = domain.refine()
output('... %d nodes %d elements'
% (domain.shape.n_nod, domain.shape.n_el))
suffix = os.path.splitext(filename)[1]
filename = domain.name + suffix
domain.mesh.write(filename, io='auto')
return filename
def test_spbox_2d(self):
"""
Check position of a given vertex in the deformed mesh.
"""
mesh = Mesh.from_file(data_dir + '/meshes/2d/square_tri1.mesh')
spb = SplineBox([[-1, 1], [-1, 0.6]], mesh.coors, nsg=[2,1])
spb.move_control_point(1, [0.1, -0.2])
spb.move_control_point(2, [0.2, -0.3])
spb.move_control_point(3, [0.0, -0.1])
pt0 = mesh.coors[175,:].copy()
mesh.cmesh.coors[:] = spb.evaluate()
pt1 = mesh.coors[175,:]
expected_distance = 0.165892726387
actual_distance = nm.linalg.norm(pt0 - pt1)
ok = nm.fabs(actual_distance - expected_distance)\
/ expected_distance < tolerance
if not ok:
self.report('expected distance:')
self.report(expected_distance)
self.report('actual distance:')
self.report(actual_distance)
return ok
def refine_2_3(mesh_in):
"""
Refines mesh out of triangles by cutting cutting each edge in half
and making 4 new finer triangles out of one coarser one.
"""
cmesh = mesh_in.cmesh
# Unique edge centres.
e_centres = cmesh.get_centroids(cmesh.dim - 1)
# New coordinates after the original ones.
coors = nm.r_[mesh_in.coors, e_centres]
o1 = mesh_in.n_nod
cc = cmesh.get_conn(cmesh.dim, cmesh.dim - 1)
conn = mesh_in.get_conn('2_3')
n_el = conn.shape[0]
e_nodes = cc.indices.reshape((n_el, 3)) + o1
c = nm.c_[conn, e_nodes].T
new_conn = nm.vstack([
c[0], c[3], c[5], c[3], c[4], c[5], c[1], c[4], c[3], c[2], c[5], c[4]
]).T
new_conn = new_conn.reshape((4 * n_el, 3))
new_mat_id = cmesh.cell_groups.repeat(4)
mesh = Mesh.from_data(mesh_in.name + '_r', coors, None, [new_conn],
[new_mat_id], mesh_in.descs)
return mesh
def _get_bqp(geometry, order):
from sfepy.discrete import Integral
from sfepy.discrete.fem.geometry_element import GeometryElement
from sfepy.discrete.fem import Mesh, FEDomain, Field
gel = GeometryElement(geometry)
mesh = Mesh.from_data('aux', gel.coors, None, [gel.conn[None, :]], [[0]],
[geometry])
domain = FEDomain('domain', mesh)
omega = domain.create_region('Omega', 'all')
surf = domain.create_region('Surf', 'vertices of surface', 'facet')
field = Field.from_args('f',
nm.float64,
shape=1,
region=omega,
approx_order=1)
field.setup_surface_data(surf)
integral = Integral('aux', order=order)
field.create_bqp('Surf', integral)
sd = field.surface_data['Surf']
qp = field.qp_coors[(integral.order, sd.bkey)]
output('geometry:', geometry, 'order:', order, 'num. points:',
qp.vals.shape[1], 'true_order:',
integral.qps[gel.surface_facet_name].order)
output('min. weight:', qp.weights.min())
output('max. weight:', qp.weights.max())
return (gel, qp.vals.reshape(
(-1, mesh.dim)), nm.tile(qp.weights, qp.vals.shape[0]))
def from_conf(conf, options):
import sfepy
from sfepy.discrete.fem import Mesh, Domain, Field
mesh = Mesh.from_file('meshes/2d/rectangle_tri.mesh',
prefix_dir=sfepy.data_dir)
domain = Domain('domain', mesh)
dim = domain.shape.dim
min_x, max_x = domain.get_mesh_bounding_box()[:,0]
eps = 1e-8 * (max_x - min_x)
omega = domain.create_region('Omega', 'all')
gamma1 = domain.create_region('Gamma1',
'vertices in x < %.10f' % (min_x + eps),
'facet')
gamma2 = domain.create_region('Gamma2',
'vertices in x > %.10f' % (max_x - eps),
'facet')
field = Field.from_args('fu', nm.float64, 'vector', omega,
approx_order=2)
test = Test(conf=conf, options=options, dim=dim,
omega=omega, gamma1=gamma1, gamma2=gamma2,
field=field)
return test
def prepare_variable(filename, n_components):
from sfepy.discrete import FieldVariable
from sfepy.discrete.fem import Mesh, FEDomain, Field
mesh = Mesh.from_file(filename)
bbox = mesh.get_bounding_box()
dd = bbox[1, :] - bbox[0, :]
data = (nm.sin(4.0 * nm.pi * mesh.coors[:, 0:1] / dd[0]) *
nm.cos(4.0 * nm.pi * mesh.coors[:, 1:2] / dd[1]))
domain = FEDomain('domain', mesh)
omega = domain.create_region('Omega', 'all')
field = Field.from_args('field',
nm.float64,
n_components,
omega,
approx_order=2)
u = FieldVariable('u',
'parameter',
field,
primary_var_name='(set-to-None)')
u.set_from_mesh_vertices(data * nm.arange(1, n_components + 1)[None, :])
return u
def refine_3_8(mesh_in, cmesh):
"""
Refines hexahedral mesh by cutting cutting each edge in half and
making 8 new finer hexahedrons out of one coarser one.
"""
# Unique edge centres.
e_centres = cmesh.get_centroids(cmesh.dim - 2)
# Unique face centres.
f_centres = cmesh.get_centroids(cmesh.dim - 1)
# Unique element centres.
coors = mesh_in.get_element_coors()
centres = 0.125 * nm.sum(coors, axis=1)
# New coordinates after the original ones.
coors = nm.r_[mesh_in.coors, e_centres, f_centres, centres]
o1 = mesh_in.n_nod
o2 = o1 + e_centres.shape[0]
o3 = o2 + f_centres.shape[0]
ecc = cmesh.get_conn(cmesh.dim, cmesh.dim - 2)
eoffs = ecc.offsets
fcc = cmesh.get_conn(cmesh.dim, cmesh.dim - 1)
foffs = fcc.offsets
st = nm.vstack
conns = []
mat_ids = []
for ig, conn in enumerate(mesh_in.conns):
off0, off1 = mesh_in.el_offsets[ig : ig + 2]
n_el = conn.shape[0]
e_nodes = ecc.indices[eoffs[off0]:eoffs[off1]].reshape((n_el, 12)) + o1
f_nodes = fcc.indices[foffs[off0]:foffs[off1]].reshape((n_el, 6)) + o2
nodes = nm.arange(n_el) + off0 + o3
c = nm.c_[conn, e_nodes, f_nodes, nodes].T
new_conn = st([c[0], c[8], c[20], c[11], c[16], c[22], c[26], c[21],
c[1], c[9], c[20], c[8], c[17], c[24], c[26], c[22],
c[2], c[10], c[20], c[9], c[18], c[25], c[26], c[24],
c[3], c[11], c[20], c[10], c[19], c[21], c[26], c[25],
c[4], c[15], c[23], c[12], c[16], c[21], c[26], c[22],
c[5], c[12], c[23], c[13], c[17], c[22], c[26], c[24],
c[6], c[13], c[23], c[14], c[18], c[24], c[26], c[25],
c[7], c[14], c[23], c[15], c[19], c[25], c[26], c[21]]).T
new_conn = new_conn.reshape((8 * n_el, 8))
conns.append(new_conn)
new_mat_id = mesh_in.mat_ids[ig].repeat(8)
mat_ids.append(new_mat_id)
mesh = Mesh.from_data(mesh_in.name + '_r', coors, None, conns,
mat_ids, mesh_in.descs )
return mesh
def from_conf(conf, options):
from sfepy.discrete import Integral
from sfepy.discrete.fem import Mesh, FEDomain
domains = []
for filename in filename_meshes:
mesh = Mesh.from_file(filename)
domain = FEDomain('domain_%s' % mesh.name.replace(data_dir, ''),
mesh)
domain.create_region('Omega', 'all')
domain.create_region('Gamma', 'vertices of surface', 'facet')
domains.append(domain)
integral = Integral('i', order=3)
qp_coors, qp_weights = integral.get_qp('3_8')
custom_integral = Integral('i',
coors=qp_coors,
weights=qp_weights,
order='custom')
test = Test(domains=domains,
integral=integral,
custom_integral=custom_integral,
conf=conf,
options=options)
return test
def test_entity_volumes(self):
import sfepy
from sfepy.discrete.fem import Mesh, FEDomain
from sfepy.discrete.common import Field
from sfepy.discrete import Integral
mesh = Mesh.from_file('meshes/3d/special/cross3d.mesh',
prefix_dir=sfepy.data_dir)
domain = FEDomain('domain', mesh)
omega = domain.create_region('Omega', 'all')
gamma = domain.create_region('Gamma', 'vertices of surface', 'facet')
top = domain.create_region('Top', 'cell 2')
vfield = Field.from_args('v', nm.float64, 'scalar', omega,
approx_order=1)
sfield = Field.from_args('s', nm.float64, 'scalar', gamma,
approx_order=1)
integral = Integral('i', order=3)
vgeo, _ = vfield.get_mapping(omega, integral, 'volume')
domain.create_surface_group(gamma)
sgeo, _ = sfield.get_mapping(gamma, integral, 'surface')
evols = mesh.cmesh.get_volumes(1)
fvols = mesh.cmesh.get_volumes(2) # Approximate for non-planar faces.
cvols = mesh.cmesh.get_volumes(3)
ok = True
_ok = abs(cvols.sum() - vgeo.volume.sum()) < 1e-15
self.report('total cell volume: %s (ok: %s)' % (cvols.sum(), _ok))
ok = _ok and ok
top_evols = nm.array([ 1. , 1. ,
1. , 1. ,
0.7211102550927979, 0.7211102550927979,
0.7211102550927979, 0.7211102550927979,
1.16619037896906 , 1.16619037896906 ,
1.16619037896906 , 1.16619037896906 ])
_ok = nm.allclose(top_evols, evols[top.edges], rtol=0.0, atol=1e-15)
self.report('total top cell edge length: %s (ok: %s)'
% (evols[top.edges].sum(), _ok))
ok = _ok and ok
i1 = [5, 6, 8, 9]
i2 = nm.setdiff1d(nm.arange(len(gamma.faces)), i1)
aux = fvols[gamma.faces] - sgeo.volume.ravel()
_ok = nm.allclose(aux[i1], 0.10560208437556773, rtol=0.0, atol=1e-15)
ok = _ok and ok
self.report('non-planar faces diff: %s (ok: %s)' % (aux[i1], _ok))
_ok = (nm.abs(aux[i2]) < 1e-15).all()
self.report('max. planar faces diff: %s (ok: %s)'
% (nm.abs(aux[i2]).max(), _ok))
ok = _ok and ok
return ok
def refine_3_4(mesh_in, cmesh):
"""
Refines tetrahedra by cutting each edge in half and making 8 new
finer tetrahedra out of one coarser one. Old nodal coordinates come
first in `coors`, then the new ones. The new tetrahedra are similar
to the old one, no degeneration is supposed to occur as at most 3
congruence classes of tetrahedra appear, even when re-applied
iteratively (provided that `conns` are not modified between two
applications - ordering of vertices in tetrahedra matters not only
for positivity of volumes).
References:
- Juergen Bey: Simplicial grid refinement: on Freudenthal s algorithm and
the optimal number of congruence classes, Numer.Math. 85 (2000),
no. 1, 1--29, or
- Juergen Bey: Tetrahedral grid refinement, Computing 55 (1995),
no. 4, 355--378, or
http://citeseer.ist.psu.edu/bey95tetrahedral.html
"""
# Unique edge centres.
e_centres = cmesh.get_centroids(cmesh.dim - 2)
# New coordinates after the original ones.
coors = nm.r_[mesh_in.coors, e_centres]
o1 = mesh_in.n_nod
cc = cmesh.get_conn(cmesh.dim, cmesh.dim - 2)
offs = cc.offsets
conns = []
mat_ids = []
for ig, conn in enumerate(mesh_in.conns):
off0, off1 = mesh_in.el_offsets[ig : ig + 2]
n_el = conn.shape[0]
e_nodes = cc.indices[offs[off0]:offs[off1]].reshape((n_el, 6)) + o1
c = nm.c_[conn, e_nodes].T
new_conn = nm.vstack([c[0], c[4], c[6], c[7],
c[4], c[1], c[5], c[8],
c[6], c[5], c[2], c[9],
c[7], c[8], c[9], c[3],
c[4], c[6], c[7], c[8],
c[4], c[6], c[8], c[5],
c[6], c[7], c[8], c[9],
c[6], c[5], c[9], c[8]]).T
new_conn = new_conn.reshape((8 * n_el, 4))
conns.append(new_conn)
new_mat_id = mesh_in.mat_ids[ig].repeat(8)
mat_ids.append(new_mat_id)
mesh = Mesh.from_data(mesh_in.name + '_r', coors, None, conns,
mat_ids, mesh_in.descs )
return mesh
def solveLaplaceEquationTetrahedral(mesh, meshVTK, boundaryPoints,
boundaryConditions):
"""
mesh: path to a 3D mesh / sfepy mesh
"""
if isinstance(mesh, str):
mesh = Mesh.from_file(mesh)
#Set domains
domain = FEDomain('domain', mesh)
omega = domain.create_region('Omega', 'all')
boundary = domain.create_region(
'gamma',
'vertex %s' % ','.join(map(str, range(meshVTK.GetNumberOfPoints()))),
'facet')
#set fields
field = Field.from_args('fu', np.float64, 1, omega, approx_order=1)
u = FieldVariable('u', 'unknown', field)
v = FieldVariable('v', 'test', field, primary_var_name='u')
m = Material('m', val=[1.])
#Define element integrals
integral = Integral('i', order=3)
#Equations defining
t1 = Term.new('dw_laplace( v, u )', integral, omega, v=v, u=u)
eq = Equation('balance', t1)
eqs = Equations([eq])
heatBoundary = boundaryConditions
points = boundaryPoints
#Boundary conditions
c = ClosestPointStupid(points, heatBoundary, meshVTK)
def u_fun(ts, coors, bc=None, problem=None, c=c):
c.distances = []
v = np.zeros(len(coors))
for i, p in enumerate(coors):
v[i] = c.interpolate(p)
#c.findClosestPoint(p)
return v
bc_fun = Function('u_fun', u_fun)
fix1 = EssentialBC('fix_u', boundary, {'u.all': bc_fun})
#Solve problem
ls = ScipyDirect({})
nls = Newton({}, lin_solver=ls)
pb = Problem('heat', equations=eqs)
pb.set_bcs(ebcs=Conditions([fix1]))
pb.set_solver(nls)
state = pb.solve(verbose=False, save_results=False)
u = state.get_parts()['u']
return u
def test_refine_hexa(self):
mesh = Mesh('mesh_hexa',
data_dir + '/meshes/various_formats/abaqus_hex.inp')
domain = FEDomain('domain', mesh)
refine(domain, self.options.out_dir)
return True
def test_refine_3_4(self):
mesh = Mesh.from_file(data_dir + '/meshes/elements/3_4_1.mesh')
domain = refine(FEDomain('domain', mesh), self.options.out_dir, 1)
ok = compare_mesh('3_4', domain.mesh.coors,
domain.mesh.get_conn('3_4'))
return ok
def test_refine_hexa(self):
filename = data_dir + '/meshes/various_formats/abaqus_hex.inp'
mesh = Mesh.from_file(filename)
domain = FEDomain('domain', mesh)
refine(domain, self.options.out_dir)
return True
def test_refine_hexa(self):
filename = data_dir + '/meshes/various_formats/abaqus_hex.inp'
mesh = Mesh.from_file(filename)
domain = FEDomain('domain', mesh)
refine(domain, self.options.out_dir)
return True
def __init__(self, name, nurbs, bmesh, regions=None, **kwargs):
"""
Create an IGA domain.
Parameters
----------
name : str
The domain name.
"""
Domain.__init__(self, name, nurbs=nurbs, bmesh=bmesh, regions=regions,
**kwargs)
from sfepy.discrete.fem.geometry_element import create_geometry_elements
from sfepy.discrete.fem import Mesh
from sfepy.discrete.fem.extmods.cmesh import CMesh
from sfepy.discrete.fem.utils import prepare_remap
ac = nm.ascontiguousarray
self.nurbs.cs = [ac(nm.array(cc, dtype=nm.float64)[:, None, ...])
for cc in self.nurbs.cs]
self.nurbs.degrees = self.nurbs.degrees.astype(nm.int32)
self.facets = iga.get_bezier_element_entities(nurbs.degrees)
tconn = iga.get_bezier_topology(bmesh.conn, nurbs.degrees)
itc = nm.unique(tconn)
remap = prepare_remap(itc, bmesh.conn.max() + 1)
ltcoors = bmesh.cps[itc]
ltconn = remap[tconn]
n_nod, dim = ltcoors.shape
n_el = ltconn.shape[0]
self.shape = Struct(n_nod=n_nod, dim=dim, tdim=0, n_el=n_el, n_gr=1)
desc = '%d_%d' % (dim, 2**dim)
mat_id = nm.zeros(ltconn.shape[0], dtype=nm.int32)
self.mesh = Mesh.from_data(self.name + '_topo', ltcoors, None, [ltconn],
[mat_id], [desc])
self.cmesh = CMesh.from_mesh(self.mesh)
gels = create_geometry_elements()
self.cmesh.set_local_entities(gels)
self.cmesh.setup_entities()
self.shape.tdim = self.cmesh.tdim
self.gel = gels[desc]
if regions is not None:
self.vertex_set_bcs = {}
for key, val in self.regions.iteritems():
self.vertex_set_bcs[key] = remap[val]
self.cell_offsets = {0 : 0}
self.reset_regions()
def test_invariance_qp(self):
from sfepy import data_dir
from sfepy.discrete import Variables, Integral
from sfepy.discrete.fem import Mesh, Domain, Field
from sfepy.terms import Term
from sfepy.discrete.fem.mappings import get_physical_qps
mesh = Mesh('source mesh', data_dir + '/meshes/3d/block.mesh')
bbox = mesh.get_bounding_box()
dd = bbox[1,:] - bbox[0,:]
data = nm.sin(4.0 * nm.pi * mesh.coors[:,0:1] / dd[0]) \
* nm.cos(4.0 * nm.pi * mesh.coors[:,1:2] / dd[1])
variables = {
'u' : ('unknown field', 'scalar_tp', 0),
'v' : ('test field', 'scalar_tp', 'u'),
}
domain = Domain('domain', mesh)
omega = domain.create_region('Omega', 'all')
field = Field.from_args('scalar_tp', nm.float64, 1, omega,
approx_order=1)
ff = {field.name : field}
vv = Variables.from_conf(transform_variables(variables), ff)
u = vv['u']
u.set_from_mesh_vertices(data)
integral = Integral('i', order=2)
term = Term.new('ev_volume_integrate(u)', integral, omega, u=u)
term.setup()
val1, _ = term.evaluate(mode='qp')
val1 = val1.ravel()
qps = get_physical_qps(omega, integral)
coors = qps.get_merged_values()
val2 = u.evaluate_at(coors).ravel()
self.report('max. difference:', nm.abs(val1 - val2).max())
ok = nm.allclose(val1, val2, rtol=0.0, atol=1e-12)
self.report('invariance in qp: %s' % ok)
return ok
def refine_3_4(mesh_in, cmesh):
"""
Refines tetrahedra by cutting each edge in half and making 8 new
finer tetrahedra out of one coarser one. Old nodal coordinates come
first in `coors`, then the new ones. The new tetrahedra are similar
to the old one, no degeneration is supposed to occur as at most 3
congruence classes of tetrahedra appear, even when re-applied
iteratively (provided that `conns` are not modified between two
applications - ordering of vertices in tetrahedra matters not only
for positivity of volumes).
References:
- Juergen Bey: Simplicial grid refinement: on Freudenthal s algorithm and
the optimal number of congruence classes, Numer.Math. 85 (2000),
no. 1, 1--29, or
- Juergen Bey: Tetrahedral grid refinement, Computing 55 (1995),
no. 4, 355--378, or
http://citeseer.ist.psu.edu/bey95tetrahedral.html
"""
# Unique edge centres.
e_centres = cmesh.get_centroids(cmesh.dim - 2)
# New coordinates after the original ones.
coors = nm.r_[mesh_in.coors, e_centres]
o1 = mesh_in.n_nod
cc = cmesh.get_conn(cmesh.dim, cmesh.dim - 2)
offs = cc.offsets
conns = []
mat_ids = []
for ig, conn in enumerate(mesh_in.conns):
off0, off1 = mesh_in.el_offsets[ig:ig + 2]
n_el = conn.shape[0]
e_nodes = cc.indices[offs[off0]:offs[off1]].reshape((n_el, 6)) + o1
c = nm.c_[conn, e_nodes].T
new_conn = nm.vstack([
c[0], c[4], c[6], c[7], c[4], c[1], c[5], c[8], c[6], c[5], c[2],
c[9], c[7], c[8], c[9], c[3], c[4], c[6], c[7], c[8], c[4], c[6],
c[8], c[5], c[6], c[7], c[8], c[9], c[6], c[5], c[9], c[8]
]).T
new_conn = new_conn.reshape((8 * n_el, 4))
conns.append(new_conn)
new_mat_id = mesh_in.mat_ids[ig].repeat(8)
mat_ids.append(new_mat_id)
mesh = Mesh.from_data(mesh_in.name + '_r', coors, None, conns, mat_ids,
mesh_in.descs)
return mesh
def from_conf( conf, options ):
from sfepy import data_dir
from sfepy.discrete.fem import Mesh, Domain
from sfepy.discrete import Functions
mesh = Mesh('test mesh',
data_dir + '/meshes/various_formats/abaqus_tet.inp')
mesh.nodal_bcs['set0'] = [0, 7]
domain = Domain('test domain', mesh)
conf_functions = {
'get_vertices' : (get_vertices,),
'get_cells' : (get_cells,),
}
functions = Functions.from_conf(transform_functions(conf_functions))
test = Test(conf=conf, options=options,
domain=domain, functions=functions)
return test
def main():
from sfepy import data_dir
parser = OptionParser(usage=usage, version="%prog")
parser.add_option("-s", "--show", action="store_true", dest="show", default=False, help=help["show"])
options, args = parser.parse_args()
mesh = Mesh.from_file(data_dir + "/meshes/2d/rectangle_tri.mesh")
domain = Domain("domain", mesh)
min_x, max_x = domain.get_mesh_bounding_box()[:, 0]
eps = 1e-8 * (max_x - min_x)
omega = domain.create_region("Omega", "all")
gamma1 = domain.create_region("Gamma1", "vertices in x < %.10f" % (min_x + eps), "facet")
gamma2 = domain.create_region("Gamma2", "vertices in x > %.10f" % (max_x - eps), "facet")
field = Field.from_args("fu", nm.float64, "vector", omega, approx_order=2)
u = FieldVariable("u", "unknown", field)
v = FieldVariable("v", "test", field, primary_var_name="u")
m = Material("m", lam=1.0, mu=1.0)
f = Material("f", val=[[0.02], [0.01]])
integral = Integral("i", order=3)
t1 = Term.new("dw_lin_elastic_iso(m.lam, m.mu, v, u)", integral, omega, m=m, v=v, u=u)
t2 = Term.new("dw_volume_lvf(f.val, v)", integral, omega, f=f, v=v)
eq = Equation("balance", t1 + t2)
eqs = Equations([eq])
fix_u = EssentialBC("fix_u", gamma1, {"u.all": 0.0})
bc_fun = Function("shift_u_fun", shift_u_fun, extra_args={"shift": 0.01})
shift_u = EssentialBC("shift_u", gamma2, {"u.0": bc_fun})
ls = ScipyDirect({})
nls_status = IndexedStruct()
nls = Newton({}, lin_solver=ls, status=nls_status)
pb = Problem("elasticity", equations=eqs, nls=nls, ls=ls)
pb.save_regions_as_groups("regions")
pb.time_update(ebcs=Conditions([fix_u, shift_u]))
vec = pb.solve()
print nls_status
pb.save_state("linear_elasticity.vtk", vec)
if options.show:
view = Viewer("linear_elasticity.vtk")
view(vector_mode="warp_norm", rel_scaling=2, is_scalar_bar=True, is_wireframe=True)
def refine_3_8(mesh_in):
"""
Refines hexahedral mesh by cutting cutting each edge in half and
making 8 new finer hexahedrons out of one coarser one.
"""
cmesh = mesh_in.cmesh
# Unique edge centres.
e_centres = cmesh.get_centroids(cmesh.dim - 2)
# Unique face centres.
f_centres = cmesh.get_centroids(cmesh.dim - 1)
# Unique element centres.
centres = cmesh.get_centroids(cmesh.dim)
# New coordinates after the original ones.
coors = nm.r_[mesh_in.coors, e_centres, f_centres, centres]
o1 = mesh_in.n_nod
o2 = o1 + e_centres.shape[0]
o3 = o2 + f_centres.shape[0]
ecc = cmesh.get_conn(cmesh.dim, cmesh.dim - 2)
fcc = cmesh.get_conn(cmesh.dim, cmesh.dim - 1)
conn = mesh_in.get_conn('3_8')
n_el = conn.shape[0]
st = nm.vstack
e_nodes = ecc.indices.reshape((n_el, 12)) + o1
f_nodes = fcc.indices.reshape((n_el, 6)) + o2
nodes = nm.arange(n_el) + o3
c = nm.c_[conn, e_nodes, f_nodes, nodes].T
new_conn = st([
c[0], c[8], c[20], c[11], c[16], c[22], c[26], c[21], c[1], c[9],
c[20], c[8], c[17], c[24], c[26], c[22], c[2], c[10], c[20], c[9],
c[18], c[25], c[26], c[24], c[3], c[11], c[20], c[10], c[19], c[21],
c[26], c[25], c[4], c[15], c[23], c[12], c[16], c[21], c[26], c[22],
c[5], c[12], c[23], c[13], c[17], c[22], c[26], c[24], c[6], c[13],
c[23], c[14], c[18], c[24], c[26], c[25], c[7], c[14], c[23], c[15],
c[19], c[25], c[26], c[21]
]).T
new_conn = new_conn.reshape((8 * n_el, 8))
new_mat_id = cmesh.cell_groups.repeat(8)
mesh = Mesh.from_data(mesh_in.name + '_r', coors, None, [new_conn],
[new_mat_id], mesh_in.descs)
return mesh