LCOV - code coverage report
Current view: top level - src/grid/common - grid_prepare_pab.h (source / functions) Hit Total Coverage
Test: CP2K Regtests (git:37c9bd6) Lines: 154 217 71.0 %
Date: 2023-03-30 11:55:16 Functions: 11 15 73.3 %

          Line data    Source code
       1             : /*----------------------------------------------------------------------------*/
       2             : /*  CP2K: A general program to perform molecular dynamics simulations         */
       3             : /*  Copyright 2000-2023 CP2K developers group <https://cp2k.org>              */
       4             : /*                                                                            */
       5             : /*  SPDX-License-Identifier: BSD-3-Clause                                     */
       6             : /*----------------------------------------------------------------------------*/
       7             : 
       8             : #include "../common/grid_common.h"
       9             : #include "../common/grid_constants.h"
      10             : #include <stdbool.h>
      11             : #include <stdio.h>
      12             : #include <stdlib.h>
      13             : 
      14             : #if defined(__CUDACC__) || defined(__HIPCC__)
      15             : #define GRID_DEVICE __device__
      16             : #else
      17             : #define GRID_DEVICE
      18             : #endif
      19             : 
      20             : /*******************************************************************************
      21             :  * \brief Adds given value to matrix element cab[idx(b)][idx(a)].
      22             :  *        This function has to be implemented by the importing compilation unit.
      23             :  *        Without thread safety it's simply: cab[idx(b) * n + idx(a)] += value;
      24             :  * \author Ole Schuett
      25             :  ******************************************************************************/
      26             : GRID_DEVICE static inline void prep_term(const orbital a, const orbital b,
      27             :                                          const double value, const int n,
      28             :                                          double *cab);
      29             : 
      30             : /*******************************************************************************
      31             :  * \brief Implementation of function GRID_FUNC_AB, ie. identity transformation.
      32             :  * \author Ole Schuett
      33             :  ******************************************************************************/
      34   971781639 : GRID_DEVICE static void prepare_pab_AB(const orbital a, const orbital b,
      35             :                                        const double pab_val, const int n,
      36             :                                        double *cab) {
      37             : 
      38             :   // simply copy pab to cab
      39   971781639 :   prep_term(a, b, pab_val, n, cab);
      40   971781639 : }
      41             : 
      42             : /*******************************************************************************
      43             :  * \brief Implementation of function GRID_FUNC_DADB.
      44             :  * \author Ole Schuett
      45             :  ******************************************************************************/
      46    13668510 : GRID_DEVICE static void prepare_pab_DADB(const orbital a, const orbital b,
      47             :                                          const double zeta, const double zetb,
      48             :                                          const double pab_val, const int n,
      49             :                                          double *cab) {
      50             : 
      51             :   // creates cab such that mapping it with pgf_a pgf_b
      52             :   // is equivalent to mapping pab with 0.5 * (nabla pgf_a) . (nabla pgf_b)
      53             :   // (ddx pgf_a ) (ddx pgf_b) = (lax pgf_{a-1x} - 2*zeta*pgf_{a+1x})*(lbx
      54             :   // pgf_{b-1x} - 2*zetb*pgf_{b+1x})
      55             : 
      56    54674040 :   for (int i = 0; i < 3; i++) {
      57    41005530 :     prep_term(down(i, a), down(i, b), 0.5 * a.l[i] * b.l[i] * pab_val, n, cab);
      58    41005530 :     prep_term(down(i, a), up(i, b), -1.0 * a.l[i] * zetb * pab_val, n, cab);
      59    41005530 :     prep_term(up(i, a), down(i, b), -1.0 * zeta * b.l[i] * pab_val, n, cab);
      60    41005530 :     prep_term(up(i, a), up(i, b), 2.0 * zeta * zetb * pab_val, n, cab);
      61             :   }
      62    13668510 : }
      63             : 
      64             : /*******************************************************************************
      65             :  * \brief Implementation of function GRID_FUNC_ADBmDAB_{X,Y,Z}.
      66             :  * \author Ole Schuett
      67             :  ******************************************************************************/
      68     1688853 : GRID_DEVICE static void prepare_pab_ADBmDAB(const int idir, const orbital a,
      69             :                                             const orbital b, const double zeta,
      70             :                                             const double zetb,
      71             :                                             const double pab_val, const int n,
      72             :                                             double *cab) {
      73             : 
      74             :   // creates cab such that mapping it with pgf_a pgf_b
      75             :   // is equivalent to mapping pab with
      76             :   //    pgf_a (nabla_{idir} pgf_b) - (nabla_{idir} pgf_a) pgf_b
      77             :   // ( pgf_a ) (ddx pgf_b) - (ddx pgf_a)( pgf_b ) =
      78             :   //          pgf_a *(lbx pgf_{b-1x} - 2*zetb*pgf_{b+1x}) -
      79             :   //                   (lax pgf_{a-1x} - 2*zeta*pgf_{a+1x}) pgf_b
      80             : 
      81     1688853 :   prep_term(a, down(idir, b), +b.l[idir] * pab_val, n, cab);
      82     1688853 :   prep_term(a, up(idir, b), -2.0 * zetb * pab_val, n, cab);
      83     1688853 :   prep_term(down(idir, a), b, -a.l[idir] * pab_val, n, cab);
      84     1688853 :   prep_term(up(idir, a), b, +2.0 * zeta * pab_val, n, cab);
      85     1688853 : }
      86             : 
      87             : /*******************************************************************************
      88             :  * \brief Implementation of function GRID_FUNC_ARDBmDARB_{X,Y,Z}{X,Y,Z}.
      89             :  * \author Ole Schuett
      90             :  ******************************************************************************/
      91             : GRID_DEVICE static void
      92     2542110 : prepare_pab_ARDBmDARB(const int idir, const int ir, const orbital a,
      93             :                       const orbital b, const double zeta, const double zetb,
      94             :                       const double pab_val, const int n, double *cab) {
      95             : 
      96             :   // creates cab such that mapping it with pgf_a pgf_b
      97             :   // is equivalent to mapping pab with
      98             :   // pgf_a (r-Rb)_{ir} (nabla_{idir} pgf_b) - (nabla_{idir} pgf_a) (r-Rb)_{ir}
      99             :   // pgf_b ( pgf_a )(r-Rb)_{ir} (ddx pgf_b) - (ddx pgf_a) (r-Rb)_{ir} ( pgf_b )
     100             :   // =
     101             :   //                        pgf_a *(lbx pgf_{b-1x+1ir} - 2*zetb*pgf_{b+1x+1ir})
     102             :   //                        -
     103             :   //                       (lax pgf_{a-1x} - 2*zeta*pgf_{a+1x}) pgf_{b+1ir}
     104             : 
     105     2542110 :   prep_term(a, down(idir, up(ir, b)), b.l[idir] * pab_val, n, cab);
     106     2542110 :   prep_term(a, up(idir, up(ir, b)), -2.0 * zetb * pab_val, n, cab);
     107     2542110 :   prep_term(down(idir, a), up(ir, b), -a.l[idir] * pab_val, n, cab);
     108     2542110 :   prep_term(up(idir, a), up(ir, b), +2.0 * zeta * pab_val, n, cab);
     109     2542110 : }
     110             : 
     111             : /*******************************************************************************
     112             :  * \brief Implementation of function GRID_FUNC_DABpADB_{X,Y,Z}.
     113             :  * \author Ole Schuett
     114             :  ******************************************************************************/
     115     3545034 : GRID_DEVICE static void prepare_pab_DABpADB(const int idir, const orbital a,
     116             :                                             const orbital b, const double zeta,
     117             :                                             const double zetb,
     118             :                                             const double pab_val, const int n,
     119             :                                             double *cab) {
     120             : 
     121             :   // creates cab such that mapping it with pgf_a pgf_b
     122             :   // is equivalent to mapping pab with
     123             :   //    pgf_a (nabla_{idir} pgf_b) + (nabla_{idir} pgf_a) pgf_b
     124             :   // ( pgf_a ) (ddx pgf_b) + (ddx pgf_a)( pgf_b ) =
     125             :   //          pgf_a *(lbx pgf_{b-1x} + 2*zetb*pgf_{b+1x}) +
     126             :   //                   (lax pgf_{a-1x} + 2*zeta*pgf_{a+1x}) pgf_b
     127             : 
     128     3545034 :   prep_term(a, down(idir, b), b.l[idir] * pab_val, n, cab);
     129     3545034 :   prep_term(a, up(idir, b), -2.0 * zetb * pab_val, n, cab);
     130     3545034 :   prep_term(down(idir, a), b, a.l[idir] * pab_val, n, cab);
     131     3545034 :   prep_term(up(idir, a), b, -2.0 * zeta * pab_val, n, cab);
     132     3545034 : }
     133             : 
     134             : /*******************************************************************************
     135             :  * \brief Implementation of function GRID_FUNC_DAB_{X,Y,Z}.
     136             :  *        This function takes the derivates with respect to nuclear positions
     137             :  *        which results in a change of signs compared to prepare_pab_DABpADB.
     138             :  *        Only the derivative with respect to the primitive on the left.
     139             :  * \author Edward Ditler
     140             :  ******************************************************************************/
     141       14661 : GRID_DEVICE static void prepare_pab_DAB(const int idir, const orbital a,
     142             :                                         const orbital b, const double zeta,
     143             :                                         const double pab_val, const int n,
     144             :                                         double *cab) {
     145             : 
     146             :   // creates cab such that mapping it with pgf_a pgf_b
     147             :   // is equivalent to mapping pab with (nabla_{idir} pgf_a) pgf_b
     148             :   // (ddX pgf_a)( pgf_b ) =
     149             :   //          (-lax pgf_{a-1x} - 2*zeta*pgf_{a+1x}) pgf_b
     150             : 
     151       14661 :   prep_term(down(idir, a), b, -a.l[idir] * pab_val, n, cab);
     152       14661 :   prep_term(up(idir, a), b, +2.0 * zeta * pab_val, n, cab);
     153       14661 : }
     154             : 
     155             : /*******************************************************************************
     156             :  * \brief Implementation of function GRID_FUNC_ADB_{X,Y,Z}.
     157             :  *        This function takes the derivates with respect to nuclear positions
     158             :  *        which results in a change of signs compared to prepare_pab_DABpADB.
     159             :  *        Only the derivative with respect to the primitive on the right.
     160             :  * \author Edward Ditler
     161             :  ******************************************************************************/
     162       14661 : GRID_DEVICE static void prepare_pab_ADB(const int idir, const orbital a,
     163             :                                         const orbital b, const double zetb,
     164             :                                         const double pab_val, const int n,
     165             :                                         double *cab) {
     166             : 
     167             :   // creates cab such that mapping it with pgf_a pgf_b
     168             :   // is equivalent to mapping pab with
     169             :   //    pgf_a (nabla_{idir} pgf_b) + (nabla_{idir} pgf_a) pgf_b
     170             :   // ( pgf_a ) (ddX pgf_b)  =
     171             :   //          pgf_a *(-lbx pgf_{b-1x} - 2*zetb*pgf_{b+1x})
     172             : 
     173       14661 :   prep_term(a, down(idir, b), -b.l[idir] * pab_val, n, cab);
     174       14661 :   prep_term(a, up(idir, b), +2.0 * zetb * pab_val, n, cab);
     175       14661 : }
     176             : 
     177             : /*******************************************************************************
     178             :  * \brief Implementation of function GRID_FUNC_CORE_{X,Y,Z}.
     179             :  *        This function takes the derivates with respect to nuclear positions.
     180             :  * \author Edward Ditler
     181             :  ******************************************************************************/
     182          54 : GRID_DEVICE static void prepare_pab_core(const int idir, const orbital a,
     183             :                                          const orbital b, const double zeta,
     184             :                                          const double pab_val, const int n,
     185             :                                          double *cab) {
     186             : 
     187             :   // creates cab such that mapping it with pgf_a pgf_b
     188             :   // is equivalent to mapping pab with (nabla_{idir} pgf_a) pgf_b
     189             :   // (ddX pgf_a)( pgf_b ) = 2*zeta*pgf_{a+1x}) pgf_b
     190             : 
     191          54 :   prep_term(a, down(idir, b), 0.0, n, cab);
     192          54 :   prep_term(a, up(idir, b), 0.0, n, cab);
     193          54 :   prep_term(down(idir, a), b, 0.0, n, cab);
     194          54 :   prep_term(up(idir, a), b, +2.0 * zeta * pab_val, n, cab);
     195          54 : }
     196             : 
     197             : /*******************************************************************************
     198             :  * \brief Implementation of function GRID_FUNC_{DX,DY,DZ}.
     199             :  * \author Ole Schuett
     200             :  ******************************************************************************/
     201     2071464 : GRID_DEVICE static void prepare_pab_Di(const int ider, const orbital a,
     202             :                                        const orbital b, const double zeta,
     203             :                                        const double zetb, const double pab_val,
     204             :                                        const int n, double *cab) {
     205             : 
     206             :   // creates cab such that mapping it with pgf_a pgf_b
     207             :   // is equivalent to mapping pab with
     208             :   //   d_{ider1} pgf_a d_{ider1} pgf_b
     209             :   // dx pgf_a dx pgf_b =
     210             :   //        (lax pgf_{a-1x})*(lbx pgf_{b-1x}) - 2*zetb*lax*pgf_{a-1x}*pgf_{b+1x}
     211             :   //        -
     212             :   //         lbx pgf_{b-1x}*2*zeta*pgf_{a+1x}+ 4*zeta*zetab*pgf_{a+1x}pgf_{b+1x}
     213             : 
     214     2071464 :   prep_term(down(ider, a), down(ider, b), a.l[ider] * b.l[ider] * pab_val, n,
     215             :             cab);
     216     2071464 :   prep_term(down(ider, a), up(ider, b), -2.0 * a.l[ider] * zetb * pab_val, n,
     217             :             cab);
     218     2071464 :   prep_term(up(ider, a), down(ider, b), -2.0 * zeta * b.l[ider] * pab_val, n,
     219             :             cab);
     220     2071464 :   prep_term(up(ider, a), up(ider, b), +4.0 * zeta * zetb * pab_val, n, cab);
     221     2071464 : }
     222             : 
     223             : /*******************************************************************************
     224             :  * \brief Helper for grid_prepare_pab_DiDj.
     225             :  * \author Ole Schuett
     226             :  ******************************************************************************/
     227           0 : GRID_DEVICE static void oneterm_dijdij(const int idir, const double func_a,
     228             :                                        const orbital a, const orbital b,
     229             :                                        const double zetb, const int n,
     230             :                                        double *cab) {
     231             : 
     232           0 :   int i1, i2;
     233           0 :   if (idir == 0) {
     234             :     i1 = 0;
     235             :     i2 = 1;
     236             :   } else if (idir == 1) {
     237             :     i1 = 1;
     238             :     i2 = 2;
     239             :   } else if (idir == 2) {
     240             :     i1 = 2;
     241             :     i2 = 0;
     242             :   } else {
     243             :     return; // error
     244             :   }
     245             : 
     246           0 :   prep_term(a, down(i1, down(i2, b)), b.l[i1] * b.l[i2] * func_a, n, cab);
     247           0 :   prep_term(a, up(i1, down(i2, b)), -2.0 * zetb * b.l[i2] * func_a, n, cab);
     248           0 :   prep_term(a, down(i1, up(i2, b)), -2.0 * zetb * b.l[i1] * func_a, n, cab);
     249           0 :   prep_term(a, up(i1, up(i2, b)), +4.0 * zetb * zetb * func_a, n, cab);
     250             : }
     251             : 
     252             : /*******************************************************************************
     253             :  * \brief Implementation of function GRID_FUNC_{DXDY,DYDZ,DZDX}
     254             :  * \author Ole Schuett
     255             :  ******************************************************************************/
     256           0 : GRID_DEVICE static void prepare_pab_DiDj(const int ider1, const int ider2,
     257             :                                          const orbital a, const orbital b,
     258             :                                          const double zeta, const double zetb,
     259             :                                          const double pab_val, const int n,
     260             :                                          double *cab) {
     261             : 
     262             :   // creates cab such that mapping it with pgf_a pgf_b
     263             :   // is equivalent to mapping pab with
     264             :   //   d_{ider1} pgf_a d_{ider1} pgf_b
     265             : 
     266           0 :   const double func_a1 = a.l[ider1] * a.l[ider2] * pab_val;
     267           0 :   oneterm_dijdij(ider1, func_a1, down(ider1, down(ider2, a)), b, zetb, n, cab);
     268             : 
     269           0 :   const double func_a2 = -2.0 * zeta * a.l[ider2] * pab_val;
     270           0 :   oneterm_dijdij(ider1, func_a2, up(ider1, down(ider2, a)), b, zetb, n, cab);
     271             : 
     272           0 :   const double func_a3 = -2.0 * zeta * a.l[ider1] * pab_val;
     273           0 :   oneterm_dijdij(ider1, func_a3, down(ider1, up(ider2, a)), b, zetb, n, cab);
     274             : 
     275           0 :   const double func_a4 = 4.0 * zeta * zeta * pab_val;
     276           0 :   oneterm_dijdij(ider1, func_a4, up(ider1, up(ider2, a)), b, zetb, n, cab);
     277           0 : }
     278             : 
     279             : /*******************************************************************************
     280             :  * \brief Helper for grid_prepare_pab_Di2.
     281             :  * \author Ole Schuett
     282             :  ******************************************************************************/
     283           0 : GRID_DEVICE static void oneterm_diidii(const int idir, const double func_a,
     284             :                                        const orbital a, const orbital b,
     285             :                                        const double zetb, const int n,
     286             :                                        double *cab) {
     287             : 
     288           0 :   prep_term(a, down(idir, down(idir, b)), b.l[idir] * (b.l[idir] - 1) * func_a,
     289             :             n, cab);
     290           0 :   prep_term(a, b, -2.0 * zetb * (2 * b.l[idir] + 1) * func_a, n, cab);
     291           0 :   prep_term(a, up(idir, up(idir, b)), +4.0 * zetb * zetb * func_a, n, cab);
     292           0 : }
     293             : 
     294             : /*******************************************************************************
     295             :  * \brief Implementation of function GRID_FUNC_{DXDX,DYDY,DZDZ}
     296             :  * \author Ole Schuett
     297             :  ******************************************************************************/
     298           0 : GRID_DEVICE static void prepare_pab_Di2(const int ider, const orbital a,
     299             :                                         const orbital b, const double zeta,
     300             :                                         const double zetb, const double pab_val,
     301             :                                         const int n, double *cab) {
     302             : 
     303             :   // creates cab such that mapping it with pgf_a pgf_b
     304             :   // is equivalent to mapping pab with
     305             :   //   dd_{ider1} pgf_a dd_{ider1} pgf_b
     306             : 
     307           0 :   const double func_a1 = a.l[ider] * (a.l[ider] - 1) * pab_val;
     308           0 :   oneterm_diidii(ider, func_a1, down(ider, down(ider, a)), b, zetb, n, cab);
     309             : 
     310           0 :   const double func_a2 = -2.0 * zeta * (2 * a.l[ider] + 1) * pab_val;
     311           0 :   oneterm_diidii(ider, func_a2, a, b, zetb, n, cab);
     312             : 
     313           0 :   const double func_a3 = 4.0 * zeta * zeta * pab_val;
     314           0 :   oneterm_diidii(ider, func_a3, up(ider, up(ider, a)), b, zetb, n, cab);
     315           0 : }
     316             : 
     317             : /*******************************************************************************
     318             :  * \brief Transforms a given element of the density matrix according to func.
     319             :  * \param func          Transformation function to apply, one of GRID_FUNC_*.
     320             :  * \param {a,b}         Orbital angular momenta.
     321             :  * \param zet_{a,b}     Gaussian exponents.
     322             :  * \param pab_val       Input matrix element of pab.
     323             :  * \param n             Leading dimensions of output matrix cab.
     324             :  * \param cab           Output matrix.
     325             :  * \author Ole Schuett
     326             :  ******************************************************************************/
     327   995326986 : GRID_DEVICE static void prepare_pab(const enum grid_func func, const orbital a,
     328             :                                     const orbital b, const double zeta,
     329             :                                     const double zetb, const double pab_val,
     330             :                                     const int n, double *cab) {
     331             : 
     332             :   // This switch statment will be in an inner loop but only with few iterations.
     333   995326986 :   switch (func) {
     334   971781639 :   case GRID_FUNC_AB:
     335   971781639 :     prepare_pab_AB(a, b, pab_val, n, cab);
     336   971781639 :     break;
     337    13668510 :   case GRID_FUNC_DADB:
     338    13668510 :     prepare_pab_DADB(a, b, zeta, zetb, pab_val, n, cab);
     339    13668510 :     break;
     340      562951 :   case GRID_FUNC_ADBmDAB_X:
     341      562951 :     prepare_pab_ADBmDAB(0, a, b, zeta, zetb, pab_val, n, cab);
     342      562951 :     break;
     343      562951 :   case GRID_FUNC_ADBmDAB_Y:
     344      562951 :     prepare_pab_ADBmDAB(1, a, b, zeta, zetb, pab_val, n, cab);
     345      562951 :     break;
     346      562951 :   case GRID_FUNC_ADBmDAB_Z:
     347      562951 :     prepare_pab_ADBmDAB(2, a, b, zeta, zetb, pab_val, n, cab);
     348      562951 :     break;
     349      275958 :   case GRID_FUNC_ARDBmDARB_XX:
     350      275958 :     prepare_pab_ARDBmDARB(0, 0, a, b, zeta, zetb, pab_val, n, cab);
     351      275958 :     break;
     352      285706 :   case GRID_FUNC_ARDBmDARB_XY:
     353      285706 :     prepare_pab_ARDBmDARB(0, 1, a, b, zeta, zetb, pab_val, n, cab);
     354      285706 :     break;
     355      285706 :   case GRID_FUNC_ARDBmDARB_XZ:
     356      285706 :     prepare_pab_ARDBmDARB(0, 2, a, b, zeta, zetb, pab_val, n, cab);
     357      285706 :     break;
     358      285706 :   case GRID_FUNC_ARDBmDARB_YX:
     359      285706 :     prepare_pab_ARDBmDARB(1, 0, a, b, zeta, zetb, pab_val, n, cab);
     360      285706 :     break;
     361      275958 :   case GRID_FUNC_ARDBmDARB_YY:
     362      275958 :     prepare_pab_ARDBmDARB(1, 1, a, b, zeta, zetb, pab_val, n, cab);
     363      275958 :     break;
     364      285706 :   case GRID_FUNC_ARDBmDARB_YZ:
     365      285706 :     prepare_pab_ARDBmDARB(1, 2, a, b, zeta, zetb, pab_val, n, cab);
     366      285706 :     break;
     367      285706 :   case GRID_FUNC_ARDBmDARB_ZX:
     368      285706 :     prepare_pab_ARDBmDARB(2, 0, a, b, zeta, zetb, pab_val, n, cab);
     369      285706 :     break;
     370      285706 :   case GRID_FUNC_ARDBmDARB_ZY:
     371      285706 :     prepare_pab_ARDBmDARB(2, 1, a, b, zeta, zetb, pab_val, n, cab);
     372      285706 :     break;
     373      275958 :   case GRID_FUNC_ARDBmDARB_ZZ:
     374      275958 :     prepare_pab_ARDBmDARB(2, 2, a, b, zeta, zetb, pab_val, n, cab);
     375      275958 :     break;
     376     1181678 :   case GRID_FUNC_DABpADB_X:
     377     1181678 :     prepare_pab_DABpADB(0, a, b, zeta, zetb, pab_val, n, cab);
     378     1181678 :     break;
     379     1181678 :   case GRID_FUNC_DABpADB_Y:
     380     1181678 :     prepare_pab_DABpADB(1, a, b, zeta, zetb, pab_val, n, cab);
     381     1181678 :     break;
     382     1181678 :   case GRID_FUNC_DABpADB_Z:
     383     1181678 :     prepare_pab_DABpADB(2, a, b, zeta, zetb, pab_val, n, cab);
     384     1181678 :     break;
     385        4887 :   case GRID_FUNC_DAB_X:
     386        4887 :     prepare_pab_DAB(0, a, b, zeta, pab_val, n, cab);
     387        4887 :     break;
     388        4887 :   case GRID_FUNC_DAB_Y:
     389        4887 :     prepare_pab_DAB(1, a, b, zeta, pab_val, n, cab);
     390        4887 :     break;
     391        4887 :   case GRID_FUNC_DAB_Z:
     392        4887 :     prepare_pab_DAB(2, a, b, zeta, pab_val, n, cab);
     393        4887 :     break;
     394        4887 :   case GRID_FUNC_ADB_X:
     395        4887 :     prepare_pab_ADB(0, a, b, zetb, pab_val, n, cab);
     396        4887 :     break;
     397        4887 :   case GRID_FUNC_ADB_Y:
     398        4887 :     prepare_pab_ADB(1, a, b, zetb, pab_val, n, cab);
     399        4887 :     break;
     400        4887 :   case GRID_FUNC_ADB_Z:
     401        4887 :     prepare_pab_ADB(2, a, b, zetb, pab_val, n, cab);
     402        4887 :     break;
     403          18 :   case GRID_FUNC_CORE_X:
     404          18 :     prepare_pab_core(0, a, b, zeta, pab_val, n, cab);
     405          18 :     break;
     406          18 :   case GRID_FUNC_CORE_Y:
     407          18 :     prepare_pab_core(1, a, b, zeta, pab_val, n, cab);
     408          18 :     break;
     409          18 :   case GRID_FUNC_CORE_Z:
     410          18 :     prepare_pab_core(2, a, b, zeta, pab_val, n, cab);
     411          18 :     break;
     412           0 :   case GRID_FUNC_DX:
     413           0 :     prepare_pab_Di(0, a, b, zeta, zetb, pab_val, n, cab);
     414           0 :     break;
     415           0 :   case GRID_FUNC_DY:
     416           0 :     prepare_pab_Di(1, a, b, zeta, zetb, pab_val, n, cab);
     417           0 :     break;
     418     2071464 :   case GRID_FUNC_DZ:
     419     2071464 :     prepare_pab_Di(2, a, b, zeta, zetb, pab_val, n, cab);
     420     2071464 :     break;
     421           0 :   case GRID_FUNC_DXDY:
     422           0 :     prepare_pab_DiDj(0, 1, a, b, zeta, zetb, pab_val, n, cab);
     423           0 :     break;
     424           0 :   case GRID_FUNC_DYDZ:
     425           0 :     prepare_pab_DiDj(1, 2, a, b, zeta, zetb, pab_val, n, cab);
     426           0 :     break;
     427           0 :   case GRID_FUNC_DZDX:
     428           0 :     prepare_pab_DiDj(2, 0, a, b, zeta, zetb, pab_val, n, cab);
     429           0 :     break;
     430           0 :   case GRID_FUNC_DXDX:
     431           0 :     prepare_pab_Di2(0, a, b, zeta, zetb, pab_val, n, cab);
     432           0 :     break;
     433           0 :   case GRID_FUNC_DYDY:
     434           0 :     prepare_pab_Di2(1, a, b, zeta, zetb, pab_val, n, cab);
     435           0 :     break;
     436           0 :   case GRID_FUNC_DZDZ:
     437           0 :     prepare_pab_Di2(2, a, b, zeta, zetb, pab_val, n, cab);
     438           0 :     break;
     439             :   default:
     440             :     break; // Error: Unknown ga_gb_function - do nothing.
     441             :   }
     442   995326986 : }
     443             : 
     444             : /*******************************************************************************
     445             :  * \brief Differences in angular momentum.
     446             :  * \author Ole Schuett
     447             :  ******************************************************************************/
     448             : typedef struct {
     449             :   int la_max_diff;
     450             :   int la_min_diff;
     451             :   int lb_max_diff;
     452             :   int lb_min_diff;
     453             : } prepare_ldiffs;
     454             : 
     455             : /*******************************************************************************
     456             :  * \brief Returns difference in angular momentum range for given func.
     457             :  * \author Ole Schuett
     458             :  ******************************************************************************/
     459    84918217 : static prepare_ldiffs prepare_get_ldiffs(const enum grid_func func) {
     460    84918217 :   prepare_ldiffs ldiffs;
     461             : 
     462    84918217 :   switch (func) {
     463             :   case GRID_FUNC_AB:
     464             :     ldiffs.la_max_diff = 0;
     465             :     ldiffs.la_min_diff = 0;
     466             :     ldiffs.lb_max_diff = 0;
     467             :     ldiffs.lb_min_diff = 0;
     468             :     break;
     469     2409252 :   case GRID_FUNC_DADB:
     470             :   case GRID_FUNC_ADBmDAB_X:
     471             :   case GRID_FUNC_ADBmDAB_Y:
     472             :   case GRID_FUNC_ADBmDAB_Z:
     473             :   case GRID_FUNC_DABpADB_X:
     474             :   case GRID_FUNC_DABpADB_Y:
     475             :   case GRID_FUNC_DABpADB_Z:
     476             :   case GRID_FUNC_DAB_X:
     477             :   case GRID_FUNC_DAB_Y:
     478             :   case GRID_FUNC_DAB_Z:
     479             :   case GRID_FUNC_ADB_X:
     480             :   case GRID_FUNC_ADB_Y:
     481             :   case GRID_FUNC_ADB_Z:
     482             :   case GRID_FUNC_CORE_X:
     483             :   case GRID_FUNC_CORE_Y:
     484             :   case GRID_FUNC_CORE_Z:
     485     2409252 :     ldiffs.la_max_diff = +1;
     486     2409252 :     ldiffs.la_min_diff = -1;
     487     2409252 :     ldiffs.lb_max_diff = +1;
     488     2409252 :     ldiffs.lb_min_diff = -1;
     489     2409252 :     break;
     490      286668 :   case GRID_FUNC_ARDBmDARB_XX:
     491             :   case GRID_FUNC_ARDBmDARB_XY:
     492             :   case GRID_FUNC_ARDBmDARB_XZ:
     493             :   case GRID_FUNC_ARDBmDARB_YX:
     494             :   case GRID_FUNC_ARDBmDARB_YY:
     495             :   case GRID_FUNC_ARDBmDARB_YZ:
     496             :   case GRID_FUNC_ARDBmDARB_ZX:
     497             :   case GRID_FUNC_ARDBmDARB_ZY:
     498             :   case GRID_FUNC_ARDBmDARB_ZZ:
     499      286668 :     ldiffs.la_max_diff = +1;
     500      286668 :     ldiffs.la_min_diff = -1;
     501      286668 :     ldiffs.lb_max_diff = +2; // this is legit
     502      286668 :     ldiffs.lb_min_diff = -1;
     503      286668 :     break;
     504       38464 :   case GRID_FUNC_DX:
     505             :   case GRID_FUNC_DY:
     506             :   case GRID_FUNC_DZ:
     507       38464 :     ldiffs.la_max_diff = +1;
     508       38464 :     ldiffs.la_min_diff = -1;
     509       38464 :     ldiffs.lb_max_diff = +1;
     510       38464 :     ldiffs.lb_min_diff = -1;
     511       38464 :     break;
     512           0 :   case GRID_FUNC_DXDY:
     513             :   case GRID_FUNC_DYDZ:
     514             :   case GRID_FUNC_DZDX:
     515             :   case GRID_FUNC_DXDX:
     516             :   case GRID_FUNC_DYDY:
     517             :   case GRID_FUNC_DZDZ:
     518           0 :     ldiffs.la_max_diff = +2;
     519           0 :     ldiffs.la_min_diff = -2;
     520           0 :     ldiffs.lb_max_diff = +2;
     521           0 :     ldiffs.lb_min_diff = -2;
     522           0 :     break;
     523           0 :   default:
     524           0 :     fprintf(stderr, "Error: Unknown ga_gb_function %i.\n", func);
     525           0 :     abort();
     526             :   }
     527             : 
     528    84918217 :   return ldiffs;
     529             : }
     530             : 
     531             : // EOF

Generated by: LCOV version 1.15