def test_104(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
n = 10
x = ceed.Vector(n)
a = np.zeros(n, dtype="float64")
x.set_array(a, cmode=libceed.USE_POINTER)
b = x.get_array()
b[3] = -3.14
x.restore_array()
assert a[3] == -3.14
def test_107(ceed_resource, capsys):
ceed = libceed.Ceed(ceed_resource)
n = 10
x = ceed.Vector(n)
a = np.arange(10, 10 + n, dtype=ceed.scalar_type())
x.set_array(a, cmode=libceed.USE_POINTER)
print(x)
stdout, stderr, ref_stdout = check.output(capsys)
assert not stderr
assert stdout == ref_stdout
def test_100(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
n = 10
x = ceed.Vector(n)
a = np.arange(10, 10 + n, dtype="float64")
x.set_array(a, cmode=libceed.USE_POINTER)
b = x.get_array_read()
for i in range(n):
assert b[i] == 10 + i
x.restore_array_read()
def test_005(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
vec = ceed.Vector(5)
array1 = vec.get_array()
exception_raised = False
try:
array2 = vec.get_array()
except BaseException:
exception_raised = True
assert exception_raised
vec.restore_array()
def test_320(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
P, Q, dim = 6, 4, 2
in_array = np.empty(P, dtype="float64")
qref = np.empty(dim * Q, dtype="float64")
qweight = np.empty(Q, dtype="float64")
interp, grad = bm.buildmats(qref, qweight)
b = ceed.BasisH1(libceed.TRIANGLE, 1, P, Q, interp, grad, qref, qweight)
print(b)
del b
def test_202(ceed_resource, capsys):
ceed = libceed.Ceed(ceed_resource)
num_elem = 8
elem_size = 2
num_blk = 2
blk_size = 5
x = ceed.Vector(num_elem + 1)
a = np.arange(10, 10 + num_elem + 1, dtype=ceed.scalar_type())
x.set_array(a, cmode=libceed.COPY_VALUES)
ind = np.zeros(2 * num_elem, dtype="int32")
for i in range(num_elem):
ind[2 * i + 0] = i
ind[2 * i + 1] = i + 1
r = ceed.BlockedElemRestriction(num_elem,
elem_size,
blk_size,
1,
1,
num_elem + 1,
ind,
cmode=libceed.COPY_VALUES)
y = ceed.Vector(num_blk * blk_size * elem_size)
y.set_value(0)
# NoTranspose
r.apply(x, y)
layout = r.get_layout()
with y.array_read() as y_array:
for i in range(elem_size):
for j in range(1):
for k in range(num_elem):
block = int(k / blk_size)
elem = k % blk_size
indx = (i * blk_size + elem) * \
layout[0] + j * blk_size * layout[1] + \
block * blk_size * layout[2]
assert y_array[indx] == a[ind[k * elem_size + i]]
x.set_value(0)
r.T.apply(y, x)
with x.array_read() as x_array:
for i in range(num_elem + 1):
assert x_array[i] == (10 +
i) * (2.0 if i > 0 and i < num_elem else 1.0)
def test_104(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
n = 10
x = ceed.Vector(n)
a = np.zeros(n, dtype=ceed.scalar_type())
x.set_array(a, cmode=libceed.USE_POINTER)
with x.array() as b:
b[3] = -3.14
if libceed.lib.CEED_SCALAR_TYPE == libceed.SCALAR_FP32:
assert a[3] == np.float32(-3.14)
else:
assert a[3] == -3.14
def test_300(ceed_resource, capsys):
ceed = libceed.Ceed(ceed_resource)
b = ceed.BasisTensorH1Lagrange(1, 1, 4, 4, libceed.GAUSS_LOBATTO)
print(b)
del b
b = ceed.BasisTensorH1Lagrange(1, 1, 4, 4, libceed.GAUSS)
print(b)
del b
stdout, stderr = capsys.readouterr()
with open(os.path.abspath("./output/test_300.out")) as output_file:
true_output = output_file.read()
assert stdout == true_output
def test_320(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
P, Q, dim = 6, 4, 2
in_array = np.empty(P, dtype=ceed.scalar_type())
qref = np.empty(dim * Q, dtype=ceed.scalar_type())
qweight = np.empty(Q, dtype=ceed.scalar_type())
interp, grad = bm.buildmats(
qref, qweight, libceed.scalar_types[libceed.lib.CEED_SCALAR_TYPE])
b = ceed.BasisH1(libceed.TRIANGLE, 1, P, Q, interp, grad, qref, qweight)
print(b)
del b
def test_300(ceed_resource, capsys):
ceed = libceed.Ceed(ceed_resource)
b = ceed.BasisTensorH1Lagrange(1, 1, 4, 4, libceed.GAUSS_LOBATTO)
print(b)
del b
b = ceed.BasisTensorH1Lagrange(1, 1, 4, 4, libceed.GAUSS)
print(b)
del b
# Only run this test in double precision
if libceed.lib.CEED_SCALAR_TYPE == libceed.SCALAR_FP64:
stdout, stderr, ref_stdout = check.output(capsys)
assert not stderr
assert stdout == ref_stdout
def test_107(ceed_resource, capsys):
ceed = libceed.Ceed(ceed_resource)
n = 10
x = ceed.Vector(n)
a = np.arange(10, 10 + n, dtype="float64")
x.set_array(a, cmode=libceed.USE_POINTER)
print(x)
stdout, stderr = capsys.readouterr()
with open(os.path.abspath("./output/test_107.out")) as output_file:
true_output = output_file.read()
assert stdout == true_output
def test_210(ceed_resource, capsys):
ceed = libceed.Ceed(ceed_resource)
num_elem = 3
ind = np.zeros(2 * num_elem, dtype="int32")
for i in range(num_elem):
ind[2 * i + 0] = i + 0
ind[2 * i + 1] = i + 1
r = ceed.ElemRestriction(num_elem, 2, 1, 1, num_elem + 1, ind,
cmode=libceed.USE_POINTER)
print(r)
stdout, stderr, ref_stdout = check.output(capsys)
assert not stderr
assert stdout == ref_stdout
def test_103(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
n = 10
x = ceed.Vector(n)
y = ceed.Vector(n)
a = np.arange(10, 10 + n, dtype="float64")
x.set_array(a, cmode=libceed.USE_POINTER)
with x.array() as x_array:
y.set_array(x_array, cmode=libceed.USE_POINTER)
with y.array_read() as y_array:
for i in range(n):
assert y_array[i] == 10 + i
def test_304(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
A = np.array([
0.2, 0.0745355993, -0.0745355993, 0.0333333333, 0.0745355993, 1.,
0.1666666667, -0.0745355993, -0.0745355993, 0.1666666667, 1.,
0.0745355993, 0.0333333333, -0.0745355993, 0.0745355993, 0.2
],
dtype="float64")
Q = A.copy()
lam = ceed.symmetric_schur_decomposition(Q, 4)
Q = Q.reshape(4, 4)
lam = np.diag(lam)
Q_lambda_Qt = np.matmul(np.matmul(Q, lam), Q.T)
assert np.max(Q_lambda_Qt - A.reshape(4, 4)) < 1E-14
def test_210(ceed_resource, capsys):
ceed = libceed.Ceed(ceed_resource)
ne = 3
ind = np.zeros(2 * ne, dtype="int32")
for i in range(ne):
ind[2 * i + 0] = i + 0
ind[2 * i + 1] = i + 1
r = ceed.ElemRestriction(ne, 2, ne + 1, 1, ind, cmode=libceed.USE_POINTER)
print(r)
stdout, stderr = capsys.readouterr()
with open(os.path.abspath("./output/test_210.out")) as output_file:
true_output = output_file.read()
assert stdout == true_output
def test_301(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
m = 4
n = 3
a = np.array([1, -1, 4, 1, 4, -2, 1, 4, 2, 1, -1, 0], dtype="float64")
qr = np.array([1, -1, 4, 1, 4, -2, 1, 4, 2, 1, -1, 0], dtype="float64")
tau = np.empty(3, dtype="float64")
qr, tau = ceed.qr_factorization(qr, tau, m, n)
np_qr, np_tau = np.linalg.qr(a.reshape(m, n), mode="raw")
for i in range(n):
assert tau[i] == np_tau[i]
qr = qr.reshape(m, n)
for i in range(m):
for j in range(n):
assert round(qr[i, j] - np_qr[j, i], 10) == 0
def test_410(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
qf_setup = ceed.QFunctionByName("Mass1DBuild")
qf_mass = ceed.QFunctionByName("MassApply")
q = 8
j_array = np.zeros(q, dtype="float64")
w_array = np.zeros(q, dtype="float64")
u_array = np.zeros(q, dtype="float64")
v_true = np.zeros(q, dtype="float64")
for i in range(q):
x = 2. * i / (q - 1) - 1
j_array[i] = 1
w_array[i] = 1 - x * x
u_array[i] = 2 + 3 * x + 5 * x * x
v_true[i] = w_array[i] * u_array[i]
j = ceed.Vector(q)
j.set_array(j_array, cmode=libceed.USE_POINTER)
w = ceed.Vector(q)
w.set_array(w_array, cmode=libceed.USE_POINTER)
u = ceed.Vector(q)
u.set_array(u_array, cmode=libceed.USE_POINTER)
v = ceed.Vector(q)
v.set_value(0)
qdata = ceed.Vector(q)
qdata.set_value(0)
inputs = [j, w]
outputs = [qdata]
qf_setup.apply(q, inputs, outputs)
inputs = [w, u]
outputs = [v]
qf_mass.apply(q, inputs, outputs)
v_array = v.get_array_read()
for i in range(q):
assert v_array[i] == v_true[i]
v.restore_array_read()
def test_105(ceed_resource):
# Skip test for non-GPU backend
if 'gpu' in ceed_resource:
ceed = libceed.Ceed(ceed_resource)
n = 10
x = ceed.Vector(n)
y = ceed.Vector(n)
a = np.arange(10, 10 + n, dtype="float64")
x.set_array(a, cmode=libceed.USE_POINTER)
arr = x.get_array_read(memtype=libceed.MEM_DEVICE)
y.set_array(arr, memtype=libceed.MEM_DEVICE)
x.restore_array_read()
with y.array_read() as b:
for i in range(n):
assert b[i] == 10 + i
def test_103(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
n = 10
x = ceed.Vector(n)
y = ceed.Vector(n)
a = np.arange(10, 10 + n, dtype="float64")
x.set_array(a, cmode=libceed.USE_POINTER)
x_array = x.get_array()
y.set_array(x_array, cmode=libceed.USE_POINTER)
x.restore_array()
y_array = y.get_array_read()
for i in range(n):
assert y_array[i] == 10 + i
y.restore_array_read()
def test_101(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
n = 10
x = ceed.Vector(n)
value = 1
a = np.arange(10, 10 + n, dtype="float64")
x.set_array(a, cmode=libceed.USE_POINTER)
with x.array() as b:
for i in range(len(b)):
assert b[i] == 10 + i
x.set_value(3.0)
check_values(ceed, x, 3.0)
del x
x = ceed.Vector(n)
# Set value before setting or getting the array
x.set_value(5.0)
check_values(ceed, x, 5.0)
def test_209(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
num_elem = 3
ind = np.zeros(4 * num_elem, dtype="int32")
for i in range(num_elem):
ind[4 * i + 0] = i * 3 + 0
ind[4 * i + 1] = i * 3 + 1
ind[4 * i + 2] = i * 3 + 2
ind[4 * i + 3] = i * 3 + 3
r = ceed.ElemRestriction(num_elem, 4, 1, 1, 3 * num_elem + 1, ind,
cmode=libceed.USE_POINTER)
mult = r.get_multiplicity()
with mult.array_read() as mult_array:
for i in range(3 * num_elem + 1):
val = 1 + (1 if (i > 0 and i < 3 * num_elem and i % 3 == 0) else 0)
assert val == mult_array[i]
def test_201(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
num_elem = 3
x = ceed.Vector(2 * num_elem)
a = np.arange(10, 10 + 2 * num_elem, dtype=ceed.scalar_type())
x.set_array(a, cmode=libceed.USE_POINTER)
strides = np.array([1, 2, 2], dtype="int32")
r = ceed.StridedElemRestriction(num_elem, 2, 1, 2 * num_elem, strides)
y = ceed.Vector(2 * num_elem)
y.set_value(0)
r.apply(x, y)
with y.array_read() as y_array:
for i in range(2 * num_elem):
assert 10 + i == y_array[i]
def test_301(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
m = 4
n = 3
a = np.array([1, -1, 4, 1, 4, -2, 1, 4, 2, 1, -1, 0],
dtype=ceed.scalar_type())
qr = np.array([1, -1, 4, 1, 4, -2, 1, 4, 2, 1, -1, 0],
dtype=ceed.scalar_type())
tau = np.empty(3, dtype=ceed.scalar_type())
qr, tau = ceed.qr_factorization(qr, tau, m, n)
np_qr, np_tau = np.linalg.qr(a.reshape(m, n), mode="raw")
for i in range(n):
assert abs(tau[i] - np_tau[i]) < TOL
qr = qr.reshape(m, n)
for i in range(m):
for j in range(n):
assert abs(qr[i, j] - np_qr[j, i]) < TOL
def test_201(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
ne = 3
x = ceed.Vector(2 * ne)
a = np.arange(10, 10 + 2 * ne, dtype="float64")
x.set_array(a, cmode=libceed.USE_POINTER)
r = ceed.IdentityElemRestriction(ne, 2, 2 * ne, 1)
y = ceed.Vector(2 * ne)
y.set_value(0)
r.apply(x, y)
y_array = y.get_array_read()
for i in range(2 * ne):
assert 10 + i == y_array[i]
y.restore_array_read()
def test_322(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
P, Q, dim = 6, 4, 2
xr = np.array([0., 0.5, 1., 0., 0.5, 0., 0., 0., 0., 0.5, 0.5, 1.],
dtype="float64")
in_array = np.empty(P, dtype="float64")
qref = np.empty(dim * Q, dtype="float64")
qweight = np.empty(Q, dtype="float64")
interp, grad = bm.buildmats(qref, qweight)
b = ceed.BasisH1(libceed.TRIANGLE, 1, P, Q, interp, grad, qref, qweight)
# Interpolate function to quadrature points
for i in range(P):
in_array[i] = feval(xr[0 * P + i], xr[1 * P + i])
in_vec = ceed.Vector(P)
in_vec.set_array(in_array, cmode=libceed.USE_POINTER)
out_vec = ceed.Vector(Q)
out_vec.set_value(0)
weights_vec = ceed.Vector(Q)
weights_vec.set_value(0)
b.apply(1, libceed.EVAL_INTERP, in_vec, out_vec)
b.apply(1, libceed.EVAL_WEIGHT, libceed.VECTOR_NONE, weights_vec)
# Check values at quadrature points
out_array = out_vec.get_array_read()
weights_array = weights_vec.get_array_read()
sum = 0
for i in range(Q):
sum += out_array[i] * weights_array[i]
assert math.fabs(sum - 17. / 24.) < 1E-10
out_vec.restore_array_read()
weights_vec.restore_array_read()
def test_202(ceed_resource, capsys):
ceed = libceed.Ceed(ceed_resource)
ne = 8
blksize = 5
x = ceed.Vector(ne + 1)
a = np.arange(10, 10 + ne + 1, dtype="float64")
x.set_array(a, cmode=libceed.USE_POINTER)
ind = np.zeros(2 * ne, dtype="int32")
for i in range(ne):
ind[2 * i + 0] = i
ind[2 * i + 1] = i + 1
r = ceed.BlockedElemRestriction(ne,
2,
blksize,
ne + 1,
1,
ind,
cmode=libceed.USE_POINTER)
y = ceed.Vector(2 * blksize * 2)
y.set_value(0)
r.apply(x, y)
print(y)
x.set_value(0)
r.T.apply(y, x)
print(x)
stdout, stderr = capsys.readouterr()
with open(os.path.abspath("./output/test_202.out")) as output_file:
true_output = output_file.read()
assert stdout == true_output
def test_323(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
P, Q, dim = 6, 4, 2
xq = np.array([0.2, 0.6, 1. / 3., 0.2, 0.2, 0.2, 1. / 3., 0.6],
dtype="float64")
xr = np.array([0., 0.5, 1., 0., 0.5, 0., 0., 0., 0., 0.5, 0.5, 1.],
dtype="float64")
in_array = np.empty(P, dtype="float64")
qref = np.empty(dim * Q, dtype="float64")
qweight = np.empty(Q, dtype="float64")
interp, grad = bm.buildmats(qref, qweight)
b = ceed.BasisH1(libceed.TRIANGLE, 1, P, Q, interp, grad, qref, qweight)
# Interpolate function to quadrature points
for i in range(P):
in_array[i] = feval(xr[0 * P + i], xr[1 * P + i])
in_vec = ceed.Vector(P)
in_vec.set_array(in_array, cmode=libceed.USE_POINTER)
out_vec = ceed.Vector(Q * dim)
out_vec.set_value(0)
b.apply(1, libceed.EVAL_GRAD, in_vec, out_vec)
# Check values at quadrature points
out_array = out_vec.get_array_read()
for i in range(Q):
value = dfeval(xq[0 * Q + i], xq[1 * Q + i])
assert math.fabs(out_array[0 * Q + i] - value) < 1E-10
value = dfeval(xq[1 * Q + i], xq[0 * Q + i])
assert math.fabs(out_array[1 * Q + i] - value) < 1E-10
out_vec.restore_array_read()
def test_411(ceed_resource):
ceed = libceed.Ceed(ceed_resource)
qf = ceed.IdentityQFunction(1, libceed.EVAL_INTERP, libceed.EVAL_INTERP)
q = 8
u_array = np.zeros(q, dtype=ceed.scalar_type())
for i in range(q):
u_array[i] = i * i
u = ceed.Vector(q)
u.set_array(u_array, cmode=libceed.USE_POINTER)
v = ceed.Vector(q)
v.set_value(0)
inputs = [u]
outputs = [v]
qf.apply(q, inputs, outputs)
with v.array_read() as v_array:
for i in range(q):
assert v_array[i] == i * i
def test_108(ceed_resource, capsys):
ceed = libceed.Ceed(ceed_resource)
n = 10
x = ceed.Vector(n)
a = np.arange(0, n, dtype="float64")
for i in range(n):
if (i % 2 == 0):
a[i] *= -1
x.set_array(a, cmode=libceed.USE_POINTER)
norm = x.norm(normtype=libceed.NORM_1)
assert abs(norm - 45.) < 1e-14
norm = x.norm()
assert abs(norm - np.sqrt(285.)) < 1e-14
norm = x.norm(normtype=libceed.NORM_MAX)
assert abs(norm - 9.) < 1e-14
def test_301(ceed_resource, capsys):
ceed = libceed.Ceed(ceed_resource)
qr = np.array([1, -1, 4, 1, 4, -2, 1, 4, 2, 1, -1, 0], dtype="float64")
tau = np.empty(3, dtype="float64")
qr, tau = libceed.Basis.qr_factorization(ceed, qr, tau, 4, 3)
for i in range(len(qr)):
if qr[i] <= 1E-14 and qr[i] >= -1E-14:
qr[i] = 0
print("%12.8f" % qr[i])
for i in range(len(tau)):
if tau[i] <= 1E-14 and tau[i] >= -1E-14:
tau[i] = 0
print("%12.8f" % tau[i])
stdout, stderr = capsys.readouterr()
with open(os.path.abspath("./output/test_301.out")) as output_file:
true_output = output_file.read()
assert stdout == true_output
