Octopus
xc_functional.F90
Go to the documentation of this file.
1!! Copyright (C) 2002-2006 M. Marques, A. Castro, A. Rubio, G. Bertsch
2!!
3!! This program is free software; you can redistribute it and/or modify
4!! it under the terms of the GNU General Public License as published by
5!! the Free Software Foundation; either version 2, or (at your option)
6!! any later version.
7!!
8!! This program is distributed in the hope that it will be useful,
9!! but WITHOUT ANY WARRANTY; without even the implied warranty of
10!! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11!! GNU General Public License for more details.
12!!
13!! You should have received a copy of the GNU General Public License
14!! along with this program; if not, write to the Free Software
15!! Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
16!! 02110-1301, USA.
17!!
18
19#include "global.h"
20
22 use debug_oct_m
23 use global_oct_m
27 use parser_oct_m
28 use pseudo_oct_m
29 use xc_f03_lib_m
30#ifdef HAVE_LIBXC_FUNCS
31 use xc_f03_funcs_m
32#endif
33
34 implicit none
35
36 ! Although the following file only contain comments, we include it here to make sure it exists.
37 ! Otherwise the code might compile, but not run properly, as the variables documentations
38 ! will be incomplete.
39#include "functionals_list.F90"
40
41 private
42 public :: &
50
51
54 integer, public, parameter :: &
55 XC_OEP_X = 901, & !< Exact exchange
56 xc_oep_x_slater = 902, &
57 xc_oep_x_fbe = 903, &
58 xc_ks_inversion = 904, &
59 xc_rdmft_xc_m = 905, &
60 xc_oep_x_fbe_sl = 906, &
61 xc_lda_c_fbe = 907, &
62 xc_lda_c_fbe_sl = 908, &
63 xc_half_hartree = 917, &
64 xc_vdw_c_vdwdf = 918, &
65 xc_vdw_c_vdwdf2 = 919, &
66 xc_vdw_c_vdwdfcx = 920, &
69 xc_mgga_x_nc_br = 923, &
70 xc_mgga_x_nc_br_1 = 924, &
71 xc_mgga_c_nc_cs = 925, &
73 ! !! with an explicit inversion of x(y), gamma = 0.8
74
77 integer, public, parameter :: &
78 XC_FAMILY_KS_INVERSION = 1024, &
79 xc_family_rdmft = 2048, &
80 xc_family_libvdwxc = 4096, &
81 xc_family_nc_lda = 8192, &
82 xc_family_nc_mgga = 16384
83
85 ! Components are public by default
86 integer :: family = xc_family_unknown
87 integer :: type = 0
88 integer :: id = 0
89
90 integer :: spin_channels = 0
91 integer :: flags = 0
92
93 logical, private :: from_libxc = .false.
94
95 type(xc_f03_func_t) :: conf
96 type(xc_f03_func_info_t), private :: info
97 type(libvdwxc_t) :: libvdwxc
98 end type xc_functional_t
99
100 integer, public, parameter :: LIBXC_C_INDEX = 1000
101
102contains
103
104 ! ---------------------------------------------------------
105 subroutine xc_functional_init(functl, namespace, id, ndim, nel, spin_channels)
106 type(xc_functional_t), intent(inout) :: functl
107 type(namespace_t), intent(in) :: namespace
108 integer, intent(in) :: id
109 integer, intent(in) :: ndim
110 real(real64), intent(in) :: nel
111 integer, intent(in) :: spin_channels
112
113 integer :: interact_1d
114 real(real64) :: alpha, parameters(2)
115
117
118 ! initialize structure
119 functl%id = id
120 functl%spin_channels = spin_channels
121
122 if (functl%id == 0) then
123 functl%family = xc_family_none
124 else
125 ! get the family of the functional
126 functl%family = xc_f03_family_from_id(functl%id)
127 ! this also ensures it is actually a functional defined by the linked version of libxc
128
129 if (functl%family == xc_family_unknown) then
130
131 select case (functl%id)
133 functl%family = xc_family_oep
134
135 case (xc_ks_inversion)
136 functl%family = xc_family_ks_inversion
137
138 case (xc_half_hartree)
139 call messages_experimental("half-Hartree exchange", namespace=namespace)
140 functl%family = xc_family_lda ! XXX not really
141
143 functl%family = xc_family_libvdwxc
144 !functl%flags = functl%flags + XC_FLAGS_HAVE_VXC + XC_FLAGS_HAVE_EXC
145
146 case (xc_rdmft_xc_m)
147 functl%family = xc_family_rdmft
148
150 functl%family = xc_family_hyb_gga
151
153 functl%family = xc_family_nc_mgga
154
155 case default
156 call messages_input_error(namespace, 'XCFunctional', 'Unknown functional')
157
158 end select
159 end if
160 end if
161
162 if (functl%family == xc_family_oep) then
163 functl%type = xc_exchange
164 functl%flags = xc_flags_1d + xc_flags_2d + xc_flags_3d
165
166 else if (functl%family == xc_family_ks_inversion .or. functl%family == xc_family_rdmft) then
167 functl%type = xc_exchange_correlation
168 functl%flags = xc_flags_1d + xc_flags_2d + xc_flags_3d
169
170 else if (functl%family == xc_family_libvdwxc) then
171 call xc_f03_func_init(functl%conf, xc_lda_c_pw, spin_channels)
172 functl%info = xc_f03_func_get_info(functl%conf)
173 functl%type = xc_f03_func_info_get_kind(functl%info)
174 functl%flags = xc_f03_func_info_get_flags(functl%info)
175 ! Convert Octopus code for functional into corresponding libvdwxc code:
176 call libvdwxc_init(functl%libvdwxc, namespace, functl%id - xc_vdw_c_vdwdf + 1)
177
178 else if (functl%id == xc_half_hartree) then
179 functl%type = xc_exchange_correlation
180 functl%flags = xc_flags_1d + xc_flags_2d + xc_flags_3d
181
182 else if(functl%id == xc_lda_c_fbe) then
183 functl%family = xc_family_lda
184 functl%type = xc_correlation
185 functl%flags = xc_flags_have_exc + xc_flags_have_vxc + xc_flags_3d
186
187 else if (functl%id == xc_mgga_x_nc_br .or. functl%id == xc_mgga_x_nc_br_1 .or. functl%id == xc_mgga_x_nc_br_explicit) then
188 functl%type = xc_exchange
189 functl%flags = xc_flags_have_vxc + xc_flags_have_exc + xc_flags_3d
190
191 else if(functl%id == xc_mgga_c_nc_cs) then
192 functl%type = xc_correlation
193 functl%flags = xc_flags_have_vxc + xc_flags_have_exc + xc_flags_3d
194
195 else if (functl%family == xc_family_none) then
196 functl%type = -1
197 functl%flags = xc_flags_1d + xc_flags_2d + xc_flags_3d
198
199 else ! handled by libxc
200 ! initialize
201 functl%from_libxc = .true.
202
203 !For the two MVORB functionals, we initialize libxc with the non-MVORB functionals
204 select case (functl%id)
206 call xc_f03_func_init(functl%conf, xc_hyb_gga_xc_hse06, spin_channels)
207
209 call xc_f03_func_init(functl%conf, xc_hyb_gga_xc_pbeh, spin_channels)
210
211 case default
212 call xc_f03_func_init(functl%conf, functl%id, spin_channels)
213 end select
214 functl%info = xc_f03_func_get_info(functl%conf)
215 functl%type = xc_f03_func_info_get_kind(functl%info)
216 functl%flags = xc_f03_func_info_get_flags(functl%info)
217
218 ! FIXME: no need to say this for kernel
219 if (bitand(functl%flags, xc_flags_have_exc) == 0) then
220 message(1) = 'Specified functional does not have total energy available.'
221 message(2) = 'Corresponding component of energy will just be left as zero.'
222 call messages_warning(2, namespace=namespace)
223 end if
224
225 if (bitand(functl%flags, xc_flags_have_vxc) == 0) then
226 message(1) = 'Specified functional does not have XC potential available.'
227 message(2) = 'Cannot run calculations. Choose another XCFunctional.'
228 call messages_fatal(2, namespace=namespace)
229 end if
230 end if
231
232 ! Octopus-defined functionals need to provide the proper flags
233 if (functl%family /= xc_family_none) then
234 call xc_check_dimension(functl, ndim, namespace)
235 end if
236
237 ! Yukawa hybrids not supported yet
238 if (bitand(functl%flags, xc_flags_hyb_camy) /= 0) then
239 call messages_not_implemented("Yukawa-range separated hybrids", namespace=namespace)
240 end if
241
242 ! VV10 correlations not supported yet
243 if (bitand(functl%flags, xc_flags_vv10) /= 0) then
244 call messages_not_implemented("VV10 correlation functionals", namespace=namespace)
245 end if
246
247 ! FIXME: aren`t there other parameters that can or should be set?
248 ! special parameters that have to be configured
249 select case (functl%id)
250 ! FIXME: aren`t there other Xalpha functionals?
251 case (xc_lda_c_xalpha)
252
253 !%Variable Xalpha
254 !%Type float
255 !%Default 1.0
256 !%Section Hamiltonian::XC
257 !%Description
258 !% The parameter of the Slater X<math>\alpha</math> functional. Applies only for
259 !% <tt>XCFunctional = xc_lda_c_xalpha</tt>.
260 !%End
261 call parse_variable(namespace, 'Xalpha', m_one, parameters(1))
262
263 call xc_f03_func_set_ext_params(functl%conf, parameters(1))
264
265 ! FIXME: doesn`t this apply to other 1D functionals?
266 case (xc_lda_x_1d_soft, xc_lda_c_1d_csc)
267 !%Variable Interaction1D
268 !%Type integer
269 !%Default interaction_soft_coulomb
270 !%Section Hamiltonian::XC
271 !%Description
272 !% When running in 1D, one has to soften the Coulomb interaction. This softening
273 !% is not unique, and several possibilities exist in the literature.
274 !%Option interaction_exp_screened 0
275 !% Exponentially screened Coulomb interaction.
276 !% See, <i>e.g.</i>, M Casula, S Sorella, and G Senatore, <i>Phys. Rev. B</i> <b>74</b>, 245427 (2006).
277 !%Option interaction_soft_coulomb 1
278 !% Soft Coulomb interaction of the form <math>1/\sqrt{x^2 + \alpha^2}</math>.
279 !%End
280 call messages_obsolete_variable(namespace, 'SoftInteraction1D_alpha', 'Interaction1D')
281 call parse_variable(namespace, 'Interaction1D', option__interaction1d__interaction_soft_coulomb, interact_1d)
282
283 !%Variable Interaction1DScreening
284 !%Type float
285 !%Default 1.0
286 !%Section Hamiltonian::XC
287 !%Description
288 !% Defines the screening parameter <math>\alpha</math> of the softened Coulomb interaction
289 !% when running in 1D.
290 !%End
291 call messages_obsolete_variable(namespace, 'SoftInteraction1D_alpha', 'Interaction1DScreening')
292 call parse_variable(namespace, 'Interaction1DScreening', m_one, alpha)
293 parameters(1) = real(interact_1d, real64)
294 parameters(2) = alpha
295 call xc_f03_func_set_ext_params(functl%conf, parameters(1))
296
297 case (xc_gga_x_lb)
298 if (parse_is_defined(namespace, 'LB94_modified')) then
299 call messages_obsolete_variable(namespace, 'LB94_modified')
300 end if
301
302 if (parse_is_defined(namespace, 'LB94_threshold')) then
303 call messages_obsolete_variable(namespace, 'LB94_threshold')
304 end if
305 end select
306
307
308 ! For functionals that depend on the number of electrons, we set the number of electrons
309 ! This is currently the case of GGA_K_TFLW, LDA_X_2D_PRM, and LDA_X_RAE
310 if (xc_functional_is_not_size_consistent(functl, namespace)) then
311 assert(xc_f03_func_info_get_n_ext_params(functl%info) == 1)
312 parameters(1) = nel
313 call xc_f03_func_set_ext_params(functl%conf, parameters(1))
314 write(message(1), '(a,i1)') "Info: Setting the number of electrons for the functional for spin ", spin_channels
315 call messages_info(1, namespace=namespace)
316 end if
317
318 pop_sub(xc_functional_init)
319 end subroutine xc_functional_init
320
321
322 ! ---------------------------------------------------------
323 subroutine xc_functional_end(functl)
324 type(xc_functional_t), intent(inout) :: functl
325
326 push_sub(xc_functional_end)
327
328 if (functl%family /= xc_family_none .and. functl%family /= xc_family_oep .and. &
329 functl%family /= xc_family_ks_inversion .and. functl%id /= xc_half_hartree &
330 .and. functl%id /= xc_lda_c_fbe &
331 .and. functl%family /= xc_family_nc_lda .and. functl%family /= xc_family_nc_mgga) then
332 call xc_f03_func_end(functl%conf)
333 end if
334
335 if (functl%family == xc_family_libvdwxc) then
336 call libvdwxc_end(functl%libvdwxc)
337 end if
338
339 pop_sub(xc_functional_end)
340 end subroutine xc_functional_end
341
342
343 ! ---------------------------------------------------------
345 subroutine xc_functional_write_info(functl, iunit, namespace)
346 type(xc_functional_t), intent(in) :: functl
347 integer, optional, intent(in) :: iunit
348 type(namespace_t), optional, intent(in) :: namespace
349
350 character(len=1024) :: reference
351 character(len=120) :: family
352 integer :: ii, ind, istart, iend
353
355
356 if (functl%family == xc_family_oep) then
357 ! this is handled separately
358
359 select case (functl%id)
360 case (xc_oep_x)
361 write(message(1), '(2x,a)') 'Exchange'
362 write(message(2), '(4x,a)') 'Exact exchange'
363 call messages_info(2, iunit=iunit, namespace=namespace)
364
365 case(xc_oep_x_slater)
366 write(message(1), '(2x,a)') 'Exchange'
367 write(message(2), '(4x,a)') 'Slater exchange'
368 call messages_info(2, iunit=iunit, namespace=namespace)
369
370 case (xc_oep_x_fbe)
371 write(message(1), '(2x,a)') 'Exchange'
372 write(message(2), '(4x,a)') 'Force-based local exchange'
373 write(message(3), '(4x,a)') '[1] Tancogne-Dejean et al., J. Chem. Phys. 160, 024103 (2024)'
374 call messages_info(3, iunit=iunit, namespace=namespace)
375
376 case (xc_oep_x_fbe_sl)
377 write(message(1), '(2x,a)') 'Exchange'
378 write(message(2), '(4x,a)') 'Force-based local exchange - Sturm-Liouville'
379 call messages_info(2, iunit=iunit, namespace=namespace)
380
381 case (xc_lda_c_fbe_sl)
382 write(message(1), '(2x,a)') 'Correlation'
383 write(message(2), '(4x,a)') 'Force-based local-density correlation - Sturm-Liouville'
384 call messages_info(2, iunit=iunit, namespace=namespace)
385
386 case default
387 assert(.false.)
388 end select
389
390 else if ( functl%family == xc_family_rdmft) then
391 select case (functl%id)
392 case (xc_rdmft_xc_m)
393 write(message(1), '(2x,a)') 'RDMFT'
394 write(message(2), '(4x,a)') 'Mueller functional'
395 call messages_info(2, iunit=iunit, namespace=namespace)
396 end select
397
398 else if (functl%family == xc_family_ks_inversion) then
399 ! this is handled separately
400 select case (functl%id)
401 case (xc_ks_inversion)
402 write(message(1), '(2x,a)') 'Exchange-Correlation:'
403 write(message(2), '(4x,a)') ' KS Inversion'
404 call messages_info(2, iunit=iunit, namespace=namespace)
405 end select
406
407 else if (functl%family == xc_family_libvdwxc) then
408 call libvdwxc_write_info(functl%libvdwxc, iunit=iunit)
409
410 else if (functl%id == xc_mgga_x_nc_br) then
411 write(message(1), '(2x,a)') 'Exchange'
412 write(message(2), '(4x,a)') 'Noncollinear Becke-Roussel (MGGA)'
413 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, A. Rubio, and C. A. Ullrich, Phys. Rev. B 107, 165111 (2023)'
414 call messages_info(3, iunit)
415
416 else if (functl%id == xc_mgga_x_nc_br_1) then
417 write(message(1), '(2x,a)') 'Exchange'
418 write(message(2), '(4x,a)') 'Noncollinear Becke-Roussel, gamma = 1.0 (MGGA)'
419 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, A. Rubio, and C. A. Ullrich, Phys. Rev. B 107, 165111 (2023)'
420 call messages_info(3, iunit)
421
422 else if (functl%id == xc_mgga_x_nc_br_explicit) then
423 write(message(1), '(2x,a)') 'Exchange'
424 write(message(2), '(4x,a)') 'Noncollinear Becke-Roussel (MGGA) with explicit inversion of x(y)'
425 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, A. Rubio, and C. A. Ullrich, Phys. Rev. B 107, 165111 (2023)'
426 write(message(4), '(4x,a)') '[2] E. Proynov et al., Chemical Physics Letters 455, 103 (2008)'
427 call messages_info(4, iunit)
428
429 else if (functl%id == xc_mgga_c_nc_cs) then
430 write(message(1), '(2x,a)') 'Correlation'
431 write(message(2), '(4x,a)') 'Noncollinear Colle-Salvetti (MGGA)'
432 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, A. Rubio, and C. A. Ullrich, Phys. Rev. B 107, 165111 (2023)'
433 call messages_info(3, iunit)
434
435
436 else if (functl%id == xc_half_hartree) then
437 write(message(1), '(2x,a)') 'Exchange-Correlation:'
438 write(message(2), '(4x,a)') 'Half-Hartree two-electron exchange'
439 call messages_info(2, iunit=iunit, namespace=namespace)
440
441 else if(functl%id == xc_lda_c_fbe) then
442 write(message(1), '(2x,a)') 'Correlation'
443 write(message(2), '(4x,a)') 'Force-based LDA correlation'
444 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, M. Penz, M. Ruggenthaler, A. Rubio, J. Phys. Chem. A 129, 3132 (2025)'
445 call messages_info(3, iunit=iunit, namespace=namespace)
446
447 else if (functl%family /= xc_family_none) then ! all the other families
448 select case (functl%type)
449 case (xc_exchange)
450 write(message(1), '(2x,a)') 'Exchange'
451 case (xc_correlation)
452 write(message(1), '(2x,a)') 'Correlation'
453 case (xc_exchange_correlation)
454 write(message(1), '(2x,a)') 'Exchange-correlation'
455 case (xc_kinetic)
456 call messages_not_implemented("kinetic-energy functionals", namespace=namespace)
457 case default
458 write(message(1), '(a,i6,a,i6)') "Unknown functional type ", functl%type, ' for functional ', functl%id
459 call messages_fatal(1, namespace=namespace)
460 end select
461
462 select case (functl%family)
463 case (xc_family_lda)
464 write(family,'(a)') "LDA"
465 case (xc_family_gga)
466 write(family,'(a)') "GGA"
467 case (xc_family_mgga)
468 write(family,'(a)') "MGGA"
469 case (xc_family_lca)
470 call messages_not_implemented("Support of LCA functional", namespace=namespace)
471 case (xc_family_hyb_lda)
472 write(family,'(a)') "Hybrid LDA"
473 case (xc_family_hyb_gga)
474 write(family,'(a)') "Hybrid GGA"
475 case (xc_family_hyb_mgga)
476 write(family,'(a)') "Hybrid MGGA"
477 end select
478 write(message(2), '(4x,4a)') trim(xc_f03_func_info_get_name(functl%info)), ' (', trim(family), ')'
479 call messages_info(2, iunit=iunit, namespace=namespace)
480
481 ii = 0
482 do while(ii >= 0)
483 ! Preventing End of record error as message(1) has length of 256, and libxc returns 1024 characters
484 ind = ii + 1
485 write(reference, '(a)') trim(xc_f03_func_reference_get_ref(xc_f03_func_info_get_references(functl%info, ii)))
486 ! Some references are in fact notes, and references are void in this case
487 if (len_trim(reference) == 0) cycle
488 istart = 1
489 iend = len(message(1))-10
490 write(message(1), '(4x,a,i1,2a)') '[', ind, '] ', trim(reference(istart:iend))
491 call messages_info(1, iunit=iunit, namespace=namespace)
492 do while (iend < len_trim(reference))
493 istart = iend
494 iend = min(istart + len(message(1))-10, len_trim(reference))
495 write(message(1), '(7x,a)') trim(reference(istart:iend))
496 call messages_info(1, iunit=iunit, namespace=namespace)
497 end do
498 end do
499 end if
500
502 end subroutine xc_functional_write_info
503
504
506 integer function xc_get_default_functional(dim, pseudo_x_functional, pseudo_c_functional) result(default)
507 integer, intent(in) :: dim
508 integer, intent(in) :: pseudo_x_functional, pseudo_c_functional
509
511
512 default = 0
513
514 if (pseudo_x_functional /= pseudo_exchange_any) then
515 default = pseudo_x_functional
516 else
517 select case (dim)
518 case (3)
519 default = xc_lda_x
520 case (2)
521 default = xc_lda_x_2d
522 case (1)
523 default = xc_lda_x_1d_soft
524 end select
525 end if
526
527 assert(default >= 0)
528
529 if (pseudo_c_functional /= pseudo_correlation_any) then
530 default = default + libxc_c_index*pseudo_c_functional
531 else
532 select case (dim)
533 case (3)
534 default = default + libxc_c_index * xc_lda_c_pz_mod
535 case (2)
536 default = default + libxc_c_index * xc_lda_c_2d_amgb
537 case (1)
538 default = default + libxc_c_index * xc_lda_c_1d_csc
539 end select
540 end if
541
542 assert(default >= 0)
543
545 end function xc_get_default_functional
546
548 subroutine xc_check_dimension(functl, ndim, namespace)
549 type(xc_functional_t), intent(in) :: functl
550 integer, intent(in) :: ndim
551 type(namespace_t), intent(in) :: namespace
552
553 logical :: ok
554
555 push_sub(xc_check_dimension)
556
557 ! Check that the functional is used for the correct space dimension
558 ok = bitand(functl%flags, xc_flags_1d) /= 0
559 if (ndim == 1 .and. (.not. ok)) then
560 message(1) = 'Cannot use the specified functionals in 1D.'
561 call messages_fatal(1, namespace=namespace)
562 end if
563
564 ok = bitand(functl%flags, xc_flags_2d) /= 0
565 if (ndim == 2 .and. (.not. ok)) then
566 message(1) = 'Cannot use the specified functionals in 2D.'
567 call messages_fatal(1, namespace=namespace)
568 end if
569
570 ok = bitand(functl%flags, xc_flags_3d) /= 0
571 if (ndim == 3 .and. (.not. ok)) then
572 message(1) = 'Cannot use the specified functionals in 3D.'
573 call messages_fatal(1, namespace=namespace)
574 end if
575
576 pop_sub(xc_check_dimension)
577 end subroutine xc_check_dimension
578
580 logical function xc_functional_is_not_size_consistent(functl, namespace)
581 type(xc_functional_t), intent(in) :: functl
582 type(namespace_t), intent(in) :: namespace
583
584 integer :: n_ext_params, ip
585 character(len=128) :: ext_params_name
586
588 if (.not. functl%from_libxc) return
589
591
592 ! External parameters
593 n_ext_params = xc_f03_func_info_get_n_ext_params(functl%info)
594 do ip = 0, n_ext_params-1
595 ext_params_name = xc_f03_func_info_get_ext_params_name(functl%info, ip)
596 ! Internal parameters starts with '_'
597 if (ext_params_name(1:1) == '_') cycle
598 if (trim(xc_f03_func_info_get_ext_params_description(functl%info, ip)) == 'Number of electrons') then
600 end if
601 end do
602
603 ! We only support size inconsistent functionals with a single parameter at the moment
604 if (xc_functional_is_not_size_consistent .and. n_ext_params > 1) then
605 message(1) = 'The selected functional is currently not supported.'
606 call messages_fatal(1, namespace=namespace)
607 end if
608
611
612 logical pure function xc_functional_is_energy_functional(functl)
613 type(xc_functional_t), intent(in) :: functl
614
615 xc_functional_is_energy_functional = bitand(functl%flags, xc_flags_have_exc) /= 0
617
618end module xc_functional_oct_m
619
620!! Local Variables:
621!! mode: f90
622!! coding: utf-8
623!! End:
real(real64), parameter, public m_one
Definition: global.F90:191
subroutine, public libvdwxc_end(this)
Definition: libvdwxc.F90:462
subroutine, public libvdwxc_init(libvdwxc, namespace, functional)
Definition: libvdwxc.F90:163
subroutine, public libvdwxc_write_info(this, iunit, namespace)
Definition: libvdwxc.F90:209
subroutine, public messages_not_implemented(feature, namespace)
Definition: messages.F90:1097
subroutine, public messages_warning(no_lines, all_nodes, namespace)
Definition: messages.F90:531
subroutine, public messages_obsolete_variable(namespace, name, rep)
Definition: messages.F90:1029
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
Definition: messages.F90:162
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
Definition: messages.F90:416
subroutine, public messages_input_error(namespace, var, details, row, column)
Definition: messages.F90:697
subroutine, public messages_experimental(name, namespace)
Definition: messages.F90:1069
subroutine, public messages_info(no_lines, iunit, debug_only, stress, all_nodes, namespace)
Definition: messages.F90:600
logical function, public parse_is_defined(namespace, name)
Definition: parser.F90:505
integer, parameter, public pseudo_correlation_any
Definition: pseudo.F90:194
integer, parameter, public pseudo_exchange_any
Definition: pseudo.F90:190
integer, parameter, public xc_ks_inversion
inversion of Kohn-Sham potential
integer, parameter, public xc_vdw_c_vdwdf
vdw-df correlation from libvdwxc
integer, parameter, public xc_family_rdmft
subroutine, public xc_functional_write_info(functl, iunit, namespace)
Write functional information.
integer function, public xc_get_default_functional(dim, pseudo_x_functional, pseudo_c_functional)
Returns the default functional given the one parsed from the pseudopotentials and the space dimension...
integer, parameter, public xc_mgga_c_nc_cs
Noncollinear version of the Colle-Salvetti correlation functional.
integer, parameter, public xc_hyb_gga_xc_mvorb_pbeh
Density-based mixing parameter of PBE0.
integer, parameter, public xc_mgga_x_nc_br
Noncollinear version of the Becke-Roussel functional.
integer, parameter, public xc_vdw_c_vdwdfcx
vdw-df-cx correlation from libvdwxc
subroutine, public xc_functional_init(functl, namespace, id, ndim, nel, spin_channels)
integer, parameter, public xc_lda_c_fbe
LDA correlation based ib the force-balance equation.
integer, parameter, public xc_family_nc_mgga
integer, parameter, public xc_half_hartree
half-Hartree exchange for two electrons (supports complex scaling)
integer, parameter, public xc_vdw_c_vdwdf2
vdw-df2 correlation from libvdwxc
subroutine xc_check_dimension(functl, ndim, namespace)
Check that the selected functional is compatible with the space dimension.
integer, parameter, public xc_family_libvdwxc
integer, parameter, public xc_hyb_gga_xc_mvorb_hse06
Density-based mixing parameter of HSE06.
subroutine, public xc_functional_end(functl)
integer, parameter, public xc_lda_c_fbe_sl
LDA correlation based ib the force-balance equation - Sturm-Liouville version.
integer, parameter, public xc_rdmft_xc_m
RDMFT Mueller functional.
integer, parameter, public xc_mgga_x_nc_br_1
Noncollinear version of the Becke-Roussel functional, gamma=1.
logical function, public xc_functional_is_not_size_consistent(functl, namespace)
Does the functional depend on the number of electrons or not.
integer, parameter, public xc_mgga_x_nc_br_explicit
Noncollinear version of the Becke-Roussel functional.
integer, parameter, public xc_family_nc_lda
integer, parameter, public xc_oep_x_fbe_sl
Exchange approximation based on the force balance equation - Sturn-Liouville version.
integer, parameter, public xc_oep_x_fbe
Exchange approximation based on the force balance equation.
logical pure function, public xc_functional_is_energy_functional(functl)
integer, parameter, public xc_oep_x_slater
Slater approximation to the exact exchange.
int true(void)