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             : 
      15             : #include "libgrpp.h"
      16             : 
      17             : #include <stdlib.h>
      18             : 
      19             : #define LIBGRPP_MAX_NUMBER_POTENTIALS 100
      20             : 
      21           0 : libgrpp_grpp_t *libgrpp_new_grpp() {
      22           0 :   return (libgrpp_grpp_t *)calloc(1, sizeof(libgrpp_grpp_t));
      23             : }
      24             : 
      25           0 : void libgrpp_grpp_set_local_potential(libgrpp_grpp_t *grpp,
      26             :                                       libgrpp_potential_t *pot) {
      27           0 :   if (grpp->U_L != NULL) {
      28           0 :     libgrpp_delete_potential(grpp->U_L);
      29             :   }
      30             : 
      31           0 :   grpp->U_L = pot;
      32           0 : }
      33             : 
      34           0 : void libgrpp_grpp_add_averaged_potential(libgrpp_grpp_t *grpp,
      35             :                                          libgrpp_potential_t *pot) {
      36           0 :   if (grpp->n_arep == 0) {
      37           0 :     grpp->U_arep = (libgrpp_potential_t **)calloc(
      38             :         LIBGRPP_MAX_NUMBER_POTENTIALS, sizeof(libgrpp_potential_t *));
      39             :   }
      40             : 
      41           0 :   grpp->U_arep[grpp->n_arep++] = pot;
      42           0 : }
      43             : 
      44           0 : void libgrpp_grpp_add_spin_orbit_potential(libgrpp_grpp_t *grpp,
      45             :                                            libgrpp_potential_t *pot) {
      46           0 :   if (grpp->n_esop == 0) {
      47           0 :     grpp->U_esop = (libgrpp_potential_t **)calloc(
      48             :         LIBGRPP_MAX_NUMBER_POTENTIALS, sizeof(libgrpp_potential_t *));
      49             :   }
      50             : 
      51           0 :   grpp->U_esop[grpp->n_esop++] = pot;
      52           0 : }
      53             : 
      54           0 : void libgrpp_grpp_add_outercore_potential(libgrpp_grpp_t *grpp,
      55             :                                           libgrpp_potential_t *pot,
      56             :                                           libgrpp_shell_t *oc_shell) {
      57           0 :   if (grpp->n_oc_shells == 0) {
      58           0 :     grpp->U_oc = (libgrpp_potential_t **)calloc(LIBGRPP_MAX_NUMBER_POTENTIALS,
      59             :                                                 sizeof(libgrpp_potential_t *));
      60           0 :     grpp->oc_shells = (libgrpp_shell_t **)calloc(LIBGRPP_MAX_NUMBER_POTENTIALS,
      61             :                                                  sizeof(libgrpp_shell_t *));
      62             :   }
      63             : 
      64           0 :   grpp->U_oc[grpp->n_oc_shells] = pot;
      65           0 :   grpp->oc_shells[grpp->n_oc_shells] = oc_shell;
      66           0 :   grpp->n_oc_shells++;
      67           0 : }
      68             : 
      69           0 : void libgrpp_delete_grpp(libgrpp_grpp_t *grpp) {
      70           0 :   if (grpp == NULL) {
      71             :     return;
      72             :   }
      73             : 
      74             :   /*
      75             :    * scalar-relativistic part
      76             :    */
      77           0 :   if (grpp->U_L != NULL) {
      78           0 :     libgrpp_delete_potential(grpp->U_L);
      79             :   }
      80             : 
      81           0 :   for (int i = 0; i < grpp->n_arep; i++) {
      82           0 :     if (grpp->U_arep[i] != NULL) {
      83           0 :       libgrpp_delete_potential(grpp->U_arep[i]);
      84             :     }
      85             :   }
      86           0 :   free(grpp->U_arep);
      87             : 
      88             :   /*
      89             :    * effective spin-orbit operator
      90             :    */
      91           0 :   for (int i = 0; i < grpp->n_esop; i++) {
      92           0 :     if (grpp->U_esop[i] != NULL) {
      93           0 :       libgrpp_delete_potential(grpp->U_esop[i]);
      94             :     }
      95             :   }
      96           0 :   free(grpp->U_esop);
      97             : 
      98             :   /*
      99             :    * outercore shells and potentials
     100             :    */
     101           0 :   for (int i = 0; i < grpp->n_oc_shells; i++) {
     102           0 :     if (grpp->U_oc[i] != NULL) {
     103           0 :       libgrpp_delete_potential(grpp->U_oc[i]);
     104             :     }
     105           0 :     if (grpp->oc_shells[i] != NULL) {
     106           0 :       libgrpp_delete_shell(grpp->oc_shells[i]);
     107             :     }
     108             :   }
     109           0 :   free(grpp->U_oc);
     110           0 :   free(grpp->oc_shells);
     111             : 
     112           0 :   free(grpp);
     113             : }