LCOV - code coverage report
Current view: top level - fem/qfunctions/22 - utils_22_qf.h (source / functions) Coverage Total Hit
Test: Palace Coverage Report Lines: 45.9 % 37 17
Test Date: 2025-10-23 22:45:05 Functions: - 0 0
Legend: Lines: hit not hit

            Line data    Source code
       1              : // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
       2              : // SPDX-License-Identifier: Apache-2.0
       3              : 
       4              : #ifndef PALACE_LIBCEED_UTILS_22_QF_H
       5              : #define PALACE_LIBCEED_UTILS_22_QF_H
       6              : 
       7              : #ifndef CEED_RUNNING_JIT_PASS
       8              : #include <math.h>
       9              : #endif
      10              : 
      11              : CEED_QFUNCTION_HELPER CeedScalar DetJ22(const CeedScalar J[4])
      12              : {
      13              :   // J: 0 2
      14              :   //    1 3
      15              :   return J[0] * J[3] - J[1] * J[2];
      16              : }
      17              : 
      18              : template <bool ComputeDet = false>
      19              : CEED_QFUNCTION_HELPER CeedScalar AdjJt22(const CeedScalar J[4], CeedScalar adjJt[4])
      20              : {
      21              :   // Compute adj(J)^T / det(J) and store the result.
      22              :   // J: 0 2   adj(J):  J22 -J12
      23              :   //    1 3           -J21  J11
      24              :   adjJt[0] = J[3];
      25      5873208 :   adjJt[1] = -J[2];
      26      5873208 :   adjJt[2] = -J[1];
      27              :   adjJt[3] = J[0];
      28      4056264 :   return ComputeDet ? (J[0] * J[3] - J[1] * J[2]) : 0.0;
      29              : }
      30              : 
      31              : CEED_QFUNCTION_HELPER void MatUnpack22(const CeedScalar *A, const CeedInt A_stride,
      32              :                                        CeedScalar A_loc[4])
      33              : {
      34      7861552 :   A_loc[0] = A[A_stride * 0];
      35      7861552 :   A_loc[1] = A[A_stride * 1];
      36      7861552 :   A_loc[2] = A[A_stride * 2];
      37      7861552 :   A_loc[3] = A[A_stride * 3];
      38              : }
      39              : 
      40              : CEED_QFUNCTION_HELPER void MultBx22(const CeedScalar B[4], const CeedScalar x[2],
      41              :                                     CeedScalar y[2])
      42              : {
      43              :   // B: 0 2
      44              :   //    1 3
      45              :   y[0] = B[0] * x[0] + B[2] * x[1];
      46              :   y[1] = B[1] * x[0] + B[3] * x[1];
      47              : }
      48              : 
      49              : CEED_QFUNCTION_HELPER void MultAtBCx22(const CeedScalar A[4], const CeedScalar B[4],
      50              :                                        const CeedScalar C[4], const CeedScalar x[2],
      51              :                                        CeedScalar y[2])
      52              : {
      53              :   // A, B, C: 0 2
      54              :   //          1 3
      55              :   CeedScalar z[2];
      56              : 
      57      3599728 :   y[0] = C[0] * x[0] + C[2] * x[1];
      58      3599728 :   y[1] = C[1] * x[0] + C[3] * x[1];
      59              : 
      60      3599728 :   z[0] = B[0] * y[0] + B[2] * y[1];
      61      3599728 :   z[1] = B[1] * y[0] + B[3] * y[1];
      62              : 
      63      3599728 :   y[0] = A[0] * z[0] + A[1] * z[1];
      64      3599728 :   y[1] = A[2] * z[0] + A[3] * z[1];
      65              : }
      66              : 
      67              : CEED_QFUNCTION_HELPER void MultBAx22(const CeedScalar A[4], const CeedScalar B[4],
      68              :                                      const CeedScalar x[2], CeedScalar y[2])
      69              : {
      70              :   // A, B: 0 2
      71              :   //       1 3
      72              :   CeedScalar z[2];
      73              : 
      74       205560 :   z[0] = A[0] * x[0] + A[2] * x[1];
      75       205560 :   z[1] = A[1] * x[0] + A[3] * x[1];
      76              : 
      77       205560 :   y[0] = B[0] * z[0] + B[2] * z[1];
      78       205560 :   y[1] = B[1] * z[0] + B[3] * z[1];
      79              : }
      80              : 
      81              : CEED_QFUNCTION_HELPER void MultAtBA22(const CeedScalar A[4], const CeedScalar B[4],
      82              :                                       CeedScalar C[4])
      83              : {
      84              :   // A, B, C: 0 2
      85              :   //          1 3
      86              : 
      87              :   // First compute entries of R = B A.
      88            0 :   const CeedScalar R11 = B[0] * A[0] + B[2] * A[1];
      89            0 :   const CeedScalar R21 = B[1] * A[0] + B[3] * A[1];
      90            0 :   const CeedScalar R12 = B[0] * A[2] + B[2] * A[3];
      91            0 :   const CeedScalar R22 = B[1] * A[2] + B[3] * A[3];
      92              : 
      93            0 :   C[0] = A[0] * R11 + A[1] * R21;
      94            0 :   C[1] = A[2] * R11 + A[3] * R21;
      95            0 :   C[2] = A[0] * R12 + A[1] * R22;
      96            0 :   C[3] = A[2] * R12 + A[3] * R22;
      97              : }
      98              : 
      99              : CEED_QFUNCTION_HELPER void MultAtBC22(const CeedScalar A[4], const CeedScalar B[4],
     100              :                                       const CeedScalar C[4], CeedScalar D[4])
     101              : {
     102              :   // A, B, C, D: 0 2
     103              :   //             1 3
     104              : 
     105              :   // First compute entries of R = B C.
     106            0 :   const CeedScalar R11 = B[0] * C[0] + B[2] * C[1];
     107            0 :   const CeedScalar R21 = B[1] * C[0] + B[3] * C[1];
     108            0 :   const CeedScalar R12 = B[0] * C[2] + B[2] * C[3];
     109            0 :   const CeedScalar R22 = B[1] * C[2] + B[3] * C[3];
     110              : 
     111            0 :   D[0] = A[0] * R11 + A[1] * R21;
     112            0 :   D[1] = A[2] * R11 + A[3] * R21;
     113            0 :   D[2] = A[0] * R12 + A[1] * R22;
     114            0 :   D[3] = A[2] * R12 + A[3] * R22;
     115              : }
     116              : 
     117              : CEED_QFUNCTION_HELPER void MultBA22(const CeedScalar A[4], const CeedScalar B[4],
     118              :                                     CeedScalar C[4])
     119              : {
     120              :   // A, B, C: 0 2
     121              :   //          1 3
     122            0 :   C[0] = B[0] * A[0] + B[2] * A[1];
     123            0 :   C[1] = B[1] * A[0] + B[3] * A[1];
     124            0 :   C[2] = B[0] * A[2] + B[2] * A[3];
     125            0 :   C[3] = B[1] * A[2] + B[3] * A[3];
     126              : }
     127              : 
     128              : #endif  // PALACE_LIBCEED_UTILS_22_QF_H
        

Generated by: LCOV version 2.0-1