@@ -66,7 +66,7 @@ There are only two keywords that must not be omitted from the input file. The fi

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.)

In parallel Spex, the value would correspond to the upper limit per (physical) 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.)

@@ -59,6 +59,9 @@ that, for greater visibility, should appear in the standard error stream.

.. note:: The keywords are detailed in the coming chapters. If a keyword belongs to a section, the section's name is specified as well, for example, ``CONTINUE (SENERGY)``.

The shell script "spex.setkey" allows the Spex input file to be modified from the command line. This is useful, in particular, for multiple calculations run from a batch script.

.. highlights:: We have successfully compiled and run the code with the Intel Fortran compiler (since version 12.1.3), Gfortran (since version 5), and NAG Fortran (since version 6.2 6214). As of May 2018, PGI compilers have a bug (TPR 23745) that prevents compilation of the Spex code. For the parallelized version, we have used IntelMPI and MPICH. In case of configuration or compilation problems, please inform us.

.. highlights:: We have successfully compiled and run the code with the Intel Fortran compiler (since version 12.1.3), Gfortran (since version 4.9), and NAG Fortran (since version 6.2 6214). As of May 2018, PGI compilers have a bug (TPR 23745) that prevents compilation of the Spex code. For the parallelized version, we have used IntelMPI and MPICH. In case of configuration or compilation problems, please inform us.

Usage

-------

...

...

@@ -145,10 +145,12 @@ The following error messages are displayed when the program run was terminated a

.. highlights:: A forbidden area of memory was accessed during the program run. First, you should make sure that the operating system

allows unlimited size of stack memory. You can set the stack size from the shell (BASH: ``ulimit -s unlimited``,

CSH: ``limit stacksize unlimited``). As an alternative, some compilers provide options to prevent the usage of stack memory

(e.g., ``-heap-arrays`` in the Intel Fortran Compiler).

If this does not solve the problem, it is likely that the error is caused by a real

(e.g., ``-heap-arrays`` in the Intel Fortran Compiler).

If this does not solve the problem, it is possible that the error is caused by a real

bug in the Spex code. Please report such an error. You can help the developers by running the same calculation again with

a Spex executable that has been compiled with ``make ADD=-DCHECK`` (slower execution). Please send the resulting output.

Unfortunately, compilers and libraries can have bugs themselves. It is not unlikely that the "segfault" is caused by such a bug.

Therefore, it is worthwhile to recompile with different compilers and/or libraries and run the program again.

.. .. highlights:: If this is caused by a too high memory demand you should try the option ``STOREIBZ`` (and ``NOSTORE``) or

reduce the maximally allowed storage with the keyword ``MEM``. With some compilers this can

@@ -286,13 +286,13 @@ thus, to calculate the ''linearized'' solution of the quasiparticle equation [Eq

(:math:`{\epsilon_{\mathbf{k}n}-0.01}` htr and :math:`{\epsilon_{\mathbf{k}n}+0.01}` htr).

The more accurate ''direct'' solution is only available if we specify a range of frequencies for the self-energy instead of a single number,

making an interpolation of the self-energy beyond a linear function possible.

This is possible by an argument such as ``{-0.1:0.15,0.01}``. Here, the range of values is relative to :math:`\epsilon_{\mathbf{k}n}>\epsilon_\mathrm{F}`.

The range is reversed (to {-0.15:0.1,0.01} in the example) for occupied states (:math:`\epsilon_{\mathbf{k}n}<\epsilon_\mathrm{F}`)

This is possible by an argument such as ``+-{-0.1:0.15,0.01}``. Here, the range of values is relative to :math:`\epsilon_{\mathbf{k}n}>\epsilon_\mathrm{F}`.

The range is reversed (to -0.15:0.1 in the example) for occupied states (:math:`\epsilon_{\mathbf{k}n}<\epsilon_\mathrm{F}`)

to reflect the fact that occupied and unoccupied states tend to shift in opposite directions by the renormalization.

(Thus, it makes sense to choose a frequency range shifted to larger energies instead of a symmetrical one.)

One can also specify an absolute frequency mesh by ``[{...}]``, where the energies are given relative to the Fermi energy.

One can also specify an absolute frequency mesh by ``{...}``, where the energies are given relative to the Fermi energy.

This is mandatory for calculations with ``FULL`` (:numref:`beyondpert`).

It is sometimes a bit inconvenient to determine suitable values for the upper and lower bound of ``[{...}]``.

It is sometimes a bit inconvenient to determine suitable values for the upper and lower bound of ``{...}``.

Therefore, Spex allows the usage of wildcards for one of the boundaries or both (see examples).

The second argument to ``CONTOUR`` gives the increment of the (equidistant) real-frequency mesh for :math:`{W(\omega')}`.

The lower and upper boundaries of this mesh are determined automatically from the first argument. As a third method,

...

...

@@ -308,13 +308,15 @@ in terms of both computational cost and numerical accuracy.

* - ``CONTOUR 0.01 0.005``

- Use contour integration to obtain the two values :math:`{\Sigma^\mathrm{xc}(\epsilon\pm 0.01\,\mathrm{htr})}` with the KS energy :math:`\epsilon`, giving :math:`{\Sigma^\mathrm{xc}}` as a linear function.

* - ``CONTOUR {-0.1:0.15,0.01} 0.005``

* - ``CONTOUR +-{-0.1:0.15,0.01} 0.005``

- Calculate :math:`{\Sigma^\mathrm{xc}(\omega)}` on a frequency mesh relative to the KS energy :math:`{\epsilon}`.

* - ``CONTOUR [{*:*,0.01}] 0.005``

* - ``CONTOUR {*:*,0.01} 0.005``

- Use an absolute frequency mesh (relative to the Fermi energy) instead. Wildcards are used for the upper and lower bounds.

* - ``CONTOUR [{*:*,0.01}]``

* - ``CONTOUR {*:*,0.01}``

- Use *hybrid* method.

.. note:: Until version 05.00pre31, the syntax was ``{...}`` for ``+-{...}`` and ``[{...}]`` for ``{...}``.

FREQINT (SENERGY)

------------------

(*) Independently of whether :math:`{\Sigma^\mathrm{xc}(i\omega_n)}` (``CONTINUE``) or :math:`{\Sigma^\mathrm{xc}(\omega_n)}` (``CONTOUR``) is evaluated,

...

...

@@ -366,9 +368,9 @@ By default, no smoothening is applied. Note that this feature leads to a small d

* - ``SMOOTH 500 250``

- In addition, average over 250 approximants to smoothen *W* (or the *T* matrix). (Requires ``FREQINT PADE``.)

NOZERO (SENERGY)

ZERO (SENERGY)

----------------

Both the exchange (HF) and the correlation self-energy contain terms of the form

(*) Both the exchange (HF) and the correlation self-energy contain terms of the form