def check_for_intersections(m):
pts, tris = m
close_or_touch_pairs = find_near_adj.find_close_or_touching(pts, tris, pts, tris, 2.0)
nearfield_pairs, va, ea = find_near_adj.split_adjacent_close(close_or_touch_pairs, tris, tris)
bad_pairs = []
t = Timer(output_fnc = logger.info)
# Three situations:
# 1) Nearfield pair is intersection
bad_pairs.extend(check_for_intersections_nearfield(pts, tris, nearfield_pairs))
t.report('nearfield')
# 2) Vertex adjacent pair actually intersects beyond just the vertex
# We can test for this by moving the shared vertex short distance
# along one of the edges of the first triangle. If there is still
# an intersection, then the triangles intersect at locations besides
# just the shared vertex.
bad_pairs.extend(check_for_intersections_va(pts, tris, va))
t.report('va')
# 3) Edge adjacent pair is actually coincident. <-- Easy!
bad_pairs.extend(check_for_intersections_ea(pts, tris, ea))
t.report('ea')
return np.array(bad_pairs, dtype = np.int64)
def benchmark_vert_adj():
from tectosaur.util.timer import Timer
import tectosaur.mesh.find_near_adj as find_near_adj
from tectosaur.nearfield.pairs_integrator import PairsIntegrator
kernel = 'elasticH3'
params = [1.0, 0.25]
float_type = np.float32
L = 5
nq_vert_adjacent = 7
nx = ny = int(2**L / np.sqrt(2))
t = Timer()
pts, tris = mesh_gen.make_rect(
nx, ny, [[-1, -1, 0], [-1, 1, 0], [1, 1, 0], [1, -1, 0]])
logger.debug('n_tris: ' + str(tris.shape[0]))
t.report('make rect')
close_or_touch_pairs = find_near_adj.find_close_or_touching(
pts, tris, 1.25)
nearfield_pairs, va, ea = find_near_adj.split_adjacent_close(
close_or_touch_pairs, tris)
t.report('find near')
pairs_int = PairsIntegrator(kernel, params, float_type, 1, 1, pts, tris)
t.report('setup integrator')
va_mat_rot = pairs_int.vert_adj(nq_vert_adjacent, va)
t.report('vert adj')
def f(nq, pairs_int, pts, tris):
import tectosaur.mesh.find_near_adj as find_near_adj
from tectosaur.nearfield.nearfield_op import (to_tri_space,
resolve_ea_rotation)
obs_subset = np.arange(tris.shape[0])
src_subset = np.arange(tris.shape[0])
close_or_touch_pairs = find_near_adj.find_close_or_touching(
pts, tris[obs_subset], pts, tris[src_subset], 2.0)
nearfield_pairs_dofs, va_dofs, ea_dofs = find_near_adj.split_adjacent_close(
close_or_touch_pairs, tris[obs_subset], tris[src_subset])
va = to_tri_space(va_dofs, obs_subset, src_subset)
return pairs_int.vert_adj(nq, va)
def check_min_adj_angle(m, ea = None):
pts, tris = m
close_or_touch_pairs = find_near_adj.find_close_or_touching(pts, tris, pts, tris, 2.0)
nearfield_pairs, va, ea = find_near_adj.split_adjacent_close(close_or_touch_pairs, tris, tris)
bad_pairs = []
lower_lim = min_intersect_angle
upper_lim = (2 * np.pi - min_intersect_angle)
for pair in ea:
obs_clicks, obs_tri, src_clicks, src_flip, src_tri = \
edge_adj_setup.orient_adj_tris(pts, tris, pair[0], pair[1])
phi = edge_adj_setup.calc_adjacent_phi(obs_tri, src_tri)
if lower_lim <= phi <= upper_lim:
continue
bad_pairs.append(pair)
return np.array(bad_pairs, dtype = np.int64)
def __init__(self, pts, tris, obs_subset, src_subset, nq_coincident,
nq_edge_adj, nq_vert_adjacent, nq_far, nq_near,
near_threshold, K_near_name, K_far_name, params, float_type):
n_obs_dofs = obs_subset.shape[0] * 9
n_src_dofs = src_subset.shape[0] * 9
self.shape = (n_obs_dofs, n_src_dofs)
timer = Timer(output_fnc=logger.debug, tabs=1)
pairs_int = PairsIntegrator(K_near_name, params, float_type, nq_far,
nq_near, pts, tris)
correction_pairs_int = PairsIntegrator(K_far_name, params, float_type,
nq_far, nq_near, pts, tris)
timer.report('setup pairs integrator')
co_tris = np.intersect1d(obs_subset, src_subset)
co_indices = np.array([co_tris, co_tris]).T.copy()
co_dofs = to_dof_space(co_indices, obs_subset, src_subset)
co_mat = pairs_int.coincident(nq_coincident, co_indices)
timer.report("Coincident")
co_mat_correction = correction_pairs_int.correction(co_indices, True)
timer.report("Coincident correction")
close_or_touch_pairs = find_near_adj.find_close_or_touching(
pts, tris[obs_subset], pts, tris[src_subset], near_threshold)
nearfield_pairs_dofs, va_dofs, ea_dofs = find_near_adj.split_adjacent_close(
close_or_touch_pairs, tris[obs_subset], tris[src_subset])
nearfield_pairs = to_tri_space(nearfield_pairs_dofs, obs_subset,
src_subset)
va = to_tri_space(va_dofs, obs_subset, src_subset)
va = np.hstack((va, np.zeros((va.shape[0], 1))))
ea = resolve_ea_rotation(tris,
to_tri_space(ea_dofs, obs_subset, src_subset))
timer.report("Find nearfield/adjacency")
ea_mat_rot = pairs_int.edge_adj(nq_edge_adj, ea)
timer.report("Edge adjacent")
if ea.shape[0] == 0:
ea_mat_correction = 0 * ea_mat_rot
else:
ea_mat_correction = correction_pairs_int.correction(
ea[:, :2], False)
timer.report("Edge adjacent correction")
va_mat_rot = pairs_int.vert_adj(nq_vert_adjacent, va)
timer.report("Vert adjacent")
va_mat_correction = correction_pairs_int.correction(va[:, :2], False)
timer.report("Vert adjacent correction")
nearfield_mat = pairs_int.nearfield(nearfield_pairs)
timer.report("Nearfield")
nearfield_correction = correction_pairs_int.correction(
nearfield_pairs, False)
timer.report("Nearfield correction")
self.mat = build_nearfield(
self.shape, (co_mat - co_mat_correction, co_dofs),
(ea_mat_rot - ea_mat_correction, ea_dofs[:, :2]),
(va_mat_rot - va_mat_correction, va_dofs[:, :2]),
(nearfield_mat - nearfield_correction, nearfield_pairs_dofs))
timer.report("Assemble matrix")
self.mat_no_correction = build_nearfield(
self.shape,
(co_mat, co_dofs),
(ea_mat_rot, ea_dofs[:, :2]),
(va_mat_rot, va_dofs[:, :2]),
(nearfield_mat, nearfield_pairs_dofs),
)
timer.report("Assemble uncorrected matrix")
def any_nearfield(pts, tris, obs_subset, src_subset, near_threshold):
close_or_touch_pairs = find_near_adj.find_close_or_touching(
pts, tris[obs_subset], pts, tris[src_subset], near_threshold)
nearfield_pairs_dofs, va_dofs, ea_dofs = find_near_adj.split_adjacent_close(
close_or_touch_pairs, tris[obs_subset], tris[src_subset])
return nearfield_pairs_dofs.shape[0] > 0