1 /// @file 2 /// Test diagonal assembly of mass matrix operator at points 3 /// \test Test diagonal assembly of mass matrix operator at points 4 #include <ceed.h> 5 #include <math.h> 6 #include <stdio.h> 7 #include <stdlib.h> 8 9 #include "t500-operator.h" 10 11 int main(int argc, char **argv) { 12 Ceed ceed; 13 CeedInt num_elem = 3, dim = 1, p = 3, q = 5; 14 CeedInt num_nodes_x = num_elem + 1, num_nodes_u = num_elem * (p - 1) + 1, num_points_per_elem = 4, num_points = num_elem * num_points_per_elem; 15 CeedInt ind_x[num_elem * 2], ind_u[num_elem * p], ind_x_points[num_elem + 1 + num_points]; 16 CeedScalar x_array_mesh[num_nodes_x], x_array_points[num_points], assembled_true[num_nodes_u]; 17 CeedVector x_points = NULL, x_elem = NULL, q_data = NULL, u = NULL, v = NULL, assembled = NULL; 18 CeedElemRestriction elem_restriction_x_points, elem_restriction_q_data, elem_restriction_x, elem_restriction_u; 19 CeedBasis basis_x, basis_u; 20 CeedQFunction qf_setup, qf_mass; 21 CeedOperator op_setup, op_mass; 22 bool is_at_points; 23 24 CeedInit(argv[1], &ceed); 25 26 // Mesh coordinates 27 for (CeedInt i = 0; i < num_nodes_x; i++) x_array_mesh[i] = (CeedScalar)i / (num_nodes_x - 1); 28 for (CeedInt i = 0; i < num_elem; i++) { 29 ind_x[2 * i + 0] = i; 30 ind_x[2 * i + 1] = i + 1; 31 } 32 CeedElemRestrictionCreate(ceed, num_elem, 2, 1, 1, num_nodes_x, CEED_MEM_HOST, CEED_USE_POINTER, ind_x, &elem_restriction_x); 33 CeedVectorCreate(ceed, num_nodes_x, &x_elem); 34 CeedVectorSetArray(x_elem, CEED_MEM_HOST, CEED_USE_POINTER, x_array_mesh); 35 36 // U mesh 37 for (CeedInt i = 0; i < num_elem; i++) { 38 for (CeedInt j = 0; j < p; j++) { 39 ind_u[p * i + j] = i * (p - 1) + j; 40 } 41 } 42 CeedElemRestrictionCreate(ceed, num_elem, p, 1, 1, num_nodes_u, CEED_MEM_HOST, CEED_USE_POINTER, ind_u, &elem_restriction_u); 43 44 // Point reference coordinates 45 { 46 CeedScalar weight_tmp[num_points_per_elem + 1]; 47 CeedInt current_index = 0; 48 49 // Use num_points_per_elem + 1 to test non-uniform quadrature 50 CeedGaussQuadrature(num_points_per_elem + 1, x_array_points, weight_tmp); 51 ind_x_points[0] = num_elem + 1; 52 for (CeedInt p = 0; p < num_points_per_elem + 1; p++, current_index++) { 53 ind_x_points[num_elem + 1 + current_index] = current_index; 54 } 55 // Use num_points_per_elem for middle elements 56 for (CeedInt e = 1; e < num_elem - 1; e++) { 57 CeedGaussQuadrature(num_points_per_elem, &x_array_points[current_index], weight_tmp); 58 ind_x_points[e] = num_elem + 1 + current_index; 59 for (CeedInt p = 0; p < num_points_per_elem; p++, current_index++) { 60 ind_x_points[num_elem + 1 + current_index] = current_index; 61 } 62 } 63 // Use num_points_per_elem - 1 to test non-uniform quadrature 64 CeedGaussQuadrature(num_points_per_elem - 1, &x_array_points[current_index], weight_tmp); 65 ind_x_points[num_elem - 1] = num_elem + 1 + current_index; 66 for (CeedInt p = 0; p < num_points_per_elem - 1; p++, current_index++) { 67 ind_x_points[num_elem + 1 + current_index] = current_index; 68 } 69 ind_x_points[num_elem] = num_elem + 1 + current_index; 70 71 CeedVectorCreate(ceed, num_elem * num_points_per_elem, &x_points); 72 CeedVectorSetArray(x_points, CEED_MEM_HOST, CEED_USE_POINTER, x_array_points); 73 CeedElemRestrictionCreateAtPoints(ceed, num_elem, num_points, 1, num_points, CEED_MEM_HOST, CEED_COPY_VALUES, ind_x_points, 74 &elem_restriction_x_points); 75 CeedElemRestrictionCreateAtPoints(ceed, num_elem, num_points, 1, num_points, CEED_MEM_HOST, CEED_COPY_VALUES, ind_x_points, 76 &elem_restriction_q_data); 77 78 // Q data 79 CeedVectorCreate(ceed, num_points, &q_data); 80 } 81 82 // Basis creation 83 CeedBasisCreateTensorH1Lagrange(ceed, dim, dim, 2, q, CEED_GAUSS, &basis_x); 84 CeedBasisCreateTensorH1Lagrange(ceed, dim, 1, p, q, CEED_GAUSS, &basis_u); 85 86 // Setup geometric scaling 87 CeedQFunctionCreateInterior(ceed, 1, setup, setup_loc, &qf_setup); 88 CeedQFunctionAddInput(qf_setup, "x", dim * dim, CEED_EVAL_GRAD); 89 CeedQFunctionAddInput(qf_setup, "weight", 1, CEED_EVAL_WEIGHT); 90 CeedQFunctionAddOutput(qf_setup, "rho", 1, CEED_EVAL_NONE); 91 92 CeedOperatorCreateAtPoints(ceed, qf_setup, CEED_QFUNCTION_NONE, CEED_QFUNCTION_NONE, &op_setup); 93 CeedOperatorSetField(op_setup, "x", elem_restriction_x, basis_x, CEED_VECTOR_ACTIVE); 94 CeedOperatorSetField(op_setup, "weight", CEED_ELEMRESTRICTION_NONE, basis_x, CEED_VECTOR_NONE); 95 CeedOperatorSetField(op_setup, "rho", elem_restriction_q_data, CEED_BASIS_NONE, CEED_VECTOR_ACTIVE); 96 CeedOperatorAtPointsSetPoints(op_setup, elem_restriction_x_points, x_points); 97 98 CeedOperatorApply(op_setup, x_elem, q_data, CEED_REQUEST_IMMEDIATE); 99 100 // Mass operator 101 CeedQFunctionCreateInterior(ceed, 1, mass, mass_loc, &qf_mass); 102 CeedQFunctionAddInput(qf_mass, "u", 1, CEED_EVAL_INTERP); 103 CeedQFunctionAddInput(qf_mass, "rho", 1, CEED_EVAL_NONE); 104 CeedQFunctionAddOutput(qf_mass, "v", 1, CEED_EVAL_INTERP); 105 106 CeedOperatorCreateAtPoints(ceed, qf_mass, CEED_QFUNCTION_NONE, CEED_QFUNCTION_NONE, &op_mass); 107 CeedOperatorSetField(op_mass, "u", elem_restriction_u, basis_u, CEED_VECTOR_ACTIVE); 108 CeedOperatorSetField(op_mass, "rho", elem_restriction_q_data, CEED_BASIS_NONE, q_data); 109 CeedOperatorSetField(op_mass, "v", elem_restriction_u, basis_u, CEED_VECTOR_ACTIVE); 110 CeedOperatorAtPointsSetPoints(op_mass, elem_restriction_x_points, x_points); 111 112 CeedOperatorIsAtPoints(op_mass, &is_at_points); 113 if (!is_at_points) printf("Error: Operator should be at points\n"); 114 115 CeedVectorCreate(ceed, num_nodes_u, &u); 116 CeedVectorSetValue(u, 0.0); 117 CeedVectorCreate(ceed, num_nodes_u, &v); 118 119 // Assemble diagonal 120 CeedVectorCreate(ceed, num_nodes_u, &assembled); 121 CeedOperatorLinearAssembleDiagonal(op_mass, assembled, CEED_REQUEST_IMMEDIATE); 122 123 // Manually assemble diagonal 124 CeedVectorSetValue(u, 0.0); 125 for (CeedInt i = 0; i < num_nodes_u; i++) { 126 CeedScalar *u_array; 127 const CeedScalar *v_array; 128 129 // Set input 130 CeedVectorGetArray(u, CEED_MEM_HOST, &u_array); 131 u_array[i] = 1.0; 132 if (i) u_array[i - 1] = 0.0; 133 CeedVectorRestoreArray(u, &u_array); 134 135 // Compute diag entry for DoF i 136 CeedOperatorApply(op_mass, u, v, CEED_REQUEST_IMMEDIATE); 137 138 // Retrieve entry 139 CeedVectorGetArrayRead(v, CEED_MEM_HOST, &v_array); 140 assembled_true[i] = v_array[i]; 141 CeedVectorRestoreArrayRead(v, &v_array); 142 } 143 144 // Check output 145 { 146 const CeedScalar *assembled_array; 147 148 CeedVectorGetArrayRead(assembled, CEED_MEM_HOST, &assembled_array); 149 for (CeedInt i = 0; i < num_nodes_u; i++) { 150 if (fabs(assembled_array[i] - assembled_true[i]) > 100. * CEED_EPSILON) { 151 // LCOV_EXCL_START 152 printf("[%" CeedInt_FMT "] Error in assembly: %f != %f\n", i, assembled_array[i], assembled_true[i]); 153 // LCOV_EXCL_STOP 154 } 155 } 156 CeedVectorRestoreArrayRead(assembled, &assembled_array); 157 } 158 159 // Cleanup 160 CeedVectorDestroy(&q_data); 161 CeedVectorDestroy(&u); 162 CeedVectorDestroy(&v); 163 CeedVectorDestroy(&x_points); 164 CeedVectorDestroy(&q_data); 165 CeedVectorDestroy(&x_elem); 166 CeedVectorDestroy(&assembled); 167 CeedElemRestrictionDestroy(&elem_restriction_q_data); 168 CeedElemRestrictionDestroy(&elem_restriction_x); 169 CeedElemRestrictionDestroy(&elem_restriction_x_points); 170 CeedElemRestrictionDestroy(&elem_restriction_u); 171 CeedBasisDestroy(&basis_x); 172 CeedBasisDestroy(&basis_u); 173 CeedQFunctionDestroy(&qf_setup); 174 CeedQFunctionDestroy(&qf_mass); 175 CeedOperatorDestroy(&op_setup); 176 CeedOperatorDestroy(&op_mass); 177 CeedDestroy(&ceed); 178 return 0; 179 } 180