[gpaw-users] Convergance Issues with B3LYP and PBE0 functionals

Andrew Long andrew.wilson.long at gmail.com
Mon Mar 21 18:36:39 CET 2011


I've been running into the "gpaw.KohnShamConvergenceError: Did not
converge!" issue trying to use the PBE0 and B3LYP functionals on a 1x1x1
unit cell of LaMnO3 and I was wondering if anyone had any tips for me, if
you've had similar issues, or if people are seeing convergence faster than I
am (well over 300 iterations). Also, I apologize that this is long and has a
lot of raw data to parse through, but I figured it would be best to be
complete in giving examples of the issues.

Note before starting: I've run the exact same structure in GPAW with
xc='PBE' and been able to find an appropriate lattice constant for LaMnO3,
so my structure should be fine (using default eigensolver, gpts =
(32,32,32), kpts=(12,12,12), and nbands = 38), and that converged in 65
iterations.

Setup generation for BLYP files:
I created the BLYP files using the gpaw-setup string `gpaw-setup
--exact-exchange -f BLYP La Mn O`, and I've added the directory for these
files to my GPAW_SETUP_PATH.

Calculation Parameters:
I've tried varying several different parameters to just converge the a=4
Angstrom cubic LaMnO3 unit cell. I've tried using both the rmm-diis and cg
eigensolvers, I'm now using nbands = -15 (to ensure an appropriate number of
empty bands, this might need to be higher/I'm running calculations with more
empty bands to check this now), and gpts in [32,40,48,56,64] (kpt sampling
is unsupported for hybrid functionals). It seems that the rmm-diis solver is
converging the PBE0 calculations better than the cg, as in 300 iterations at
32 gpts,

xc='PBE0', Eigensolver = rmm-diis, gpts=(32,32,32) grep on 'iter:' from
output txt file:
iter: 294  17:18:17  -4.0   -3.3     -268670.68734 0      4
iter: 295  17:35:51  -4.1   -3.3     -268670.68991 0      4
iter: 296  17:53:06  -4.2   -3.4     -268670.69695 0      4
iter: 297  18:07:30  -4.3   -3.5     -268670.69772 0      4
iter: 298  18:21:42  -4.3   -3.6     -268670.69917 0      4
iter: 299  18:37:00  -4.1   -3.7     -268670.70235 0      4
iter: 300  18:51:06  -4.7   -3.9     -268670.70431 0      3

xc='PBE0', Eigensolver = cg, gpts=(32,32,32) grep on 'iter:' from output txt
file:
iter: 294  23:33:26  +0.7   -1.1     -268668.31406 0      7
iter: 295  23:45:39  +0.8   -1.1     -268674.86126 0      8
iter: 296  23:57:30  +1.3   -0.8     -268693.73136 0      6
iter: 297  00:09:26  +1.4   -0.8     -268673.48216 0      7
iter: 298  00:21:28  +0.7   -0.8     -268663.46448 0      8
iter: 299  00:32:53  +1.1   -0.9     -268665.24148 0      8
iter: 300  00:44:17  +0.8   -1.2     -268667.46744 0      7

Even still, the PBE0 with rmm-diis has not reached the convergence criteria
in 300 iterations, although it is certainly approaching it better than the
cg solver. If others using hybrid functionals have noticed this, then I
guess I'm just stuck running extremely long number of iteration
calculations, but this seemed abnormal.

B3LYP has some much bigger issues, namely that it occasionally diverges, and
the conjugate gradient solver seems to cause this divergence to happen
almost immediately with almost no chance of returning to stable values.

xc='B3LYP', Eigensolver = rmm-diis, gpts=(32,32,32) grep on 'iter:' from
output txt file
iter: 294  20:31:19  +1.3   -1.0     -268766.37986 0      8
iter: 295  20:43:42  +0.6   -0.5     -268766.01134 0      7
iter: 296  20:55:58  +0.3   -0.5     -268729.09616 0      7
iter: 297  21:08:27  +11.9  -0.5     -22638322.11476 0      9
iter: 298  21:23:06  +11.9  -0.1     -15204779.31868 0      9
iter: 299  21:36:55  +12.0  -0.2     -11321250.78445 0      9
iter: 300  21:50:42  +5.9   -0.4     -269415.17823 0      11

