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_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 do_interpolation(m2, m1, data, field_name, force=False):
"""Interpolate data from m1 to m2. """
from sfepy.discrete import Variables
from sfepy.discrete.fem import FEDomain, Field
fields = {
'scalar_si': ((1, 1), 'Omega', 2),
'vector_si': ((3, 1), 'Omega', 2),
'scalar_tp': ((1, 1), 'Omega', 1),
'vector_tp': ((3, 1), 'Omega', 1),
}
d1 = FEDomain('d1', m1)
omega1 = d1.create_region('Omega', 'all')
f = fields[field_name]
field1 = Field.from_args('f',
nm.float64,
f[0],
d1.regions[f[1]],
approx_order=f[2])
ff = {field1.name: field1}
vv = Variables.from_conf(transform_variables(variables), ff)
u1 = vv['u']
u1.set_from_mesh_vertices(data)
d2 = FEDomain('d2', m2)
omega2 = d2.create_region('Omega', 'all')
field2 = Field.from_args('f',
nm.float64,
f[0],
d2.regions[f[1]],
approx_order=f[2])
ff2 = {field2.name: field2}
vv2 = Variables.from_conf(transform_variables(variables), ff2)
u2 = vv2['u']
if not force:
# 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.5)
else:
coors = u2.field.get_coor()
vals = u1.evaluate_at(coors, close_limit=0.5)
u2.set_data(vals)
return u1, u2
def do_interpolation(m2, m1, data, field_name, force=False):
"""Interpolate data from m1 to m2. """
from sfepy.discrete import Variables
from sfepy.discrete.fem import FEDomain, Field
fields = {
'scalar_si' : ((1,1), 'Omega', 2),
'vector_si' : ((3,1), 'Omega', 2),
'scalar_tp' : ((1,1), 'Omega', 1),
'vector_tp' : ((3,1), 'Omega', 1),
}
d1 = FEDomain('d1', m1)
omega1 = d1.create_region('Omega', 'all')
f = fields[field_name]
field1 = Field.from_args('f', nm.float64, f[0], d1.regions[f[1]],
approx_order=f[2])
ff = {field1.name : field1}
vv = Variables.from_conf(transform_variables(variables), ff)
u1 = vv['u']
u1.set_from_mesh_vertices(data)
d2 = FEDomain('d2', m2)
omega2 = d2.create_region('Omega', 'all')
field2 = Field.from_args('f', nm.float64, f[0], d2.regions[f[1]],
approx_order=f[2])
ff2 = {field2.name : field2}
vv2 = Variables.from_conf(transform_variables(variables), ff2)
u2 = vv2['u']
if not force:
# 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.5)
else:
coors = u2.field.get_coor()
vals = u1.evaluate_at(coors, close_limit=0.5)
u2.set_data(vals)
return u1, u2
def test_evaluate_at(self):
from sfepy import data_dir
from sfepy.discrete.fem import Mesh
from sfepy.discrete import Variables
from sfepy.discrete.fem import FEDomain, Field
meshes = {
'tp': Mesh.from_file(data_dir + '/meshes/3d/block.mesh'),
}
datas = gen_datas(meshes)
fields = {
'scalar_tp': ((1, 1), 'Omega', 1),
'vector_tp': ((3, 1), 'Omega', 1),
}
ok = True
for field_name in ['scalar_tp', 'vector_tp']:
d = FEDomain('d', meshes['tp'])
d.create_region('Omega', 'all')
f = fields[field_name]
field = Field.from_args('f',
nm.complex128,
f[0],
d.regions[f[1]],
approx_order=f[2])
ff = {field.name: field}
vv = Variables.from_conf(transform_variables(variables), ff)
u = vv['u']
bbox = d.get_mesh_bounding_box()
t = nm.expand_dims(nm.linspace(0, 1, 100), 1)
coors = nm.expand_dims(bbox[1] - bbox[0], 0) * t + bbox[0]
data_r = datas[field_name]
data_i = 2. / (1 + datas[field_name])
u.set_from_mesh_vertices(data_r)
vals_r = u.evaluate_at(coors)
u.set_from_mesh_vertices(data_i)
vals_i = u.evaluate_at(coors)
u.set_from_mesh_vertices(data_r + data_i * 1j)
vals = u.evaluate_at(coors)
_ok = nm.allclose(vals_r + vals_i * 1j, vals, rtol=0.0, atol=1e-12)
_ok = _ok and nm.abs(vals).sum() > 1
self.report('evaluating complex field %s: %s' % (field_name, _ok))
ok = ok and _ok
return ok
def test_evaluate_at(self):
from sfepy import data_dir
from sfepy.discrete.fem import Mesh
from sfepy.discrete import Variables
from sfepy.discrete.fem import FEDomain, Field
meshes = {
'tp' : Mesh.from_file(data_dir + '/meshes/3d/block.mesh'),
}
datas = gen_datas(meshes)
fields = {
'scalar_tp' : ((1,1), 'Omega', 1),
'vector_tp' : ((3,1), 'Omega', 1),
}
ok = True
for field_name in ['scalar_tp', 'vector_tp']:
d = FEDomain('d', meshes['tp'])
d.create_region('Omega', 'all')
f = fields[field_name]
field = Field.from_args('f', nm.complex128, f[0],
d.regions[f[1]],
approx_order=f[2])
ff = {field.name : field}
vv = Variables.from_conf(transform_variables(variables), ff)
u = vv['u']
bbox = d.get_mesh_bounding_box()
t = nm.expand_dims(nm.linspace(0, 1, 100), 1)
coors = nm.expand_dims(bbox[1] - bbox[0], 0) * t + bbox[0]
data_r = datas[field_name]
data_i = 2. / (1 + datas[field_name])
u.set_from_mesh_vertices(data_r)
vals_r = u.evaluate_at(coors)
u.set_from_mesh_vertices(data_i)
vals_i = u.evaluate_at(coors)
u.set_from_mesh_vertices(data_r + data_i * 1j)
vals = u.evaluate_at(coors)
_ok = nm.allclose(vals_r + vals_i * 1j, vals, rtol=0.0, atol=1e-12)
_ok = _ok and nm.abs(vals).sum() > 1
self.report('evaluating complex field %s: %s' % (field_name, _ok))
ok = ok and _ok
return ok
def test_pbc( self ):
from sfepy.discrete import Variables, Conditions
problem = self.problem
conf = self.conf
ebcs = Conditions.from_conf(conf.ebcs, problem.domain.regions)
epbcs = Conditions.from_conf(conf.epbcs, problem.domain.regions)
variables = Variables.from_conf(conf.variables, problem.fields)
variables.equation_mapping(ebcs, epbcs, None, problem.functions)
state = variables.create_state_vector()
variables.apply_ebc(state)
return variables.has_ebc(state)
def test_pbc(self):
from sfepy.discrete import Variables, Conditions
problem = self.problem
conf = self.conf
ebcs = Conditions.from_conf(conf.ebcs, problem.domain.regions)
epbcs = Conditions.from_conf(conf.epbcs, problem.domain.regions)
variables = Variables.from_conf(conf.variables, problem.fields)
variables.equation_mapping(ebcs, epbcs, None, problem.functions)
state = variables.create_state_vector()
variables.apply_ebc(state)
return variables.has_ebc(state)
def test_consistency_d_dw(self):
from sfepy.discrete import Variables
ok = True
pb = self.problem
for aux in test_terms:
term_template, (prefix, par_name, d_vars, dw_vars) = aux
print term_template, prefix, par_name, d_vars, dw_vars
term1 = term_template % ((prefix, ) + d_vars)
variables = Variables.from_conf(self.conf.variables, pb.fields)
for var_name in d_vars:
var = variables[var_name]
n_dof = var.field.n_nod * var.field.shape[0]
aux = nm.arange(n_dof, dtype=nm.float64)
var.set_data(aux)
if prefix == 'd':
val1 = pb.evaluate(term1, var_dict=variables.as_dict())
else:
val1 = pb.evaluate(term1,
call_mode='d_eval',
var_dict=variables.as_dict())
self.report('%s: %s' % (term1, val1))
term2 = term_template % (('dw', ) + dw_vars[:2])
vec, vv = pb.evaluate(term2,
mode='weak',
var_dict=variables.as_dict(),
ret_variables=True)
pvec = vv.get_state_part_view(vec, dw_vars[2])
val2 = nm.dot(variables[par_name](), pvec)
self.report('%s: %s' % (term2, val2))
err = nm.abs(val1 - val2) / nm.abs(val1)
_ok = err < 1e-12
self.report('relative difference: %e -> %s' % (err, _ok))
ok = ok and _ok
return ok
def test_consistency_d_dw(self):
from sfepy.discrete import Variables
ok = True
pb = self.problem
for aux in test_terms:
term_template, (prefix, par_name, d_vars, dw_vars) = aux
print term_template, prefix, par_name, d_vars, dw_vars
term1 = term_template % ((prefix,) + d_vars)
variables = Variables.from_conf(self.conf.variables, pb.fields)
for var_name in d_vars:
var = variables[var_name]
n_dof = var.field.n_nod * var.field.shape[0]
aux = nm.arange(n_dof, dtype=nm.float64)
var.set_data(aux)
if prefix == 'd':
val1 = pb.evaluate(term1, var_dict=variables.as_dict())
else:
val1 = pb.evaluate(term1, call_mode='d_eval',
var_dict=variables.as_dict())
self.report('%s: %s' % (term1, val1))
term2 = term_template % (('dw',) + dw_vars[:2])
vec, vv = pb.evaluate(term2, mode='weak',
var_dict=variables.as_dict(),
ret_variables=True)
pvec = vv.get_state_part_view(vec, dw_vars[2])
val2 = nm.dot(variables[par_name](), pvec)
self.report('%s: %s' % (term2, val2))
err = nm.abs(val1 - val2) / nm.abs(val1)
_ok = err < 1e-12
self.report('relative difference: %e -> %s' % (err, _ok))
ok = ok and _ok
return ok
def test_invariance_qp(self):
from sfepy import data_dir
from sfepy.discrete import Variables, Integral
from sfepy.discrete.fem import Mesh, FEDomain, Field
from sfepy.terms import Term
from sfepy.discrete.common.mappings import get_physical_qps
mesh = Mesh.from_file(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 = FEDomain('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.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 test_sensitivity(self):
from sfepy.discrete import Variables
from sfepy.mesh.splinebox import SplineBox
tolerance = 1e-4
ok = True
pb = self.problem
variables = Variables.from_conf(self.conf.variables, pb.fields)
for var_name in variables.names:
var = variables[var_name]
n_dof = var.field.n_nod * var.field.shape[0]
aux = nm.arange(n_dof, dtype=nm.float64)
var.set_data(aux)
mesh = pb.domain.mesh
bbox = nm.array(mesh.get_bounding_box()).T
spbox = SplineBox(bbox, mesh.coors)
dvel_modes = [
# expand inner cylinder, no volume change
[([20, 21, 22, 23], (-1, -1, 0)),
([24, 25, 26, 27], (-1, 1, 0)),
([36, 37, 38, 39], (1, -1, 0)),
([40, 41, 42, 43], (1, 1, 0))],
# volume change
[(range(16, 32), (0.2, 0, 0)),
(range(32, 48), (0.4, 0, 0)),
(range(48, 52), (0.6, 0.2, 0.2)),
(range(52, 56), (0.8, 0.2, 0.3)),
(range(56, 60), (1.0, 0.2, 0.4)),
(range(60, 64), (1.2, 0.2, 0.5))],
]
r4 = range(4)
cp_pos = {i*16 + j*4 + k: (i, j, k)
for k in r4 for j in r4 for i in r4}
# compute design velocities
dvels = []
for dv_mode in dvel_modes:
dvel = 0
for pts, dir in dv_mode:
for pt in pts:
dvel += spbox.evaluate_derivative(cp_pos[pt], dir)
dvels.append(dvel)
for tname_sa, tname, rname, mat, var1, var2 in test_terms:
args = [] if mat is None else [mat]
args += [var1] if var2 is None else [var1, var2]
term = '%s.i.%s(%s)' % (tname, rname, ', '.join(args))
term_sa = '%s.i.%s(%s)' % (tname_sa, rname, ', '.join(args + ['V']))
val = pb.evaluate(term, var_dict=variables.as_dict())
self.report('%s: %s' % (tname, val))
dt = 1e-6
for ii, dvel in enumerate(dvels):
val = pb.evaluate(term, var_dict=variables.as_dict())
variables['V'].set_data(dvel)
val_sa = pb.evaluate(term_sa, var_dict=variables.as_dict())
self.report('%s - mesh_velocity mode %d' % (tname_sa, ii))
# mesh perturbation +
new_coors = modify_mesh(dt/2., spbox, dvel_modes[ii], cp_pos)
pb.set_mesh_coors(new_coors, update_fields=True)
val1 = pb.evaluate(term, var_dict=variables.as_dict())
# mesh perturbation -
new_coors = modify_mesh(-dt/2., spbox, dvel_modes[ii], cp_pos)
pb.set_mesh_coors(new_coors, update_fields=True)
val2 = pb.evaluate(term, var_dict=variables.as_dict())
val_fd = (val1 - val2) / dt
err = nm.abs(val_sa - val_fd) / nm.linalg.norm(val_sa)
self.report('term: %s' % val)
self.report('sensitivity term: %s' % val_sa)
self.report('finite differences: %s' % val_fd)
self.report('relative error: %s' % err)
_ok = err < tolerance
ok = ok and _ok
return ok