beddalumia / mottlab

MOTT transition within MATLAB. Blazing fast IPT code treating Bethe-Hubbard model at half-filling.

What MOTTlab is

An efficient implementation of (real axis) IPT-based dynamical mean-field theory for the half-filled Mott-Hubbard transition on the Bethe lattice, within pure MATLAB.

What you can get out of it

Here we present a few examples of what you can obtain fiddling around the MOTTlab.

Characterize the interaction-driven quantum Mott transition through different physical markers, such as the timeless classic quasiparticle renormalization weight Z_F , or the quantized Luttinger integral I_L, getting some exotic hints of a topological interpretation.

Truly visualize what happens at different relevant temperatures by means of pretty animations!

Temperature	DOS	SELF-ENERGY
T -> 0: 2nd order MIT
Intermediate T: 1st order MIT
High T: supercritical MIT

Dependencies

I've tried hard to avoid exceeding with the infamous MathWorks add-ons. At the moment the only additional dependence is the Signal Processing Toolbox, which provides an efficient implementation of the discrete Hilbert transforms, at the heart of the numerical evaluation of the Kramers-Kronig relationships. Nevertheless I provide also a FOSS options, through GNU Octave packages.

First of all you need to install the main software. The easiest way that I know is through Homebrew (you won't need sudo rights, they just take care of everything):

brew install octave

Then run an instance of Octave in your shell (just type octave) and install the control package, by typing:

pkg install -forge control

Finally proceed to install the signal package, which provides a FOSS implementation¹ of the hilbert() function:

pkg install -forge signal

You should now be set... enjoy!

Licensing and legacy code

This code has been implemented taking inspiration from these didactic sources:

1. Kristjan Haule lecture on lattice vs local SOPT (local copy).
2. Marcelo Rozenberg lecture on DMFT and the MIT (local copy) and the hands-on material linked therein, in particular a tutorial-intended jupyter notebook provided by Óscar Nájera under the BSD 3-Clause License.

Here we provide an efficient pure MATLAB rewrite of the original real-axis IPT algorithm, complemented by basic phase-diagram workflows, convergence and self-mixing control and various post-processing tools. Further material is being added gradually, with the aim to explore novel research ideas. You can find here a roadmap of the project, with a concise description of each addition and references to the relevant research papers.

Everything mantains the original BSD 3-Clause License. You can read more about permitted use and conditions in the LICENSE file.

© 2020 | Gabriele Bellomia

Footnotes

1. note that while the MATLAB fft family is always built on top of FFTW, with Octave you could end up wrapping FFTPACK instead, depending on how your binaries have been built. ↩

mottlab's Issues

Optimize Luttinger integral evaluation

I_L calculation requires a very high frequency resolution (wres ~ 2^15). This causes the convolutions in the SOPT function to saturate almost all the cpu time (~90% of the DMFT_loop self-time). So we want to build a optimized convolution function, that could give a noticeable speedup within our specific requirements (very long arrays to convolve, equal in length).

The idea: FFT-based convolution exploiting the "power of 2" golden rule.