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      574678 : static int cartesian_generator_dirac(int L, int *cart_list) {
      79      574678 :   int count = 0;
      80      574678 :   int n_cart = (L + 1) * (L + 2) / 2;
      81             : 
      82     1689120 :   for (int r = L; r >= 0; r--) {
      83     3664120 :     for (int s = L; s >= 0; s--) {
      84     9142816 :       for (int t = L; t >= 0; t--) {
      85     6593138 :         if (r + s + t == L) {
      86     1832060 :           cart_list[3 * count + 0] = r;
      87     1832060 :           cart_list[3 * count + 1] = s;
      88     1832060 :           cart_list[3 * count + 2] = t;
      89     1832060 :           count++;
      90             :         }
      91             :       }
      92             :     }
      93             :   }
      94             : 
      95      574678 :   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             : }