self_consistent_field function takes as the
keyword argument one function to be called after each iteration.
This function gets passed the complete internal state of the SCF
solver and can thus be used both to monitor and debug the iterations
as well as to quickly patch it with additional functionality.
This example discusses a few aspects of the
taking again our favourite silicon example.
We setup silicon in an LDA model using the ASE interface to build the silicon lattice, see Creating slabs with ASE for more details.
using DFTK using PyCall silicon = pyimport("ase.build").bulk("Si") atoms = [ElementPsp(el.symbol, psp=load_psp("hgh/lda/si-q4.hgh")) for el in load_atoms(silicon)] positions = load_positions(silicon) lattice = load_lattice(silicon); model = model_LDA(lattice, atoms, positions) basis = PlaneWaveBasis(model; Ecut=5, kgrid=[3, 3, 3]);
DFTK already defines a few callback functions for standard
tasks. One example is the usual convergence table,
which is defined in the callback
Another example is
ScfPlotTrace, which records the total
energy at each iteration and uses it to plot the convergence
of the SCF graphically once it is converged.
For details and other callbacks
!!! note "Callbacks are not exported"
Callbacks are not exported from the DFTK namespace as of now,
so you will need to use them, e.g., as
In this example we define a custom callback, which plots the change in density at each SCF iteration after the SCF has finished. For this we first define the empty plot canvas and an empty container for all the density differences:
using Plots p = plot(yaxis=:log) density_differences = Float64;
The callback function itself gets passed a named tuple
similar to the one returned by
which contains the input and output density of the SCF step
ρout. Since the callback gets called
both during the SCF iterations as well as after convergence
self_consistent_field finishes we can both
collect the data and initiate the plotting in one function.
using LinearAlgebra function plot_callback(info) if info.stage == :finalize plot!(p, density_differences, label="|ρout - ρin|", markershape=:x) else push!(density_differences, norm(info.ρout - info.ρin)) end info end callback = DFTK.ScfDefaultCallback() ∘ plot_callback;
Notice that for constructing the
callback function we chained the
(which does the plotting) with the
ScfDefaultCallback, such that when using
plot_callback function with
self_consistent_field we still get the usual
convergence table printed. We run the SCF with this callback ...
scfres = self_consistent_field(basis, tol=1e-8, callback=callback);
n Energy log10(ΔE) log10(Δρ) α Diag --- --------------- --------- --------- ---- ---- 1 -7.846712147581 -0.70 0.80 4.2 2 -7.852281470674 -2.25 -1.54 0.80 1.0 3 -7.852621342771 -3.47 -2.53 0.80 3.0 4 -7.852621950103 -6.22 -3.35 0.80 2.2 5 -7.852621959119 -8.04 -4.63 0.80 1.2
... and show the plot
info object passed to the callback contains not just the densities
but also the complete Bloch wave (in
and so on.
for all currently available keys.
!!! tip "Debugging with callbacks"
Very handy for debugging SCF algorithms is to employ callbacks
@infiltrate from Infiltrator.jl
to interactively monitor what is happening each SCF step.