Revert some whitespace changes for review

Author: sebastiangrimberg

interface/ceed-preconditioning.c

@@ -276,6 +276,7 @@ static inline int CeedSingleOperatorAssembleAddDiagonal_Core(CeedOperator op, Ce
   CeedElemRestriction assembled_elem_rstr;
   CeedInt             num_input_fields, num_output_fields;
   CeedInt             layout[3];
+
   CeedCall(CeedOperatorGetQFunction(op, &qf));
   CeedCall(CeedQFunctionGetNumArgs(qf, &num_input_fields, &num_output_fields));
   CeedCall(CeedOperatorLinearAssembleQFunctionBuildOrUpdate(op, &assembled_qf, &assembled_elem_rstr, request));
@@ -300,8 +301,10 @@ static inline int CeedSingleOperatorAssembleAddDiagonal_Core(CeedOperator op, Ce
   for (CeedInt b = 0; b < num_active_bases; b++) {
     // Assemble point block diagonal restriction, if needed
     CeedElemRestriction diag_elem_rstr = active_elem_rstrs[b];
+
     if (is_pointblock) {
       CeedElemRestriction point_block_elem_rstr;
+
       CeedCall(CeedOperatorCreateActivePointBlockRestriction(diag_elem_rstr, &point_block_elem_rstr));
       diag_elem_rstr = point_block_elem_rstr;
     }
@@ -313,6 +316,7 @@ static inline int CeedSingleOperatorAssembleAddDiagonal_Core(CeedOperator op, Ce
     // Assemble element operator diagonals
     CeedScalar *elem_diag_array;
     CeedInt     num_elem, num_nodes, num_qpts, num_components;
+
     CeedCall(CeedVectorSetValue(elem_diag, 0.0));
     CeedCall(CeedVectorGetArray(elem_diag, CEED_MEM_HOST, &elem_diag_array));
     CeedCall(CeedElemRestrictionGetNumElements(diag_elem_rstr, &num_elem));
@@ -547,6 +551,7 @@ static int CeedSingleOperatorAssemble(CeedOperator op, CeedInt offset, CeedVecto
   // Early exit for empty operator
   {
     CeedInt num_elem = 0;
+
     CeedCall(CeedOperatorGetNumElements(op, &num_elem));
     if (num_elem == 0) return CEED_ERROR_SUCCESS;
   }
@@ -558,6 +563,7 @@ static int CeedSingleOperatorAssemble(CeedOperator op, CeedInt offset, CeedVecto
   } else {
     // Operator fallback
     CeedOperator op_fallback;
+
     CeedCall(CeedOperatorGetFallback(op, &op_fallback));
     if (op_fallback) {
       CeedCall(CeedSingleOperatorAssemble(op_fallback, offset, values));
@@ -573,6 +579,7 @@ static int CeedSingleOperatorAssemble(CeedOperator op, CeedInt offset, CeedVecto
   CeedCall(CeedOperatorLinearAssembleQFunctionBuildOrUpdate(op, &assembled_qf, &rstr_q, CEED_REQUEST_IMMEDIATE));
   CeedSize qf_length;
   CeedCall(CeedVectorGetLength(assembled_qf, &qf_length));
+
   CeedInt            num_input_fields, num_output_fields;
   CeedOperatorField *input_fields;
   CeedOperatorField *output_fields;
@@ -607,16 +614,18 @@ static int CeedSingleOperatorAssemble(CeedOperator op, CeedInt offset, CeedVecto
   CeedCall(CeedElemRestrictionGetElementSize(active_rstr, &elem_size));
   CeedCall(CeedElemRestrictionGetNumComponents(active_rstr, &num_comp));
   CeedCall(CeedBasisGetNumQuadraturePoints(basis_in, &num_qpts));
+
   CeedInt local_num_entries = elem_size * num_comp * elem_size * num_comp * num_elem;
 
-  // Loop over elements and put in data structure
+  // loop over elements and put in data structure
   const CeedScalar *assembled_qf_array;
   CeedCall(CeedVectorGetArrayRead(assembled_qf, CEED_MEM_HOST, &assembled_qf_array));
+
   CeedInt layout_qf[3];
   CeedCall(CeedElemRestrictionGetELayout(rstr_q, &layout_qf));
   CeedCall(CeedElemRestrictionDestroy(&rstr_q));
 
-  // We store B_mat_in, B_mat_out, BTD, elem_mat in row-major order
+  // we store B_mat_in, B_mat_out, BTD, elem_mat in row-major order
   const CeedScalar **B_mats_in, **B_mats_out;
   CeedCall(CeedOperatorAssemblyDataGetBases(data, NULL, NULL, &B_mats_in, &B_mats_out));
   const CeedScalar *B_mat_in = B_mats_in[0], *B_mat_out = B_mats_out[0];
@@ -644,10 +653,10 @@ static int CeedSingleOperatorAssemble(CeedOperator op, CeedInt offset, CeedVecto
             }
           }
         }
-        // Form element matrix itself (for each block component)
+        // form element matrix itself (for each block component)
         CeedCall(CeedMatrixMatrixMultiply(ceed, BTD_mat, B_mat_in, elem_mat, elem_size, elem_size, num_qpts * num_eval_modes_in[0]));
 
-        // Put element matrix in coordinate data structure
+        // put element matrix in coordinate data structure
         for (CeedInt i = 0; i < elem_size; i++) {
           for (CeedInt j = 0; j < elem_size; j++) {
             vals[offset + count] = elem_mat[i * elem_size + j];
@@ -663,6 +672,7 @@ static int CeedSingleOperatorAssemble(CeedOperator op, CeedInt offset, CeedVecto
     // LCOV_EXCL_STOP
   }
   CeedCall(CeedVectorRestoreArray(values, &vals));
+
   CeedCall(CeedVectorRestoreArrayRead(assembled_qf, &assembled_qf_array));
   CeedCall(CeedVectorDestroy(&assembled_qf));
 
@@ -1081,8 +1091,8 @@ int CeedQFunctionAssemblyDataDestroy(CeedQFunctionAssemblyData *data) {
   CeedCall(CeedDestroy(&(*data)->ceed));
   CeedCall(CeedVectorDestroy(&(*data)->vec));
   CeedCall(CeedElemRestrictionDestroy(&(*data)->rstr));
-  CeedCall(CeedFree(data));
 
+  CeedCall(CeedFree(data));
   return CEED_ERROR_SUCCESS;
 }
 
@@ -1099,6 +1109,7 @@ int CeedQFunctionAssemblyDataDestroy(CeedQFunctionAssemblyData *data) {
 int CeedOperatorGetOperatorAssemblyData(CeedOperator op, CeedOperatorAssemblyData *data) {
   if (!op->op_assembled) {
     CeedOperatorAssemblyData data;
+
     CeedCall(CeedOperatorAssemblyDataCreate(op->ceed, op, &data));
     op->op_assembled = data;
   }
@@ -2054,7 +2065,6 @@ int CeedCompositeOperatorGetMultiplicity(CeedOperator op, CeedInt num_skip_indic
     CeedCall(CeedElemRestrictionApply(elem_rstr, CEED_NOTRANSPOSE, ones_l_vec, ones_e_vec, CEED_REQUEST_IMMEDIATE));
     CeedCall(CeedElemRestrictionApply(elem_rstr, CEED_TRANSPOSE, ones_e_vec, sub_mult_l_vec, CEED_REQUEST_IMMEDIATE));
     CeedCall(CeedVectorGetArrayRead(sub_mult_l_vec, CEED_MEM_HOST, &sub_mult_array));
-
     // ---- Flag every node present in the current suboperator
     for (CeedInt j = 0; j < l_vec_len; j++) {
       if (sub_mult_array[j] > 0.0) mult_array[j] += 1.0;

tests/README.md

@@ -4,25 +4,25 @@ This page provides a brief description of the tests for the libCEED library.
 
 The tests are organized by API object, and some tests are further organized, as required.
 
-0. Ceed Tests
-1. CeedVector Tests
-    1.0. CeedVector general tests
-    1.1. CeedVector error tests
-2. CeedElemRestriction Tests
-3. CeedBasis Tests
-    3.0. CeedBasis utility tests
-    3.1. CeedBasis tensor basis tests
-    3.2. CeedBasis simplex basis tests
-    3.3. CeedBasis non-tensor H(div) basis tests
-    3.4. CeedBasis non-tensor H(curl) basis tests
-4. CeedQFunction Tests
-    4.0. CeedQFunction user code tests
-    4.1. CeedQFunction gallery code tests
-5. CeedOperator Tests
-    5.0. CeedOperator with tensor bases tests
-    5.1. CeedOperator with simplex bases tests
-    5.2. CeedOperator with operator composition tests
-    5.3. CeedOperator diagonal and CeedQFunction assembly tests
-    5.4. CeedOperator element inverse tests
-    5.5. CeedOperator multigrid level tests
+0. Ceed Tests  
+1. CeedVector Tests  
+    1.0. CeedVector general tests  
+    1.1. CeedVector error tests  
+2. CeedElemRestriction Tests  
+3. CeedBasis Tests  
+    3.0. CeedBasis utility tests  
+    3.1. CeedBasis tensor basis tests  
+    3.2. CeedBasis simplex basis tests  
+    3.3. CeedBasis non-tensor H(div) basis tests  
+    3.4. CeedBasis non-tensor H(curl) basis tests  
+4. CeedQFunction Tests  
+    4.0. CeedQFunction user code tests  
+    4.1. CeedQFunction gallery code tests  
+5. CeedOperator Tests  
+    5.0. CeedOperator with tensor bases tests  
+    5.1. CeedOperator with simplex bases tests  
+    5.2. CeedOperator with operator composition tests  
+    5.3. CeedOperator diagonal and CeedQFunction assembly tests  
+    5.4. CeedOperator element inverse tests  
+    5.5. CeedOperator multigrid level tests  
     5.6. CeedOperator full assembly tests