def test_lr_spline_insert_line_multiple():
LR = init_tensor_product_LR_spline(1, 1, [0, 1, 2, 3], [0, 1, 2])
M1 = Meshline(0, 2, constant_value=0.5, axis=1) # horizontal split
M2 = Meshline(0, 1, constant_value=1.5, axis=0) # vertical split
LR.insert_line(M1)
LR.insert_line(M2)
# expected functions
b1 = BSpline(1, 1, [0, 1, 1.5], [0, 0.5, 1])
b2 = BSpline(1, 1, [1, 1.5, 2], [0, 0.5, 1])
b3 = BSpline(1, 1, [0, 1, 2], [0.5, 1, 2])
b4 = BSpline(1, 1, [1, 2, 3], [0, 1, 2])
assert b1 in LR.S
assert b2 in LR.S
assert b3 in LR.S
assert b3 in LR.S
assert len(LR.S) == 4
expected_elements = [
Element(0, 0, 1, 0.5),
Element(1, 0, 1.5, 0.5),
Element(1.5, 0, 2, 0.5),
Element(0, 0.5, 1, 1),
Element(1, 0.5, 1.5, 1),
Element(1.5, 0.5, 2, 1),
Element(2, 0, 3, 1),
Element(0, 1, 1, 2),
Element(1, 1, 2, 2),
Element(2, 1, 3, 2)
]
assert all([LR.contains_element(e) for e in expected_elements])
assert len(LR.M) == 10
def test_lr_spline_unique_basis_functions():
LR = init_tensor_product_LR_spline(1, 1, [0, 0, 1, 1], [0, 1, 2])
m = Meshline(0, 2, constant_value=0.5, axis=0)
LR.insert_line(m, debug=False)
m = Meshline(0, 1, constant_value=0.5, axis=1)
LR.insert_line(m, debug=False)
c = Counter(LR.S)
assert all([count == 1 for count in c.values()])
def test_element_overloaded():
LR = init_tensor_product_LR_spline(1, 1, [0, 0, 1, 2, 2], [0, 0, 1, 2, 2])
e = LR.M[2]
assert not e.is_overloaded()
e.add_supported_b_spline(LR.S[2])
assert e.is_overloaded()
def test_lr_spline_at_end_vs_knots_tensor_product():
d1, d2 = 2, 2
ku = [0, 0, 0, 0.5, 0.75, 1, 1, 1]
kv = [0, 0, 0, 1, 2, 3, 3, 3]
LR = init_tensor_product_LR_spline(d1, d2, ku, kv)
for b in LR.S:
if b.end_u:
assert ku[-1] in b.knots_u
if b.end_v:
assert kv[-1] in b.knots_v
def test_lr_spline_dimension_bilinear():
ku = [0, 0, 1, 2, 2]
kv = [0, 0, 1, 1]
du = 1
dv = 1
LR = init_tensor_product_LR_spline(du, dv, ku, kv)
m = Meshline(1, 2, constant_value=0.5, axis=1)
LR.insert_line(m)
assert len(LR.S) == 7
def test_lr_spline_partition_at_end_uv_point():
d1, d2 = 2, 2
ku = [0, 0, 0, 0.5, 0.75, 1, 1, 1]
kv = [0, 0, 0, 1, 2, 3, 3, 3]
LR = init_tensor_product_LR_spline(d1, d2, ku, kv)
e = LR.find_element_containing_point(1, 3)
for b in e.supported_b_splines:
assert b.end_v
assert 3 in b.knots_v
if b.end_u:
assert 1 in b.knots_u
def test_lr_spline_minimal_span_line():
d1, d2 = (2, 2)
ku = [0, 1, 2, 3]
kv = [0, 1, 2, 3]
LR = init_tensor_product_LR_spline(d1, d2, ku, kv)
element_to_refine = LR.M[1]
minimal_span_meshline = LR.get_minimal_span_meshline(element_to_refine,
axis=0)
assert minimal_span_meshline.start == 0
assert minimal_span_meshline.stop == 3
assert minimal_span_meshline.constant_value == 0.5
def test_lr_spline_partition_of_unity_tensor_product(N):
d1, d2 = 2, 2
ku = [0, 0, 0, 0.5, 0.75, 1, 1, 1]
LR = init_tensor_product_LR_spline(d1, d2, ku, ku)
x = np.linspace(0, 1, N, endpoint=True)
np.random.seed(42)
z = np.zeros((N, N))
for i in range(N):
for j in range(N):
z[i, j] = LR(x[i], x[j])
expected = np.ones((N, N))
np.testing.assert_array_almost_equal(z, expected)
def test_lr_spline_partition_of_unity_interior(N):
LR = init_tensor_product_LR_spline(2, 2, [0, 0, 0, 1, 2, 4, 5, 6, 6, 6], [0, 0, 0, 1, 2, 4, 5, 6, 6, 6])
x = np.linspace(0, 6, N, endpoint=False)
y = np.linspace(0, 6, N, endpoint=False)
for j in range(12):
m = LR.get_minimal_span_meshline(np.random.choice(LR.M), axis=j % 2)
LR.insert_line(m)
z = np.zeros((N, N))
for i in range(N):
for j in range(N):
z[i, j] = LR(x[i], y[j])
expected = np.ones((N, N))
np.testing.assert_array_almost_equal(z, expected)
def test_lr_spline_global_knot_vector():
ku = [0, 0, 1, 2, 3, 3]
kv = [0, 0, 0.5, 1, 1]
du = 1
dv = 1
LR = init_tensor_product_LR_spline(du, dv, ku, kv)
np.testing.assert_array_almost_equal([0, 1, 2, 3], LR.global_knots_u)
np.testing.assert_array_almost_equal([0, 0.5, 1], LR.global_knots_v)
m = Meshline(start=0, stop=0.5, constant_value=1.5, axis=0)
LR.insert_line(m)
np.testing.assert_array_almost_equal([0, 1, 1.5, 2, 3], LR.global_knots_u)
def test_lr_spline_partition_of_unity_two_full(N):
d1, d2 = 2, 2
ku = [0, 0, 0, 0.5, 0.75, 1, 1, 1]
LR = init_tensor_product_LR_spline(d1, d2, ku, ku)
x = np.linspace(0, 1, N, endpoint=True)
np.random.seed(42)
for k in range(12):
m = LR.get_minimal_span_meshline(np.random.choice(LR.M), axis=k % 2)
LR.insert_line(m)
z = np.zeros((N, N))
for i in range(N):
for j in range(N):
z[i, j] = LR(x[i], x[j])
expected = np.ones((N, N))
np.testing.assert_array_almost_equal(z, expected)
def test_lr_spline_at_end_vs_knots_refined():
d1, d2 = 2, 2
ku = [0, 0, 0, 0.5, 0.75, 1, 1, 1]
kv = [0, 0, 0, 1, 2, 3, 3, 3]
LR = init_tensor_product_LR_spline(d1, d2, ku, kv)
np.random.seed(42)
for k in range(12):
m = LR.get_minimal_span_meshline(np.random.choice(LR.M), axis=k % 2)
LR.insert_line(m)
for b in LR.S:
if b.end_u:
assert ku[-1] in b.knots_u
if b.end_v:
assert kv[-1] in b.knots_v
def test_lr_spline_overloading_count_bilinear():
LR = init_tensor_product_LR_spline(1, 1, [0, 0, 1, 2, 3, 4, 5, 6, 6],
[0, 0, 1, 2, 3, 4, 5, 6, 6])
m1 = Meshline(2, 4, constant_value=3.5, axis=0)
m2 = Meshline(2, 4, constant_value=2.5, axis=0)
m3 = Meshline(2, 4, constant_value=2.5, axis=1)
m4 = Meshline(2, 4, constant_value=3.5, axis=1)
# culprit = 3, 3.5, 4 x 2 3 4
LR.insert_line(m1, debug=True)
LR.insert_line(m2, debug=True)
LR.insert_line(m3, debug=True)
LR.insert_line(m4, debug=True)
for e in LR.M:
c = Counter(e.supported_b_splines)
assert all([count == 1 for count in c.values()])
for e in LR.M:
assert len(e.supported_b_splines) in [4, 5]
from LRSplines import Element, np
from LRSplines.lr_spline import init_tensor_product_LR_spline
def element_contribution(e: Element):
mp_x, mp_y = e.midpoint
return (mp_x - 3)**2 + (mp_y - 3)**2 < 3
def circle(t):
return 2.5 * np.cos(t) + 3, 2.5 * np.sin(t) + 3
if __name__ == '__main__':
LR = init_tensor_product_LR_spline(1, 1, [0, 0, 1, 2, 3, 4, 5, 6, 6],
[0, 0, 1, 2, 3, 4, 5, 6, 6])
LR.visualize_mesh(False, False)
# LR.refine(beta=0.5, error_function=element_contribution, refinement_strategy='full')
# LR.visualize_mesh(False, False)
while len(LR.S) < 200:
print(len(LR.S))
circl_vals = [circle(t) for t in np.linspace(0, 2 * np.pi, 50)]
for x, y in circl_vals:
e = LR.find_element_containing_point(x, y)
LR.refine_by_element_minimal(e)
LR.visualize_mesh(False, False)
w,
h,
fill=True,
color='green',
alpha=0.2))
axs.text(m.midpoint[0], m.midpoint[1],
'{}'.format(len(m.supported_b_splines)))
plt.title('dim(S) = {}'.format(len(LR.S)))
if __name__ == '__main__':
for N in [2, 4, 6, 8]:
d1, d2 = 2, 2
ku = [0, 0, 0, 0.5, 0.75, 1, 1, 1]
LR = init_tensor_product_LR_spline(d1, d2, ku, ku)
x = np.linspace(0, 1, N, endpoint=False)
np.random.seed(42)
for k in range(12):
m = LR.get_minimal_span_meshline(np.random.choice(LR.M),
axis=k % 2)
LR.insert_line(m)
visualize_mesh(LR)
z = np.zeros((N, N))
for i in range(N):
for j in range(N):
z[i, j] = LR(x[i], x[j])
expected = np.ones((N, N))
X, Y = np.meshgrid(x, x)
def test_lr_spline_previously_split_functions():
LR = init_tensor_product_LR_spline(2, 2, [0, 0, 0, 1, 2, 4, 5, 6, 6, 6],
[0, 0, 0, 1, 2, 4, 5, 6, 6, 6])
m = Meshline(1, 5, constant_value=3, axis=0)
LR.insert_line(m)