1 /// @file
2 /// Test creation, action, and destruction for mass matrix operator with multigrid level, tensor basis
3 /// \test Test creation, action, and destruction for mass matrix operator with multigrid level, tensor basis
4 #include <ceed.h>
5 #include <math.h>
6 #include <stdio.h>
7 #include <stdlib.h>
8
9 #include "t502-operator.h"
10
main(int argc,char ** argv)11 int main(int argc, char **argv) {
12 Ceed ceed;
13 CeedElemRestriction elem_restriction_x, elem_restriction_q_data, elem_restriction_u_coarse, elem_restr_coarse_fine;
14 CeedBasis basis_x, basis_u;
15 CeedQFunction qf_setup, qf_mass;
16 CeedOperator op_setup, op_mass_coarse, op_mass_fine, op_prolong, op_restrict;
17 CeedVector q_data, x, u_coarse, u_fine, v_coarse, v_fine, p_mult_fine;
18 CeedInt num_elem = 15, p_coarse = 3, p_fine = 5, q = 8, num_comp = 2;
19 CeedInt num_dofs_x = num_elem + 1, num_dofs_u_coarse = num_elem * (p_coarse - 1) + 1, num_dofs_u_fine = num_elem * (p_fine - 1) + 1;
20 CeedInt ind_u_coarse[num_elem * p_coarse], ind_u_fine[num_elem * p_fine], ind_x[num_elem * 2];
21
22 CeedInit(argv[1], &ceed);
23
24 CeedVectorCreate(ceed, num_dofs_x, &x);
25 {
26 CeedScalar x_array[num_dofs_x];
27
28 for (CeedInt i = 0; i < num_dofs_x; i++) x_array[i] = (CeedScalar)i / (num_dofs_x - 1);
29 CeedVectorSetArray(x, CEED_MEM_HOST, CEED_COPY_VALUES, x_array);
30 }
31 CeedVectorCreate(ceed, num_comp * num_dofs_u_fine, &p_mult_fine);
32 CeedVectorCreate(ceed, num_comp * num_dofs_u_coarse, &u_coarse);
33 CeedVectorCreate(ceed, num_comp * num_dofs_u_coarse, &v_coarse);
34 CeedVectorCreate(ceed, num_comp * num_dofs_u_fine, &u_fine);
35 CeedVectorCreate(ceed, num_comp * num_dofs_u_fine, &v_fine);
36 CeedVectorCreate(ceed, num_elem * q, &q_data);
37
38 // Restrictions
39 for (CeedInt i = 0; i < num_elem; i++) {
40 ind_x[2 * i + 0] = i;
41 ind_x[2 * i + 1] = i + 1;
42 }
43 CeedElemRestrictionCreate(ceed, num_elem, 2, 1, 1, num_dofs_x, CEED_MEM_HOST, CEED_USE_POINTER, ind_x, &elem_restriction_x);
44
45 for (CeedInt i = 0; i < num_elem; i++) {
46 for (CeedInt j = 0; j < p_coarse; j++) {
47 ind_u_coarse[p_coarse * i + j] = i * (p_coarse - 1) + j;
48 }
49 }
50 CeedElemRestrictionCreate(ceed, num_elem, p_coarse, num_comp, num_dofs_u_coarse, num_comp * num_dofs_u_coarse, CEED_MEM_HOST, CEED_USE_POINTER,
51 ind_u_coarse, &elem_restriction_u_coarse);
52
53 for (CeedInt i = 0; i < num_elem; i++) {
54 for (CeedInt j = 0; j < p_fine; j++) {
55 ind_u_fine[p_fine * i + j] = i * (p_fine - 1) + j;
56 }
57 }
58 CeedElemRestrictionCreate(ceed, num_elem, p_fine, num_comp, num_dofs_u_fine, num_comp * num_dofs_u_fine, CEED_MEM_HOST, CEED_USE_POINTER,
59 ind_u_fine, &elem_restr_coarse_fine);
60
61 CeedInt strides_q_data[3] = {1, q, q};
62 CeedElemRestrictionCreateStrided(ceed, num_elem, q, 1, q * num_elem, strides_q_data, &elem_restriction_q_data);
63
64 // Bases
65 CeedBasisCreateTensorH1Lagrange(ceed, 1, 1, 2, q, CEED_GAUSS, &basis_x);
66 CeedBasisCreateTensorH1Lagrange(ceed, 1, num_comp, p_fine, q, CEED_GAUSS, &basis_u);
67
68 // QFunctions
69 CeedQFunctionCreateInterior(ceed, 1, setup, setup_loc, &qf_setup);
70 CeedQFunctionAddInput(qf_setup, "weight", 1, CEED_EVAL_WEIGHT);
71 CeedQFunctionAddInput(qf_setup, "dx", 1 * 1, CEED_EVAL_GRAD);
72 CeedQFunctionAddOutput(qf_setup, "q data", 1, CEED_EVAL_NONE);
73
74 CeedQFunctionCreateInterior(ceed, 1, mass, mass_loc, &qf_mass);
75 CeedQFunctionAddInput(qf_mass, "q data", 1, CEED_EVAL_NONE);
76 CeedQFunctionAddInput(qf_mass, "u", num_comp, CEED_EVAL_INTERP);
77 CeedQFunctionAddOutput(qf_mass, "v", num_comp, CEED_EVAL_INTERP);
78
79 // Operators
80 CeedOperatorCreate(ceed, qf_setup, CEED_QFUNCTION_NONE, CEED_QFUNCTION_NONE, &op_setup);
81 CeedOperatorSetField(op_setup, "weight", CEED_ELEMRESTRICTION_NONE, basis_x, CEED_VECTOR_NONE);
82 CeedOperatorSetField(op_setup, "dx", elem_restriction_x, basis_x, CEED_VECTOR_ACTIVE);
83 CeedOperatorSetField(op_setup, "q data", elem_restriction_q_data, CEED_BASIS_NONE, CEED_VECTOR_ACTIVE);
84
85 CeedOperatorCreate(ceed, qf_mass, CEED_QFUNCTION_NONE, CEED_QFUNCTION_NONE, &op_mass_fine);
86 CeedOperatorSetField(op_mass_fine, "q data", elem_restriction_q_data, CEED_BASIS_NONE, q_data);
87 CeedOperatorSetField(op_mass_fine, "u", elem_restr_coarse_fine, basis_u, CEED_VECTOR_ACTIVE);
88 CeedOperatorSetField(op_mass_fine, "v", elem_restr_coarse_fine, basis_u, CEED_VECTOR_ACTIVE);
89
90 CeedOperatorApply(op_setup, x, q_data, CEED_REQUEST_IMMEDIATE);
91
92 // Create multigrid level
93 CeedVectorSetValue(p_mult_fine, 1.0);
94 CeedBasis basis_u_coarse, basis_coarse_to_fine;
95 CeedBasisCreateTensorH1Lagrange(ceed, 1, num_comp, p_coarse, q, CEED_GAUSS, &basis_u_coarse);
96 CeedBasisCreateTensorH1Lagrange(ceed, 1, num_comp, p_coarse, p_fine, CEED_GAUSS_LOBATTO, &basis_coarse_to_fine);
97 const CeedScalar *interp_coarse_to_fine;
98 CeedBasisGetInterp1D(basis_coarse_to_fine, &interp_coarse_to_fine);
99 CeedOperatorMultigridLevelCreateTensorH1(op_mass_fine, p_mult_fine, elem_restriction_u_coarse, basis_u_coarse, interp_coarse_to_fine,
100 &op_mass_coarse, &op_prolong, &op_restrict);
101
102 // Coarse problem
103 CeedVectorSetValue(u_coarse, 1.0);
104 CeedOperatorApply(op_mass_coarse, u_coarse, v_coarse, CEED_REQUEST_IMMEDIATE);
105
106 // Check output
107 {
108 const CeedScalar *v_array;
109 CeedScalar sum = 0.;
110
111 CeedVectorGetArrayRead(v_coarse, CEED_MEM_HOST, &v_array);
112 for (CeedInt i = 0; i < num_comp * num_dofs_u_coarse; i++) {
113 sum += v_array[i];
114 }
115 CeedVectorRestoreArrayRead(v_coarse, &v_array);
116 if (fabs(sum - 2.) > 1000. * CEED_EPSILON) printf("Computed Area Coarse Grid: %f != True Area: 2.0\n", sum);
117 }
118
119 // Prolong coarse u
120 CeedOperatorApply(op_prolong, u_coarse, u_fine, CEED_REQUEST_IMMEDIATE);
121
122 // Fine problem
123 CeedOperatorApply(op_mass_fine, u_fine, v_fine, CEED_REQUEST_IMMEDIATE);
124
125 // Check output
126 {
127 const CeedScalar *v_array;
128 CeedScalar sum = 0.;
129 CeedVectorGetArrayRead(v_fine, CEED_MEM_HOST, &v_array);
130 for (CeedInt i = 0; i < num_comp * num_dofs_u_fine; i++) {
131 sum += v_array[i];
132 }
133 CeedVectorRestoreArrayRead(v_fine, &v_array);
134 if (fabs(sum - 2.) > 1000. * CEED_EPSILON) printf("Computed Area Fine Grid: %f != True Area: 2.0\n", sum);
135 }
136
137 // Restrict state to coarse grid
138 CeedOperatorApply(op_restrict, v_fine, v_coarse, CEED_REQUEST_IMMEDIATE);
139
140 // Check output
141 {
142 const CeedScalar *v_array;
143 CeedScalar sum = 0.;
144 CeedVectorGetArrayRead(v_coarse, CEED_MEM_HOST, &v_array);
145 sum = 0.;
146 for (CeedInt i = 0; i < num_comp * num_dofs_u_coarse; i++) {
147 sum += v_array[i];
148 }
149 CeedVectorRestoreArrayRead(v_coarse, &v_array);
150 if (fabs(sum - 2.) > 1000. * CEED_EPSILON) printf("Computed Area Coarse Grid: %f != True Area: 2.0\n", sum);
151 }
152
153 // Cleanup
154 CeedVectorDestroy(&x);
155 CeedVectorDestroy(&u_coarse);
156 CeedVectorDestroy(&u_fine);
157 CeedVectorDestroy(&v_coarse);
158 CeedVectorDestroy(&v_fine);
159 CeedVectorDestroy(&p_mult_fine);
160 CeedVectorDestroy(&q_data);
161 CeedElemRestrictionDestroy(&elem_restriction_u_coarse);
162 CeedElemRestrictionDestroy(&elem_restr_coarse_fine);
163 CeedElemRestrictionDestroy(&elem_restriction_x);
164 CeedElemRestrictionDestroy(&elem_restriction_q_data);
165 CeedBasisDestroy(&basis_u);
166 CeedBasisDestroy(&basis_x);
167 CeedBasisDestroy(&basis_u_coarse);
168 CeedBasisDestroy(&basis_coarse_to_fine);
169 CeedQFunctionDestroy(&qf_setup);
170 CeedQFunctionDestroy(&qf_mass);
171 CeedOperatorDestroy(&op_setup);
172 CeedOperatorDestroy(&op_mass_coarse);
173 CeedOperatorDestroy(&op_mass_fine);
174 CeedOperatorDestroy(&op_prolong);
175 CeedOperatorDestroy(&op_restrict);
176 CeedDestroy(&ceed);
177 return 0;
178 }
179