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
116 push_sub(xc_functional_init)
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 ! FIXME: aren`t there other parameters that can or should be set?
243 ! special parameters that have to be configured
244 select case (functl%id)
245 ! FIXME: aren`t there other Xalpha functionals?
246 case (xc_lda_c_xalpha)
247
248 !%Variable Xalpha
249 !%Type float
250 !%Default 1.0
251 !%Section Hamiltonian::XC
252 !%Description
253 !% The parameter of the Slater X<math>\alpha</math> functional. Applies only for
254 !% <tt>XCFunctional = xc_lda_c_xalpha</tt>.
255 !%End
256 call parse_variable(namespace, 'Xalpha', m_one, parameters(1))
257
258 call xc_f03_func_set_ext_params(functl%conf, parameters(1))
259
260 ! FIXME: doesn`t this apply to other 1D functionals?
261 case (xc_lda_x_1d_soft, xc_lda_c_1d_csc)
262 !%Variable Interaction1D
263 !%Type integer
264 !%Default interaction_soft_coulomb
265 !%Section Hamiltonian::XC
266 !%Description
267 !% When running in 1D, one has to soften the Coulomb interaction. This softening
268 !% is not unique, and several possibilities exist in the literature.
269 !%Option interaction_exp_screened 0
270 !% Exponentially screened Coulomb interaction.
271 !% See, <i>e.g.</i>, M Casula, S Sorella, and G Senatore, <i>Phys. Rev. B</i> <b>74</b>, 245427 (2006).
272 !%Option interaction_soft_coulomb 1
273 !% Soft Coulomb interaction of the form <math>1/\sqrt{x^2 + \alpha^2}</math>.
274 !%End
275 call messages_obsolete_variable(namespace, 'SoftInteraction1D_alpha', 'Interaction1D')
276 call parse_variable(namespace, 'Interaction1D', option__interaction1d__interaction_soft_coulomb, interact_1d)
277
278 !%Variable Interaction1DScreening
279 !%Type float
280 !%Default 1.0
281 !%Section Hamiltonian::XC
282 !%Description
283 !% Defines the screening parameter <math>\alpha</math> of the softened Coulomb interaction
284 !% when running in 1D.
285 !%End
286 call messages_obsolete_variable(namespace, 'SoftInteraction1D_alpha', 'Interaction1DScreening')
287 call parse_variable(namespace, 'Interaction1DScreening', m_one, alpha)
288 parameters(1) = real(interact_1d, real64)
289 parameters(2) = alpha
290 call xc_f03_func_set_ext_params(functl%conf, parameters(1))
291
292 case (xc_gga_x_lb)
293 if (parse_is_defined(namespace, 'LB94_modified')) then
294 call messages_obsolete_variable(namespace, 'LB94_modified')
295 end if
296
297 if (parse_is_defined(namespace, 'LB94_threshold')) then
298 call messages_obsolete_variable(namespace, 'LB94_threshold')
299 end if
300 end select
301
302
303 ! For functionals that depend on the number of electrons, we set the number of electrons
304 ! This is currently the case of GGA_K_TFLW, LDA_X_2D_PRM, and LDA_X_RAE
305 if (xc_functional_is_not_size_consistent(functl, namespace)) then
306 assert(xc_f03_func_info_get_n_ext_params(functl%info) == 1)
307 parameters(1) = nel
308 call xc_f03_func_set_ext_params(functl%conf, parameters(1))
309 write(message(1), '(a,i1)') "Info: Setting the number of electrons for the functional for spin ", spin_channels
310 call messages_info(1, namespace=namespace)
311 end if
312
313 pop_sub(xc_functional_init)
314 end subroutine xc_functional_init
315
316
317 ! ---------------------------------------------------------
318 subroutine xc_functional_end(functl)
319 type(xc_functional_t), intent(inout) :: functl
320
321 push_sub(xc_functional_end)
322
323 if (functl%family /= xc_family_none .and. functl%family /= xc_family_oep .and. &
324 functl%family /= xc_family_ks_inversion .and. functl%id /= xc_half_hartree &
325 .and. functl%id /= xc_lda_c_fbe &
326 .and. functl%family /= xc_family_nc_lda .and. functl%family /= xc_family_nc_mgga) then
327 call xc_f03_func_end(functl%conf)
328 end if
329
330 if (functl%family == xc_family_libvdwxc) then
331 call libvdwxc_end(functl%libvdwxc)
332 end if
333
334 pop_sub(xc_functional_end)
335 end subroutine xc_functional_end
336
337
338 ! ---------------------------------------------------------
340 subroutine xc_functional_write_info(functl, iunit, namespace)
341 type(xc_functional_t), intent(in) :: functl
342 integer, optional, intent(in) :: iunit
343 type(namespace_t), optional, intent(in) :: namespace
344
345 character(len=120) :: family
346 integer :: ii
347
349
350 if (functl%family == xc_family_oep) then
351 ! this is handled separately
352
353 select case (functl%id)
354 case (xc_oep_x)
355 write(message(1), '(2x,a)') 'Exchange'
356 write(message(2), '(4x,a)') 'Exact exchange'
357 call messages_info(2, iunit=iunit, namespace=namespace)
358
359 case(xc_oep_x_slater)
360 write(message(1), '(2x,a)') 'Exchange'
361 write(message(2), '(4x,a)') 'Slater exchange'
362 call messages_info(2, iunit=iunit, namespace=namespace)
363
364 case (xc_oep_x_fbe)
365 write(message(1), '(2x,a)') 'Exchange'
366 write(message(2), '(4x,a)') 'Force-based local exchange'
367 write(message(3), '(4x,a)') '[1] Tancogne-Dejean et al., J. Chem. Phys. 160, 024103 (2024)'
368 call messages_info(3, iunit=iunit, namespace=namespace)
369
370 case (xc_oep_x_fbe_sl)
371 write(message(1), '(2x,a)') 'Exchange'
372 write(message(2), '(4x,a)') 'Force-based local exchange - Sturm-Liouville'
373 call messages_info(2, iunit=iunit, namespace=namespace)
374
375 case (xc_lda_c_fbe_sl)
376 write(message(1), '(2x,a)') 'Correlation'
377 write(message(2), '(4x,a)') 'Force-based local-density correlation - Sturm-Liouville'
378 call messages_info(2, iunit=iunit, namespace=namespace)
379
380 case default
381 assert(.false.)
382 end select
383
384 else if (functl%family == xc_family_ks_inversion) then
385 ! this is handled separately
386 select case (functl%id)
387 case (xc_ks_inversion)
388 write(message(1), '(2x,a)') 'Exchange-Correlation:'
389 write(message(2), '(4x,a)') ' KS Inversion'
390 call messages_info(2, iunit=iunit, namespace=namespace)
391 end select
392
393 else if (functl%family == xc_family_libvdwxc) then
394 call libvdwxc_write_info(functl%libvdwxc, iunit=iunit)
395
396 else if (functl%id == xc_mgga_x_nc_br) then
397 write(message(1), '(2x,a)') 'Exchange'
398 write(message(2), '(4x,a)') 'Noncollinear Becke-Roussel (MGGA)'
399 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, A. Rubio, and C. A. Ullrich, Phys. Rev. B 107, 165111 (2023)'
400 call messages_info(3, iunit)
401
402 else if (functl%id == xc_mgga_x_nc_br_1) then
403 write(message(1), '(2x,a)') 'Exchange'
404 write(message(2), '(4x,a)') 'Noncollinear Becke-Roussel, gamma = 1.0 (MGGA)'
405 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, A. Rubio, and C. A. Ullrich, Phys. Rev. B 107, 165111 (2023)'
406 call messages_info(3, iunit)
407
408 else if (functl%id == xc_mgga_x_nc_br_explicit) then
409 write(message(1), '(2x,a)') 'Exchange'
410 write(message(2), '(4x,a)') 'Noncollinear Becke-Roussel (MGGA) with explicit inversion of x(y)'
411 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, A. Rubio, and C. A. Ullrich, Phys. Rev. B 107, 165111 (2023)'
412 write(message(4), '(4x,a)') '[2] E. Proynov et al., Chemical Physics Letters 455, 103 (2008)'
413 call messages_info(4, iunit)
414
415 else if (functl%id == xc_mgga_c_nc_cs) then
416 write(message(1), '(2x,a)') 'Correlation'
417 write(message(2), '(4x,a)') 'Noncollinear Colle-Salvetti (MGGA)'
418 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, A. Rubio, and C. A. Ullrich, Phys. Rev. B 107, 165111 (2023)'
419 call messages_info(3, iunit)
420
421
422 else if (functl%id == xc_half_hartree) then
423 write(message(1), '(2x,a)') 'Exchange-Correlation:'
424 write(message(2), '(4x,a)') 'Half-Hartree two-electron exchange'
425 call messages_info(2, iunit=iunit, namespace=namespace)
426
427 else if(functl%id == xc_lda_c_fbe) then
428 write(message(1), '(2x,a)') 'Correlation'
429 write(message(2), '(4x,a)') 'Force-based LDA correlation'
430 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, M. Penz, M. Ruggenthaler, A. Rubio, J. Phys. Chem. A 129, 3132 (2025)'
431 call messages_info(3, iunit=iunit, namespace=namespace)
432
433 else if (functl%family /= xc_family_none) then ! all the other families
434 select case (functl%type)
435 case (xc_exchange)
436 write(message(1), '(2x,a)') 'Exchange'
437 case (xc_correlation)
438 write(message(1), '(2x,a)') 'Correlation'
439 case (xc_exchange_correlation)
440 write(message(1), '(2x,a)') 'Exchange-correlation'
441 case (xc_kinetic)
442 call messages_not_implemented("kinetic-energy functionals", namespace=namespace)
443 case default
444 write(message(1), '(a,i6,a,i6)') "Unknown functional type ", functl%type, ' for functional ', functl%id
445 call messages_fatal(1, namespace=namespace)
446 end select
447
448 select case (functl%family)
449 case (xc_family_lda)
450 write(family,'(a)') "LDA"
451 case (xc_family_gga)
452 write(family,'(a)') "GGA"
453 case (xc_family_mgga)
454 write(family,'(a)') "MGGA"
455 case (xc_family_lca)
456 call messages_not_implemented("Support of LCA functional", namespace=namespace)
457 case (xc_family_hyb_lda)
458 write(family,'(a)') "Hybrid LDA"
459 case (xc_family_hyb_gga)
460 write(family,'(a)') "Hybrid GGA"
461 case (xc_family_hyb_mgga)
462 write(family,'(a)') "Hybrid MGGA"
463 end select
464 write(message(2), '(4x,4a)') trim(xc_f03_func_info_get_name(functl%info)), ' (', trim(family), ')'
465 call messages_info(2, iunit=iunit, namespace=namespace)
466
467 ii = 0
468 do while(ii >= 0)
469 write(message(1), '(4x,a,i1,2a)') '[', ii + 1, '] ', &
470 trim(xc_f03_func_reference_get_ref(xc_f03_func_info_get_references(functl%info, ii)))
471 call messages_info(1, iunit=iunit, namespace=namespace)
472 end do
473 end if
474
476 end subroutine xc_functional_write_info
477
478
480 integer function xc_get_default_functional(dim, pseudo_x_functional, pseudo_c_functional) result(default)
481 integer, intent(in) :: dim
482 integer, intent(in) :: pseudo_x_functional, pseudo_c_functional
483
485
486 default = 0
487
488 if (pseudo_x_functional /= pseudo_exchange_any) then
489 default = pseudo_x_functional
490 else
491 select case (dim)
492 case (3)
493 default = xc_lda_x
494 case (2)
495 default = xc_lda_x_2d
496 case (1)
497 default = xc_lda_x_1d_soft
498 end select
499 end if
500
501 assert(default >= 0)
502
503 if (pseudo_c_functional /= pseudo_correlation_any) then
504 default = default + libxc_c_index*pseudo_c_functional
505 else
506 select case (dim)
507 case (3)
508 default = default + libxc_c_index * xc_lda_c_pz_mod
509 case (2)
510 default = default + libxc_c_index * xc_lda_c_2d_amgb
511 case (1)
512 default = default + libxc_c_index * xc_lda_c_1d_csc
513 end select
514 end if
515
516 assert(default >= 0)
517
519 end function xc_get_default_functional
520
522 subroutine xc_check_dimension(functl, ndim, namespace)
523 type(xc_functional_t), intent(in) :: functl
524 integer, intent(in) :: ndim
525 type(namespace_t), intent(in) :: namespace
526
527 logical :: ok
528
529 push_sub(xc_check_dimension)
530
531 ! Check that the functional is used for the correct space dimension
532 ok = bitand(functl%flags, xc_flags_1d) /= 0
533 if (ndim == 1 .and. (.not. ok)) then
534 message(1) = 'Cannot use the specified functionals in 1D.'
535 call messages_fatal(1, namespace=namespace)
536 end if
537
538 ok = bitand(functl%flags, xc_flags_2d) /= 0
539 if (ndim == 2 .and. (.not. ok)) then
540 message(1) = 'Cannot use the specified functionals in 2D.'
541 call messages_fatal(1, namespace=namespace)
542 end if
543
544 ok = bitand(functl%flags, xc_flags_3d) /= 0
545 if (ndim == 3 .and. (.not. ok)) then
546 message(1) = 'Cannot use the specified functionals in 3D.'
547 call messages_fatal(1, namespace=namespace)
548 end if
549
550 pop_sub(xc_check_dimension)
551 end subroutine xc_check_dimension
552
554 logical function xc_functional_is_not_size_consistent(functl, namespace)
555 type(xc_functional_t), intent(in) :: functl
556 type(namespace_t), intent(in) :: namespace
557
558 integer :: n_ext_params, ip
559 character(len=128) :: ext_params_name
560
562 if (.not. functl%from_libxc) return
563
565
566 ! External parameters
567 n_ext_params = xc_f03_func_info_get_n_ext_params(functl%info)
568 do ip = 0, n_ext_params-1
569 ext_params_name = xc_f03_func_info_get_ext_params_name(functl%info, ip)
570 ! Internal parameters starts with '_'
571 if (ext_params_name(1:1) == '_') cycle
572 if (trim(xc_f03_func_info_get_ext_params_description(functl%info, ip)) == 'Number of electrons') then
574 end if
575 end do
576
577 ! We only support size inconsistent functionals with a single parameter at the moment
578 if (xc_functional_is_not_size_consistent .and. n_ext_params > 1) then
579 message(1) = 'The selected functional is currently not supported.'
580 call messages_fatal(1, namespace=namespace)
581 end if
582
585
586 logical pure function xc_functional_is_energy_functional(functl)
587 type(xc_functional_t), intent(in) :: functl
588
589 xc_functional_is_energy_functional = bitand(functl%flags, xc_flags_have_exc) /= 0
591
592end module xc_functional_oct_m
593
594!! Local Variables:
595!! mode: f90
596!! coding: utf-8
597!! End:
real(real64), parameter, public m_one
Definition: global.F90:189
subroutine, public libvdwxc_end(this)
Definition: libvdwxc.F90:481
subroutine, public libvdwxc_init(libvdwxc, namespace, functional)
Definition: libvdwxc.F90:161
subroutine, public libvdwxc_write_info(this, iunit, namespace)
Definition: libvdwxc.F90:207
subroutine, public messages_not_implemented(feature, namespace)
Definition: messages.F90:1113
subroutine, public messages_warning(no_lines, all_nodes, namespace)
Definition: messages.F90:537
subroutine, public messages_obsolete_variable(namespace, name, rep)
Definition: messages.F90:1045
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
Definition: messages.F90:160
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
Definition: messages.F90:414
subroutine, public messages_input_error(namespace, var, details, row, column)
Definition: messages.F90:713
subroutine, public messages_experimental(name, namespace)
Definition: messages.F90:1085
subroutine, public messages_info(no_lines, iunit, debug_only, stress, all_nodes, namespace)
Definition: messages.F90:616
logical function, public parse_is_defined(namespace, name)
Definition: parser.F90:502
integer, parameter, public pseudo_correlation_any
Definition: pseudo.F90:192
integer, parameter, public pseudo_exchange_any
Definition: pseudo.F90:188
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)