Commit 73876f19 authored by Christoph Friedrich's avatar Christoph Friedrich

Added "spex.x", new treatment of KPTPATH, and possibility of running INTERPOL with a file.

parent c62a2dd2
......@@ -205,7 +205,7 @@ The mathematical definition is
.. math::
\displaystyle w_{\mathbf{R}n}(\mathbf{r}) = \frac{1}{N} \sum_\mathbf{k} e^{-i\mathbf{kR}}
\sum_m U_{\mathbf{k}m,n} \varphi_{\mathbf{k}m}(\mathbf{r})
\sum_m U_{\mathbf{k}m,n} \phi_{\mathbf{k}m}(\mathbf{r})
:label: wannier
with the lattice vector :math:`\mathbf{R}` (the Wannier orbital is localized in the respective unit cell),
......@@ -272,7 +272,7 @@ symmetry in this case) is rotated.
The so-generated Wannier function are *first-guess* Wannier functions. To be more precise,
the expansion coefficients :math:`U_{\mathbf{k}n,m}` are obtained from projecting the Bloch functions
:math:`\varphi_{\mathbf{k}n}` onto localized functions with the chosen orbital character. Then, an
:math:`\phi_{\mathbf{k}n}` onto localized functions with the chosen orbital character. Then, an
orthonormalization procedure is applied to make the Wannier set orthonormal. For many purposes, the
resulting set of Wannier functions is already usable. However, it is not yet maximally localized.
The following keyword enforces maximal localization with Wannier90 (using the Wannier90 library),
......
......@@ -9,17 +9,6 @@ This section discusses several settings that are common for all calculations. So
General Settings
=================
MEM
-----------
Calculations based on many-body perturbation theory are costly, not only in terms of computation time but also in terms of memory. Since the problem sizes (e.g., number of atoms) are thus effectively restricted by the memory hardware of the computer, the latter constitutes in some ways a more serious limit than the computation time the user can afford to invest. Therefore, an upper limit for the memory that Spex is allowed to use can be defined with the keyword ``MEM x`` with x in MB. The default is ``MEM 1000``.
In parallel Spex, the value would correspond to the upper limit per node. If possible, Spex will divide the work load into packets in such a way that the memory usage stays below the limit. (Actually, Spex might use a bit more memory than specified.)
.. list-table:: Example
:widths: 16 100
* - ``MEM 2000``
- Restrict memory usage to 2GB (Default: 1GB).
.. _job:
JOB
......@@ -66,6 +55,25 @@ There are only two keywords that must not be omitted from the input file. The fi
* - ``BZ 8 4 2``.
- Define a :math:`8\times 4\times 2` k-point sampling.
MEM
-----------
Calculations based on many-body perturbation theory are costly, not only in terms of computation time but also in terms of memory. Since the problem sizes (e.g., number of atoms) are thus effectively restricted by the memory hardware of the computer, the latter constitutes in some ways a more serious limit than the computation time the user can afford to invest. Therefore, an upper limit for the memory that Spex is allowed to use can be defined with the keyword ``MEM x`` with x in MB. The default is ``MEM 1000``.
In parallel Spex, the value would correspond to the upper limit per node. If possible, Spex will divide the work load into packets in such a way that the memory usage stays below the limit. (Actually, Spex might use a bit more memory than specified.)
.. list-table:: Example
:widths: 16 100
* - ``MEM 2000``
- Restrict memory usage to 2GB (Default: 1GB).
STOREIBZ
---------
Spex reads wavefunctions and energies as a first step. In general, these have to be stored for all k vectors in the set (e.g., for all 64 points of a :math:`4\times 4\times 4` set), filling up a lot of memory. This can be restricted to the irreducible zone (only eight points in the example) with the keyword ``STOREIBZ``. Spex then regenerates the wavefunctions on equivalent k points on the fly. This might slow down the calculation but is more economical with computer memory.
--enable-load
-----------------
(*) Another possibility to reduce the memory consumption is to reconfigure (and recompile) the code with the option ``--enable-load`` (or recompile with the flag ``-DLOAD`` in the Makefile). With this option, Spex stores the wavefunctions in memory only temporarily and rereads them from harddisc whenever they are needed. Obviously, this requires a fast harddisc and network connection. The HDF5 library is used for the data transfer. There is no possibility to set the option in the input file because it strongly affects the way the wavefunction data is handled in the code.
RESTART
--------
This is an important keyword. It enables (a) continuing a calculation that has, for some reason, stopped or crashed and (b) reusing data of a previous calculation. If specified, Spex will store intermediate results in a file or read them if the particular data is already present in the file. Even if ``RESTART`` was not specified in the first run, Spex might still be able to reuse data from a previous run with ``RESTART 2``. (This option usually gives less freedom for a change of parameters. ``RESTART 1`` and ``RESTART`` are equivalent.) It depends on the particular job definition whether ``RESTART`` and/or ``RESTART 2`` are available and how they work. See below for details.
......@@ -77,14 +85,6 @@ This is an important keyword. It enables (a) continuing a calculation that has,
- Read/write restart file.
* - ``RESTART 2``
- Try to reuse data from standard output files.
STOREIBZ
---------
Spex reads wavefunctions and energies as a first step. In general, these have to be stored for all k vectors in the set (e.g., for all 64 points of a :math:`4\times 4\times 4` set), filling up a lot of memory. This can be restricted to the irreducible zone (only eight points in the example) with the keyword ``STOREIBZ``. Spex then regenerates the wavefunctions on equivalent k points on the fly. This might slow down the calculation but is more economical with computer memory.
--enable-load
-----------------
(*) Another possibility to reduce the memory consumption is to reconfigure (and recompile) the code with the option ``--enable-load`` (or recompile with the flag ``-DLOAD`` in the Makefile). With this option, Spex stores the wavefunctions in memory only temporarily and rereads them from harddisc whenever they are needed. Obviously, this requires a fast harddisc and network connection. The HDF5 library is used for the data transfer. There is no possibility to set the option in the input file because it strongly affects the way the wavefunction data is handled in the code.
Input data
===========
......
......@@ -25,10 +25,11 @@ project = 'Spex'
copyright = u'2019, PGI, Forschungszentrum J\u00fclich, Germany'
author = ''
spexversion = open('version').read()
# The short X.Y version
version = '0.0.1'
version = spexversion
# The full version, including alpha/beta/rc tags
release = open('version').read()
release = spexversion
# -- General configuration ---------------------------------------------------
......
......@@ -6,7 +6,7 @@ General information
Although the Spex executable can have different names (e.g., "spex.inv", "spex.noinv"),
we assume that "spex" is the name of the executable in the following.
(This can be achieved by using the caller utility, see the file "INSTALL".)
(This can be achieved by using the caller utility, see :numref:`installation`.)
.. note:: Paragraphs discussing advanced options are preceded with (*), and the ones about obsolete, unmaintained, or experimental options are marked with (**). You can safely skip the paragraphs marked with (*) and (**) at first reading.
......
......@@ -51,4 +51,32 @@ The compilation creates the executables
which may be installed with ``make install``. Installation is optional. See the file "INSTALL" for details.
The reason for having two executables, one for systems with inversion symmetry and the other for systems without, is that many quantities
(such as the Coulomb matrix, the screened interaction on the imaginary axis, the exchange self-energy, etc.) can be declared in the code
as real-valued instead of complex-valued arrays in the case of inversion symmetry, which speeds up the computation considerably.
(The floating-point multiplication of complex numbers are about eight times slower than the multiplication of real numbers.)
For the sake of code clarity, it is then advantageous to have two executables.
The user can call "spex.inv" or "spex.noinv" directly or use the caller utility "spex.x". The caller utility simply returns the
name of the executable that should be used for the present system ("spex.inv" or "spex.noinv") and prepends the path. (It is assumed that
all executables reside in the same directory.) This allows the proper executable to be called generally by ```spex.x``` (all shells) or
``$(spex.x)`` (BASH). The shell calls "spex.x", which returns the executable's name, and then immediately runs that executable.
For convenience, you can add the line::
alias spex='$(spex.x)'
(BASH) or::
alias spex '`spex.x`'
(other shells) to your shell config file (".bashrc" or similar). Spex is then called simply by::
$ spex
and the parallelized version by::
$ mpiexec -np 8 spex
as an example.
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment