def evaluate_at(self, coors, source_vals, strategy='kdtree',
close_limit=0.1, cache=None, ret_cells=False,
ret_status=False, ret_ref_coors=False):
"""
Evaluate source DOF values corresponding to the field in the given
coordinates using the field interpolation.
Parameters
----------
coors : array
The coordinates the source values should be interpolated into.
source_vals : array
The source DOF values corresponding to the field.
strategy : str, optional
The strategy for finding the elements that contain the
coordinates. Only 'kdtree' is supported for the moment.
close_limit : float, optional
The maximum limit distance of a point from the closest
element allowed for extrapolation.
cache : Struct, optional
To speed up a sequence of evaluations, the field mesh, the inverse
connectivity of the field mesh and the KDTree instance can
be cached as `cache.mesh`, `cache.offsets`, `cache.iconn` and
`cache.kdtree`. Optionally, the cache can also contain the
reference element coordinates as `cache.ref_coors`,
`cache.cells` and `cache.status`, if the evaluation occurs
in the same coordinates repeatedly. In that case the KDTree
related data are ignored.
ret_cells : bool, optional
If True, return also the cell indices the coordinates are in.
ret_status : bool, optional
If True, return also the status for each point: 0 is
success, 1 is extrapolation within `close_limit`, 2 is
extrapolation outside `close_limit`, 3 is failure.
ret_ref_coors : bool, optional
If True, return also the found reference element coordinates.
Returns
-------
vals : array
The interpolated values.
cells : array
The cell indices, if `ret_cells` or `ret_status` are True.
status : array
The status, if `ret_status` is True.
"""
output('evaluating in %d points...' % coors.shape[0])
ref_coors, cells, status = get_ref_coors(self, coors,
strategy=strategy,
close_limit=close_limit,
cache=cache)
tt = time.clock()
vertex_coorss, nodess, orders, mtx_is = [], [], [], []
conns = []
for ap in self.aps.itervalues():
ps = ap.interp.poly_spaces['v']
vertex_coorss.append(ps.geometry.coors)
nodess.append(ps.nodes)
mtx_is.append(ps.get_mtx_i())
orders.append(ps.order)
conns.append(ap.econn)
orders = nm.array(orders, dtype=nm.int32)
# Interpolate to the reference coordinates.
vals = nm.empty((coors.shape[0], source_vals.shape[1]),
dtype=source_vals.dtype)
evaluate_in_rc(vals, ref_coors, cells, status, source_vals,
conns, vertex_coorss, nodess, orders, mtx_is,
1e-15)
output('interpolation: %f s' % (time.clock()-tt))
output('...done')
if ret_ref_coors:
return vals, ref_coors, cells, status
elif ret_status:
return vals, cells, status
elif ret_cells:
return vals, cells
else:
return vals
def _gen_common_data(orders, gels, report):
import sfepy
from sfepy.base.base import Struct
from sfepy.linalg import combine
from sfepy.fem import Mesh, Domain, Field, FieldVariable, Integral
from sfepy.fem.global_interp import get_ref_coors
bases = ([ii for ii in combine([['2_4', '3_8'],
['lagrange', 'lobatto']])]
+ [ii for ii in combine([['2_3', '3_4'],
['lagrange']])])
for geom, poly_space_base in bases:
report('geometry: %s, base: %s' % (geom, poly_space_base))
order = orders[geom]
integral = Integral('i', order=order)
aux = '' if geom in ['2_4', '3_8'] else 'z'
mesh0 = Mesh.from_file('meshes/elements/%s_2%s.mesh' % (geom, aux),
prefix_dir=sfepy.data_dir)
gel = gels[geom]
perms = gel.get_conn_permutations()
qps, qp_weights = integral.get_qp(gel.surface_facet.name)
zz = nm.zeros_like(qps[:, :1])
qps = nm.hstack(([qps] + [zz]))
shift = shifts[geom]
rcoors = nm.ascontiguousarray(qps
+ shift[:1, :] - shift[1:, :])
ccoors = nm.ascontiguousarray(qps
+ shift[:1, :] + shift[1:, :])
for ir, pr in enumerate(perms):
for ic, pc in enumerate(perms):
report('ir: %d, ic: %d' % (ir, ic))
report('pr: %s, pc: %s' % (pr, pc))
mesh = mesh0.copy()
conn = mesh.conns[0]
conn[0, :] = conn[0, pr]
conn[1, :] = conn[1, pc]
cache = Struct(mesh=mesh)
domain = Domain('domain', mesh)
omega = domain.create_region('Omega', 'all')
region = domain.create_region('Facet', rsels[geom], 'facet')
field = Field.from_args('f', nm.float64, shape=1,
region=omega, approx_order=order,
poly_space_base=poly_space_base)
var = FieldVariable('u', 'unknown', field, 1)
report('# dofs: %d' % var.n_dof)
vec = nm.empty(var.n_dof, dtype=var.dtype)
ap = field.aps[0]
ps = ap.interp.poly_spaces['v']
dofs = field.get_dofs_in_region_group(region, 0,
merge=False)
edofs, fdofs = nm.unique(dofs[1]), nm.unique(dofs[2])
rrc, rcells, rstatus = get_ref_coors(field, rcoors,
cache=cache)
crc, ccells, cstatus = get_ref_coors(field, ccoors,
cache=cache)
assert_((rstatus == 0).all() and (cstatus == 0).all())
yield (geom, poly_space_base, qp_weights, mesh, ir, ic,
ap, ps, rrc, rcells[0, 1], crc, ccells[0, 1],
vec, edofs, fdofs)
def _gen_common_data(order, gels, report):
import sfepy
from sfepy.base.base import Struct
from sfepy.linalg import combine
from sfepy.fem import Mesh, Domain, Field, FieldVariable, Integral
from sfepy.fem.global_interp import get_ref_coors
integral = Integral('i', order=order)
for geom, poly_space_base in combine([['2_4', '3_8'],
['lagrange', 'lobatto']]):
report('geometry: %s, base: %s' % (geom, poly_space_base))
mesh0 = Mesh.from_file('meshes/elements/%s_2.mesh' % geom,
prefix_dir=sfepy.data_dir)
gel = gels[geom]
perms = gel.get_conn_permutations()
qps, qp_weights = integral.get_qp(gel.surface_facet.name)
zz = nm.zeros_like(qps[:, :1])
qps = nm.hstack(([qps] + [zz]))
rot = rots[geom]
if rot is not None:
pass
shift = shifts[geom]
rcoors = nm.ascontiguousarray(qps
+ shift[:1, :] - shift[1:, :])
ccoors = nm.ascontiguousarray(qps
+ shift[:1, :] + shift[1:, :])
for ir, pr in enumerate(perms):
for ic, pc in enumerate(perms):
report('ir: %d, ic: %d' % (ir, ic))
mesh = mesh0.copy()
conn = mesh.conns[0]
conn[0, :] = conn[0, pr]
conn[1, :] = conn[1, pc]
cache = Struct(mesh=mesh)
domain = Domain('domain', mesh)
omega = domain.create_region('Omega', 'all')
region = domain.create_region('Facet', rsels[geom])
field = Field.from_args('f', nm.float64, shape=1,
region=omega, approx_order=order,
poly_space_base=poly_space_base)
var = FieldVariable('u', 'unknown', field, 1)
report('# dofs: %d' % var.n_dof)
vec = nm.empty(var.n_dof, dtype=var.dtype)
ap = field.aps[0]
ps = ap.interp.poly_spaces['v']
dofs = field.get_dofs_in_region_group(region, 0,
merge=False)
edofs, fdofs = nm.unique(dofs[1]), nm.unique(dofs[2])
rrc, rcells, rstatus = get_ref_coors(field, rcoors,
cache=cache)
crc, ccells, cstatus = get_ref_coors(field, ccoors,
cache=cache)
yield (geom, poly_space_base, qp_weights, mesh, ir, ic,
ap, ps, rrc, crc, vec, edofs, fdofs)
def evaluate_at(self, coors, source_vals, strategy='kdtree',
close_limit=0.1, cache=None, ret_cells=False,
ret_status=False, ret_ref_coors=False):
"""
Evaluate source DOF values corresponding to the field in the given
coordinates using the field interpolation.
Parameters
----------
coors : array
The coordinates the source values should be interpolated into.
source_vals : array
The source DOF values corresponding to the field.
strategy : str, optional
The strategy for finding the elements that contain the
coordinates. Only 'kdtree' is supported for the moment.
close_limit : float, optional
The maximum limit distance of a point from the closest
element allowed for extrapolation.
cache : Struct, optional
To speed up a sequence of evaluations, the field mesh, the inverse
connectivity of the field mesh and the KDTree instance can
be cached as `cache.mesh`, `cache.offsets`, `cache.iconn` and
`cache.kdtree`. Optionally, the cache can also contain the
reference element coordinates as `cache.ref_coors`,
`cache.cells` and `cache.status`, if the evaluation occurs
in the same coordinates repeatedly. In that case the KDTree
related data are ignored.
ret_cells : bool, optional
If True, return also the cell indices the coordinates are in.
ret_status : bool, optional
If True, return also the status for each point: 0 is
success, 1 is extrapolation within `close_limit`, 2 is
extrapolation outside `close_limit`, 3 is failure.
ret_ref_coors : bool, optional
If True, return also the found reference element coordinates.
Returns
-------
vals : array
The interpolated values.
cells : array
The cell indices, if `ret_cells` or `ret_status` are True.
status : array
The status, if `ret_status` is True.
"""
output('evaluating in %d points...' % coors.shape[0])
ref_coors, cells, status = get_ref_coors(self, coors,
strategy=strategy,
close_limit=close_limit,
cache=cache)
tt = time.clock()
vertex_coorss, nodess, orders, mtx_is = [], [], [], []
conns = []
for ap in self.aps.itervalues():
ps = ap.interp.poly_spaces['v']
vertex_coorss.append(ps.geometry.coors)
nodess.append(ps.nodes)
mtx_is.append(ps.get_mtx_i())
orders.append(ps.order)
conns.append(ap.econn)
orders = nm.array(orders, dtype=nm.int32)
# Interpolate to the reference coordinates.
vals = nm.empty((coors.shape[0], source_vals.shape[1]),
dtype=source_vals.dtype)
evaluate_in_rc(vals, ref_coors, cells, status, source_vals,
conns, vertex_coorss, nodess, orders, mtx_is,
1e-15)
output('interpolation: %f s' % (time.clock()-tt))
output('...done')
if ret_ref_coors:
return vals, ref_coors, cells, status
elif ret_status:
return vals, cells, status
elif ret_cells:
return vals, cells
else:
return vals
