(git:1f285aa)
eri_mme_types.F
Go to the documentation of this file.
1 !--------------------------------------------------------------------------------------------------!
2 ! CP2K: A general program to perform molecular dynamics simulations !
3 ! Copyright 2000-2024 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  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  WRITE (string, '(I2)') n_minimax_max
130  IF (n_minimax .GT. n_minimax_max) &
131  cpabort("The maximum allowed number of minimax points N_MINIMAX is "//trim(string))
132 
133  param%n_minimax = n_minimax
134  param%n_grids = 1
135  param%cutoff = cutoff
136  param%do_calib_cutoff = do_calib_cutoff
137  param%do_error_est = do_error_est
138  param%cutoff_min = cutoff_min
139  param%cutoff_max = cutoff_max
140  param%cutoff_eps = cutoff_eps
141  param%cutoff_delta = cutoff_delta
142  param%sum_precision = sum_precision
143  param%debug = debug
144  param%debug_delta = debug_delta
145  param%debug_nsum = debug_nsum
146  param%print_calib = print_calib
147  param%unit_nr = unit_nr
148  param%err_mm = -1.0_dp
149  param%err_c = -1.0_dp
150 
151  param%is_valid = .false.
152  ALLOCATE (param%minimax_grid(param%n_grids))
153  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  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  REAL(kind=dp), ALLOCATABLE, DIMENSION(:) :: minimax_aw
190 
191  CALL timeset(routinen, handle)
192 
193  ! Note: in MP2 default logger hacked and does not use global default print level
194  s_only = l_max .EQ. 0
195 
196  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  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  param%hmat = hmat
204  param%h_inv = inv_3x3(hmat)
205  param%vol = abs(det_3x3(hmat))
206  param%is_ortho = is_ortho
207 
208  ! Minimum lattice vectors
209  param%G_min = g_abs_min(param%h_inv)
210  param%R_min = r_abs_min(param%hmat)
211 
212  ! Minimum and maximum exponents
213  param%zet_max = zet_max
214  param%zet_min = zet_min
215  param%l_max_zet = l_max_zet
216  param%l_mm = l_mm
217 
218  ! cutoff calibration not yet implemented for general cell
219  IF (.NOT. param%is_ortho) THEN
220  param%do_calib_cutoff = .false.
221  param%do_error_est = .false.
222  END IF
223 
224  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  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  param%C_mm, para_env, param%print_calib, param%unit_nr)
235 
236  param%cutoff = cutoff
237  ELSE IF (param%do_error_est) THEN
238  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  minimax_aw, param%err_mm, param%err_c, param%C_mm, para_env)
242  DEALLOCATE (minimax_aw)
243  END IF
244 
245  param%is_valid = .true.
246 
247  CALL eri_mme_set_potential(param, potential=potential, pot_par=pot_par)
248 
249  CALL timestop(handle)
250  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  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  REAL(kind=dp), ALLOCATABLE, DIMENSION(:) :: minimax_aw
268 
269  cpassert(param%is_valid)
270 
271  IF (PRESENT(potential)) THEN
272  param%potential = potential
273  ELSE
274  param%potential = eri_mme_coulomb
275  END IF
276 
277  IF (PRESENT(pot_par)) THEN
278  param%pot_par = pot_par
279  ELSE
280  param%pot_par = 0.0_dp
281  END IF
282 
283  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  param%n_minimax, minimax_aw, param%err_mm, param%mm_delta, potential=potential, pot_par=pot_par)
287 
288  DEALLOCATE (minimax_aw)
289 
290  cpassert(param%zet_max + 1.0e-12 .GT. param%zet_min)
291  cpassert(param%n_grids .GE. 1)
292 
293  cutoff_max = param%cutoff
294  cutoff_rel = param%cutoff/param%zet_max
295  cutoff_min = param%zet_min*cutoff_rel
296 
297  CALL eri_mme_destroy_minimax_grids(param%minimax_grid)
298  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  param%mm_delta, potential=potential, pot_par=pot_par)
303 
304  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  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  REAL(kind=dp), ALLOCATABLE, DIMENSION(:) :: minimax_aw, minimax_aw_prev
333 
334  cutoff_delta = (cutoff_max/cutoff_min)**(1.0_dp/(n_grids))
335  cutoff = cutoff_max
336 
337  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  potential=potential, pot_par=pot_par)
341  cpassert(err_mm .LT. 1.1_dp*target_error + 1.0e-12)
342  CALL create_minimax_grid(minimax_grids(n_grids), cutoff, n_minimax, minimax_aw, err_mm)
343  DEALLOCATE (minimax_aw)
344 
345  DO i_grid = n_grids - 1, 1, -1
346  DO n_mm = n_minimax, 1, -1
347  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  potential=potential, pot_par=pot_par)
350 
351  IF (err_mm .GT. 1.1_dp*target_error) THEN
352  cpassert(n_mm .NE. n_minimax)
353  CALL create_minimax_grid(minimax_grids(i_grid), cutoff, n_mm + 1, minimax_aw_prev, err_mm_prev)
354 
355  DEALLOCATE (minimax_aw)
356  EXIT
357  END IF
358 
359  IF (ALLOCATED(minimax_aw_prev)) DEALLOCATE (minimax_aw_prev)
360  ALLOCATE (minimax_aw_prev(2*n_mm))
361  minimax_aw_prev(:) = minimax_aw(:)
362  DEALLOCATE (minimax_aw)
363  err_mm_prev = err_mm
364  END DO
365  cutoff = cutoff/cutoff_delta
366  END DO
367  END SUBROUTINE
368 
369 ! **************************************************************************************************
370 !> \brief ...
371 !> \param minimax_grids ...
372 ! **************************************************************************************************
373  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  IF (ALLOCATED(minimax_grids)) THEN
380  DO igrid = 1, SIZE(minimax_grids)
381  IF (ASSOCIATED(minimax_grids(igrid)%minimax_aw)) THEN
382  DEALLOCATE (minimax_grids(igrid)%minimax_aw)
383  END IF
384  END DO
385  DEALLOCATE (minimax_grids)
386  END IF
387  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  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  grid%cutoff = cutoff
405  grid%n_minimax = n_minimax
406  ALLOCATE (grid%minimax_aw(2*n_minimax))
407  grid%minimax_aw(:) = minimax_aw(:)
408  grid%error = error
409 
410  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  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  grid_no = 0
430  DO igrid = 1, SIZE(grids)
431  IF (grids(igrid)%cutoff .GE. cutoff/2) THEN
432  n_minimax = grids(igrid)%n_minimax
433  minimax_aw => grids(igrid)%minimax_aw
434  grid_no = igrid
435  EXIT
436  END IF
437  END DO
438  IF (grid_no == 0) THEN
439  igrid = SIZE(grids)
440  n_minimax = grids(igrid)%n_minimax
441  minimax_aw => grids(igrid)%minimax_aw
442  grid_no = igrid
443  END IF
444  END SUBROUTINE
445 
446 ! **************************************************************************************************
447 !> \brief ...
448 !> \param grid ...
449 !> \param grid_no ...
450 !> \param unit_nr ...
451 ! **************************************************************************************************
452  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  IF (unit_nr > 0) THEN
457  WRITE (unit_nr, '(T2, A, 1X, I2)') "ERI_MME | Info for grid no.", grid_no
458  WRITE (unit_nr, '(T2, A, 1X, ES9.2)') "ERI_MME | Cutoff", grid%cutoff
459  WRITE (unit_nr, '(T2, A, 1X, I2)') "ERI_MME | Number of minimax points", grid%n_minimax
460  WRITE (unit_nr, '(T2, A, 1X, 2ES9.2)') "ERI_MME | minimax error", grid%error
461  WRITE (unit_nr, *)
462  END IF
463 
464  END SUBROUTINE
465 
466 ! **************************************************************************************************
467 !> \brief ...
468 !> \param param ...
469 ! **************************************************************************************************
470  SUBROUTINE eri_mme_release(param)
471  TYPE(eri_mme_param), INTENT(INOUT) :: param
472 
473  IF (ALLOCATED(param%minimax_grid)) THEN
474  CALL eri_mme_destroy_minimax_grids(param%minimax_grid)
475  END IF
476  END SUBROUTINE eri_mme_release
477 
478 END MODULE eri_mme_types
det_3x3
real(kind=dp) function det_3x3(a)
...
Definition: dumpdcd.F:1091
eri_mme_error_control
Methods aiming for error estimate and automatic cutoff calibration. integrals.
Definition: eri_mme_error_control.F:16
eri_mme_error_control::calibrate_cutoff
subroutine, public calibrate_cutoff(hmat, h_inv, G_min, vol, zet_min, l_mm, zet_max, l_max_zet, n_minimax, cutoff_l, cutoff_r, tol, delta, cutoff, err_mm, err_c, C_mm, para_env, print_calib, unit_nr)
Find optimal cutoff minimizing errors due to minimax approximation and due to finite cutoff using bis...
Definition: eri_mme_error_control.F:66
eri_mme_error_control::minimax_error
subroutine, public minimax_error(cutoff, hmat, vol, G_min, zet_min, l_mm, n_minimax, minimax_aw, err_mm, delta_mm, potential, pot_par)
Minimax error, simple analytical formula Note minimax error may blow up for small exponents....
Definition: eri_mme_error_control.F:242
eri_mme_error_control::cutoff_minimax_error
subroutine, public cutoff_minimax_error(cutoff, hmat, h_inv, vol, G_min, zet_min, l_mm, zet_max, l_max_zet, n_minimax, minimax_aw, err_mm, err_ctff, C_mm, para_env)
Compute upper bounds for the errors of 2-center ERI's (P|P) due to minimax approximation and due to f...
Definition: eri_mme_error_control.F:204
eri_mme_gaussian
Methods related to properties of Hermite and Cartesian Gaussian functions.
Definition: eri_mme_gaussian.F:15
eri_mme_gaussian::eri_mme_longrange
integer, parameter, public eri_mme_longrange
Definition: eri_mme_gaussian.F:29
eri_mme_gaussian::eri_mme_coulomb
integer, parameter, public eri_mme_coulomb
Definition: eri_mme_gaussian.F:29
eri_mme_gaussian::get_minimax_coeff_v_gspace
subroutine, public get_minimax_coeff_v_gspace(n_minimax, cutoff, G_min, minimax_aw, potential, pot_par, err_minimax)
Get minimax coefficient a_i and w_i for approximating 1/G^2 by sum_i w_i exp(-a_i G^2)
Definition: eri_mme_gaussian.F:99
eri_mme_gaussian::eri_mme_yukawa
integer, parameter, public eri_mme_yukawa
Definition: eri_mme_gaussian.F:29
eri_mme_types
Types and initialization / release routines for Minimax-Ewald method for electron repulsion integrals...
Definition: eri_mme_types.F:16
eri_mme_types::eri_mme_release
subroutine, public eri_mme_release(param)
...
Definition: eri_mme_types.F:471
eri_mme_types::get_minimax_from_cutoff
subroutine, public get_minimax_from_cutoff(grids, cutoff, n_minimax, minimax_aw, grid_no)
...
Definition: eri_mme_types.F:421
eri_mme_types::eri_mme_init
subroutine, public eri_mme_init(param, n_minimax, cutoff, do_calib_cutoff, do_error_est, cutoff_min, cutoff_max, cutoff_eps, cutoff_delta, sum_precision, debug, debug_delta, debug_nsum, unit_nr, print_calib)
...
Definition: eri_mme_types.F:116
eri_mme_types::eri_mme_set_potential
subroutine, public eri_mme_set_potential(param, potential, pot_par)
...
Definition: eri_mme_types.F:262
eri_mme_types::n_minimax_max
integer, parameter, public n_minimax_max
Definition: eri_mme_types.F:42
eri_mme_types::eri_mme_set_params
subroutine, public eri_mme_set_params(param, hmat, is_ortho, zet_min, zet_max, l_max_zet, l_max, para_env, potential, pot_par)
Set parameters for MME method with manual specification of basis parameters. Takes care of cutoff cal...
Definition: eri_mme_types.F:175
eri_mme_types::eri_mme_print_grid_info
subroutine, public eri_mme_print_grid_info(grid, grid_no, unit_nr)
...
Definition: eri_mme_types.F:453
eri_mme_util
Some utility methods used in different contexts.
Definition: eri_mme_util.F:15
eri_mme_util::g_abs_min
real(kind=dp) function, public g_abs_min(h_inv)
Find minimum length of G vectors, for a general (not necessarily orthorhombic) cell.
Definition: eri_mme_util.F:67
eri_mme_util::r_abs_min
real(kind=dp) function, public r_abs_min(hmat)
Find minimum length of R vectors, for a general (not necessarily orthorhombic) cell.
Definition: eri_mme_util.F:34
kinds
Defines the basic variable types.
Definition: kinds.F:23
kinds::dp
integer, parameter, public dp
Definition: kinds.F:34
mathlib
Collection of simple mathematical functions and subroutines.
Definition: mathlib.F:15
mathlib::inv_3x3
pure real(kind=dp) function, dimension(3, 3), public inv_3x3(a)
Returns the inverse of the 3 x 3 matrix a.
Definition: mathlib.F:516
message_passing
Interface to the message passing library MPI.
Definition: message_passing.F:23
orbital_pointers
Provides Cartesian and spherical orbital pointers and indices.
Definition: orbital_pointers.F:15
orbital_pointers::init_orbital_pointers
subroutine, public init_orbital_pointers(maxl)
Initialize or update the orbital pointers.
Definition: orbital_pointers.F:253