xc='B3LYP', Eigensolver = cg, gpts=(32,32,32) grep on 'iter:' from output
txt file
iter:  26  17:10:17  +1.5   -0.5     -268972.15494 0      7
iter:  27  17:23:58  +1.5   -0.4     -268769.43458 0      8
iter:  28  17:38:25  +10.0  -0.5     -12946072.36830 0      9
iter:  29  17:59:36  +10.2  +0.2     -29325678.97489 0      9
iter:  30  18:24:48  +3.5   +0.3     -267327.36211 0      9
iter:  31  18:43:15  +12.1  -0.1     -79931041.86473 0      9
iter:  32  19:08:54  +11.6  +0.1     -41043447.56353 0      9
iter:  33  19:32:13  +12.7  +0.1     -185879403.34907 0      9

The xc=B3LYP with rmm-diis looks like it might fully converge at gpts=40,
though this calculation has not finished yet so I'm unsure of whether it
will (been running for almost 100 hours and at 209 iterations):
iter: 205  11:26:21  -4.9   -3.8     -268696.15484 0      3
iter: 206  11:52:16  -4.7   -3.8     -268696.15383 0      3
iter: 207  12:17:03  -4.9   -3.8     -268696.15325 0      3
iter: 208  12:39:00  -5.0   -3.9     -268696.15316 0      4
iter: 209  13:01:48  -4.9   -4.2     -268696.15376 0      3

I'm also unsure of what happened but for gpts=[40,48,56] with rmm-diis, I
see energy spikes that come back and stabilize. I don't know if these trends
exist in the gpts=64 case, as 100 hours has only resulted in ~60 iterations.
This seemed extremely abnormal, as I don't see any of these peaks in the
PBE0, meaning something with B3LYP is specifically causing this.
xc='B3LYP', Eigensolver = rmm-diis, gpts=(40,40,40) grep on 'iter:' from
output txt file
iter:  36  03:07:54  +1.0   -0.6     -268748.34025 0      8
iter:  37  03:31:07  +9.6   -0.7     -1316167.90156 0      10
iter:  38  03:57:22  +7.6   -0.3     -313190.14697 0      7
iter:  39  04:25:28  +1.9   -0.3     -268634.10803 0      9

xc='B3LYP', Eigensolver = rmm-diis, gpts=(48,48,48) grep on 'iter:' from
output txt file
iter:  54  12:31:59  +0.4   -0.8     -268709.67470 0      7
iter:  55  13:22:54  +8.4   -0.9     -312728.04233 0      8
iter:  56  14:30:57  +5.6   -0.3     -268946.26055 0      6
...
iter:  67  01:31:01  +1.8   -0.3     -268679.04502 0      9
iter:  68  02:15:58  +9.1   -0.3     -447263.27650 0      9
iter:  69  03:10:37  +8.8   -0.4     -362153.71279 0      8
iter:  70  04:19:19  +7.0   -0.3     -274627.59113 0      8

xc='B3LYP', Eigensolver = rmm-diis, gpts=(56,56,56) grep on 'iter:' from
output txt file
iter:  76  18:30:07  +0.7   -0.8     -268682.77118 0      6
iter:  77  19:30:04  +9.9   -0.8     -1090384.83029 0      10
iter:  78  20:35:55  +2.0   -0.2     -268620.74846 0      10
iter:  79  21:41:14  +1.4   -0.7     -268718.26284 0      7


If anyone has some ideas or sees some issues I'd be extremely grateful. I'm
wondering if others have noticed that hybrid functionals take a much higher
number of iterations to converge, or if my results are seemingly abnormal.
Also, I think I've setup the gpaw setup files properly for B3LYP/PBE0 (don't
need anything except for defaults from the setup package for PBE0 and need
to generate BLYP files with exact exchange for B3LYP), but if I could get
confirmation that this is correct, that'll also narrow down my range of
possible issues.

Thank you so much for taking the time to read through this,
Andy Long
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://listserv.fysik.dtu.dk/pipermail/gpaw-users/attachments/20110321/54d1c333/attachment.html 


More information about the gpaw-users mailing list