def test_interpolation_two_meshes(self):
from sfepy import data_dir
from sfepy.fem import Mesh, Domain, H1NodalVolumeField, Variables
m1 = Mesh('source mesh', data_dir + '/meshes/3d/block.mesh')
m2 = Mesh('target mesh',
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 = Domain('d1', m1)
omega1 = d1.create_region('Omega', 'all')
field1 = H1NodalVolumeField('scalar_tp',
nm.float64, (1, 1),
omega1,
approx_order=1)
ff1 = {field1.name: field1}
d2 = Domain('d2', m2)
omega2 = d2.create_region('Omega', 'all')
field2 = H1NodalVolumeField('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_refine_3_8(self):
mesh = Mesh('3_8', data_dir + '/meshes/elements/3_8_1.mesh')
domain = refine(Domain('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, version="%prog")
options, args = parser.parse_args()
if (len(args) == 1):
mesh_filename = args[0];
else:
parser.print_help(),
return
mesh = Mesh('mesh', mesh_filename)
print mesh
domain = Domain('domain', mesh)
print domain
reg = domain.create_region('Surface',
'nodes of surface',
{'can_cells' : True})
dual_mesh = DualMesh(reg)
dual_mesh.save('dual_mesh.mesh',)
dual_mesh.save_axes('axes.vtk',)
print dual_mesh
def test_refine_hexa(self):
mesh = Mesh('mesh_hexa',
data_dir + '/meshes/various_formats/abaqus_hex.inp')
domain = Domain('domain', mesh)
refine(domain, self.options.out_dir)
return True
def test_interpolation(self):
from sfepy import data_dir
from sfepy.fem import Mesh
from sfepy.linalg import make_axis_rotation_matrix
fname = in_dir(self.options.out_dir)
meshes = {
'tp': Mesh('original mesh', data_dir + '/meshes/3d/block.mesh'),
'si': Mesh('original mesh', 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_invariance(self):
from sfepy import data_dir
from sfepy.fem import Mesh
meshes = {
'tp': Mesh('original mesh', data_dir + '/meshes/3d/block.mesh'),
'si': Mesh('original mesh', data_dir + '/meshes/3d/cylinder.mesh'),
}
datas = gen_datas(meshes)
ok = True
for field_name in ['scalar_si', 'vector_si', 'scalar_tp', 'vector_tp']:
m1 = meshes[field_name[-2:]]
data = datas[field_name]
u1, u2 = do_interpolation(m1, m1, data, field_name, force=True)
self.report('max. difference:', nm.abs(u1() - u2()).max())
_ok = nm.allclose(u1(), u2(), rtol=0.0, atol=1e-12)
self.report('invariance for %s field: %s' % (field_name, _ok))
ok = ok and _ok
return ok
def test_invariance_qp(self):
from sfepy import data_dir
from sfepy.fem import (Mesh, Domain, H1NodalVolumeField, Variables,
Integral)
from sfepy.terms import Term
from sfepy.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 = H1NodalVolumeField('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 from_conf(conf, options):
from sfepy import data_dir
from sfepy.fem import Mesh, Domain, Functions
mesh = Mesh('test mesh',
data_dir + '/meshes/various_formats/abaqus_tet.inp')
domain = Domain('test domain', mesh)
conf_functions = {
'get_nodes': (get_nodes, ),
'get_elements': (get_elements, ),
}
functions = Functions.from_conf(transform_functions(conf_functions))
test = Test(conf=conf,
options=options,
domain=domain,
functions=functions)
return test
def from_conf(conf, options):
from sfepy import data_dir
from sfepy.fem import Mesh, Domain, 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 from_conf(conf, options):
mesh = Mesh('mesh_tetra',
data_dir + '/meshes/various_formats/small3d.mesh')
domain = Domain('domain', mesh)
return Test(conf=conf, options=options, domain=domain)
