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_vdw_c_vdwdf = 918, &
64 xc_vdw_c_vdwdf2 = 919, &
65 xc_vdw_c_vdwdfcx = 920, &
68 xc_mgga_x_nc_br = 923, &
69 xc_mgga_x_nc_br_1 = 924, &
70 xc_mgga_c_nc_cs = 925, &
72 ! !! with an explicit inversion of x(y), gamma = 0.8
73
76 integer, public, parameter :: &
77 XC_FAMILY_KS_INVERSION = 1024, &
78 xc_family_rdmft = 2048, &
79 xc_family_libvdwxc = 4096, &
80 xc_family_nc_lda = 8192, &
81 xc_family_nc_mgga = 16384
82
84 ! Components are public by default
85 integer :: family = xc_family_unknown
86 integer :: type = 0
87 integer :: id = 0
88
89 integer :: spin_channels = 0
90 integer :: flags = 0
91
92 logical, private :: from_libxc = .false.
93
94 type(xc_f03_func_t) :: conf
95 type(xc_f03_func_info_t), private :: info
96 type(libvdwxc_t) :: libvdwxc
97 end type xc_functional_t
98
99 integer, public, parameter :: LIBXC_C_INDEX = 1000
100
101contains
102
103 ! ---------------------------------------------------------
104 subroutine xc_functional_init(functl, namespace, id, ndim, nel, spin_channels)
105 type(xc_functional_t), intent(inout) :: functl
106 type(namespace_t), intent(in) :: namespace
107 integer, intent(in) :: id
108 integer, intent(in) :: ndim
109 real(real64), intent(in) :: nel
110 integer, intent(in) :: spin_channels
111
112 integer :: interact_1d
113 real(real64) :: alpha, parameters(2)
114
115 push_sub(xc_functional_init)
117 ! initialize structure
118 functl%id = id
119 functl%spin_channels = spin_channels
120
121 if (functl%id == 0) then
122 functl%family = xc_family_none
123 else
124 ! get the family of the functional
125 functl%family = xc_f03_family_from_id(functl%id)
126 ! this also ensures it is actually a functional defined by the linked version of libxc
127
128 if (functl%family == xc_family_unknown) then
129
130 select case (functl%id)
132 functl%family = xc_family_oep
133
134 case (xc_ks_inversion)
135 functl%family = xc_family_ks_inversion
136
138 functl%family = xc_family_libvdwxc
139 !functl%flags = functl%flags + XC_FLAGS_HAVE_VXC + XC_FLAGS_HAVE_EXC
140
141 case (xc_rdmft_xc_m)
142 functl%family = xc_family_rdmft
143
145 functl%family = xc_family_hyb_gga
146
148 functl%family = xc_family_nc_mgga
149
150 case default
151 call messages_input_error(namespace, 'XCFunctional', 'Unknown functional')
152
153 end select
154 end if
155 end if
156
157 if (functl%family == xc_family_oep) then
158 functl%type = xc_exchange
159 functl%flags = xc_flags_1d + xc_flags_2d + xc_flags_3d
160
161 else if (functl%family == xc_family_ks_inversion .or. functl%family == xc_family_rdmft) then
162 functl%type = xc_exchange_correlation
163 functl%flags = xc_flags_1d + xc_flags_2d + xc_flags_3d
164
165 else if (functl%family == xc_family_libvdwxc) then
166 call xc_f03_func_init(functl%conf, xc_lda_c_pw, spin_channels)
167 functl%info = xc_f03_func_get_info(functl%conf)
168 functl%type = xc_f03_func_info_get_kind(functl%info)
169 functl%flags = xc_f03_func_info_get_flags(functl%info)
170 ! Convert Octopus code for functional into corresponding libvdwxc code:
171 call libvdwxc_init(functl%libvdwxc, namespace, functl%id - xc_vdw_c_vdwdf + 1)
172
173 else if(functl%id == xc_lda_c_fbe) then
174 functl%family = xc_family_lda
175 functl%type = xc_correlation
176 functl%flags = xc_flags_have_exc + xc_flags_have_vxc + xc_flags_3d
177
178 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
179 functl%type = xc_exchange
180 functl%flags = xc_flags_have_vxc + xc_flags_have_exc + xc_flags_3d
181
182 else if(functl%id == xc_mgga_c_nc_cs) then
183 functl%type = xc_correlation
184 functl%flags = xc_flags_have_vxc + xc_flags_have_exc + xc_flags_3d
185
186 else if (functl%family == xc_family_none) then
187 functl%type = -1
188 functl%flags = xc_flags_1d + xc_flags_2d + xc_flags_3d
189
190 else ! handled by libxc
191 ! initialize
192 functl%from_libxc = .true.
193
194 !For the two MVORB functionals, we initialize libxc with the non-MVORB functionals
195 select case (functl%id)
197 call xc_f03_func_init(functl%conf, xc_hyb_gga_xc_hse06, spin_channels)
198
200 call xc_f03_func_init(functl%conf, xc_hyb_gga_xc_pbeh, spin_channels)
201
202 case default
203 call xc_f03_func_init(functl%conf, functl%id, spin_channels)
204 end select
205 functl%info = xc_f03_func_get_info(functl%conf)
206 functl%type = xc_f03_func_info_get_kind(functl%info)
207 functl%flags = xc_f03_func_info_get_flags(functl%info)
208
209 ! FIXME: no need to say this for kernel
210 if (bitand(functl%flags, xc_flags_have_exc) == 0) then
211 message(1) = 'Specified functional does not have total energy available.'
212 message(2) = 'Corresponding component of energy will just be left as zero.'
213 call messages_warning(2, namespace=namespace)
214 end if
215
216 if (bitand(functl%flags, xc_flags_have_vxc) == 0) then
217 message(1) = 'Specified functional does not have XC potential available.'
218 message(2) = 'Cannot run calculations. Choose another XCFunctional.'
219 call messages_fatal(2, namespace=namespace)
220 end if
221 end if
222
223 ! Octopus-defined functionals need to provide the proper flags
224 if (functl%family /= xc_family_none) then
225 call xc_check_dimension(functl, ndim, namespace)
226 end if
227
228 ! Yukawa hybrids not supported yet
229 if (bitand(functl%flags, xc_flags_hyb_camy) /= 0) then
230 call messages_not_implemented("Yukawa-range separated hybrids", namespace=namespace)
231 end if
232
233 ! VV10 correlations not supported yet
234 if (bitand(functl%flags, xc_flags_vv10) /= 0) then
235 call messages_not_implemented("VV10 correlation functionals", namespace=namespace)
236 end if
237
238 ! FIXME: aren`t there other parameters that can or should be set?
239 ! special parameters that have to be configured
240 select case (functl%id)
241 ! FIXME: aren`t there other Xalpha functionals?
242 case (xc_lda_c_xalpha)
243
244 !%Variable Xalpha
245 !%Type float
246 !%Default 1.0
247 !%Section Hamiltonian::XC
248 !%Description
249 !% The parameter of the Slater X<math>\alpha</math> functional. Applies only for
250 !% <tt>XCFunctional = xc_lda_c_xalpha</tt>.
251 !%End
252 call parse_variable(namespace, 'Xalpha', m_one, parameters(1))
253
254 call xc_f03_func_set_ext_params(functl%conf, parameters(1))
255
256 ! FIXME: doesn`t this apply to other 1D functionals?
257 case (xc_lda_x_1d_soft, xc_lda_c_1d_csc)
258 !%Variable Interaction1D
259 !%Type integer
260 !%Default interaction_soft_coulomb
261 !%Section Hamiltonian::XC
262 !%Description
263 !% When running in 1D, one has to soften the Coulomb interaction. This softening
264 !% is not unique, and several possibilities exist in the literature.
265 !%Option interaction_exp_screened 0
266 !% Exponentially screened Coulomb interaction.
267 !% See, <i>e.g.</i>, M Casula, S Sorella, and G Senatore, <i>Phys. Rev. B</i> <b>74</b>, 245427 (2006).
268 !%Option interaction_soft_coulomb 1
269 !% Soft Coulomb interaction of the form <math>1/\sqrt{x^2 + \alpha^2}</math>.
270 !%End
271 call messages_obsolete_variable(namespace, 'SoftInteraction1D_alpha', 'Interaction1D')
272 call parse_variable(namespace, 'Interaction1D', option__interaction1d__interaction_soft_coulomb, interact_1d)
273
274 !%Variable Interaction1DScreening
275 !%Type float
276 !%Default 1.0
277 !%Section Hamiltonian::XC
278 !%Description
279 !% Defines the screening parameter <math>\alpha</math> of the softened Coulomb interaction
280 !% when running in 1D.
281 !%End
282 call messages_obsolete_variable(namespace, 'SoftInteraction1D_alpha', 'Interaction1DScreening')
283 call parse_variable(namespace, 'Interaction1DScreening', m_one, alpha)
284 parameters(1) = real(interact_1d, real64)
285 parameters(2) = alpha
286 call xc_f03_func_set_ext_params(functl%conf, parameters(1))
287
288 case (xc_gga_x_lb)
289 if (parse_is_defined(namespace, 'LB94_modified')) then
290 call messages_obsolete_variable(namespace, 'LB94_modified')
291 end if
292
293 if (parse_is_defined(namespace, 'LB94_threshold')) then
294 call messages_obsolete_variable(namespace, 'LB94_threshold')
295 end if
296 end select
297
298
299 ! For functionals that depend on the number of electrons, we set the number of electrons
300 ! This is currently the case of GGA_K_TFLW, LDA_X_2D_PRM, and LDA_X_RAE
301 if (xc_functional_is_not_size_consistent(functl, namespace)) then
302 assert(xc_f03_func_info_get_n_ext_params(functl%info) == 1)
303 parameters(1) = nel
304 call xc_f03_func_set_ext_params(functl%conf, parameters(1))
305 write(message(1), '(a,i1)') "Info: Setting the number of electrons for the functional for spin ", spin_channels
306 call messages_info(1, namespace=namespace)
307 end if
308
309 pop_sub(xc_functional_init)
310 end subroutine xc_functional_init
311
312
313 ! ---------------------------------------------------------
314 subroutine xc_functional_end(functl)
315 type(xc_functional_t), intent(inout) :: functl
316
317 push_sub(xc_functional_end)
318
319 if (functl%family /= xc_family_none .and. functl%family /= xc_family_oep .and. &
320 functl%family /= xc_family_ks_inversion .and. functl%id /= xc_lda_c_fbe &
321 .and. functl%family /= xc_family_nc_lda .and. functl%family /= xc_family_nc_mgga) then
322 call xc_f03_func_end(functl%conf)
323 end if
324
325 if (functl%family == xc_family_libvdwxc) then
326 call libvdwxc_end(functl%libvdwxc)
327 end if
328
329 pop_sub(xc_functional_end)
330 end subroutine xc_functional_end
331
332
333 ! ---------------------------------------------------------
335 subroutine xc_functional_write_info(functl, iunit, namespace)
336 type(xc_functional_t), intent(in) :: functl
337 integer, optional, intent(in) :: iunit
338 type(namespace_t), optional, intent(in) :: namespace
339
340 character(len=1024) :: reference
341 character(len=120) :: family
342 integer :: ii, ind, istart, iend
343
345
346 if (functl%family == xc_family_oep) then
347 ! this is handled separately
348
349 select case (functl%id)
350 case (xc_oep_x)
351 write(message(1), '(2x,a)') 'Exchange'
352 write(message(2), '(4x,a)') 'Exact exchange'
353 call messages_info(2, iunit=iunit, namespace=namespace)
354
355 case(xc_oep_x_slater)
356 write(message(1), '(2x,a)') 'Exchange'
357 write(message(2), '(4x,a)') 'Slater exchange'
358 call messages_info(2, iunit=iunit, namespace=namespace)
359
360 case (xc_oep_x_fbe)
361 write(message(1), '(2x,a)') 'Exchange'
362 write(message(2), '(4x,a)') 'Force-based local exchange'
363 write(message(3), '(4x,a)') '[1] Tancogne-Dejean et al., J. Chem. Phys. 160, 024103 (2024)'
364 call messages_info(3, iunit=iunit, namespace=namespace)
365
366 case (xc_oep_x_fbe_sl)
367 write(message(1), '(2x,a)') 'Exchange'
368 write(message(2), '(4x,a)') 'Force-based local exchange - Sturm-Liouville'
369 call messages_info(2, iunit=iunit, namespace=namespace)
370
371 case (xc_lda_c_fbe_sl)
372 write(message(1), '(2x,a)') 'Correlation'
373 write(message(2), '(4x,a)') 'Force-based local-density correlation - Sturm-Liouville'
374 call messages_info(2, iunit=iunit, namespace=namespace)
375
376 case default
377 assert(.false.)
378 end select
379
380 else if ( functl%family == xc_family_rdmft) then
381 select case (functl%id)
382 case (xc_rdmft_xc_m)
383 write(message(1), '(2x,a)') 'RDMFT'
384 write(message(2), '(4x,a)') 'Mueller functional'
385 call messages_info(2, iunit=iunit, namespace=namespace)
386 end select
387
388 else if (functl%family == xc_family_ks_inversion) then
389 ! this is handled separately
390 select case (functl%id)
391 case (xc_ks_inversion)
392 write(message(1), '(2x,a)') 'Exchange-Correlation:'
393 write(message(2), '(4x,a)') ' KS Inversion'
394 call messages_info(2, iunit=iunit, namespace=namespace)
395 end select
396
397 else if (functl%family == xc_family_libvdwxc) then
398 call libvdwxc_write_info(functl%libvdwxc, iunit=iunit)
399
400 else if (functl%id == xc_mgga_x_nc_br) then
401 write(message(1), '(2x,a)') 'Exchange'
402 write(message(2), '(4x,a)') 'Noncollinear Becke-Roussel (MGGA)'
403 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, A. Rubio, and C. A. Ullrich, Phys. Rev. B 107, 165111 (2023)'
404 call messages_info(3, iunit)
405
406 else if (functl%id == xc_mgga_x_nc_br_1) then
407 write(message(1), '(2x,a)') 'Exchange'
408 write(message(2), '(4x,a)') 'Noncollinear Becke-Roussel, gamma = 1.0 (MGGA)'
409 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, A. Rubio, and C. A. Ullrich, Phys. Rev. B 107, 165111 (2023)'
410 call messages_info(3, iunit)
411
412 else if (functl%id == xc_mgga_x_nc_br_explicit) then
413 write(message(1), '(2x,a)') 'Exchange'
414 write(message(2), '(4x,a)') 'Noncollinear Becke-Roussel (MGGA) with explicit inversion of x(y)'
415 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, A. Rubio, and C. A. Ullrich, Phys. Rev. B 107, 165111 (2023)'
416 write(message(4), '(4x,a)') '[2] E. Proynov et al., Chemical Physics Letters 455, 103 (2008)'
417 call messages_info(4, iunit)
418
419 else if (functl%id == xc_mgga_c_nc_cs) then
420 write(message(1), '(2x,a)') 'Correlation'
421 write(message(2), '(4x,a)') 'Noncollinear Colle-Salvetti (MGGA)'
422 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, A. Rubio, and C. A. Ullrich, Phys. Rev. B 107, 165111 (2023)'
423 call messages_info(3, iunit)
424
425 else if(functl%id == xc_lda_c_fbe) then
426 write(message(1), '(2x,a)') 'Correlation'
427 write(message(2), '(4x,a)') 'Force-based LDA correlation'
428 write(message(3), '(4x,a)') '[1] N. Tancogne-Dejean, M. Penz, M. Ruggenthaler, A. Rubio, J. Phys. Chem. A 129, 3132 (2025)'
429 call messages_info(3, iunit=iunit, namespace=namespace)
430
431 else if (functl%family /= xc_family_none) then ! all the other families
432 select case (functl%type)
433 case (xc_exchange)
434 write(message(1), '(2x,a)') 'Exchange'
435 case (xc_correlation)
436 write(message(1), '(2x,a)') 'Correlation'
437 case (xc_exchange_correlation)
438 write(message(1), '(2x,a)') 'Exchange-correlation'
439 case (xc_kinetic)
440 call messages_not_implemented("kinetic-energy functionals", namespace=namespace)
441 case default
442 write(message(1), '(a,i6,a,i6)') "Unknown functional type ", functl%type, ' for functional ', functl%id
443 call messages_fatal(1, namespace=namespace)
444 end select
445
446 select case (functl%family)
447 case (xc_family_lda)
448 write(family,'(a)') "LDA"
449 case (xc_family_gga)
450 write(family,'(a)') "GGA"
451 case (xc_family_mgga)
452 write(family,'(a)') "MGGA"
453 case (xc_family_lca)
454 call messages_not_implemented("Support of LCA functional", namespace=namespace)
455 case (xc_family_hyb_lda)
456 write(family,'(a)') "Hybrid LDA"
457 case (xc_family_hyb_gga)
458 write(family,'(a)') "Hybrid GGA"
459 case (xc_family_hyb_mgga)
460 write(family,'(a)') "Hybrid MGGA"
461 end select
462 write(message(2), '(4x,4a)') trim(xc_f03_func_info_get_name(functl%info)), ' (', trim(family), ')'
463 call messages_info(2, iunit=iunit, namespace=namespace)
464
465 ii = 0
466 do while(ii >= 0)
467 ! Preventing End of record error as message(1) has length of 256, and libxc returns 1024 characters
468 ind = ii + 1
469 write(reference, '(a)') trim(xc_f03_func_reference_get_ref(xc_f03_func_info_get_references(functl%info, ii)))
470 ! Some references are in fact notes, and references are void in this case
471 if (len_trim(reference) == 0) cycle
472 istart = 1
473 iend = len(message(1))-10
474 write(message(1), '(4x,a,i1,2a)') '[', ind, '] ', trim(reference(istart:iend))
475 call messages_info(1, iunit=iunit, namespace=namespace)
476 do while (iend < len_trim(reference))
477 istart = iend
478 iend = min(istart + len(message(1))-10, len_trim(reference))
479 write(message(1), '(7x,a)') trim(reference(istart:iend))
480 call messages_info(1, iunit=iunit, namespace=namespace)
481 end do
482 end do
483 end if
484
486 end subroutine xc_functional_write_info
487
488
490 integer function xc_get_default_functional(dim, pseudo_x_functional, pseudo_c_functional) result(default)
491 integer, intent(in) :: dim
492 integer, intent(in) :: pseudo_x_functional, pseudo_c_functional
493
495
496 default = 0
497
498 if (pseudo_x_functional /= pseudo_exchange_any) then
499 default = pseudo_x_functional
500 else
501 select case (dim)
502 case (3)
503 default = xc_lda_x
504 case (2)
505 default = xc_lda_x_2d
506 case (1)
507 default = xc_lda_x_1d_soft
508 end select
509 end if
510
511 assert(default >= 0)
512
513 if (pseudo_c_functional /= pseudo_correlation_any) then
514 default = default + libxc_c_index*pseudo_c_functional
515 else
516 select case (dim)
517 case (3)
518 default = default + libxc_c_index * xc_lda_c_pz_mod
519 case (2)
520 default = default + libxc_c_index * xc_lda_c_2d_amgb
521 case (1)
522 default = default + libxc_c_index * xc_lda_c_1d_csc
523 end select
524 end if
525
526 assert(default >= 0)
527
529 end function xc_get_default_functional
530
532 subroutine xc_check_dimension(functl, ndim, namespace)
533 type(xc_functional_t), intent(in) :: functl
534 integer, intent(in) :: ndim
535 type(namespace_t), intent(in) :: namespace
536
537 logical :: ok
538
539 push_sub(xc_check_dimension)
540
541 ! Check that the functional is used for the correct space dimension
542 ok = bitand(functl%flags, xc_flags_1d) /= 0
543 if (ndim == 1 .and. (.not. ok)) then
544 message(1) = 'Cannot use the specified functionals in 1D.'
545 call messages_fatal(1, namespace=namespace)
546 end if
547
548 ok = bitand(functl%flags, xc_flags_2d) /= 0
549 if (ndim == 2 .and. (.not. ok)) then
550 message(1) = 'Cannot use the specified functionals in 2D.'
551 call messages_fatal(1, namespace=namespace)
552 end if
553
554 ok = bitand(functl%flags, xc_flags_3d) /= 0
555 if (ndim == 3 .and. (.not. ok)) then
556 message(1) = 'Cannot use the specified functionals in 3D.'
557 call messages_fatal(1, namespace=namespace)
558 end if
559
560 pop_sub(xc_check_dimension)
561 end subroutine xc_check_dimension
562
564 logical function xc_functional_is_not_size_consistent(functl, namespace)
565 type(xc_functional_t), intent(in) :: functl
566 type(namespace_t), intent(in) :: namespace
567
568 integer :: n_ext_params, ip
569 character(len=128) :: ext_params_name
570
572 if (.not. functl%from_libxc) return
573
575
576 ! External parameters
577 n_ext_params = xc_f03_func_info_get_n_ext_params(functl%info)
578 do ip = 0, n_ext_params-1
579 ext_params_name = xc_f03_func_info_get_ext_params_name(functl%info, ip)
580 ! Internal parameters starts with '_'
581 if (ext_params_name(1:1) == '_') cycle
582 if (trim(xc_f03_func_info_get_ext_params_description(functl%info, ip)) == 'Number of electrons') then
584 end if
585 end do
586
587 ! We only support size inconsistent functionals with a single parameter at the moment
588 if (xc_functional_is_not_size_consistent .and. n_ext_params > 1) then
589 message(1) = 'The selected functional is currently not supported.'
590 call messages_fatal(1, namespace=namespace)
591 end if
592
595
596 logical pure function xc_functional_is_energy_functional(functl)
597 type(xc_functional_t), intent(in) :: functl
598
599 xc_functional_is_energy_functional = bitand(functl%flags, xc_flags_have_exc) /= 0
601
602end module xc_functional_oct_m
603
604!! Local Variables:
605!! mode: f90
606!! coding: utf-8
607!! End:
real(real64), parameter, public m_one
Definition: global.F90:192
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:1091
subroutine, public messages_warning(no_lines, all_nodes, namespace)
Definition: messages.F90:525
subroutine, public messages_obsolete_variable(namespace, name, rep)
Definition: messages.F90:1023
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:410
subroutine, public messages_input_error(namespace, var, details, row, column)
Definition: messages.F90:691
subroutine, public messages_info(no_lines, iunit, debug_only, stress, all_nodes, namespace)
Definition: messages.F90:594
logical function, public parse_is_defined(namespace, name)
Definition: parser.F90:455
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_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)