LCOV - code coverage report
Current view: top level - src/eri_mme - eri_mme_types.F (source / functions) Coverage Total Hit
Test: CP2K Regtests (git:42dac4a) Lines: 83.8 % 142 119
Test Date: 2025-07-25 12:55:17 Functions: 66.7 % 12 8

            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: GPL-2.0-or-later                                                      !
       6              : !--------------------------------------------------------------------------------------------------!
       7              : 
       8              : ! **************************************************************************************************
       9              : !> \brief Types and initialization / release routines for Minimax-Ewald method for electron
      10              : !>        repulsion integrals.
      11              : !> \par History
      12              : !>       2015 09 created
      13              : !> \author Patrick Seewald
      14              : ! **************************************************************************************************
      15              : 
      16              : MODULE eri_mme_types
      17              : 
      18              :    USE eri_mme_error_control,           ONLY: calibrate_cutoff,&
      19              :                                               cutoff_minimax_error,&
      20              :                                               minimax_error
      21              :    USE eri_mme_gaussian,                ONLY: eri_mme_coulomb,&
      22              :                                               eri_mme_longrange,&
      23              :                                               eri_mme_yukawa,&
      24              :                                               get_minimax_coeff_v_gspace
      25              :    USE eri_mme_util,                    ONLY: G_abs_min,&
      26              :                                               R_abs_min
      27              :    USE kinds,                           ONLY: dp
      28              :    USE mathlib,                         ONLY: det_3x3,&
      29              :                                               inv_3x3
      30              :    USE message_passing,                 ONLY: mp_para_env_type
      31              :    USE orbital_pointers,                ONLY: init_orbital_pointers
      32              : #include "../base/base_uses.f90"
      33              : 
      34              :    IMPLICIT NONE
      35              : 
      36              :    PRIVATE
      37              : 
      38              :    LOGICAL, PRIVATE, PARAMETER :: debug_this_module = .FALSE.
      39              : 
      40              :    CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'eri_mme_types'
      41              : 
      42              :    INTEGER, PARAMETER, PUBLIC :: n_minimax_max = 53
      43              : 
      44              :    PUBLIC :: eri_mme_param, &
      45              :              eri_mme_init, &
      46              :              eri_mme_release, &
      47              :              eri_mme_set_params, &
      48              :              eri_mme_print_grid_info, &
      49              :              get_minimax_from_cutoff, &
      50              :              eri_mme_coulomb, &
      51              :              eri_mme_yukawa, &
      52              :              eri_mme_longrange, &
      53              :              eri_mme_set_potential
      54              : 
      55              :    TYPE minimax_grid
      56              :       REAL(KIND=dp)                    :: cutoff = 0.0_dp
      57              :       INTEGER                          :: n_minimax = 0
      58              :       REAL(KIND=dp), POINTER, &
      59              :          DIMENSION(:)                  :: minimax_aw => NULL()
      60              :       REAL(KIND=dp)                    :: error = 0.0_dp
      61              :    END TYPE
      62              : 
      63              :    TYPE eri_mme_param
      64              :       INTEGER                          :: n_minimax = 0
      65              :       REAL(KIND=dp), DIMENSION(3, 3)   :: hmat = 0.0_dp, h_inv = 0.0_dp
      66              :       REAL(KIND=dp)                    :: vol = 0.0_dp
      67              :       LOGICAL                          :: is_ortho = .FALSE.
      68              :       REAL(KIND=dp)                    :: cutoff = 0.0_dp
      69              :       LOGICAL                          :: do_calib_cutoff = .FALSE.
      70              :       LOGICAL                          :: do_error_est = .FALSE.
      71              :       LOGICAL                          :: print_calib = .FALSE.
      72              :       REAL(KIND=dp)                    :: cutoff_min = 0.0_dp, cutoff_max = 0.0_dp, cutoff_delta = 0.0_dp, &
      73              :                                           cutoff_eps = 0.0_dp
      74              :       REAL(KIND=dp)                    :: err_mm = 0.0_dp, err_c = 0.0_dp
      75              :       REAL(KIND=dp)                    :: mm_delta = 0.0_dp
      76              :       REAL(KIND=dp)                    :: G_min = 0.0_dp, R_min = 0.0_dp
      77              :       LOGICAL                          :: is_valid = .FALSE.
      78              :       LOGICAL                          :: debug = .FALSE.
      79              :       REAL(KIND=dp)                    :: debug_delta = 0.0_dp
      80              :       INTEGER                          :: debug_nsum = 0
      81              :       REAL(KIND=dp)                    :: C_mm = 0.0_dp
      82              :       INTEGER                          :: unit_nr = -1
      83              :       REAL(KIND=dp)                    :: sum_precision = 0.0_dp
      84              :       INTEGER                          :: n_grids = 0
      85              :       TYPE(minimax_grid), DIMENSION(:), &
      86              :          ALLOCATABLE                   :: minimax_grid
      87              :       REAL(KIND=dp)                    :: zet_max = 0.0_dp, zet_min = 0.0_dp
      88              :       INTEGER                          :: l_mm = -1, l_max_zet = -1
      89              :       INTEGER                          :: potential = 0
      90              :       REAL(KIND=dp)                    :: pot_par = 0.0_dp
      91              :    END TYPE eri_mme_param
      92              : 
      93              : CONTAINS
      94              : 
      95              : ! **************************************************************************************************
      96              : !> \brief ...
      97              : !> \param param ...
      98              : !> \param n_minimax ...
      99              : !> \param cutoff ...
     100              : !> \param do_calib_cutoff ...
     101              : !> \param do_error_est ...
     102              : !> \param cutoff_min ...
     103              : !> \param cutoff_max ...
     104              : !> \param cutoff_eps ...
     105              : !> \param cutoff_delta ...
     106              : !> \param sum_precision ...
     107              : !> \param debug ...
     108              : !> \param debug_delta ...
     109              : !> \param debug_nsum ...
     110              : !> \param unit_nr ...
     111              : !> \param print_calib ...
     112              : ! **************************************************************************************************
     113         1782 :    SUBROUTINE eri_mme_init(param, n_minimax, cutoff, do_calib_cutoff, do_error_est, &
     114              :                            cutoff_min, cutoff_max, cutoff_eps, cutoff_delta, sum_precision, &
     115              :                            debug, debug_delta, debug_nsum, unit_nr, print_calib)
     116              :       TYPE(eri_mme_param), INTENT(OUT)                   :: param
     117              :       INTEGER, INTENT(IN)                                :: n_minimax
     118              :       REAL(KIND=dp), INTENT(IN)                          :: cutoff
     119              :       LOGICAL, INTENT(IN)                                :: do_calib_cutoff, do_error_est
     120              :       REAL(KIND=dp), INTENT(IN)                          :: cutoff_min, cutoff_max, cutoff_eps, &
     121              :                                                             cutoff_delta, sum_precision
     122              :       LOGICAL, INTENT(IN)                                :: debug
     123              :       REAL(KIND=dp), INTENT(IN)                          :: debug_delta
     124              :       INTEGER, INTENT(IN)                                :: debug_nsum, unit_nr
     125              :       LOGICAL, INTENT(IN)                                :: print_calib
     126              : 
     127              :       CHARACTER(len=2)                                   :: string
     128              : 
     129           66 :       WRITE (string, '(I2)') n_minimax_max
     130           66 :       IF (n_minimax .GT. n_minimax_max) &
     131            0 :          CPABORT("The maximum allowed number of minimax points N_MINIMAX is "//TRIM(string))
     132              : 
     133           66 :       param%n_minimax = n_minimax
     134           66 :       param%n_grids = 1
     135           66 :       param%cutoff = cutoff
     136           66 :       param%do_calib_cutoff = do_calib_cutoff
     137           66 :       param%do_error_est = do_error_est
     138           66 :       param%cutoff_min = cutoff_min
     139           66 :       param%cutoff_max = cutoff_max
     140           66 :       param%cutoff_eps = cutoff_eps
     141           66 :       param%cutoff_delta = cutoff_delta
     142           66 :       param%sum_precision = sum_precision
     143           66 :       param%debug = debug
     144           66 :       param%debug_delta = debug_delta
     145           66 :       param%debug_nsum = debug_nsum
     146           66 :       param%print_calib = print_calib
     147           66 :       param%unit_nr = unit_nr
     148           66 :       param%err_mm = -1.0_dp
     149           66 :       param%err_c = -1.0_dp
     150              : 
     151           66 :       param%is_valid = .FALSE.
     152          132 :       ALLOCATE (param%minimax_grid(param%n_grids))
     153           66 :    END SUBROUTINE eri_mme_init
     154              : 
     155              : ! **************************************************************************************************
     156              : !> \brief Set parameters for MME method with manual specification of basis parameters.
     157              : !>        Takes care of cutoff calibration if requested.
     158              : !> \param param ...
     159              : !> \param hmat ...
     160              : !> \param is_ortho ...
     161              : !> \param zet_min Exponent used to estimate error of minimax approximation.
     162              : !> \param zet_max  Exponent used to estimate error of finite cutoff.
     163              : !> \param l_max_zet    Total ang. mom. quantum numbers l to be combined with exponents in
     164              : !>                        zet_max.
     165              : !> \param l_max           Maximum total angular momentum quantum number
     166              : !> \param para_env ...
     167              : !> \param potential   potential to use. Accepts the following values:
     168              : !>                    1: coulomb potential V(r)=1/r
     169              : !>                    2: yukawa potential V(r)=e(-a*r)/r
     170              : !>                    3: long-range coulomb erf(a*r)/r
     171              : !> \param pot_par     potential parameter a for yukawa V(r)=e(-a*r)/r or long-range coulomb V(r)=erf(a*r)/r
     172              : ! **************************************************************************************************
     173          158 :    SUBROUTINE eri_mme_set_params(param, hmat, is_ortho, zet_min, zet_max, l_max_zet, l_max, para_env, &
     174              :                                  potential, pot_par)
     175              :       TYPE(eri_mme_param), INTENT(INOUT)                 :: param
     176              :       REAL(KIND=dp), DIMENSION(3, 3), INTENT(IN)         :: hmat
     177              :       LOGICAL, INTENT(IN)                                :: is_ortho
     178              :       REAL(KIND=dp), INTENT(IN)                          :: zet_min, zet_max
     179              :       INTEGER, INTENT(IN)                                :: l_max_zet, l_max
     180              :       TYPE(mp_para_env_type), INTENT(IN), OPTIONAL       :: para_env
     181              :       INTEGER, INTENT(IN), OPTIONAL                      :: potential
     182              :       REAL(KIND=dp), INTENT(IN), OPTIONAL                :: pot_par
     183              : 
     184              :       CHARACTER(LEN=*), PARAMETER :: routineN = 'eri_mme_set_params'
     185              : 
     186              :       INTEGER                                            :: handle, l_mm, n_grids
     187              :       LOGICAL                                            :: s_only
     188              :       REAL(KIND=dp)                                      :: cutoff
     189          158 :       REAL(KIND=dp), ALLOCATABLE, DIMENSION(:)           :: minimax_aw
     190              : 
     191          158 :       CALL timeset(routineN, handle)
     192              : 
     193              :       ! Note: in MP2 default logger hacked and does not use global default print level
     194          158 :       s_only = l_max .EQ. 0
     195              : 
     196          158 :       CALL init_orbital_pointers(3*l_max) ! allow for orbital pointers of combined index
     197              : 
     198              :       ! l values for minimax error estimate (l_mm) and for cutoff error estimate (l_max_zet)
     199          308 :       l_mm = MERGE(0, 1, s_only)
     200              : 
     201              :       ! cell info
     202              :       ! Note: we recompute basic quantities from hmat to avoid dependency on cp2k cell type
     203         2054 :       param%hmat = hmat
     204         2054 :       param%h_inv = inv_3x3(hmat)
     205          158 :       param%vol = ABS(det_3x3(hmat))
     206          158 :       param%is_ortho = is_ortho
     207              : 
     208              :       ! Minimum lattice vectors
     209          158 :       param%G_min = G_abs_min(param%h_inv)
     210          158 :       param%R_min = R_abs_min(param%hmat)
     211              : 
     212              :       ! Minimum and maximum exponents
     213          158 :       param%zet_max = zet_max
     214          158 :       param%zet_min = zet_min
     215          158 :       param%l_max_zet = l_max_zet
     216          158 :       param%l_mm = l_mm
     217              : 
     218              :       ! cutoff calibration not yet implemented for general cell
     219          158 :       IF (.NOT. param%is_ortho) THEN
     220           36 :          param%do_calib_cutoff = .FALSE.
     221           36 :          param%do_error_est = .FALSE.
     222              :       END IF
     223              : 
     224          158 :       n_grids = param%n_grids
     225              : 
     226              :       ! Cutoff calibration and error estimate for orthorhombic cell
     227              :       ! Here we assume Coulomb potential which should give an upper bound error also for the other
     228              :       ! potentials
     229          158 :       IF (param%do_calib_cutoff) THEN
     230              :          CALL calibrate_cutoff(param%hmat, param%h_inv, param%G_min, param%vol, &
     231              :                                zet_min, l_mm, zet_max, l_max_zet, param%n_minimax, &
     232              :                                param%cutoff_min, param%cutoff_max, param%cutoff_eps, &
     233              :                                param%cutoff_delta, cutoff, param%err_mm, param%err_c, &
     234           84 :                                param%C_mm, para_env, param%print_calib, param%unit_nr)
     235              : 
     236           84 :          param%cutoff = cutoff
     237           74 :       ELSE IF (param%do_error_est) THEN
     238          114 :          ALLOCATE (minimax_aw(2*param%n_minimax))
     239              :          CALL cutoff_minimax_error(param%cutoff, param%hmat, param%h_inv, param%vol, param%G_min, &
     240              :                                    zet_min, l_mm, zet_max, l_max_zet, param%n_minimax, &
     241           38 :                                    minimax_aw, param%err_mm, param%err_c, param%C_mm, para_env)
     242           38 :          DEALLOCATE (minimax_aw)
     243              :       END IF
     244              : 
     245          158 :       param%is_valid = .TRUE.
     246              : 
     247          158 :       CALL eri_mme_set_potential(param, potential=potential, pot_par=pot_par)
     248              : 
     249          158 :       CALL timestop(handle)
     250          158 :    END SUBROUTINE eri_mme_set_params
     251              : 
     252              : ! **************************************************************************************************
     253              : !> \brief ...
     254              : !> \param param ...
     255              : !> \param potential   potential to use. Accepts the following values:
     256              : !>                    1: coulomb potential V(r)=1/r
     257              : !>                    2: yukawa potential V(r)=e(-a*r)/r
     258              : !>                    3: long-range coulomb erf(a*r)/r
     259              : !> \param pot_par     potential parameter a for yukawa V(r)=e(-a*r)/r or long-range coulomb V(r)=erf(a*r)/r
     260              : ! **************************************************************************************************
     261        85492 :    SUBROUTINE eri_mme_set_potential(param, potential, pot_par)
     262              :       TYPE(eri_mme_param), INTENT(INOUT)                 :: param
     263              :       INTEGER, INTENT(IN), OPTIONAL                      :: potential
     264              :       REAL(KIND=dp), INTENT(IN), OPTIONAL                :: pot_par
     265              : 
     266              :       REAL(KIND=dp)                                      :: cutoff_max, cutoff_min, cutoff_rel
     267        85492 :       REAL(KIND=dp), ALLOCATABLE, DIMENSION(:)           :: minimax_aw
     268              : 
     269        85492 :       CPASSERT(param%is_valid)
     270              : 
     271        85492 :       IF (PRESENT(potential)) THEN
     272        85342 :          param%potential = potential
     273              :       ELSE
     274          150 :          param%potential = eri_mme_coulomb
     275              :       END IF
     276              : 
     277        85492 :       IF (PRESENT(pot_par)) THEN
     278        85342 :          param%pot_par = pot_par
     279              :       ELSE
     280          150 :          param%pot_par = 0.0_dp
     281              :       END IF
     282              : 
     283       256476 :       ALLOCATE (minimax_aw(2*param%n_minimax))
     284              : 
     285              :       CALL minimax_error(param%cutoff, param%hmat, param%vol, param%G_min, param%zet_min, param%l_mm, &
     286        85492 :                          param%n_minimax, minimax_aw, param%err_mm, param%mm_delta, potential=potential, pot_par=pot_par)
     287              : 
     288        85492 :       DEALLOCATE (minimax_aw)
     289              : 
     290        85492 :       CPASSERT(param%zet_max + 1.0E-12 .GT. param%zet_min)
     291        85492 :       CPASSERT(param%n_grids .GE. 1)
     292              : 
     293        85492 :       cutoff_max = param%cutoff
     294        85492 :       cutoff_rel = param%cutoff/param%zet_max
     295        85492 :       cutoff_min = param%zet_min*cutoff_rel
     296              : 
     297        85492 :       CALL eri_mme_destroy_minimax_grids(param%minimax_grid)
     298       341968 :       ALLOCATE (param%minimax_grid(param%n_grids))
     299              : 
     300              :       CALL eri_mme_create_minimax_grids(param%n_grids, param%minimax_grid, param%n_minimax, &
     301              :                                         cutoff_max, cutoff_min, param%G_min, &
     302        85492 :                                         param%mm_delta, potential=potential, pot_par=pot_par)
     303              : 
     304        85492 :    END SUBROUTINE
     305              : 
     306              : ! **************************************************************************************************
     307              : !> \brief ...
     308              : !> \param n_grids ...
     309              : !> \param minimax_grids ...
     310              : !> \param n_minimax ...
     311              : !> \param cutoff_max ...
     312              : !> \param cutoff_min ...
     313              : !> \param G_min ...
     314              : !> \param target_error ...
     315              : !> \param potential ...
     316              : !> \param pot_par ...
     317              : ! **************************************************************************************************
     318       170984 :    SUBROUTINE eri_mme_create_minimax_grids(n_grids, minimax_grids, n_minimax, &
     319              :                                            cutoff_max, cutoff_min, G_min, &
     320              :                                            target_error, potential, pot_par)
     321              :       INTEGER, INTENT(IN)                                :: n_grids
     322              :       TYPE(minimax_grid), DIMENSION(n_grids), &
     323              :          INTENT(OUT)                                     :: minimax_grids
     324              :       INTEGER, INTENT(IN)                                :: n_minimax
     325              :       REAL(KIND=dp), INTENT(IN)                          :: cutoff_max, cutoff_min, G_min, &
     326              :                                                             target_error
     327              :       INTEGER, INTENT(IN), OPTIONAL                      :: potential
     328              :       REAL(KIND=dp), INTENT(IN), OPTIONAL                :: pot_par
     329              : 
     330              :       INTEGER                                            :: i_grid, n_mm
     331              :       REAL(KIND=dp)                                      :: cutoff, cutoff_delta, err_mm, err_mm_prev
     332        85492 :       REAL(KIND=dp), ALLOCATABLE, DIMENSION(:)           :: minimax_aw, minimax_aw_prev
     333              : 
     334        85492 :       cutoff_delta = (cutoff_max/cutoff_min)**(1.0_dp/(n_grids))
     335        85492 :       cutoff = cutoff_max
     336              : 
     337       256476 :       ALLOCATE (minimax_aw(2*n_minimax))
     338              :       ! for first grid (for max. cutoff) always use default n_minimax
     339              :       CALL get_minimax_coeff_v_gspace(n_minimax, cutoff, G_min, minimax_aw, err_minimax=err_mm, &
     340        85492 :                                       potential=potential, pot_par=pot_par)
     341        85492 :       CPASSERT(err_mm .LT. 1.1_dp*target_error + 1.0E-12)
     342        85492 :       CALL create_minimax_grid(minimax_grids(n_grids), cutoff, n_minimax, minimax_aw, err_mm)
     343        85492 :       DEALLOCATE (minimax_aw)
     344              : 
     345        85492 :       DO i_grid = n_grids - 1, 1, -1
     346            0 :          DO n_mm = n_minimax, 1, -1
     347            0 :             ALLOCATE (minimax_aw(2*n_mm))
     348              :             CALL get_minimax_coeff_v_gspace(n_mm, cutoff, G_min, minimax_aw, err_minimax=err_mm, &
     349            0 :                                             potential=potential, pot_par=pot_par)
     350              : 
     351            0 :             IF (err_mm .GT. 1.1_dp*target_error) THEN
     352            0 :                CPASSERT(n_mm .NE. n_minimax)
     353            0 :                CALL create_minimax_grid(minimax_grids(i_grid), cutoff, n_mm + 1, minimax_aw_prev, err_mm_prev)
     354              : 
     355            0 :                DEALLOCATE (minimax_aw)
     356            0 :                EXIT
     357              :             END IF
     358              : 
     359            0 :             IF (ALLOCATED(minimax_aw_prev)) DEALLOCATE (minimax_aw_prev)
     360            0 :             ALLOCATE (minimax_aw_prev(2*n_mm))
     361            0 :             minimax_aw_prev(:) = minimax_aw(:)
     362            0 :             DEALLOCATE (minimax_aw)
     363            0 :             err_mm_prev = err_mm
     364              :          END DO
     365        85492 :          cutoff = cutoff/cutoff_delta
     366              :       END DO
     367       170984 :    END SUBROUTINE
     368              : 
     369              : ! **************************************************************************************************
     370              : !> \brief ...
     371              : !> \param minimax_grids ...
     372              : ! **************************************************************************************************
     373        85558 :    SUBROUTINE eri_mme_destroy_minimax_grids(minimax_grids)
     374              :       TYPE(minimax_grid), ALLOCATABLE, DIMENSION(:), &
     375              :          INTENT(INOUT)                                   :: minimax_grids
     376              : 
     377              :       INTEGER                                            :: igrid
     378              : 
     379        85558 :       IF (ALLOCATED(minimax_grids)) THEN
     380       171116 :          DO igrid = 1, SIZE(minimax_grids)
     381       171116 :             IF (ASSOCIATED(minimax_grids(igrid)%minimax_aw)) THEN
     382        85492 :                DEALLOCATE (minimax_grids(igrid)%minimax_aw)
     383              :             END IF
     384              :          END DO
     385        85558 :          DEALLOCATE (minimax_grids)
     386              :       END IF
     387        85558 :    END SUBROUTINE
     388              : 
     389              : ! **************************************************************************************************
     390              : !> \brief ...
     391              : !> \param grid ...
     392              : !> \param cutoff ...
     393              : !> \param n_minimax ...
     394              : !> \param minimax_aw ...
     395              : !> \param error ...
     396              : ! **************************************************************************************************
     397        85492 :    SUBROUTINE create_minimax_grid(grid, cutoff, n_minimax, minimax_aw, error)
     398              :       TYPE(minimax_grid), INTENT(OUT)                    :: grid
     399              :       REAL(KIND=dp), INTENT(IN)                          :: cutoff
     400              :       INTEGER, INTENT(IN)                                :: n_minimax
     401              :       REAL(KIND=dp), DIMENSION(2*n_minimax), INTENT(IN)  :: minimax_aw
     402              :       REAL(KIND=dp), INTENT(IN)                          :: error
     403              : 
     404        85492 :       grid%cutoff = cutoff
     405        85492 :       grid%n_minimax = n_minimax
     406       341968 :       ALLOCATE (grid%minimax_aw(2*n_minimax))
     407      2745732 :       grid%minimax_aw(:) = minimax_aw(:)
     408        85492 :       grid%error = error
     409              : 
     410        85492 :    END SUBROUTINE
     411              : 
     412              : ! **************************************************************************************************
     413              : !> \brief ...
     414              : !> \param grids ...
     415              : !> \param cutoff ...
     416              : !> \param n_minimax ...
     417              : !> \param minimax_aw ...
     418              : !> \param grid_no ...
     419              : ! **************************************************************************************************
     420       210488 :    SUBROUTINE get_minimax_from_cutoff(grids, cutoff, n_minimax, minimax_aw, grid_no)
     421              :       TYPE(minimax_grid), DIMENSION(:), INTENT(IN)       :: grids
     422              :       REAL(KIND=dp), INTENT(IN)                          :: cutoff
     423              :       INTEGER, INTENT(OUT)                               :: n_minimax
     424              :       REAL(KIND=dp), DIMENSION(:), INTENT(OUT), POINTER  :: minimax_aw
     425              :       INTEGER, INTENT(OUT)                               :: grid_no
     426              : 
     427              :       INTEGER                                            :: igrid
     428              : 
     429       210488 :       grid_no = 0
     430       226830 :       DO igrid = 1, SIZE(grids)
     431       226830 :          IF (grids(igrid)%cutoff .GE. cutoff/2) THEN
     432       194146 :             n_minimax = grids(igrid)%n_minimax
     433       194146 :             minimax_aw => grids(igrid)%minimax_aw
     434       194146 :             grid_no = igrid
     435       194146 :             EXIT
     436              :          END IF
     437              :       END DO
     438       210488 :       IF (grid_no == 0) THEN
     439        16342 :          igrid = SIZE(grids)
     440        16342 :          n_minimax = grids(igrid)%n_minimax
     441        16342 :          minimax_aw => grids(igrid)%minimax_aw
     442        16342 :          grid_no = igrid
     443              :       END IF
     444       210488 :    END SUBROUTINE
     445              : 
     446              : ! **************************************************************************************************
     447              : !> \brief ...
     448              : !> \param grid ...
     449              : !> \param grid_no ...
     450              : !> \param unit_nr ...
     451              : ! **************************************************************************************************
     452            0 :    SUBROUTINE eri_mme_print_grid_info(grid, grid_no, unit_nr)
     453              :       TYPE(minimax_grid), INTENT(IN)                     :: grid
     454              :       INTEGER, INTENT(IN)                                :: grid_no, unit_nr
     455              : 
     456            0 :       IF (unit_nr > 0) THEN
     457            0 :          WRITE (unit_nr, '(T2, A, 1X, I2)') "ERI_MME | Info for grid no.", grid_no
     458            0 :          WRITE (unit_nr, '(T2, A, 1X, ES9.2)') "ERI_MME | Cutoff", grid%cutoff
     459            0 :          WRITE (unit_nr, '(T2, A, 1X, I2)') "ERI_MME | Number of minimax points", grid%n_minimax
     460            0 :          WRITE (unit_nr, '(T2, A, 1X, 2ES9.2)') "ERI_MME | minimax error", grid%error
     461            0 :          WRITE (unit_nr, *)
     462              :       END IF
     463              : 
     464            0 :    END SUBROUTINE
     465              : 
     466              : ! **************************************************************************************************
     467              : !> \brief ...
     468              : !> \param param ...
     469              : ! **************************************************************************************************
     470           66 :    SUBROUTINE eri_mme_release(param)
     471              :       TYPE(eri_mme_param), INTENT(INOUT)                 :: param
     472              : 
     473           66 :       IF (ALLOCATED(param%minimax_grid)) THEN
     474           66 :          CALL eri_mme_destroy_minimax_grids(param%minimax_grid)
     475              :       END IF
     476           66 :    END SUBROUTINE eri_mme_release
     477              : 
     478            0 : END MODULE eri_mme_types
        

Generated by: LCOV version 2.0-1