Line data    Source code

       1              : /*----------------------------------------------------------------------------*/
       2              : /*  CP2K: A general program to perform molecular dynamics simulations         */
       3              : /*  Copyright 2000-2025 CP2K developers group <https://cp2k.org>              */
       4              : /*                                                                            */
       5              : /*  SPDX-License-Identifier: MIT                                              */
       6              : /*----------------------------------------------------------------------------*/
       7              : 
       8              : /*
       9              :  *  libgrpp - a library for the evaluation of integrals over
      10              :  *            generalized relativistic pseudopotentials.
      11              :  *
      12              :  *  Copyright (C) 2021-2023 Alexander Oleynichenko
      13              :  */
      14              : #include <assert.h>
      15              : 
      16              : #include "grpp_parameters.h"
      17              : 
      18              : static int cartesian_generator_dirac(int L, int *cart_list);
      19              : 
      20              : static int cartesian_generator_turbomole(int L, int *cart_list);
      21              : 
      22              : libgrpp_parameters_t libgrpp_params = {
      23              :     // tolerance of radial integration
      24              :     1e-16,
      25              :     // tolerance of angular integral screening
      26              :     1e-16,
      27              :     // tolerance of modified Bessel functions evaluation
      28              :     // is it really needed?
      29              :     1e-16,
      30              :     // subroutine to generate cartesian components with given ang momentum L
      31              :     cartesian_generator_dirac};
      32              : 
      33            0 : void libgrpp_set_default_parameters() {
      34              :   // #pragma omp critical
      35              :   {
      36            0 :     libgrpp_set_radial_tolerance(1e-16);
      37            0 :     libgrpp_set_angular_screening_tolerance(1e-16);
      38            0 :     libgrpp_set_modified_bessel_tolerance(1e-16);
      39            0 :     libgrpp_set_cartesian_generator(cartesian_generator_dirac);
      40              :   }
      41            0 : }
      42              : 
      43            0 : void libgrpp_set_radial_tolerance(double tolerance) {
      44              :   // #pragma omp critical
      45            0 :   { libgrpp_params.radial_tolerance = tolerance; }
      46            0 : }
      47              : 
      48            0 : void libgrpp_set_angular_screening_tolerance(double tolerance) {
      49              :   // #pragma omp critical
      50            0 :   { libgrpp_params.angular_screening_tolerance = tolerance; }
      51            0 : }
      52              : 
      53            0 : void libgrpp_set_modified_bessel_tolerance(double tolerance) {
      54              :   // #pragma omp critical
      55            0 :   { libgrpp_params.modified_bessel_tolerance = tolerance; }
      56            0 : }
      57              : 
      58            0 : void libgrpp_set_cartesian_order(int order) {
      59              :   // #pragma omp critical
      60              :   {
      61            0 :     assert(order == LIBGRPP_CART_ORDER_DIRAC ||
      62              :            order == LIBGRPP_CART_ORDER_TURBOMOLE);
      63              : 
      64            0 :     if (order == LIBGRPP_CART_ORDER_DIRAC) {
      65            0 :       libgrpp_set_cartesian_generator(cartesian_generator_dirac);
      66            0 :     } else if (order == LIBGRPP_CART_ORDER_TURBOMOLE) {
      67            0 :       libgrpp_set_cartesian_generator(cartesian_generator_turbomole);
      68              :     }
      69              :   }
      70            0 : }
      71              : 
      72            0 : void libgrpp_set_cartesian_generator(
      73              :     int (*cartesian_generator)(int L, int *cart_list)) {
      74              :   // #pragma omp critical
      75            0 :   { libgrpp_params.cartesian_generator = cartesian_generator; }
      76            0 : }
      77              : 
      78       701560 : static int cartesian_generator_dirac(int L, int *cart_list) {
      79       701560 :   int count = 0;
      80       701560 :   int n_cart = (L + 1) * (L + 2) / 2;
      81              : 
      82      2053782 :   for (int r = L; r >= 0; r--) {
      83      4442764 :     for (int s = L; s >= 0; s--) {
      84     11112736 :       for (int t = L; t >= 0; t--) {
      85      8022194 :         if (r + s + t == L) {
      86      2221382 :           cart_list[3 * count + 0] = r;
      87      2221382 :           cart_list[3 * count + 1] = s;
      88      2221382 :           cart_list[3 * count + 2] = t;
      89      2221382 :           count++;
      90              :         }
      91              :       }
      92              :     }
      93              :   }
      94              : 
      95       701560 :   return n_cart;
      96              : }
      97              : 
      98            0 : static int cartesian_generator_turbomole(int L, int *cart_list) {
      99            0 :   int count = 0;
     100            0 :   int n_cart = (L + 1) * (L + 2) / 2;
     101              : 
     102            0 :   for (int r = L; r >= 0; r--) {
     103            0 :     for (int s = L - r; s >= 0; s--) {
     104            0 :       int t = L - r - s;
     105              : 
     106            0 :       cart_list[3 * count + 0] = r;
     107            0 :       cart_list[3 * count + 1] = s;
     108            0 :       cart_list[3 * count + 2] = t;
     109              : 
     110            0 :       count++;
     111              :     }
     112              :   }
     113              : 
     114            0 :   return n_cart;
     115              : }