Lines Matching +full:- +full:- +full:ceed
1 # Copyright (c) 2017-2026, Lawrence Livermore National Security, LLC and other CEED contributors
2 # All Rights Reserved. See the top-level LICENSE and NOTICE files for details.
4 # SPDX-License-Identifier: BSD-2-Clause
6 # This file is part of CEED: http://github.com/ceed
9 # Test Ceed Operator functionality
19 # -------------------------------------------------------------------------------
21 # -------------------------------------------------------------------------------
36 # -------------------------------------------------------------------------------
38 # -------------------------------------------------------------------------------
42 ceed = libceed.Ceed(ceed_resource)
48 nu = nelem * (p - 1) + 1
51 x = ceed.Vector(nx)
54 x_array[i] = i / (nx - 1.0)
57 qdata = ceed.Vector(nelem * q)
58 u = ceed.Vector(nu)
59 v = ceed.Vector(nu)
66 rx = ceed.ElemRestriction(nelem, 2, 1, 1, nx, indx,
72 indu[p * i + j] = i * (p - 1) + j
73 ru = ceed.ElemRestriction(nelem, p, 1, 1, nu, indu,
76 rui = ceed.StridedElemRestriction(nelem, q, 1, q * nelem, strides)
79 bx = ceed.BasisTensorH1Lagrange(1, 1, 2, q, libceed.GAUSS)
80 bu = ceed.BasisTensorH1Lagrange(1, 1, p, q, libceed.GAUSS)
86 qf_setup = ceed.QFunction(1, qfs.setup_mass,
87 os.path.join(file_dir, "test-qfunctions.h:setup_mass"))
92 qf_mass = ceed.QFunction(1, qfs.apply_mass,
93 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
99 op_setup = ceed.Operator(qf_setup)
107 op_mass = ceed.Operator(qf_mass)
125 # -------------------------------------------------------------------------------
127 # -------------------------------------------------------------------------------
131 ceed = libceed.Ceed(ceed_resource)
137 nu = nelem * (p - 1) + 1
140 x = ceed.Vector(nx)
141 x_array = np.zeros(nx, dtype=ceed.scalar_type())
143 x_array[i] = i / (nx - 1.0)
146 qdata = ceed.Vector(nelem * q)
147 u = ceed.Vector(nu)
148 v = ceed.Vector(nu)
155 rx = ceed.ElemRestriction(nelem, 2, 1, 1, nx, indx,
161 indu[p * i + j] = i * (p - 1) + j
162 ru = ceed.ElemRestriction(nelem, p, 1, 1, nu, indu,
165 rui = ceed.StridedElemRestriction(nelem, q, 1, q * nelem, strides)
168 bx = ceed.BasisTensorH1Lagrange(1, 1, 2, q, libceed.GAUSS)
169 bu = ceed.BasisTensorH1Lagrange(1, 1, p, q, libceed.GAUSS)
175 qf_setup = ceed.QFunction(1, qfs.setup_mass,
176 os.path.join(file_dir, "test-qfunctions.h:setup_mass"))
181 qf_mass = ceed.QFunction(1, qfs.apply_mass,
182 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
188 op_setup = ceed.Operator(qf_setup)
195 op_mass = ceed.Operator(qf_mass)
212 assert abs(total - 1.0) < TOL
214 # -------------------------------------------------------------------------------
217 # -------------------------------------------------------------------------------
221 ceed = libceed.Ceed(ceed_resource)
227 nu = nelem * (p - 1) + 1
230 x = ceed.Vector(nx)
231 x_array = np.zeros(nx, dtype=ceed.scalar_type())
233 x_array[i] = i / (nx - 1.0)
236 qdata = ceed.Vector(nelem * q)
237 u = ceed.Vector(2 * nu)
238 v = ceed.Vector(2 * nu)
245 rx = ceed.ElemRestriction(nelem, 2, 1, 1, nx, indx,
251 indu[p * i + j] = 2 * (i * (p - 1) + j)
252 ru = ceed.ElemRestriction(nelem, p, 2, 1, 2 * nu, indu,
255 rui = ceed.StridedElemRestriction(nelem, q, 1, q * nelem, strides)
258 bx = ceed.BasisTensorH1Lagrange(1, 1, 2, q, libceed.GAUSS)
259 bu = ceed.BasisTensorH1Lagrange(1, 2, p, q, libceed.GAUSS)
265 qf_setup = ceed.QFunction(1, qfs.setup_mass,
266 os.path.join(file_dir, "test-qfunctions.h:setup_mass"))
271 qf_mass = ceed.QFunction(1, qfs.apply_mass_two,
272 os.path.join(file_dir, "test-qfunctions.h:apply_mass_two"))
278 op_setup = ceed.Operator(qf_setup)
285 op_mass = ceed.Operator(qf_mass)
308 assert abs(total_1 - 1.0) < TOL
309 assert abs(total_2 - 2.0) < TOL
311 # -------------------------------------------------------------------------------
314 # -------------------------------------------------------------------------------
318 ceed = libceed.Ceed(ceed_resource)
324 nu = nelem * (p - 1) + 1
327 x = ceed.Vector(nx)
328 x_array = np.zeros(nx, dtype=ceed.scalar_type())
330 x_array[i] = i / (nx - 1.0)
333 qdata = ceed.Vector(nelem * q)
334 u = ceed.Vector(nu)
335 v = ceed.Vector(nu)
342 rx = ceed.ElemRestriction(nelem, 2, 1, 1, nx, indx,
348 indu[p * i + j] = i * (p - 1) + j
349 ru = ceed.ElemRestriction(nelem, p, 1, 1, nu, indu,
352 rui = ceed.StridedElemRestriction(nelem, q, 1, q * nelem, strides)
355 bx = ceed.BasisTensorH1Lagrange(1, 1, 2, q, libceed.GAUSS)
356 bu = ceed.BasisTensorH1Lagrange(1, 1, p, q, libceed.GAUSS)
362 qf_setup = ceed.QFunction(1, qfs.setup_mass,
363 os.path.join(file_dir, "test-qfunctions.h:setup_mass"))
368 qf_mass = ceed.QFunction(1, qfs.apply_mass,
369 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
375 op_setup = ceed.Operator(qf_setup)
382 op_mass = ceed.Operator(qf_mass)
399 assert abs(total - 1.0) < TOL
401 # -------------------------------------------------------------------------------
403 # -------------------------------------------------------------------------------
407 ceed = libceed.Ceed(ceed_resource)
413 nu = nelem * (p - 1) + 1
416 qdata = ceed.Vector(nelem * q)
423 rx = ceed.ElemRestriction(nelem, 2, 1, 1, nx, indx,
429 indu[p * i + j] = i * (p - 1) + j
430 ru = ceed.ElemRestriction(nelem, p, 1, 1, nu, indu,
433 rui = ceed.StridedElemRestriction(nelem, q, 1, q * nelem, strides)
436 bx = ceed.BasisTensorH1Lagrange(1, 1, 2, q, libceed.GAUSS)
437 bu = ceed.BasisTensorH1Lagrange(1, 1, p, q, libceed.GAUSS)
443 qf_setup = ceed.QFunction(1, qfs.setup_mass,
444 os.path.join(file_dir, "test-qfunctions.h:setup_mass"))
449 qf_mass = ceed.QFunction(1, qfs.apply_mass,
450 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
456 op_setup = ceed.Operator(qf_setup)
463 op_mass = ceed.Operator(qf_mass)
476 # -------------------------------------------------------------------------------
478 # -------------------------------------------------------------------------------
482 ceed = libceed.Ceed(ceed_resource)
488 nu = nelem * (p - 1) + 1
491 x = ceed.Vector(nx)
492 x_array = np.zeros(nx, dtype=ceed.scalar_type())
494 x_array[i] = i / (nx - 1.0)
497 qdata = ceed.Vector(nelem * q)
498 u = ceed.Vector(nu)
499 v = ceed.Vector(nu)
506 rx = ceed.ElemRestriction(nelem, 2, 1, 1, nx, indx,
512 indu[p * i + j] = i * (p - 1) + j
513 ru = ceed.ElemRestriction(nelem, p, 1, 1, nu, indu,
516 rui = ceed.StridedElemRestriction(nelem, q, 1, q * nelem, strides)
519 bx = ceed.BasisTensorH1Lagrange(1, 1, 2, q, libceed.GAUSS)
520 bu = ceed.BasisTensorH1Lagrange(1, 1, p, q, libceed.GAUSS)
526 qf_setup = ceed.QFunction(1, qfs.setup_mass,
527 os.path.join(file_dir, "test-qfunctions.h:setup_mass"))
532 qf_mass = ceed.QFunction(1, qfs.apply_mass,
533 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
539 op_setup = ceed.Operator(qf_setup)
546 op_mass = ceed.Operator(qf_mass)
564 assert abs(total - 1.0) < TOL
572 total = -nu
575 assert abs(total - 1.0) < 10. * TOL
577 # -------------------------------------------------------------------------------
579 # -------------------------------------------------------------------------------
583 ceed = libceed.Ceed(ceed_resource)
594 x = ceed.Vector(dim * ndofs)
601 qdata = ceed.Vector(nqpts)
602 u = ceed.Vector(ndofs)
603 v = ceed.Vector(ndofs)
626 rx = ceed.ElemRestriction(nelem, p, dim, ndofs, dim * ndofs, indx,
629 ru = ceed.ElemRestriction(nelem, p, 1, 1, ndofs, indx,
632 rui = ceed.StridedElemRestriction(nelem, q, 1, nqpts, strides)
635 qref = np.empty(dim * q, dtype=ceed.scalar_type())
636 qweight = np.empty(q, dtype=ceed.scalar_type())
640 bx = ceed.BasisH1(libceed.TRIANGLE, dim, p, q, interp, grad, qref, qweight)
641 bu = ceed.BasisH1(libceed.TRIANGLE, 1, p, q, interp, grad, qref, qweight)
647 qf_setup = ceed.QFunction(1, qfs.setup_mass_2d,
648 os.path.join(file_dir, "test-qfunctions.h:setup_mass_2d"))
653 qf_mass = ceed.QFunction(1, qfs.apply_mass,
654 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
660 op_setup = ceed.Operator(qf_setup)
667 op_mass = ceed.Operator(qf_mass)
684 # -------------------------------------------------------------------------------
686 # -------------------------------------------------------------------------------
690 ceed = libceed.Ceed(ceed_resource)
701 x = ceed.Vector(dim * ndofs)
702 x_array = np.zeros(dim * ndofs, dtype=ceed.scalar_type())
708 qdata = ceed.Vector(nqpts)
709 u = ceed.Vector(ndofs)
710 v = ceed.Vector(ndofs)
733 rx = ceed.ElemRestriction(nelem, p, dim, ndofs, dim * ndofs, indx,
736 ru = ceed.ElemRestriction(nelem, p, 1, 1, ndofs, indx,
739 rui = ceed.StridedElemRestriction(nelem, q, 1, nqpts, strides)
742 qref = np.empty(dim * q, dtype=ceed.scalar_type())
743 qweight = np.empty(q, dtype=ceed.scalar_type())
747 bx = ceed.BasisH1(libceed.TRIANGLE, dim, p, q, interp, grad, qref, qweight)
748 bu = ceed.BasisH1(libceed.TRIANGLE, 1, p, q, interp, grad, qref, qweight)
754 qf_setup = ceed.QFunction(1, qfs.setup_mass_2d,
755 os.path.join(file_dir, "test-qfunctions.h:setup_mass_2d"))
760 qf_mass = ceed.QFunction(1, qfs.apply_mass,
761 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
767 op_setup = ceed.Operator(qf_setup)
774 op_mass = ceed.Operator(qf_mass)
791 assert abs(total - 1.0) < 10. * TOL
793 # -------------------------------------------------------------------------------
795 # -------------------------------------------------------------------------------
799 ceed = libceed.Ceed(ceed_resource)
810 x = ceed.Vector(dim * ndofs)
818 qdata_hex = ceed.Vector(nqpts_hex)
819 qdata_tet = ceed.Vector(nqpts_tet)
820 u = ceed.Vector(ndofs)
821 v = ceed.Vector(ndofs)
823 # ------------------------- Tet Elements -------------------------
846 rx_tet = ceed.ElemRestriction(nelem_tet, p_tet, dim, ndofs, dim * ndofs,
849 ru_tet = ceed.ElemRestriction(nelem_tet, p_tet, 1, 1, ndofs, indx_tet,
852 rui_tet = ceed.StridedElemRestriction(nelem_tet, q_tet, 1, nqpts_tet,
856 qref = np.empty(dim * q_tet, dtype=ceed.scalar_type())
857 qweight = np.empty(q_tet, dtype=ceed.scalar_type())
861 bx_tet = ceed.BasisH1(libceed.TRIANGLE, dim, p_tet, q_hex, interp, grad, qref,
863 bu_tet = ceed.BasisH1(libceed.TRIANGLE, 1, p_tet, q_hex, interp, grad, qref,
870 qf_setup_tet = ceed.QFunction(1, qfs.setup_mass_2d,
871 os.path.join(file_dir, "test-qfunctions.h:setup_mass_2d"))
876 qf_mass_tet = ceed.QFunction(1, qfs.apply_mass,
877 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
883 op_setup_tet = ceed.Operator(qf_setup_tet)
890 op_mass_tet = ceed.Operator(qf_mass_tet)
895 # ------------------------- Hex Elements -------------------------
909 rx_hex = ceed.ElemRestriction(nelem_hex, p_hex * p_hex, dim, ndofs,
912 ru_hex = ceed.ElemRestriction(nelem_hex, p_hex * p_hex, 1, 1, ndofs,
915 rui_hex = ceed.StridedElemRestriction(nelem_hex, q_hex * q_hex, 1,
919 bx_hex = ceed.BasisTensorH1Lagrange(dim, dim, p_hex, q_hex, libceed.GAUSS)
920 bu_hex = ceed.BasisTensorH1Lagrange(dim, 1, p_hex, q_hex, libceed.GAUSS)
923 qf_setup_hex = ceed.QFunction(1, qfs.setup_mass_2d,
924 os.path.join(file_dir, "test-qfunctions.h:setup_mass_2d"))
929 qf_mass_hex = ceed.QFunction(1, qfs.apply_mass,
930 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
936 op_setup_hex = ceed.Operator(qf_setup_tet)
943 op_mass_hex = ceed.Operator(qf_mass_hex)
948 # ------------------------- Composite Operators -------------------------
951 op_setup = ceed.CompositeOperator()
957 op_mass = ceed.CompositeOperator()
969 # -------------------------------------------------------------------------------
971 # -------------------------------------------------------------------------------
975 ceed = libceed.Ceed(ceed_resource)
986 x = ceed.Vector(dim * ndofs)
987 x_array = np.zeros(dim * ndofs, dtype=ceed.scalar_type())
994 qdata_hex = ceed.Vector(nqpts_hex)
995 qdata_tet = ceed.Vector(nqpts_tet)
996 u = ceed.Vector(ndofs)
997 v = ceed.Vector(ndofs)
999 # ------------------------- Tet Elements -------------------------
1022 rx_tet = ceed.ElemRestriction(nelem_tet, p_tet, dim, ndofs, dim * ndofs,
1025 ru_tet = ceed.ElemRestriction(nelem_tet, p_tet, 1, 1, ndofs, indx_tet,
1028 rui_tet = ceed.StridedElemRestriction(nelem_tet, q_tet, 1, nqpts_tet,
1032 qref = np.empty(dim * q_tet, dtype=ceed.scalar_type())
1033 qweight = np.empty(q_tet, dtype=ceed.scalar_type())
1037 bx_tet = ceed.BasisH1(libceed.TRIANGLE, dim, p_tet, q_hex, interp, grad, qref,
1039 bu_tet = ceed.BasisH1(libceed.TRIANGLE, 1, p_tet, q_hex, interp, grad, qref,
1046 qf_setup_tet = ceed.QFunction(1, qfs.setup_mass_2d,
1047 os.path.join(file_dir, "test-qfunctions.h:setup_mass_2d"))
1052 qf_mass_tet = ceed.QFunction(1, qfs.apply_mass,
1053 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
1059 op_setup_tet = ceed.Operator(qf_setup_tet)
1066 op_mass_tet = ceed.Operator(qf_mass_tet)
1071 # ------------------------- Hex Elements -------------------------
1085 rx_hex = ceed.ElemRestriction(nelem_hex, p_hex * p_hex, dim, ndofs,
1088 ru_hex = ceed.ElemRestriction(nelem_hex, p_hex * p_hex, 1, 1, ndofs,
1091 rui_hex = ceed.StridedElemRestriction(nelem_hex, q_hex * q_hex, 1,
1095 bx_hex = ceed.BasisTensorH1Lagrange(dim, dim, p_hex, q_hex, libceed.GAUSS)
1096 bu_hex = ceed.BasisTensorH1Lagrange(dim, 1, p_hex, q_hex, libceed.GAUSS)
1099 qf_setup_hex = ceed.QFunction(1, qfs.setup_mass_2d,
1100 os.path.join(file_dir, "test-qfunctions.h:setup_mass_2d"))
1105 qf_mass_hex = ceed.QFunction(1, qfs.apply_mass,
1106 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
1112 op_setup_hex = ceed.Operator(qf_setup_tet)
1119 op_mass_hex = ceed.Operator(qf_mass_hex)
1124 # ------------------------- Composite Operators -------------------------
1127 op_setup = ceed.CompositeOperator()
1133 op_mass = ceed.CompositeOperator()
1144 assert abs(total - 1.0) < 10. * TOL
1146 # -------------------------------------------------------------------------------
1148 # -------------------------------------------------------------------------------
1152 ceed = libceed.Ceed(ceed_resource)
1163 qdata_hex = ceed.Vector(nqpts_hex)
1164 qdata_tet = ceed.Vector(nqpts_tet)
1166 # ------------------------- Tet Elements -------------------------
1189 rx_tet = ceed.ElemRestriction(nelem_tet, p_tet, dim, ndofs, dim * ndofs,
1192 ru_tet = ceed.ElemRestriction(nelem_tet, p_tet, 1, 1, ndofs, indx_tet,
1195 rui_tet = ceed.StridedElemRestriction(nelem_tet, q_tet, 1, nqpts_tet,
1199 qref = np.empty(dim * q_tet, dtype=ceed.scalar_type())
1200 qweight = np.empty(q_tet, dtype=ceed.scalar_type())
1204 bx_tet = ceed.BasisH1(libceed.TRIANGLE, dim, p_tet, q_hex, interp, grad, qref,
1206 bu_tet = ceed.BasisH1(libceed.TRIANGLE, 1, p_tet, q_hex, interp, grad, qref,
1213 qf_setup_tet = ceed.QFunction(1, qfs.setup_mass_2d,
1214 os.path.join(file_dir, "test-qfunctions.h:setup_mass_2d"))
1219 qf_mass_tet = ceed.QFunction(1, qfs.apply_mass,
1220 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
1226 op_setup_tet = ceed.Operator(qf_setup_tet)
1234 op_mass_tet = ceed.Operator(qf_mass_tet)
1240 # ------------------------- Hex Elements -------------------------
1254 rx_hex = ceed.ElemRestriction(nelem_hex, p_hex * p_hex, dim, ndofs,
1258 ru_hex = ceed.ElemRestriction(nelem_hex, p_hex * p_hex, 1, 1, ndofs,
1261 rui_hex = ceed.StridedElemRestriction(nelem_hex, q_hex * q_hex, 1,
1265 bx_hex = ceed.BasisTensorH1Lagrange(dim, dim, p_hex, q_hex, libceed.GAUSS)
1266 bu_hex = ceed.BasisTensorH1Lagrange(dim, 1, p_hex, q_hex, libceed.GAUSS)
1269 qf_setup_hex = ceed.QFunction(1, qfs.setup_mass_2d,
1270 os.path.join(file_dir, "test-qfunctions.h:setup_mass_2d"))
1275 qf_mass_hex = ceed.QFunction(1, qfs.apply_mass,
1276 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
1282 op_setup_hex = ceed.Operator(qf_setup_tet)
1290 op_mass_hex = ceed.Operator(qf_mass_hex)
1296 # ------------------------- Composite Operators -------------------------
1299 op_setup = ceed.CompositeOperator()
1305 op_mass = ceed.CompositeOperator()
1318 # -------------------------------------------------------------------------------
1320 # -------------------------------------------------------------------------------
1324 ceed = libceed.Ceed(ceed_resource)
1335 x = ceed.Vector(dim * ndofs)
1336 x_array = np.zeros(dim * ndofs, dtype=ceed.scalar_type())
1343 qdata_hex = ceed.Vector(nqpts_hex)
1344 qdata_tet = ceed.Vector(nqpts_tet)
1345 u = ceed.Vector(ndofs)
1346 v = ceed.Vector(ndofs)
1348 # ------------------------- Tet Elements -------------------------
1371 rx_tet = ceed.ElemRestriction(nelem_tet, p_tet, dim, ndofs, dim * ndofs,
1374 ru_tet = ceed.ElemRestriction(nelem_tet, p_tet, 1, 1, ndofs, indx_tet,
1377 rui_tet = ceed.StridedElemRestriction(nelem_tet, q_tet, 1, nqpts_tet,
1381 qref = np.empty(dim * q_tet, dtype=ceed.scalar_type())
1382 qweight = np.empty(q_tet, dtype=ceed.scalar_type())
1386 bx_tet = ceed.BasisH1(libceed.TRIANGLE, dim, p_tet, q_hex, interp, grad, qref,
1388 bu_tet = ceed.BasisH1(libceed.TRIANGLE, 1, p_tet, q_hex, interp, grad, qref,
1395 qf_setup_tet = ceed.QFunction(1, qfs.setup_mass_2d,
1396 os.path.join(file_dir, "test-qfunctions.h:setup_mass_2d"))
1401 qf_mass_tet = ceed.QFunction(1, qfs.apply_mass,
1402 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
1408 op_setup_tet = ceed.Operator(qf_setup_tet)
1415 op_mass_tet = ceed.Operator(qf_mass_tet)
1420 # ------------------------- Hex Elements -------------------------
1434 rx_hex = ceed.ElemRestriction(nelem_hex, p_hex * p_hex, dim, ndofs,
1438 ru_hex = ceed.ElemRestriction(nelem_hex, p_hex * p_hex, 1, 1, ndofs,
1441 rui_hex = ceed.StridedElemRestriction(nelem_hex, q_hex * q_hex, 1,
1445 bx_hex = ceed.BasisTensorH1Lagrange(dim, dim, p_hex, q_hex, libceed.GAUSS)
1446 bu_hex = ceed.BasisTensorH1Lagrange(dim, 1, p_hex, q_hex, libceed.GAUSS)
1449 qf_setup_hex = ceed.QFunction(1, qfs.setup_mass_2d,
1450 os.path.join(file_dir, "test-qfunctions.h:setup_mass_2d"))
1455 qf_mass_hex = ceed.QFunction(1, qfs.apply_mass,
1456 os.path.join(file_dir, "test-qfunctions.h:apply_mass"))
1462 op_setup_hex = ceed.Operator(qf_setup_tet)
1469 op_mass_hex = ceed.Operator(qf_mass_hex)
1474 # ------------------------- Composite Operators -------------------------
1477 op_setup = ceed.CompositeOperator()
1483 op_mass = ceed.CompositeOperator()
1494 assert abs(total - 1.0) < 10. * TOL
1502 total = -ndofs
1505 assert abs(total - 1.0) < 10. * TOL
1507 # -------------------------------------------------------------------------------
1509 # -------------------------------------------------------------------------------
1513 ceed = libceed.Ceed(ceed_resource)
1525 x = ceed.Vector(dim * ndofs)
1533 qdata = ceed.Vector(nqpts)
1534 u = ceed.Vector(ndofs)
1535 v = ceed.Vector(ndofs)
1542 offset = col * (p - 1) + row * (nx * 2 + 1) * (p - 1)
1546 rx = ceed.ElemRestriction(nelem, p * p, dim, ndofs, dim * ndofs,
1549 ru = ceed.ElemRestriction(nelem, p * p, 1, 1, ndofs, indx,
1552 rui = ceed.StridedElemRestriction(nelem, q * q, 1, nqpts, strides)
1555 bx = ceed.BasisTensorH1Lagrange(dim, dim, p, q, libceed.GAUSS)
1556 bu = ceed.BasisTensorH1Lagrange(dim, 1, p, q, libceed.GAUSS)
1559 qf_setup = ceed.QFunctionByName("Mass2DBuild")
1561 # -------------------------------------------------------------------------------
1564 # -------------------------------------------------------------------------------
1568 ceed = libceed.Ceed(ceed_resource)
1576 nu_coarse = nelem * (p_coarse - 1) + 1
1577 nu_fine = nelem * (p_fine - 1) + 1
1580 x = ceed.Vector(nx)
1581 x_array = np.zeros(nx, dtype=ceed.scalar_type())
1583 x_array[i] = i / (nx - 1.0)
1586 qdata = ceed.Vector(nelem * q)
1587 u_coarse = ceed.Vector(ncomp * nu_coarse)
1588 v_coarse = ceed.Vector(ncomp * nu_coarse)
1589 u_fine = ceed.Vector(ncomp * nu_fine)
1590 v_fine = ceed.Vector(ncomp * nu_fine)
1597 rx = ceed.ElemRestriction(nelem, 2, 1, 1, nx, indx,
1603 indu_coarse[p_coarse * i + j] = i * (p_coarse - 1) + j
1604 ru_coarse = ceed.ElemRestriction(nelem, p_coarse, ncomp, nu_coarse,
1611 indu_fine[p_fine * i + j] = i * (p_fine - 1) + j
1612 ru_fine = ceed.ElemRestriction(nelem, p_fine, ncomp, nu_fine,
1617 rui = ceed.StridedElemRestriction(nelem, q, 1, q * nelem, strides)
1620 bx = ceed.BasisTensorH1Lagrange(1, 1, 2, q, libceed.GAUSS)
1621 bu_coarse = ceed.BasisTensorH1Lagrange(1, ncomp, p_coarse, q, libceed.GAUSS)
1622 bu_fine = ceed.BasisTensorH1Lagrange(1, ncomp, p_fine, q, libceed.GAUSS)
1628 qf_setup = ceed.QFunction(1, qfs.setup_mass,
1629 os.path.join(file_dir, "test-qfunctions.h:setup_mass"))
1634 qf_mass = ceed.QFunction(1, qfs.apply_mass_two,
1635 os.path.join(file_dir, "test-qfunctions.h:apply_mass_two"))
1641 op_setup = ceed.Operator(qf_setup)
1648 op_mass_fine = ceed.Operator(qf_mass)
1657 p_mult_fine = ceed.Vector(ncomp * nu_fine)
1672 assert abs(total - 2.0) < 10. * TOL
1685 assert abs(total - 2.0) < 10. * TOL
1695 assert abs(total - 2.0) < 10. * TOL
1697 # -------------------------------------------------------------------------------
1700 # -------------------------------------------------------------------------------
1704 ceed = libceed.Ceed(ceed_resource)
1712 nu_coarse = nelem * (p_coarse - 1) + 1
1713 nu_fine = nelem * (p_fine - 1) + 1
1716 x = ceed.Vector(nx)
1717 x_array = np.zeros(nx, dtype=ceed.scalar_type())
1719 x_array[i] = i / (nx - 1.0)
1722 qdata = ceed.Vector(nelem * q)
1723 u_coarse = ceed.Vector(ncomp * nu_coarse)
1724 v_coarse = ceed.Vector(ncomp * nu_coarse)
1725 u_fine = ceed.Vector(ncomp * nu_fine)
1726 v_fine = ceed.Vector(ncomp * nu_fine)
1733 rx = ceed.ElemRestriction(nelem, 2, 1, 1, nx, indx,
1739 indu_coarse[p_coarse * i + j] = i * (p_coarse - 1) + j
1740 ru_coarse = ceed.ElemRestriction(nelem, p_coarse, ncomp, nu_coarse,
1747 indu_fine[p_fine * i + j] = i * (p_fine - 1) + j
1748 ru_fine = ceed.ElemRestriction(nelem, p_fine, ncomp, nu_fine,
1753 rui = ceed.StridedElemRestriction(nelem, q, 1, q * nelem, strides)
1756 bx = ceed.BasisTensorH1Lagrange(1, 1, 2, q, libceed.GAUSS)
1757 bu_coarse = ceed.BasisTensorH1Lagrange(1, ncomp, p_coarse, q, libceed.GAUSS)
1758 bu_fine = ceed.BasisTensorH1Lagrange(1, ncomp, p_fine, q, libceed.GAUSS)
1764 qf_setup = ceed.QFunction(1, qfs.setup_mass,
1765 os.path.join(file_dir, "test-qfunctions.h:setup_mass"))
1770 qf_mass = ceed.QFunction(1, qfs.apply_mass_two,
1771 os.path.join(file_dir, "test-qfunctions.h:apply_mass_two"))
1777 op_setup = ceed.Operator(qf_setup)
1784 op_mass_fine = ceed.Operator(qf_mass)
1793 p_mult_fine = ceed.Vector(ncomp * nu_fine)
1795 b_c_to_f = ceed.BasisTensorH1Lagrange(
1810 assert abs(total - 2.0) < TOL
1823 assert abs(total - 2.0) < TOL
1833 assert abs(total - 2.0) < TOL
1835 # -------------------------------------------------------------------------------
1837 # multigrid level, non-tensor basis
1838 # -------------------------------------------------------------------------------
1842 ceed = libceed.Ceed(ceed_resource)
1850 nu_coarse = nelem * (p_coarse - 1) + 1
1851 nu_fine = nelem * (p_fine - 1) + 1
1854 x = ceed.Vector(nx)
1855 x_array = np.zeros(nx, dtype=ceed.scalar_type())
1857 x_array[i] = i / (nx - 1.0)
1860 qdata = ceed.Vector(nelem * q)
1861 u_coarse = ceed.Vector(ncomp * nu_coarse)
1862 v_coarse = ceed.Vector(ncomp * nu_coarse)
1863 u_fine = ceed.Vector(ncomp * nu_fine)
1864 v_fine = ceed.Vector(ncomp * nu_fine)
1871 rx = ceed.ElemRestriction(nelem, 2, 1, 1, nx, indx,
1877 indu_coarse[p_coarse * i + j] = i * (p_coarse - 1) + j
1878 ru_coarse = ceed.ElemRestriction(nelem, p_coarse, ncomp, nu_coarse,
1885 indu_fine[p_fine * i + j] = i * (p_fine - 1) + j
1886 ru_fine = ceed.ElemRestriction(nelem, p_fine, ncomp, nu_fine,
1891 rui = ceed.StridedElemRestriction(nelem, q, 1, q * nelem, strides)
1894 bx = ceed.BasisTensorH1Lagrange(1, 1, 2, q, libceed.GAUSS)
1895 bu_coarse = ceed.BasisTensorH1Lagrange(1, ncomp, p_coarse, q, libceed.GAUSS)
1896 bu_fine = ceed.BasisTensorH1Lagrange(1, ncomp, p_fine, q, libceed.GAUSS)
1902 qf_setup = ceed.QFunctionByName("Mass1DBuild")
1903 qf_mass = ceed.QFunctionByName("MassApply")
1906 op_setup = ceed.Operator(qf_setup)
1913 op_mass_fine = ceed.Operator(qf_mass)
1922 p_mult_fine = ceed.Vector(ncomp * nu_fine)
1924 b_c_to_f = ceed.BasisTensorH1Lagrange(
1939 assert abs(total - 1.0) < TOL
1952 assert abs(total - 1.0) < TOL
1962 assert abs(total - 1.0) < TOL
1964 # -------------------------------------------------------------------------------