diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index a301b007..74395174 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -25,6 +25,7 @@ jobs: - name: Install ubuntu dependencies if: matrix.os == 'ubuntu-20.04' run: > + sudo apt-get update && sudo apt-get install clang-10 g++-10 diff --git a/README.md b/README.md index d0e39ba3..e5a4a9bb 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,12 @@ # *TPRF*: the Two-Particle Response Function tool box for TRIQS -Copyright (C) 2017, H. U.R. Strand +Copyright (C) 2017-2020, H. U.R. Strand Copyright (C) 2018-2019, The Simons Foundation +Copyright (C) 2019-2020, S. Käser + TPRF is a TRIQS application containing various tools for working with two particle response functions. diff --git a/benchmark/eliashberg/eliashberg_benchmark_k_mesh_2.h5 b/benchmark/eliashberg/comparison_to_previous_impl/eliashberg_benchmark_k_mesh_2.h5 similarity index 100% rename from benchmark/eliashberg/eliashberg_benchmark_k_mesh_2.h5 rename to benchmark/eliashberg/comparison_to_previous_impl/eliashberg_benchmark_k_mesh_2.h5 diff --git a/benchmark/eliashberg/tprf_implementation.py b/benchmark/eliashberg/comparison_to_previous_impl/tprf_implementation.py similarity index 100% rename from benchmark/eliashberg/tprf_implementation.py rename to benchmark/eliashberg/comparison_to_previous_impl/tprf_implementation.py diff --git a/benchmark/eliashberg/particle_hole_transformation/PHT_Hubbard_Model.ipynb b/benchmark/eliashberg/particle_hole_transformation/PHT_Hubbard_Model.ipynb new file mode 100644 index 00000000..fba7bff7 --- /dev/null +++ b/benchmark/eliashberg/particle_hole_transformation/PHT_Hubbard_Model.ipynb @@ -0,0 +1,2280 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import numpy as np\n", + "\n", + "from triqs.plot.mpl_interface import plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "plt.style.use('../../../doc/user_guide/notebook.mplstyle')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Using the (semi) particle-hole transformation on the Hubbard model on a square lattice" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hubbard model on a square lattice" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Hamiltonian of the Hubbard model on a square lattice is given by\n", + "\n", + "$$\n", + "H=-t \\sum_{\\langle j, l\\rangle \\sigma}\\left(c_{j \\sigma}^{\\dagger} c_{l \\sigma}+c_{l \\sigma}^{\\dagger} c_{j \\sigma}\\right)+U \\sum_{j} n_{j \\uparrow} n_{j \\downarrow}-\\mu \\sum_{j}\\left(n_{j \\uparrow}+n_{j \\downarrow}\\right)\\,,\n", + "$$\n", + "\n", + "here $c_{j\\sigma}^{\\dagger}$ creates an electron on site $j$ with spin $\\sigma$ while $c_{j\\sigma}$ destroys such an electron, further the operator $n_{j\\sigma}$ count the number of electrons on site $j$ with spin $\\sigma$.\n", + "\n", + "The first term describes the kinetic energy of the electrons, which can be interpreted as an electron with spin $\\sigma$ *hopping* from site $l$ to site $j$ and vice versa.\n", + "Here the angular braket under the sum means that we only take *hopping* terms between neighboring lattice sites into account and the energy that is gained by such a *hopping* process is given by $t$.\n", + "This is the most basic version of the kinetic part of the Hubbard model which can, and will be, extended later.\n", + "\n", + "The second term describes the repulsive interaction between the electrons.\n", + "This repulsion is crudely approximated in the Hubbard model in the sense, that electrons only *see* each other if they occupy the same lattice site.\n", + "The energy that is needed to have a lattice site doubly occupied is given by $U$.\n", + "\n", + "The last term describes the filling of the lattice via an energy offset by the chemical potential $\\mu$.\n", + "\n", + "The Hubbard model is therefore defined by the parameters $t$, $U$ and $\\mu$, but we also need to know the temperature $T$ at which we shall observe the Hubbard model.\n", + "We will record these parameters using the `ParameterCollection` class in `triqs_tprf.ParameterCollection`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "T = 1000\n", + "U = 1.0\n", + "mu = 0.0\n", + "nk = 32\n", + "norb = 1\n", + "nw = 50\n", + "spin = False\n", + "t = 1.0\n", + "tp = 0.0\n", + "zeeman = 0.0" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from triqs_tprf.ParameterCollection import ParameterCollection\n", + "\n", + "hubbard = ParameterCollection( # -- Model Parameter\n", + " norb=1, # Number of orbitals.\n", + " t=1.0, # Hopping to nearest neighbor\n", + " U=1.0, # Strength of the on-site interaction\n", + " mu=0.0, # Chemical potential determining the filling.\n", + " T=1000, # Temperature.\n", + " spin=False, # Treat indices only for orbital character.\n", + " \n", + " # -- Model Parameter which will be used later\n", + " tp=0.0, # Hopping to next-nearest neighbor\n", + " zeeman=0.0, # Strength of zeeman term\n", + " \n", + " # -- Technical parameter\n", + " nk=32, # Number of points in one dimension considered in the Brillouin zone.\n", + " nw=50, # Number of Matsubara points in positive dimension.\n", + " )\n", + "hubbard" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A representation of the kinetic part of the Hubbard model can be constructed using the `create_square_lattice` function in`triqs_tprf.tight_binding`.\n", + "This function needs information about the number of orbitals `norb` and the hopping energy `t`, so we can construct it with the parameters stored in `hubbard`. \n", + "It returns a `TBLattice` object from which we can obtain the dispersion relation as a mesh over the Brillouin zone via its member function `on_mesh_brillouin_zone`.\n", + "\n", + "The dispersion relation is stored in a `Gf` object and we can plot its bandstructure via the `bsplot` function in `plotting_tools`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Starting run with 1 MPI rank(s) at : 2020-08-18 10:29:06.218793\n" + ] + } + ], + "source": [ + "from triqs_tprf.tight_binding import create_square_lattice\n", + "\n", + "H = create_square_lattice(norb=hubbard.norb, t=hubbard.t)\n", + "\n", + "e_k = H.on_mesh_brillouin_zone(n_k=(hubbard.nk, hubbard.nk, 1))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "path = [(r'$\\Gamma$', 2*np.pi*np.array([0.0, 0.0, 0.0])), \n", + " ('X', 2*np.pi*np.array([0.5, 0.0, 0.0])),\n", + " ('M', 2*np.pi*np.array([0.5, 0.5, 0.0])), \n", + " (r'$\\Gamma$', 2*np.pi*np.array([0.0, 0.0, 0.0])), \n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'DOS')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import gridspec\n", + "from triqs_tprf.plotting_tools import bsplot, dosplot\n", + "\n", + "gs = gridspec.GridSpec(1, 2, width_ratios=[3, 1]) \n", + "gs.update(wspace=0.2, hspace=0.05)\n", + "\n", + "# -- Bandstructure\n", + "ax_bs = plt.subplot(gs[0])\n", + "ax_bs.bsplot(e_k[0,0], path)\n", + "ax_bs.set_ylabel('$\\epsilon(\\mathbf{k})$', rotation=0, ha='right')\n", + "\n", + "# -- Density of states\n", + "ax_dos = plt.subplot(gs[1])\n", + "ax_dos.dosplot(e_k[0,0])\n", + "ax_dos.set_xlabel('DOS')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Charge- and spin-susceptibility\n", + "\n", + "To get physical information about the Hubbard model we will calculate the spin and charge susceptibilites in the random phase approximation (RPA) limit to see at which parameters they diverge and a phase transition occurs.\n", + "\n", + "To use the RPA we need the non-interaction particle-hole bubble which is contstructed via the non-interaction Green's function.\n", + "We therefore first construct a Matsubara frequency mesh object by using `MeshImFreq` from `triqs.gf`.\n", + "This constructor needs to know the inverse temperature `beta` in $1/\\mathrm{eV}$, which we can get from the temperature in $\\mathrm{Kelvin}$ by using the converter function `temperature_to_beta` from `triqs_tprf.utilities`, the statistic of our particle `S`, in our case a Fermion, and the number of points to use `n_max` in one dimension.\n", + "With this mesh object and the dispersion relation `e_k` we can then use `lattice_dyson_g0_wk` from `triqs_tprf.lattice` to construct the non-interaction Green's function for a specific filling given by `mu`.\n", + "The non-interaction particle-hole bubble is then constructed from this `Gf` object by using `imtime_bubble_chi0_wk` from `triqs_tprf.lattice_utils`.\n", + "\n", + "We wraped all of this in the function `get_chi0` which uses a `ParameterCollection` as an input to get all the parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n" + ] + } + ], + "source": [ + "from triqs.gf import MeshImFreq\n", + "from triqs_tprf.lattice import lattice_dyson_g0_wk\n", + "from triqs_tprf.lattice_utils import imtime_bubble_chi0_wk\n", + "from triqs_tprf.utilities import temperature_to_beta\n", + "\n", + "def get_chi0(p, e_k=None):\n", + " \"\"\"Return the non-interaction susceptibility for model parameters in a ParameterCollection\n", + " \"\"\"\n", + " if not e_k:\n", + " H = create_square_lattice(**p)\n", + " e_k = H.on_mesh_brillouin_zone(n_k=(p.nk, p.nk, 1))\n", + "\n", + " wmesh = MeshImFreq(beta=temperature_to_beta(p.T), S='Fermion', n_max=p.nw)\n", + " g0_wk = lattice_dyson_g0_wk(mu=p.mu, e_k=e_k, mesh=wmesh)\n", + " \n", + " chi0_wk = imtime_bubble_chi0_wk(g0_wk, nw=p.nw)\n", + " \n", + " return chi0_wk\n", + "\n", + "chi0_wk = get_chi0(hubbard, e_k)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now calculate the spin and charge susceptibiliy in the RPA limit with the known equations.\n", + "\n", + "$$\n", + "\\chi^{(\\mathrm{c})}=\\frac{\\chi^{(0)}}{1+\\chi^{(0)} U}\n", + "\\quad\n", + "\\mathrm{and}\n", + "\\quad\n", + "\\chi^{(\\mathrm{s})}=\\frac{\\chi^{(0)}}{1-\\chi^{(0)} U}\\,.\n", + "$$\n", + "\n", + "These kind of equation is implemented as `solve_rpa_PH` in `triqs_tprf.lattice` and we wrapped it in the function `get_chiRPA` to immediately obtain the charge- and spin-susceptibilites in RPA from given parameters.\n", + "We can plot them for $\\nu=0$, using the `Idx` object from `from triqs.gf`, in the same fashion as the bandstructure.\n", + "There we can see, that the spin-susceptibiliy has a peak at the M-point, which will lead to an antiferromagnetic (AFM) state for large enough $U$." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from triqs_tprf.lattice import solve_rpa_PH\n", + "\n", + "def get_chiRPA(p, chi0_wk=None):\n", + " \"\"\"Return the charge- and spin-susceptibility in the RPA limit for model parameters in a ParameterCollection\n", + " \"\"\"\n", + " \n", + " if not chi0_wk:\n", + " chi0_wk = get_chi0(p)\n", + " \n", + " U = p.U * np.ones(shape=(1,1,1,1), dtype=complex)\n", + "\n", + " chi_c_wk = solve_rpa_PH(chi0_wk, -U) # Minus for correct charge rpa equation\n", + " chi_s_wk = solve_rpa_PH(chi0_wk, U)\n", + " \n", + " return chi_c_wk, chi_s_wk\n", + "\n", + "chi_c_wk, chi_s_wk = get_chiRPA(hubbard, chi0_wk)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kaeser/my_triqs_installations/triqs_3.0.x/lib/python3.8/site-packages/triqs/gf/gf.py:323: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", + " dat = self._data[k]\n", + "/home/kaeser/my_triqs_installations/triqs_3.0.x/lib/python3.8/site-packages/triqs/gf/gf.py:323: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", + " dat = self._data[k]\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.55, 0.18, '$\\\\chi^{(c)}$')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "from triqs.gf import Idx\n", + "\n", + "ax_bs = plt.subplot(111)\n", + "\n", + "ax_bs.bsplot(chi_s_wk[(Idx(0), slice(None))], path)\n", + "ax_bs.bsplot(chi_c_wk[(Idx(0), slice(None))], path)\n", + "\n", + "ax_bs.set_ylabel(r'$\\chi(\\nu=0, \\mathbf{k})$', rotation=0, ha='right')\n", + "ax_bs.text(0.62, 0.6, \"$\\chi^{(s)}$\", transform = ax_bs.transAxes, size=22, color='C0')\n", + "ax_bs.text(0.55, 0.18, \"$\\chi^{(c)}$\", transform = ax_bs.transAxes, size=22, color='C1')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will now introduce a small function `get_spin_phase_transistion` that will find $U_\\mathrm{c}$, the interaction strength at which the Hubbard model goes into a spin ordered phase.\n", + "This is done by searching for the $U$ at which \n", + "\n", + "$$\n", + "\\frac{1}{\\chi^{(s)}} \\approx 0\\,,\n", + "$$\n", + "\n", + "via [`scipy.optimize.brentq`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.brentq.html#scipy.optimize.brentq)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.optimize import brentq\n", + "\n", + "def get_spin_phase_transistion(p):\n", + " \"\"\"Return U at which model p transitions to spin order via root search\n", + " \"\"\" \n", + " chi0_wk = get_chi0(p)\n", + " \n", + " def one_over_spin(U):\n", + "\n", + " _, chi_s_wk = get_chiRPA(p.alter(U=U), chi0_wk)\n", + " \n", + " # -- If any value is below zero we are already in an ordered phase\n", + " if np.any(chi_s_wk.data[np.abs(chi_s_wk.data) > 1e-3] < 0.0 ):\n", + " return -1\n", + " \n", + " chi_at_critical_k = np.max(chi_s_wk.data)\n", + " return 1./chi_at_critical_k\n", + " \n", + " U_c = brentq(one_over_spin, 0.0, 10.0)\n", + " \n", + " return U_c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To scan through some parameters we will alter our base model `hubbard`, which parameters are stored as a `ParameterCollection`, and only change the specific parameters.\n", + "We do this with the function `parameter_scan` which outputs us a `ParameterCollections` objects which is a container for multiple `ParameterCollection`.\n", + "We can then loop over the `ParameterCollections` object to access the individual `ParameterCollection` objects.\n", + "\n", + "To show this off we will do a crude scan of a $T-U$ phase diagram to map out the AFM phase." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kaeser/anaconda3/envs/triqs_3/lib/python3.8/site-packages/scipy/optimize/zeros.py:776: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " r = _zeros._brentq(f, a, b, xtol, rtol, maxiter, args, full_output, disp)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 15.472700008220936\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 23.209050012331403\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 46.418100024662806\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n" + ] + } + ], + "source": [ + "from triqs_tprf.ParameterCollection import parameter_scan\n", + "\n", + "Ts = [1000, 750, 500, 250]\n", + "# -- Use the hubbard model as a template for the parameters and only change T\n", + "hubbard_models = parameter_scan(hubbard, T=Ts)\n", + "\n", + "U_cs = []\n", + "\n", + "for hubbard_model in hubbard_models:\n", + " \n", + " U_c = get_spin_phase_transistion(hubbard_model) \n", + " U_cs.append(U_c)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.625, 0.3, 'AFM')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax_pd = plt.subplot()\n", + "\n", + "ax_pd.plot(U_cs, Ts, \"o\", ls=\"-\")\n", + "ax_pd.fill_between(U_cs, Ts, [Ts[-1]]*len(Ts), alpha=0.25)\n", + "\n", + "ax_pd.set_ylabel('Temperature\\n[Kelvin]', rotation=0, ha='right', multialignment='center')\n", + "ax_pd.set_xlabel('U [eV]')\n", + "\n", + "ax_pd.set_yticks(Ts)\n", + "ax_pd.set_xticks([np.round(ele,2) for ele in U_cs])\n", + "\n", + "ax_pd.spines['left'].set_bounds(Ts[-1], Ts[0])\n", + "ax_pd.spines['bottom'].set_bounds(ax_pd.get_xticks()[0], ax_pd.get_xticks()[-1])\n", + "\n", + "ax_pd.text(0.625, 0.3, \"AFM\", transform = ax_pd.transAxes, size=24, color='C0')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Particle-Hole Symmetry\n", + "\n", + "The Hubbard model with only nearest neighbor hopping inhibts a useful particle-hole symmetry.\n", + "To introduce this, let us first introduce the notation of a bipartite lattice.\n", + "A bipartite lattice can be subdivided into two sublattices for which every lattice site on one of them only has neighboring sites from the other sublattice.\n", + "This is the case for our square lattice.\n", + "\n", + "Let us now introduce a new kind of creation and annihilation operator\n", + "\n", + "$$\n", + "d_{l \\sigma}=(-1)^{l} c^\\dagger_{l \\sigma}\\,,\\quad\n", + "\\mathrm{and}\\quad\n", + "d_{l \\sigma}^{\\dagger}=(-1)^{l} c_{l \\sigma}\\,.\\\\\n", + "$$\n", + "\n", + "Here $l$ is either $0$ for one sublattice and $1$ for the other.\n", + "\n", + "Using this substitution is called particle-hole transformation (PHT), because the analog of the number operator for these new ones counts the number of holes, i.e.\n", + "\n", + "$$\n", + "\\tilde{n}_{l \\sigma} = d_{l \\sigma}^{\\dagger} d_{l \\sigma}= \\underbrace{(-1)^{2l}}_{=1} c_{l \\sigma}c_{l \\sigma}^{\\dagger} = 1-c_{l \\sigma}^{\\dagger} c_{l \\sigma}=\n", + "1-n_{l \\sigma}\\,.\n", + "$$\n", + "\n", + "Let us now inspect how the Hubbard Hamiltonian changes under such a PHT.\n", + "The kinetic part consists for only nearest neighbor hopping of terms of the form $c_{1 \\sigma}^{\\dagger} c_{j \\sigma}$, where $l$ and $j$ are always from a different sublattice.\n", + "Using the PHT on it yields\n", + "\n", + "$$\n", + "c_{l \\sigma}^{\\dagger} c_{j \\sigma} \\xrightarrow{\\mathrm{PHT}} \\underbrace{(-1)^{j+l}}_{=-1} d_{l \\sigma} d_{j \\sigma}^{\\dagger}=\n", + "-d_{l \\sigma} d_{j \\sigma}^{\\dagger}= d_{l \\sigma}^{\\dagger} d_{j \\sigma}\\,,\n", + "$$\n", + "\n", + "showing that the kinetic part is invariant.\n", + "\n", + "The interaction has terms of the form $n_{j \\uparrow} n_{j \\downarrow}$, using the PHT here yields\n", + "\n", + "$$\n", + "n_{j \\uparrow} n_{j \\downarrow} = c_{j \\uparrow}^{\\dagger} c_{j \\uparrow} c_{j \\downarrow}^{\\dagger} c_{j \\downarrow}\n", + "\\xrightarrow{\\mathrm{PHT}}\n", + "(-1)^{4j} d_{j \\uparrow} d_{j \\uparrow}^{\\dagger} d_{j \\downarrow} d_{j \\downarrow}^{\\dagger}=\n", + "(1- d_{j \\uparrow}^{\\dagger}d_{j \\uparrow}) (1-d_{j \\downarrow}^{\\dagger}d_{j \\downarrow})=\\\\ \n", + "(1 - \\tilde{n}_{j \\uparrow}) (1 -\\tilde{n}_{j \\downarrow})=\n", + "1 - \\tilde{n}_{j \\uparrow} - \\tilde{n}_{j \\downarrow} + \\tilde{n}_{j \\uparrow}\\tilde{n}_{j \\downarrow}\\,,\n", + "$$\n", + "\n", + "which leads to additional terms.\n", + "But those terms only consist of a shift in chemical potential and an constant energy.\n", + "We can therfore write a new Hamiltonian for the Hubbard model which is also invariant in the interaction term for a PHT\n", + "\n", + "$$\n", + "H=-t \\sum_{\\langle j, l\\rangle \\sigma}\\left(c_{j \\sigma}^{\\dagger} c_{l \\sigma}+c_{l \\sigma}^{\\dagger} c_{j \\sigma}\\right)+U \\sum_{j}\\left(n_{j \\uparrow}-\\frac{1}{2}\\right)\\left(n_{j \\downarrow}-\\frac{1}{2}\\right)-\\mu \\sum_{j}\\left(n_{j \\uparrow}+n_{j \\downarrow}\\right)\\,,\n", + "$$\n", + "\n", + "we will cal this the particle-hole symmetric form of the Hubbard model.\n", + "\n", + "Doing the PHT on its interaction term yields\n", + "\n", + "$$\n", + "\\left(n_{j \\uparrow}-\\frac{1}{2}\\right)\\left(n_{j \\downarrow}-\\frac{1}{2}\\right) \\xrightarrow{\\mathrm{PHT}}\n", + "\\left(1-\\tilde{n}_{j \\uparrow}-\\frac{1}{2}\\right)\\left(1-\\tilde{n}_{j \\downarrow}-\\frac{1}{2}\\right) = \n", + "\\left(-\\tilde{n}_{j \\uparrow}+\\frac{1}{2}\\right)\\left(-\\tilde{n}_{j \\downarrow}+\\frac{1}{2}\\right)=\\\\\n", + "(-1)^2 \\left(\\tilde{n}_{j \\uparrow}-\\frac{1}{2}\\right)\\left(\\tilde{n}_{j \\downarrow}-\\frac{1}{2}\\right)=\n", + "\\left(\\tilde{n}_{j \\uparrow}-\\frac{1}{2}\\right)\\left(\\tilde{n}_{j \\downarrow}-\\frac{1}{2}\\right)\n", + "$$\n", + "\n", + "showing the invariance.\n", + "\n", + "Using the PHT on the chemical potential term yields\n", + "\n", + "$$\n", + "n_{j \\uparrow}+n_{j \\downarrow} \\xrightarrow{\\mathrm{PHT}} (1-\\tilde{n}_{j \\uparrow}) + (1-\\tilde{n}_{j \\downarrow}) = 2 - (\\tilde{n}_{j \\uparrow} + \\tilde{n}_{j \\downarrow})\\,,\n", + "$$\n", + "\n", + "and therefore an unimportant constant term, but also a sign change.\n", + "\n", + "The particle-hole symmetric form of the Hubbard model can therefore be mapped via a PHT to an identical Hubbard model with only a negative chemical potential.\n", + "\n", + "To use this knowledge let us now see how the spin operator in $z$-direction changes under a PHT\n", + "\n", + "$$\n", + "S^z_j = n_{j \\uparrow} - n_{j \\downarrow} \\xrightarrow{\\mathrm{PHT}} (1 - \\tilde{n}_{j \\uparrow}) - (1 - \\tilde{n}_{j \\downarrow}) = \\tilde{n}_{j \\downarrow} - \\tilde{n}_{j \\uparrow} = \\tilde{S}^z_j\\,.\n", + "$$\n", + "\n", + "This sign change for the direction of the spin is unimportant for the calculation of susceptibilites and therefore the spin susceptibility is invariant under PHT\n", + "\n", + "$$\n", + "\\langle S^z_jS^z_j \\rangle = \\langle \\tilde{S}^z_j\\tilde{S}^z_j \\rangle\\,.\n", + "$$\n", + "\n", + "The spin susceptibility calculated at a Hubbard model with some chemical potential $\\mu$ is therefore the same as for a Hubbard model with chemical potential $-\\mu$.\n", + "We test this by calculating the phase transition to the AFM for a few chemical potential" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n" + ] + } + ], + "source": [ + "mus = [-.5, -.25, -0.1, 0.1, .25, .5]\n", + "\n", + "hubbard_models = parameter_scan(hubbard, mu=mus)\n", + "\n", + "U_cs = []\n", + "\n", + "for hubbard_model in hubbard_models:\n", + " \n", + " U_c = get_spin_phase_transistion(hubbard_model) \n", + " U_cs.append(U_c)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.125, 0.3, 'AFM')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax_pd = plt.subplot(111)\n", + "\n", + "ax_pd.plot(mus, U_cs, \"o\", ls=\"-\")\n", + "ax_pd.fill_between(mus,[min(U_cs)]*len(U_cs),U_cs, alpha=0.25)\n", + "\n", + "ax_pd.set_ylabel('U [eV]', rotation=0, ha='right')\n", + "ax_pd.set_xlabel('$\\mu$ [eV]')\n", + "\n", + "ax_pd.set_yticks([min(U_cs), max(U_cs)])\n", + "ax_pd.set_xticks(mus)\n", + "ax_pd.set_xticklabels(mus, rotation=25)\n", + "\n", + "ax_pd.spines['left'].set_bounds(min(U_cs), max(U_cs))\n", + "ax_pd.spines['bottom'].set_bounds(min(mus), max(mus))\n", + "\n", + "ax_pd.text(0.725, 0.3, \"AFM\", transform = ax_pd.transAxes, size=24, color='C0')\n", + "ax_pd.text(0.125, 0.3, \"AFM\", transform = ax_pd.transAxes, size=24, color='C0')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we see that the AFM phase is indeed symmetric for $\\mu=0$.\n", + "\n", + "If we now introduce next-nearest neighbor hopping we introduce hopping between sublattices of the same type.\n", + "The kinetic term of the Hubbard model does then contain terms of the form $c_{1 \\sigma}^{\\dagger} c_{l \\sigma}$, which are not invariant under PHT\n", + "\n", + "$$\n", + "c_{l \\sigma}^{\\dagger} c_{l \\sigma} \\longrightarrow \\underbrace{(-1)^{2l}}_{=1} d_{l \\sigma} d_{l \\sigma}^{\\dagger}=\n", + "d_{l \\sigma} d_{l \\sigma}^{\\dagger}= -d_{l \\sigma}^{\\dagger} d_{l \\sigma}\\,.\n", + "$$\n", + "\n", + "Such a model is therefore not symmetric in its AFM phase for $\\mu=0$, which we can test.\n", + "\n", + "We alter our `ParameterCollection` `hubbard` where we have stored the parameters of our Hubbard model and give this new one the additional parameter `tp`.\n", + "This parameter stands for the energy gain of next-nearest neighbor hopping processes.\n", + "The `SquareLattice` class knows about this parameter and we can proceed as before to obatin the dispersion relation.\n", + "Plotting it, we already see, that the density of states is no longer symmetric.\n", + "We preceed as before and obtain a $\\mu-U$ phase diagram.\n", + "There we can observe that the symmetry is destroyed." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "hubbard_next_nearest_neighbor_hopping = hubbard.alter(tp=-0.05)\n", + "\n", + "H = create_square_lattice(**hubbard_next_nearest_neighbor_hopping)\n", + "\n", + "e_k_nn = H.on_mesh_brillouin_zone(n_k=(hubbard_next_nearest_neighbor_hopping.nk,\n", + " hubbard_next_nearest_neighbor_hopping.nk, 1))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'DOS')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "# -- Bandstructure\n", + "ax_bs = plt.subplot(gs[0])\n", + "ax_bs.bsplot(e_k[0,0], path, color='grey', ls=\"dotted\", alpha=0.5)\n", + "ax_bs.bsplot(e_k_nn[0,0], path)\n", + "ax_bs.set_ylabel('$\\epsilon(\\mathbf{k})$', rotation=0, ha='right')\n", + "\n", + "# -- Density of states\n", + "ax_dos = plt.subplot(gs[1])\n", + "ax_dos.dosplot(e_k[0,0], color='grey', linestyle='dotted')\n", + "ax_dos.dosplot(e_k_nn[0,0])\n", + "ax_dos.set_xlabel('DOS')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kaeser/anaconda3/envs/triqs_3/lib/python3.8/site-packages/scipy/optimize/zeros.py:776: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " r = _zeros._brentq(f, a, b, xtol, rtol, maxiter, args, full_output, disp)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n" + ] + } + ], + "source": [ + "mus = [-.5, -.25, -0.1, 0.1, .25, .5]\n", + "\n", + "hubbard_models = parameter_scan(hubbard_next_nearest_neighbor_hopping, mu=mus)\n", + "\n", + "U_cs = []\n", + "\n", + "for hubbard_model in hubbard_models:\n", + " \n", + " U_c = get_spin_phase_transistion(hubbard_model) \n", + " U_cs.append(U_c)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.08, 0.1, 'AFM')" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax_pd = plt.subplot(111)\n", + "\n", + "ax_pd.plot(mus, U_cs, \"o\", ls=\"-\")\n", + "ax_pd.fill_between(mus,[min(U_cs)]*len(U_cs),U_cs, alpha=0.25)\n", + "\n", + "ax_pd.set_ylabel('U [eV]', rotation=0, ha='right')\n", + "ax_pd.set_xlabel('$\\mu$ [eV]')\n", + "\n", + "ax_pd.set_yticks([min(U_cs), max(U_cs)])\n", + "ax_pd.set_xticks(mus)\n", + "ax_pd.set_xticklabels(mus, rotation=25)\n", + "\n", + "ax_pd.spines['left'].set_bounds(min(U_cs), max(U_cs))\n", + "ax_pd.spines['bottom'].set_bounds(min(mus), max(mus))\n", + "\n", + "ax_pd.text(0.725, 0.3, \"AFM\", transform = ax_pd.transAxes, size=24, color='C0')\n", + "ax_pd.text(0.08, 0.1, \"AFM\", transform = ax_pd.transAxes, size=24, color='C0')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Semi particle-hole transformation\n", + "\n", + "If we use the PHT only on one spin specices it is called a semi particle-hole transformation (SPHT).\n", + "This means\n", + "\n", + "$$\n", + "c_{j \\uparrow}^{\\dagger} \\xrightarrow{\\mathrm{SPHT}} d_{j \\uparrow}^{\\dagger}\\quad\\mathrm{and}\\quad\n", + "c_{j \\uparrow} \\xrightarrow{\\mathrm{SPHT}} d_{j \\uparrow}\\\\\n", + "c_{j \\downarrow}^{\\dagger} \\xrightarrow{\\mathrm{SPHT}} (-1)^j d_{j \\downarrow}\\quad\\mathrm{and}\\quad\n", + "c_{j \\downarrow} \\xrightarrow{\\mathrm{SPHT}} (-1)^j d_{j \\downarrow}^{\\dagger}\\,.\n", + "$$\n", + "\n", + "Lets remember the particle-hole symmetric Hubbard model that is invariant under a PHT\n", + "\n", + "$$\n", + "H=-t \\sum_{\\langle j, l\\rangle \\sigma}\\left(c_{j \\sigma}^{\\dagger} c_{l \\sigma}+c_{l \\sigma}^{\\dagger} c_{j \\sigma}\\right)+U \\sum_{j}\\left(n_{j \\uparrow}-\\frac{1}{2}\\right)\\left(n_{j \\downarrow}-\\frac{1}{2}\\right)-\\mu \\sum_{j}\\left(n_{j \\uparrow}+n_{j \\downarrow}\\right)\\,.\n", + "$$\n", + "\n", + "The kinetic term only consist of operators with the same spin and is therefore invariant under SPHT as it was under PHT.\n", + "The interaction term on the underhand has to be treated with more care\n", + "\n", + "$$\n", + "\\left(n_{j \\uparrow}-\\frac{1}{2}\\right)\\left(n_{j \\downarrow}-\\frac{1}{2}\\right) \\xrightarrow{\\mathrm{SPHT}}\n", + "\\left(\\tilde{n}_{j \\uparrow}-\\frac{1}{2}\\right)\\left(1-\\tilde{n}_{j \\downarrow}-\\frac{1}{2}\\right) = \n", + "\\left(\\tilde{n}_{j \\uparrow} - \\frac{1}{2}\\right)\\left(\\frac{1}{2}-\\tilde{n}_{j \\downarrow}\\right) = \\\\\n", + "-\\left(\\tilde{n}_{j \\uparrow} - \\frac{1}{2}\\right)\\left(\\tilde{n}_{j \\downarrow}-\\frac{1}{2}\\right)\\,.\n", + "$$\n", + "\n", + "Under a SPHT we map the repulsive Hubbard model with $U$ to the attractive one with $-U$.\n", + "The chemical potential term is also not invariant under a SPHT\n", + "\n", + "$$\n", + "n_{j \\uparrow}+n_{j \\downarrow} \\xrightarrow{\\mathrm{SPHT}}\n", + "\\tilde{n}_{j \\uparrow}+1-\\tilde{n}_{j \\downarrow} = \n", + "1 + \\left(\\tilde{n}_{j \\uparrow}-\\tilde{n}_{j \\downarrow}\\right)\\,,\n", + "$$\n", + "\n", + "and transforms into a Zeeman term.\n", + "\n", + "To summarize the SPHT maps the Hubbard Hamiltonian with interaction strength $U$ and chemical potential $\\mu$ to a Hubbard Hamiltonian with interaction strength $-U$, a chemical potential of $0$ and an additional Zeeman term of strength $\\mu$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets start again with the spin operator in $z$-direction,\n", + "\n", + "$$\n", + "S^z_j = n_{j \\uparrow} - n_{j \\downarrow} \\xrightarrow{\\mathrm{SPHT}} \\tilde{n}_{j \\uparrow} - (1 - \\tilde{n}_{j \\downarrow}) = -1 + \\tilde{n}_{j \\uparrow} + \\tilde{n}_{j \\downarrow}\\,.\n", + "$$\n", + "\n", + "which is just the density operator \n", + "\n", + "$$\n", + "\\tilde{n}_{j}= \\tilde{n}_{j \\uparrow} + \\tilde{n}_{j \\downarrow}\n", + "$$\n", + "\n", + "with a constant.\n", + "If one calculates a susceptibility one is only interested in the change of the expectation value of an obserable $A$ when going from an unperturbed system to one which is perturbed by a field coupling to operator $B$.\n", + "Therefore a constant factor in an observable is unimportant when calculating susceptibilites.\n", + "\n", + "If we consider a Hubbard model at half-filling, i.e. $\\mu=0.0$ the $T-U$, this means, that the spin-susceptibility in the repulsive Hubbard model is equal to the charge-suscpeitbility in the attractive one.\n", + "We already see this in the RPA equations for the susceptibilites were they only differ by a sign, but we will test it anyways.\n", + "To study the transition to a charge density wave we will the function `get_charge_phase_transistion`, were we scan for divergences is the range of negative $U$." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def get_charge_phase_transistion(p):\n", + " \"\"\"Return U at which model p transitions to charge order via root search\n", + " \"\"\"\n", + " chi0_wk = get_chi0(p)\n", + " \n", + " def one_over_charge(U):\n", + "\n", + " chi_c_wk, _ = get_chiRPA(p.alter(U=U), chi0_wk)\n", + " \n", + " # -- If any value is below zero we are already in an ordered phase\n", + " if np.any(chi_c_wk.data[np.abs(chi_c_wk.data) > 1e-3] < 0.0 ):\n", + " return -1\n", + " \n", + " chi_at_critical_k = np.max(chi_c_wk.data)\n", + " return 1./chi_at_critical_k\n", + " \n", + " U_c = brentq(one_over_charge, -10, 0.0)\n", + " \n", + " return U_c" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 15.472700008220936\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 15.472700008220936\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 23.209050012331403\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 23.209050012331403\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 46.418100024662806\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 46.418100024662806\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n" + ] + } + ], + "source": [ + "Ts = [1000, 750, 500, 250]\n", + "hubbard_models = parameter_scan(hubbard, T=Ts)\n", + "\n", + "U_spin_cs = []\n", + "U_charge_cs = []\n", + "\n", + "for hubbard_model in hubbard_models:\n", + " \n", + " U_spin_c = get_spin_phase_transistion(hubbard_model)\n", + " U_charge_c = get_charge_phase_transistion(hubbard_model) \n", + "\n", + " U_spin_cs.append(U_spin_c)\n", + " U_charge_cs.append(U_charge_c)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.07, 0.15, 'CDW')" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(10,7))\n", + "\n", + "ax_pd = plt.subplot(111)\n", + "\n", + "ax_pd.plot(U_spin_cs, Ts, \"o\", ls=\"-\")\n", + "ax_pd.fill_between(U_spin_cs, Ts, [Ts[-1]]*len(Ts), alpha=0.25)\n", + "\n", + "ax_pd.plot(U_charge_cs, Ts, \"o\", ls=\"-\")\n", + "ax_pd.fill_between(U_charge_cs, Ts, [Ts[-1]]*len(Ts), alpha=0.25)\n", + "\n", + "ax_pd.set_ylabel('Temperature\\n[Kelvin]', rotation=0, ha='right', multialignment='center')\n", + "ax_pd.set_xlabel('U [eV]')\n", + "\n", + "ax_pd.set_yticks(Ts)\n", + "ax_pd.set_xticks([np.round(ele,2) for ele in U_spin_cs+U_charge_cs])\n", + "ax_pd.set_xticklabels([np.round(ele,2) for ele in U_spin_cs+U_charge_cs], rotation=45)\n", + "\n", + "ax_pd.spines['left'].set_bounds(Ts[-1], Ts[0])\n", + "ax_pd.spines['bottom'].set_bounds(min(ax_pd.get_xticks()), max(ax_pd.get_xticks()))\n", + "\n", + "ax_pd.text(0.83, 0.15, \"AFM\", transform = ax_pd.transAxes, size=22, color='C0')\n", + "ax_pd.text(0.07, 0.15, \"CDW\", transform = ax_pd.transAxes, size=22, color='C1')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see the two phases are perfectly symmetric for $U=0$.\n", + "\n", + "The SPHT also gives information about the superconducting phase of the attractive Hubbard model, this can be seen by transforming the ladder operators of the spin\n", + "\n", + "$$\n", + "S^+_j = S^x_j + iS^y_j = c_{j \\uparrow}^{\\dagger}c_{j \\downarrow} \\xrightarrow{\\mathrm{SPHT}} (-1)^j d_{j \\uparrow}^{\\dagger}d_{j \\downarrow}^{\\dagger} = \\tilde{\\Delta}^{\\dagger}\\,,\\\\\n", + "S^-_j = S^x_j - iS^y_j = c_{j \\downarrow}^{\\dagger}c_{j \\uparrow} \\xrightarrow{\\mathrm{SPHT}} (-1)^j d_{j \\downarrow}d_{j \\uparrow} = \\tilde{\\Delta}\\,.\n", + "$$\n", + "\n", + "The x- and y-components of the spin operator are transformed to the complex superconducting oder parameter with a phase factor.\n", + "We wil focus on $S^x$, because even if we apply a Zeeman term the x- and y-components will be degenerate.\n", + "This means, that if we find a diverging $\\langle S^xS^x \\rangle$ in the repulsive model at some $U$, giving us AFM inplane order, we will see a homogeneous superconducting phase at $-U$.\n", + "\n", + "To calculate $\\langle S^xS^x \\rangle$ we need the spin dependent general susceptibility tensor.\n", + "We can obtain this from $\\chi^{(c)}$ and $\\chi^{(s)}$ if our system is $\\mathrm{SU(2)}$ symmetric.\n", + "This can be done via the `general_susceptibility_from_charge_and_spin` function from `triqs_tprf.rpa_tensor`." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n" + ] + } + ], + "source": [ + "from triqs_tprf.rpa_tensor import general_susceptibility_from_charge_and_spin\n", + "\n", + "chi_c_wk, chi_s_wk = get_chiRPA(hubbard)\n", + "\n", + "chi_rpa_general_wk = general_susceptibility_from_charge_and_spin(chi_c_wk, chi_s_wk)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then use the matrix representation of $S^x$ to do the contraction with `chi_rpa_general_wk` to obtain $\\langle S^xS^x \\rangle$.\n", + "This can be done via the function `chi_contraction` in `triqs_tprf.lattice_utils`." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "from triqs_tprf.lattice_utils import chi_contraction\n", + "\n", + "S_x = 0.5 * np.array([[0,1], [1,0]])\n", + "\n", + "chi_sxsx = chi_contraction(chi_rpa_general_wk, S_x, S_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But for a $\\mathrm{SU(2)}$ symmetric system doing this is unnecessary, because\n", + "\n", + "$$\n", + "\\langle S^z S^z \\rangle = \\langle S^x S^x \\rangle\\,,\n", + "$$\n", + "\n", + "and we therefore already know where the superconducting phase in the attractive model lies, it is degenerate with the CDW.\n", + "\n", + "### Linearized Eliashberg equation\n", + "\n", + "We will now use the implementation of the linearized Eliashberg equation to confirm this superconducting phase.\n", + "To do this we need to construct the (singlet) particle-particle vertex $\\Gamma(\\omega, \\mathbf{k})$ which is for the attractive Hubbard model [N. E. Bickers, Self-Consistent Many-Body Theory for Condensed Matter Systems. Theoretical Methods for Strongly Correlated Electrons, 237–296. 6 (2006)]\n", + "\n", + "$$\n", + "\\Gamma(\\omega, \\mathbf{k}) = -2U\\,.\n", + "$$\n", + "\n", + "We can then use the `solve_eliashberg` function of the `triqs_tprf.eliashberg` module to solve the linearized eliashberg equation for the specifc $\\Gamma$ to obtain the $\\lambda$ as an indicator for the strength of the superconducting phase.\n", + "If\n", + "\n", + "$$\n", + "\\lambda = 1\n", + "$$\n", + "\n", + "we encounter a phase transition to the superconducting phase.\n", + "To find this phase transition we use the same procedure as for the susceptibilites and search when\n", + "\n", + "$$\n", + "\\lambda - 1 \\approx 0\\,.\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "from triqs.gf import Gf, MeshProduct\n", + "from triqs_tprf.eliashberg import solve_eliashberg\n", + "\n", + "def get_lambda_delta(p, g0_wk=None):\n", + " \"\"\"Solve the linearized eliashberg equation for model parameters in a ParameterCollection\n", + " \"\"\"\n", + " if not g0_wk:\n", + " H = create_square_lattice(**p)\n", + " e_k = H.on_mesh_brillouin_zone(n_k=(p.nk, p.nk, 1))\n", + "\n", + " wmesh = MeshImFreq(beta=temperature_to_beta(p.T), S='Fermion', n_max=p.nw)\n", + " g0_wk = lattice_dyson_g0_wk(mu=p.mu, e_k=e_k, mesh=wmesh)\n", + " \n", + " # -- Make particle-particle vertex that is constant is frequency and momentum space\n", + " wmesh_boson = MeshImFreq(beta=temperature_to_beta(p.T), S='Boson', n_max=p.nw)\n", + " gamma_pp = Gf(mesh=MeshProduct(wmesh_boson, g0_wk.mesh[1]),\n", + " target_shape=g0_wk.target_shape*2)\n", + " gamma_pp.data[:] = 2*p.U\n", + " \n", + " Es, eigen_modes = solve_eliashberg(gamma_pp, g0_wk, solver='IRAM', tol=1e-5)\n", + "\n", + " return Es[0], eigen_modes[0]\n", + "\n", + "def get_sc_phase_transistion(p, guess=None):\n", + " \"\"\"Return U at which model p transitions to superconducting order via root search\n", + " \"\"\"\n", + " H = create_square_lattice(**p)\n", + " e_k = H.on_mesh_brillouin_zone(n_k=(p.nk, p.nk, 1))\n", + "\n", + " wmesh = MeshImFreq(beta=temperature_to_beta(p.T), S='Fermion', n_max=p.nw)\n", + " g0_wk = lattice_dyson_g0_wk(mu=p.mu, e_k=e_k, mesh=wmesh)\n", + " \n", + " def lambda_minus_1(U):\n", + " lamb, _ = get_lambda_delta(p.alter(U=U), g0_wk) \n", + " return lamb - 1.0\n", + " \n", + " upper = 1.1*guess\n", + " lower = 0.9*guess\n", + " \n", + " U_c = brentq(lambda_minus_1, lower, upper)\n", + "\n", + " return U_c" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "Ts = [1000, 750, 500, 250]\n", + "hubbard_models = parameter_scan(hubbard, T=Ts)\n", + "guesses = [-ele for ele in U_spin_cs]\n", + "\n", + "U_sc_cs = []\n", + "\n", + "for hubbard_model, guess in zip(hubbard_models, guesses):\n", + " \n", + " U_sc_c = get_sc_phase_transistion(hubbard_model, guess)\n", + "\n", + " U_sc_cs.append(U_sc_c)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.07, 0.15, 'SC')" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxUAAAHjCAYAAABVSTInAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXxcV3n/8c/MaGTJkiVrJFl2pJG3eImdOItJcNgcKBQTSAiLISwlpqUQGlIKlBKW/k4PZS0pSwktZactEBoIKVBCUiAOSxLbsWMbL5LlOHIsW5JtyZYs2aNlZn5/3JnRSB7to7kzo++7L73u3HvPvfcZ0cjzzDnPOZ5oNIqIiIiIiMhUed0OQEREREREcpuSChERERERmRYlFSIiIiIiMi1KKkREREREZFqUVIiIiIiIyLQoqRARERERkWkpcDsAEUHzOouIiEiu8KQ6qJ4KERERERGZFiUVIiIiIiIyLUoqRERERERkWpRUiIiIiIjItCipEBERERGRaVFSISIiIiIi06KkQkREREREpkVJhYiIiIiITIuSChERERERmRYlFSIiIiIiMi0FbgcgMpK19vXARuAq4EpgHvA9Y8xbx7jmecDHgA1AEXAY+BbwZWNMeJRrbgPuANYAYeAp4G5jzM9HaV8M3AXcCiwGuoGtgDHGHJz0GxURERHJE0oqJBt9DCeZ6AFagNVjNbbWvhr4MRACfgh0AjcBXwCeD2xOcc3dwAdi9/86UIiTLPzMWnunMeaeEe3nAP8Xu9+TwJeAYOzer7TWvsQYs22K73dGdHZ28vjjj7N37176+/spLCxk3bp1XH/99QQCAbfDExERkWlq7W3lgcP3s/XYI4QGQxQVFHFD8MXcculrWVSyKKOxaPiTZKP3ASuBMuDdYzW01pbhJAVh4AZjzF8YYz6I08vxOPB6a+2tI655Hk5C8TSwzhjzPmPMHcB6nITkbmvtkhGPej9OQvEj4LnGmA8ZY94MvB6YC3zLWps1/z01NTXx1a9+lV27dtHf3w9Af38/u3bt4qtf/SpNTU0uRygiIiLTsbP9Sf76N3fwcPNDXBi8QJQoFwYv8HDzQ/z1b+5gZ/uTGY0naz4EicQZYx4xxjQZY6ITaP56oBq41xiT+K/HGBPC6fGAixOT22PbTxpjziRd0wx8BZgDvD1+3FrrSbrm74wxkaRr/gf4Hc4Qqo0TiHfGdXZ2ct999zEwMEAkEhl2LhKJMDAwwH333UdnZ6dLEYqIiMh0tPa28pntn6Iv3Ec4OnyUdzgapi/cx2e2f4rW3taMxaSkQnLdS2LbX6Y491vgPPC82PCliVzz4Ig2AMuBeuCQMeaZCV7jmscff5xwOGUZSUI4HOaJJ57IUEQiIiKSTg8cvp/ByOCYbQYjg/zP4Z9kKCLVVEjuWxXbHhp5whgzaK19BlgLLAMOWmtLgFqgxxiTKn2PjwtaOZFnjHHNMNbaLcCWFKcurays5NJLL2XTpk2jXT4pe/fuvaiHYqRIJMLevXu58cYb0/JMERERyZytxx65qIdipHA0zNZjj3D7lX+VkZiUVEiuK49tu0Y5Hz8+f4rtp3rNSEsYZXhUR0cHpaWlY1w6OfEainS1ExERkewSGgxNqN2FwQszHMkQJRWS7zyx7UTqM5JNpv1EntEMPJri+FUMJS1pUVhYOKGEobCwMJ2PFRERkQwpKiiaUMJQXFCcgWgcSiok18V7CUb7YF42ot147VP1Skz2GRcxxnwH+M7I49baraS5wHvdunXs2rVrzCFQXq+XdevWpfOxIiIikiE3BF/Mw80PjTkEyufxcUPwxRmLSYXakusaY9uL6hmstQXAUmAQOAJgjOkFjgOl1tpUEziviG2T6ydGfcYY17jm+uuvx+fzjdnG5/OxYcOGDEUkIiIi6XTLpa+lwDt230CBt4BXX/qaDEWkpEJy329i21RVzi/CWUPiMWNM3wSvecWINuCsZ/EssNJau3SC17gmEAiwefNm/H4/Xu/F/4n7/X42b96sBfBERERy1KKSRdx13Ufwe/0XnfN5fMzxzeGu6z6S0QXwlFRIrvsRcBq41Vr7nPhBa20R8InY7r+NuOarse1HrbUVSdcsAe4A+oBvx4/H1suIX/NPyYvcxVbzfiFwgNQ1E65YsWIFt99+O+vXr8fvH/qDU1BQwLve9S5WrFgxxtUiIiKS7dbXPIeX1f/psGPFBcW8fMkm/uUlX2F9zXNGuXJmeKLRydaviswsa+0twC2x3YXAy3GGL/0uduy0MeZvR7T/ERAC7sVZFftmnKlgfwS8YeRCetbaf8ZZJbsl1qYQeCNQCdxpjLlnRPs5OD0RzwOeBH6Ns3bFZqAfeIkxZtsU3utWYOPixYvZsmXLZC+fkGg0yqc//WkGBgYAeM973kNlZeWMPEtEREQy5yO/u4t9HX8E4FXLbuYNq97I/DljTUaZFp5UB9VTIdnoKuC22M/LY8eWJR17fXJjY8wDOMXOvwVeB9wJDOAkDbemWpnbGPMBnHUj2oB3Am8D9gM3jUwoYu37gJcCH8eZOvZ9wMuAB4Brp5JQZIrH46Gqqiqxf/ToURejERERkXQYCA/QeKYhsV9XWudiNOqpEHFVJnoqAH7yk5+wd+9eAK688kpuueWWca4QERGRbHag4wB3/e6DAMyfU8E7rvhL1lVfqZ4KEZk56qkQERHJLwc69iVeLylb7GIkDiUVIrNARUVFYprZs2fP0t3d7XJEIiIiMh0HOvYnXi8tW+5iJA4lFSKzgM/nG9Zb8eyzz7oYjYiIiExHOBrmQMeBxP7S8iXuBROjpEJklqipqUm81hAoERGR3HW0q5nzg+cBKPGXEChyf1ZHJRUis8SCBQsSr5VUiIiI5K7koU+L5y3G40lZO51RSipEZomqqqrEH51Tp05x4cIFlyMSERGRqdifXE9RvszFSIYoqRCZJfx+P4FAILGvugoREZHcE41GhxdpK6kQkUxLrqtQUiEiIpJ7WntPcKbvDABzfHOomVszzhWZoaRCZBZRsbaIiEhuSx76FCwN4vVkx8f57IhCRDIiuVi7tbWVgYEBF6MRERGRycrGoU+gpEJkVikqKqK8vByASCRCS0uLyxGJiIjIZGRjkTYoqRCZdTQESkREJDd1XOigrbcVgAJPAbWltS5HNERJhcgso6RCREQkNyUPfbqk9BIKvAUuRjOckgqRWSY5qWhpaSEcDrsYjYiIiEzUsKFPZdkz9AmUVIjMOiUlJZSUlAAwODhIa2uryxGJiIjIRCT3VCybr6RCRFym9SpERERyS0//OY52NwPgwUNwXr27AY2gpEJkFlJdhYiISG452HmQKFEAaubWMMc3x+WIhlNSITILjeypiEajLkYjIiIi49nfsS/xOpumko1TUiEyC5WVlVFUVARAKBTi1KlTLkckIiIiYxlWT6GkQkSygcfjGba6toZAiYiIZK++wRCHzxxO7C8uW+JeMKNQUiEyS6lYW0REJDc0nmlkMDoIQGVRJSX+EpcjupiSCpFZKjmpaG5uVl2FiIhIlkoe+rQkC3spQEmFyKxVUVFBQYGzEmdPTw9nz551OSIRERFJZdiid+XLXYxkdEoqRGYpr9c7rK5CQ6BERESyz2BkkMbOhsT+0vKlLkYzOiUVIrOYirVFRESy25GupwmFQwCUFZYxf858lyNKTUmFyCymRfBERESy2/7TQ0Of6uctdjGSsSmpEJnFqqur8XqdPwOdnZ309PS4HJGIiIgky/b1KeKUVIjMYj6fj6qqqsS+6ipERESyRyQa4UDngcR+Nq6kHaekQmSWU7G2iIhIdmo518K5/m4AiguKqS6udjmi0SmpEJnlVFchIiKSnfZ37Eu8Ds6rx+PxuBjN2JRUiMxyyT0V7e3t9PX1uRiNiIiIxCXXUyzP0vUp4pRUiMxyhYWFBAIBAKLRKMeOHXM5IhEREYHhi94tKcvO9SnilFSIiNarEBERyTInz5/k9IVTAPi9fhaVLnI5orEpqRAR1VWIiIhkmf2nh+op6krr8Hl8LkYzPiUVIjIsqThx4gSDg4MuRiMiIiLJRdrZPJVsnJIKEaG4uJiysjIAwuEwx48fdzkiERGR2S1XFr2LU1IhIoDWqxAREckWXX1dtPS0AOD1eKkrDboc0fiUVIgIoLoKERGRbJHcS7Go5BL8Pr+L0UyMkgoRAYYnFceOHSMSibgYjYiIyOyVXE+xpGyJe4FMgpIKEQGgtLSU4uJiAPr7+2lvb3c5IhERkdkplxa9i1NSISIAeDweDYESERFx2fmB8xw5eySxX1+22MVoJk5JhYgkKKkQERFxV+OZBiI4Q5AXFC+guKDY5YgmRkmFiCQkJxXPPvss0WjUxWhERERmn+RF7xbnSD0FKKkQkSTz58+nsLAQgPPnz9PR0eFyRCIiIrPL/uR6ivm5UU8BSipEJInH49F6FSIiIi4ZCA9w6ExjYl89FSKSs1RXISIi4o6ms00MRAYAmD+ngrLCMpcjmjglFSIyjJIKERERdxwYtj5Fbsz6FKekQkSGCQQC+Hw+ALq6uuju7nY5IhERkdkhuZ5iaVnu1FOAkgoRGcHn81FdXZ3YV2+FiIjIzAtHwxzsOJDYX1q+1MVoJk9JhYhcZOTUsiIiIjKzjnY1c37wPAAl/hICRQGXI5ocJRUichHVVYiIiGTWgaShT4vnLcbj8bgYzeQpqRCRi1RVVSX+mJ06dYrz58+7HJGIiEh+25dUpL20fJmLkUyNkgoRuYjf76eysjKxf+zYMRejERERyW/RaHRYT4WSChHJG8mL4GkIlIiIyMxp7T3B2b6zAMzxzaFmbs04V2QfJRUikpLqKkRERDIjeSrZYGkQryf3PqLnXsQikhHJPRVtbW309/e7GI2IiEj+yvWhT6CkQkRGUVRUxPz58wGIRCK0tLS4HJGIiEh+2n86t4u0QUmFiIwhubdC61WIiIikX8eFDtrOtwFQ4CmgtrTW5YimRkmFiIxKdRUiIiIzK3no0yWltRR4C1yMZuqUVIjIqJKTipaWFsLhsIvRiIiI5J/kIu2lZUtdjGR6lFSIyKhKSkooLS0FYHBwkNbWVpcjEhERyS/7kxa9WzY/N+spQEmFiIxD61WIiIjMjJ7+czzb7fzb6sFDcF69yxFNnZIKERmT6ipERERmxsHOg0SJArCwZCFzfHNcjmjqlFSIyJiSk4pjx44RjUZdjEZERCR/JA99WpLD9RSgpEJExlFWVkZRUREAoVCIkydPuhyRiIhIfkie+WlZjq5PEaekQkTG5PF4tF6FiIhImvUNhmg605TYX1y2xL1g0kBJhYiMS3UVIiIi6dV4ppFw1JmqvbKoihJ/icsRTY+SChEZ18ikQnUVIiIi05M89GlJ2WIXI0kPJRUiMq6Kigr8fj8APT09nD171uWIREREctuwRe/Kl7sYSXooqRCRcXm9XqqrqxP7GgIlIiIydYORQRo6Dyb2l5bn9sxPoKRCRCYoeQiUirVFRESm7kjX0/SF+wAoKyxj/pz5Lkc0fUoqRGRCtLK2iIhIeuw/PTT0afG8Je4FkkZKKkRkQqqrq/F6nT8ZnZ2d9PT0uByRiIhIbjowrJ4i94c+gZIKEZkgn89HVVVVYl9DoERERCYvEo1woPNAYn9pji96F6ekQkQmTOtViIiITE/LuWOc6+8GoLigmOri6nGuyA1KKkRkwlRXISIiMj3JU8nWz6vH4/G4GE36KKkQkQlbsGBB4o9fe3s7oVDI5YhERERyS3I9xbI8WJ8iTkmFiExYYWEhFRUVif1jx465GI2IiEhuiUaj7O/Yl9hfUpYfRdqgpEJEJknrVYiIiEzNyfMnOX3hNAB+r59FpYtcjih9lFSIyKSorkJERGRqkoc+1ZUG8Xl8LkaTXkoqRGRSknsqTpw4weDgoIvRiIiI5I7koU/5sj5FnJIKEZmU4uJiysrKAAiHwxw/ftzliERERHLD8CLt/FifIk5JhYhMmtarEBERmZyzfWdp6WkBwOvxUlcadDmi9FJSISKTproKERGRyUnupVhUcgl+n9/FaNJPSYWITFpyT8WxY8eIRCIuRiMiIpL9kpOKpXk0lWyckgoRmbTS0lLmzp0LwMDAAG1tbS5HJCIikt3yuZ4ClFSIyBR4PJ5hQ6C0XoWIiMjozg+c58jZI4n9+rLFLkYzM5RUiMiUqFhbRERkYho6DxLBGSq8oHgBxQXFLkeUfkoqRGRKRq6sHY1GXYxGREQkeyUPfVqSZ+tTxCmpEJEpmT9/PoWFhQCcP3+ejo4OlyMSERHJTvuH1VMsdzGSmaOkQkSmZGRdhYZAiYiIXGwgPMChM42J/SVlS9wLZgYpqRCRKRs5BEpERESGazp7iIHIAADz51Qwr3CeyxHNDCUVIjJlyUlFc3Oze4GIiIhkqeShT0vycNanOCUVIjJlgUCAgoICALq7u+nq6nI5IhERkexyYBbUU4CSChGZBp/PR1VVVWJfQ6BERESGhKNhDnYcSOwvycOVtOOUVIjItGi9ChERkdSOdjVzfvA8ACX+UgJFAZcjmjlKKkRkWpRUiIiIpJZcT7F4Xj0ej8fFaGaWkgoRmZaqqqrEH8nTp09z/vx5lyMSERHJDvs79iVe53M9BSipEJFp8vv9VFZWJvZVVyEiIgLRaHRYkfbSPF1JO05JhYhMm9arEBERGa619wRn+84CMMc3hwVza8a5IrcVuB2ASDpYa7cA3x6nWcQY44u1XwI8M0bbHxpjbh3lWbcBdwBrgDDwFHC3Mebnk4s6fyxYsID9+51vY1RXISIiAvtODw19CpYG8Xry+7t8JRWSL3YDdpRzLwReAjyY4twe4IEUx/elOIa19m7gA0AL8HWgELgV+Jm19k5jzD2TjDsvLFiwIPH6xIkTWGspLCxk3bp1XH/99QQC+TvbhYiISLLW3lYeOHw/Dzc/lDgWCofouNBBZXHlGFfmNiUVkheMMbtxEouLWGsfj738WorTu40x/zCRZ1hrn4eTUDwNXGuMORM7/jlgJ3C3tfbnxpjmyUWf+06fPn3Rsf7+fnbt2sWePXvYvHkzK1ascCEyERGRzNnZ/iSf2f4pBiODhKPhxPHjPcf58u4v8abVb2FVxSoXI5w5+d0PI7OetfZyYANwHPjfad7u9tj2k/GEAiCWRHwFmAO8fZrPyDnd3d08+uijKc9FIhEGBga477776OzszHBkIiIimdPa28pntn+KvnDfsIQCIEqUgcgAP2j4Hh0XOlyKcGapp0Ly3bti228aY8Ipzl9irX0XUAl0AI8bY/aOcq+XxLa/THHuQeDvY23MNOLNOQcOHCAcTvWrHRIOh3niiSe48cYbMxSViIhIZj1w+H4GI4NjtglHwvzhxO+5efmrMxRV5iipkLxlrS0G3gpEgG+M0uxlsZ/k67YCtxljnk06VgLUAj3GmNYU92mKbVeOEssWYEuKU1eN+gZyxJEjR4hGo2O2iUQi7N27V0mFiIjkra3HHrmoh2KkCBF2n3oqL5MKDX+SfPYGYD7woDHm2Ihz54F/BNYDFbGfjcAjwA3Ar2OJRFx5bNs1yrPix+ePcn5J7P4jf8pHaZ8zBgYGJtSuv79/hiMRERFxT2gwNKF2/eH8/PdQPRWSz94Z2/77yBPGmJPA/xtx+LfW2j8Ffg88F3gH8KVJPnO0r+ybgVSFB1eR44mF3++fUGJRWFiYgWhERETcUVRQxIXBC+O2K/Tl57+HSiokL1lr1wDPw5n69RcTvc4YM2it/QZOUvEihpKKeE/EaAnAmD0ZxpjvAN9JEedWnB6LnLVs2TIOHTo05hAor9fLunXrMhiViIhIZt0QfDEPNz805hAoL16uqr46g1FljoY/Sb4ar0B7LKdi28TwJ2NML84MUqXW2kUpronPl3poks/KeWvWrMHn843ZxufzsWHDhgxFJCIiknm3XPpaCrxjf1/v8/p4/iUvyFBEmaWkQvKOtbYI+DOcAu1vTuEW8U+/R0Yc/01suynFNa8Y0WbWKCsrY+PGjRQUFODxeC467/f72bx5sxbAExGRvLaoZBF3XHVnynNevPi9ft60+i15uwCekgrJR5txCq9/kaJAGwBr7XOttRcNarTWvgR4X2z3v0ac/mps+1FrbUXSNUuAO4A+4NvTijxH1dXVcdNNN7Fy5cphvRbFxcXcfvvtWvhORERmhb5wX+K1J/Z/c3xzuHbhddx51XvzduE7UE2F5Kd4gXaqFbTjPgusjdU0tMSOrWNoLYq/N8Y8lnyBMeYxa+3ngfcDe621PwIKgTcCAeDO2biadlxZWRkbNmzgmmuu4d577yUajXLhwgUKCvRnRkREZodtrU8kXr98ySt4Ye0LXYwms9RTIXnFWnsZ8ALGL9D+T2AbcC3wl8Bf4dRF/DfwImPMJ1JdZIz5AM56E204ycvbgP3ATcaYe9LzLnJbYWEhCxcuTOw3Nja6GI2IiEhmXBi8wJ5TuxP7ayvXuhhN5o35FaK1duwVrUb3qDHmhileK5Ngrb0BZ12F3caYB9yNxn3GmIPAxQP7L273TaZWb4Ex5rvAd6dy7WwRDAZpbXXWCGxoaODaa691OSIREZGZtfvkUwxEnCnWq4qrCRTNrlrC8Xoq2kf5iU9KHxrlfOdMBCsp3QAY4BaX4xBJCAaDidfNzc309fWN0VpERCT3JQ99uixwmYuRuGPMngpjzMJUx5Pm1v+hMWZL+sMSkVxWWlpKIBCgs7OTSCTC4cOHWbt2dnUDi4jI7BGOhNnRviOxf3nl5S5G4w7VVIjIjEjurWhoaHAxEhERkZl1sPMg5/q7ASjxl3JJaa3LEWXejEzLYq31Am/BKWK9Cme14dPA74DPG2O2pbjmH3CG8XwXeDtO4ew7gJVAN/Aw8FFjTEus/QrgY8CfAFXAYeBLxpivp7j3DcAjwFFjzBJr7U04M/hcBfiBPwJfNsZ8f5z39QLgPTiFwNVAD/AUztj8e40x0RHtRz73FcBfA+tjMb/fGPPFWNvn4gxhejEQjN3/LLAL+IYx5kcj7r0EeCbp0G3W2ttGhLzUGNM8Mo5R3tsWnOlQL6qHSaqtWQoUA3fhzJK0EPhfY8wtSW2rcX63r4q198Ti/B/gn40xGho3SwSDQfbs2QNAU1MT4XB43EXyREREctH2tqGhT6srVuH1zL7v7dP+jq2184CHgP8AXgpUAheARcAbgMeste8Z5zY/AO4B1gBRnA+vbwN+a62tttZuALbHjpXiTOu5FviatfaD48T3XuCnOMO3wPmQvAH4nrX2y2Nc91mcpOiNQC3OmgTzcZKa7wPfjyVTo13/AZzZiF6Ok8hEks6VAk/gfFh/Lk5CEYptXw7cZ6399xG3DOPUr/TG9lPVt0x2JenxvBB4Euf3Xg4MJp+MJV0NsfdxOc779OD8b/MRYLe1Nn8naJZhAoEAJSXOouR9fX08++yzLkckIiKSftFolG2tQ9+Xr626wsVo3DMTaVQ8mdgLvBIoMcaU4yxG9hGcD6JfstY+f5Trb4ld91ZgXuznRThTeC4F/hG4F/g9sNwYMx/nw318YbKPW2tHW6qwGvhcLMZFxpgKnB6Df46df4+19s0jL4olIn8HnMLpQakwxpQBJTiJUitwK/ChUZ5bg7Muwr8mPbcUiPc+RHASjjfhJCxFsftXAHfi9Ii801q7OX5DY8yxWM3L3bFDPzTGLBzxk3Lht2n4V2AHcEUsvrnABwCstYuBn+Gs1/ANYDVOwlaCk2D8EqcH5n5rrb6ungU8Hg91dXWJfQ2BEhGRfHTs3DFae08A4Pf6WV6+3OWI3JHW4U/W2pfiJAXNwIuTh7oYY84Cn7bWhnE+YH8YZ4jMSOXAFmPM95KO/c5a+3c4ycC7gCbgNcaYwdi9u621d+AkM5fiJCX/keLec4H/i90/Grv2DPC31toq4DbnbdgfxM9ba+cDn8BJhl5ljNme9J5COL0Ix4DHgA9aa//ZGNM/4rlFwA+MMXeMuLYl9vp8LOZhYr+ze6y1XbH381fAfSneV6acBF5hjLkQiy8KPB0790mc5O5fjDHvHXHdfmvtq3F6l64EXsNQQiV5rL6+PrFORWNjI5s2bcLjGXfGXxERkZyRPPRpeflyCryzc9HXdPdUxMf0f2eMsfPxuoUXj/KNdQvOwmQj/Srp9efiCUWcMSaCUzcAzjfjo/n0yNqHmE/GtpfifPCNex1Or8LvkxOKEc9+AjiC07OwfpTnfm6MmMbzs9h2g8vf8t8TTyiSWWuLgXgvyudTXRhLtOKJxMtmJjzJNjU1Nfj9fgC6urpob293OSIREZH0Gjb0aRbO+hSX7lTqebHt+6y17x6n7VyceouTI44fiCUIIyW32zfKPeOfWCpGOT8A/CHVCWNMk7W2Faf24xogviRi/D0911rbNsp9wRn2A84Qn8dHnLsA7BnjWqy1BThJ2WacpCaAUyuSrAjnvZ0e614zaOT7insOQ7Fus9aOdn1xbBscrYHkF5/PR21tLc3NzYDTW5G82raIiEguOxPq5NAZp0feg4fVs3B9irh091Qsim3LceoIRvuJm5viHq2pbmyMCY/XhqHCZP8o50+nGJqU7HhsW510LP6eihn7PcWfmeo9dYySKAGJQu1HcWoRXo5TmB7GqeGIF13HlYwR/0w7NcrxRUmvx/odlcXapPodSZ7S1LIiIpKvtrdtJ4ozACY4L8hc/+z9iJPunop4kvJqY8xP03zvTEg12Dv+nr5gjHn/FO873ixMf4/TI3Iap/D5l8aYRM9MbMhTfLiXmwPSR3sf8d/RGWPM7FqTXsZVV1eHx+MhGo3S1tZGd3c3ZWVl418oIiKS5bYnDX1aUzm7F3lNd09F/Bv1NWm+b7pUWWtHDilKFv/GPfkb+Uy8p3g9wp3GmP9ITihiakZeMEnxhKRojDbl07h/YtiZtVZjW2SYwsLCYUOe4oXbIiIiuSw0GGLPqd2J/dlcTwHpTyriY+5fl+b7posfuD7VCWvtpcAlsd1dSafi72njGFPVTld83s2nRjn/0jGujQ+rGqsH42xsu2CMpOraMa4fz5MMJS6vncZ9JE9pCJSIiOSbp07uoj/ijKqvKq4mUDS7B2ukO6n4Tmz7HGvt25ct9PcAACAASURBVMZqaK0drZh6pn3YWpvqA/iHY9smhhdV34ezwFwR48zgNI331BXbXrRaSqze4qNjXNsd284fo80hnMX6PMBNKZ5xKdNIBI0x54Afx3Y/Zq0dtWfFWlsQe08yiyQnFc3NzYRCIRejERERmb5trUNTyV42iwu049JaU2GM+aW19n6cb6u/Za1dDnzVGNMKiQ/dLwL+HOgE3p7O50/AeeAlwDettXcZY07G1qH4cCwmgH9InnLWGNNhrf0w8C/A22MfiD9ujNkHYK0twpn96E3Ai5naMKn/i13/eWvtKeC3xpiotfZanJXFq8a4dn9s+wJr7QpjTNPIBsaYfmvt/+As1PcFa207zroa4PSC/DvODFVjDY8az104U8Uuwlk1/W+BXxhj+iCRuLwKuAP4S2DrNJ4lOaa0tJRAIEBnZyeRSISnn36atWtn99hTERHJXeFomB3tOxL7s33oE6S/UBvgbTg9ILcA/w/4f7HF2zwMzf4DQ70amXQK+CLwBWCLtfYsTi1BvMfmK8aY74+8yBjzZWttOfBxnPqHzdba8zjf/idf3zzFuD6G84E8iPNhOxRbJLAE58P+LcBDo1y7FWcBuuVAo7X2NE7yBPACY0xL7PWHgT+JPeN3sTZenERiN87v5EtTjB9jTLO1dhPwALAMuB8YjP1vXwrMSWqeap0QyXPBYJDOTmf5moaGBiUVIiKSsxo6DnKu3xksUuIvpba01uWI3Jfu4U8YY3qNMa/B+Vb6fpxpWotx1jE4jLP43etxVofOOGPMF4GbcaZw9QIh4AngrcaY94xx3Sdw1o/4Gs4QKQ/Oh/5W4EHg3cBzpxjTEeA64L9w1uPw4dRBfA+41hjz8BjXDuAkC/+J87uuABbHfgqS2h2JxfcDnOTKh7PQ4CeB5zM0jGrKjDE7gNXAh3B6Qs7hDMu6gFN38dnY+3l0us+S3JM8BKqpqYlweLxJ0URERLLTtqRVtFdXrMLrSftH6pzjiUbz/0tja+0NOKttHzXGLHE3GpEh1tqtwMbFixezZcuWGXvOwYMHmTNnDl6ve3/0otEoP/7xj+nt7QXgz/7sz1i2bJlr8YiIiExFNBrl9l+9k9beEwC8bc0WVlWscjkqONN3hnXVVzJ/zlhltmmRcnIgpVUikhEej4e6urrEvqaWFRGRXNTScyyRUPi9fpaV6wsyUFIhIhlUX1+feN3Y2Mhs6CkVEZH8kjzr0/Ly5fi9fhejyR5KKkQkY2pqavD7nT++XV1dtLe3j3OFiIhIdtmWtIq2Zn0aoqRCRDLG5/NRWzs0Q4aGQImISC45E+rk0Bnn3y4PHlZrfYqEmZhSNusYY7Yy9orTIpIhwWCQ5uZmwJladuPGje4GJCIiMkE72nYQjc2MH5wXZK5/rssRZQ/1VIhIRtXV1eHxODl+W1sb3d3Tns1YREQkI5LrKdYEtN5SMiUVIpJRhYWFLFy4MLGvIVAiIpILQoMh9pzandhfW6V6imRKKkQk45IXwmtoaHAxEhERkYl56uQu+iP9AFQVVxMoCrgcUXbJ+poKa+1Fc04aY1yvj7DWLgGegfTFM1OL9Flr/wb4wsjDxph/SNczRCYjGAyyfft2AJqbmwmFQhQVFbkclYiIyOi2tw3N+nSZCrQvkvVJRZLTQDjViaQP4wBLjTHNo7T7DPCh2O4njDF/n+YYs1UvEJ+7sxzQpzdxVWlpKYFAgM7OTiKRCE8//TRr12psqoiIZKdwNMyOtu2JfU0le7FcSiquHS1ZmAhr7ReAv4ntftQY86m0RJVe54FG4Hg6b2qM+TrwdQBr7XeA29J5f5GpCAaDdHZ2As4QKCUVIiKSrRo6DtLd70wsUuIvpba0NmW7u5/8pyk/w+Px8IH1H5zy9W7LpaRiSqy1HuBfgdtjh95vjBk5FCgrGGO2A6vdjkMkE4LBIHv27AGgqamJcDiMz+dzOSoREZGLbWsbmvVpdcUqvJ7UZcln+85mKqSsk9dJhbXWC3wDeDsQBe4wxvybu1GJCEAgEKCkpITe3l76+vo4evQoy5YtczssERGRYaLR6KRX0a4rrePqBeupm1c3k6FllbxNKqy1BcB3gTcDEeAdxphvj9H+BcB7gBcA1UAP8BTwTeBeY8xFBeOj3KcJuBS40xhzzxjtHgL+FPiCMeb9sWM3MEqhtrV2K7ARJ0H6IU5tyJuAeuAc8Bvg740xTROJU8RtHo+Hurq6xJSyjY2NSipERCTrtPQco7X3BAB+r59l85eP2vZFdRvZc2o3LT0ttPS0sGBuDesXrOfK6qsoLSzNVMiuyMspZa21fuBenIRiEPizcRKKzwK/A94I1AJ9wHzgT4DvA9+P9XpMxA9i2zeP8bwFsXsTu/9klAF/AAywGKcHpjoW+xPW2tH/P10ky9TX1ydeNzY2Eo1OKHcXERHJmOQF75aXL8fv9Y/a9k8Xv5y/Xf933LZmC1dUraMz1MGDzb/gn578DP918D850LGfcDTlvEM5Lx+TijnA/cDrgAHgjcaYUT+4W2vfC/wdcAr4K6DCGFMGlABvAFqBWxmaNWo834ttr49NO5vKZsAHNBljnpzgfRMhAxXApliMpcCLgBYgAHx6kvcTcU1NTQ1+v/PHuauri/b29nGuEBERyazJDn3yeDysqFjJG1fdyl3XfoSbl7+aS0ouoaHzIN9v+B6f3fFpfvHMz2ntbZ3JsDMuH5OKHwCvwulteI0x5v7RGlpr5wOfwOnNeJUx5t+MMWcBjDEhY8x9wGtxegM+aK0tHO/hxphGnGFT4AxPSiV+fLK9FOAkTS8zxjxkjAkbYyLGmN8xNLPVzROJUyQb+Hw+amuHZtDQ6toiIpJNzoQ6OXTG+bfJg4fVgcnNp1NUUMR1C5/L7Vf+Fe+9+n28oPaFePHy2InH+MruL/ONP35tJsJ2RT4mFVfHtt81xvzvOG1fh/NN/+9jMy9dxBjzBHAEp3dg/QRjiCcLFyUV1tp64Hkj2k3Gj4wxh1Mc/ylO8jMHp6ZDJCckD4HS6toiIpJNdrTtIIozNDc4L8hcf8mU71U9t5pNS17BnVe/l1UVTnJy8sLJtMSZDfKxUHsb8FzgndbaPcaYfx2jbfzD/XOttW1jtIuvwx4EHp9ADD8APgtcYa293BizL+ncmwAPsNMYc2gC9xppR6qDxpgBa+1JoAYnARLJCbW1tXg8HqLRKG1tbXR3d1NWVuZ2WCIiIsPqKdYEpr6eUjQa5fDZJnad3MnBzoMMRgbxerxcOn9FOsLMCvnYU/E24Jex1/dYa/9ijLaLYttinA/jo/3EK3LmTiQAY8xxnMJvuLi3YjpDn8CZ6Wk0odh29AoikSxTWFjIwoULE/saAiUiItkgNBhiz6ndif01lZNPKk6dP8VDzb/kc09+lu8e+A5/PP1HKosqecWSG/nQtXfxhpVvTGfIrsrHnop+4DXAz3FmWPqatTZkjPleirbxpCoxrWsafR9nCtg3AR8FsNZeBlyJM8XtvWl+nkjOCgaDtLY6BWsNDQ1ce+21LkckIiKz3e6TT9Ef6QegqqiKyuLKCV0XGgyx9/Renjq5k2PnjgFQXFDMcxdt4JoF60ddjTvX5WNPBcaYEHAzTm+BF/iutfb1KZrGp5pZMwNh3IeT4Cy11m6IHYv3UjxqjDkxA88UyUnBYDDxurm5mVAoNEZrERGRmZe8ivZllRP7qPjfjffymR2f4qdPP0BLTwsrKlZy66o38aFrP8xNy27O24QC8jSpADDGnAdeCTyBM33r9621N49oFq+P2GitnVj6OfHnnwEeiu3G16y4Nbad6tAnkbxUWlpKIOCULkUiEQ4fTjUXgYiISGaEo2F2tA3N4TORqWQB9p7ey2BkkNrSWm5c+kqeU/McPB4PjWca2N+xb9yfXJaPw58SjDHnrLWbcFabvgb4b2vtq40x8Q/79wF346z38Dngz0e7l7W2IpYoTMb3gZuAN1hrvw+swOm9+PEk7yOS94LBIJ2dnYBTV3H55RP7Ay4iIpJuDR0H6e7vBqDEXzrpHobjPcc53nN80s/9xPM/NelrskVeJxUAxpgua+3LgEeAdcBPrLWvNMY8YozpsNZ+GPgX4O3W2lLg4/HZmqy1RcBzcIYtvZjJD5P6KdCDU+z9ldixB6eQnIjkvWAwyJ49ewBoamoiHA7j8/lcjkpERGaj7W1DC96tqliF1zOxwT1LypbgTPI5++R9UgFgjOmMJRZbgcuAn1lrX26M+YMx5svW2nLg4zgrXW+21p7HWTyvnKEhYs1TeO55a+3/AG/B6SkBDX0SSSkQCFBSUkJvby99fX0cPXqUZcuWuR2WiIjMMtFodNhUshMd+gTwjiveORMh5YS8rakYyRhzEmc2qCac4U6/sNZeFzv3CZxZmb4WO++JtWkFHgTejbP2xVQkzzrVA/xsivcRyWsej2dYwbamlhURETe09BzjRK8zn47f62f5/OUuR5Qb8qKnwhizlQn0NRljWoGVo5z7I/CuSTyzeYLPfHAi7WJtt47W1hhzwwSuXzKR54hkq2AwmFhVu7GxkU2bNuHxzM5uZBERcUdyL8Xy8uX4vVr+ayJmTU+FiGS/mpoa/H7nj3dXVxft7e3jXCEiIpJeyfUUayYx9Angnt1f5tfP/irlubN9Zzk/cH5asWWzXOqpeMZaC4AxRl9dToK19m+AL7gdh8h4fD4ftbW1NDc3A05vRfJq2yIiIjPpTOgMjZ3O8FsPHi4LrJ7U9W29rSwqWZTy3N1P/hPXLFjPa1e8btpxZqNc6KloT/Ejk9PLxb/DHlcjEhlFfX194nV8KJSIiEgm7GjbTpQoAMF5Qeb6S9J6//i981HW91QYY/Q15TQZY74OfN3tOEQmora2Fo/HQzQapa2tja6uLsrLy90OS0REZoHkeoo1gbUuRpJ7cqGnQkRmkcLCwmFDng4dOuRiNCIiMluEBkPsObU7sb+mUknFZCipEJGskzy1rIZAiYhIJuw++RT9kX4AqoqqqCyudDmi3KKkQkSyTnJS0dzcTCgUcjEaERGZDba1DQ19uqxyjYuR5Kasr6kQkdmntLSUQCBAZ2cnkUiEw4cPc/nlk5vWT0REZKLC0TA72rYn9iezivZITWcO8c19qUtZxzoHHv7i8ndM+bluU1IhIlkpGAzS2dkJOFPLKqkQEZGZ0tjZQHd/NwAl/lJqS2unfK+egR56ulJPsjnWuVynpEJEslIwGGTPnj0ANDU1EQ6H8fl8LkclIiL5KHnWp1UVq/B6plYhkK9rUEyEkgoRyUqBQICSkhJ6e3vp6+vj6NGjLFu2zO2wREQkz0Sj0WFJxXSGPl2zYH06QspJKtQWkazk8XiGFWw3Nja6GI2IiOSrlp5jnOg9AYDf62f5/OWuxNHe2+bKc9NFSYWIZK2RU8tGo/m7EqmIiLhje+u2xOtl5cvxe/0Ze3ZoMMS21m38656vcM/uL2fsuTNBw59EJGvV1NTg9/sZGBigu7ub9vb2YQvjiYiITFfyVLLTGfo0GU+ffZqdJ5/kQMd+BiODAFOu48gWSipEJGv5fD5qa2tpbm4GnCFQSipERCRdzoTO0NjpDK/14OGywOoZe9bZvrPsat/JrpM7Odt3NnF8UcklXL3gatZVXTljz84EJRUiktXq6+sTSUVDQwMbN250NyAREckbO9q2E8UZWls3r465/pK03n8wMsiBjv3sPPkkR84eSTwr7r1X/w3Vcxek9ZluUVIhIlmttrYWj8dDNBqlra2Nrq4uysvL3Q5LRETywPakoU9rAukb+nS85zg7259k7+k9hAZDgDO8aVXFaq5ZsJ7fHt9Ky7mWvEkoQEmFiGS5wsJCFi5cSGtrK+AMgbruuutcjkpERHJdaDDE7pO7E/trK9dO+56PnfgDO0/uHDaTU/XcBaxfsJ6rqq+mtLAUgN+f+N20n5VtlFSISNYLBoNKKkREJK12n3yK/kg/AFVFVVQWV077nr945n8BKCoo4oqqdaxfsJ66ecFxrsoPuV1mLiKzQvLUss3NzYRCIRejERGRfLCtbWgq2dWBy9J670g0QjgSZjAaTut9s5mSChHJeqWlpQQCAQAikQiHDx92OSIREcll4WiYJ9u2J/Yvr0pPPcXNy2+hbl4d/eF+dp3cyTf++DU+v/Nuth57hK6+rrQ8I1tp+JOI5IRgMEhnZyfgDIG6/PLMzCUuIiL5p7Gzga5+50N+ib+U2tK6tNz3uoXXcd3C6zh1/iRPtj/J7lO76Qx18qtn/49fP/srls9fzjUL1ifWpsgnSipEJCcEg0H27NkDQFNTE+FwGJ/P53JUIiKSi7a1Ds36tKpiVdoXnqueu4BXLL2Rly/ZREPnQXa276Tp7CEOnz3M4bNDve3Pdh+lvmxxWp/tFiUVIpITAoEAJSUl9Pb20tfXx9GjR1m2bJnbYYmISA7anlRPsTYw/VmfRuP1eFlTuZY1lWvp6e9h18mdPHVyF6cunALga3/8dyqKKriq+mquqr6KyuKqGYtlpqmmQkRygsfjGVaw3djY6GI0IiKSq1rOHeN4z3EA/F4/yysuzchzSwtLeVHdRt57zft45xXv4poF6yn0FXImdIZHjv2GL+76QkbimClKKkQkZyQnFQ0NDUSj0TFai4iIXCx56NOy8uX4vf6Mx1BftpjXrngdd137EV674nUsLlt80WrbuUbDn0QkZ9TU1OD3+xkYGKC7u5v29nYWLlzodlgiIpJDtiWtor220t1JPwp9hVyzYD3XLFhPZ6jT1VimSz0VIpIzfD4ftbW1iX0NgRIRkck4EzpDY6fzb4cHD6sDq12OaEigKOB2CNOipEJEckp9fX3idUNDg4uRiIhIrtnRtj0xzKhuXh0l/hKXI8ofSipEJKfU1tbi9Tp/utra2ujqyu/FhEREJH22Jw19WhPQekfppKRCRHJKYWEhNTU1iX0NgRIRkYkIDYbYfXJ3Yn9t5cxNJTsbKakQkZyjqWVFRGSydp96iv5IPwCVRVVUFle6HFF+UVIhIjknOalobm4mFAq5GI2IiOSCba1DC95dFrjMxUjyk5IKEck5paWlBALOLBmRSITDhw+7HJGIiGSzcDTMk23bE/uXV6meIt2UVIhITtIQKBERmajGzga6+p2JPUr8JdSW1mU8htBgiMNnD7Pn1G6Odh/N+PNnmha/E5GcVF9fz549ewBoamoiHA7j8/lcjkpERLJR8tCnVfNX4fVk7nv10GCI/33m5+w5tZtINALA1QuuYXHZYgCeaH2crcce4c2XvZX6efVj3SqrqadCRHJSRUUFJSXO/OJ9fX0cPZp/3/qIiEh6bHdpFe3+cD/f2Pc1njq5i+KCYlZWrLyozcqKVfQM9HCw40DG4poJSipEJCd5PB4NgRIRkXG1nDvG8Z7jAPi9fpZXXJqxZ//u+G9p623jyuqr+MD6D/K2NVsuahMoClBZXMXTXU9nLK6ZoKRCRHJWclLR0NBANBp1MRoREclG21qHeimWlS/H7/Vn7Nn7OvYxr3Aer7n0tRT6CkdtN39OOd393RmLayYoqRCRnLVw4UL8fucfh+7ubtrb212OSEREss22tqF6ikwveHcm1EltaR0F3rHLmOcWlHBh4HyGopoZSipEJGd5vV5qa2sT+xoCJSIiyc6EztDY2QCABw+rM7w+hdfjZTAyOG677v6uMXsycoGSChHJafX1QzNlNDQ0uBiJiIhkmx1t24niDI2tm1dHib8ko8+vKq6mtfcEA5GBUdtcGLxAa28rNXMXZjCy9FNSISI5rba2Fq/X+VPW1tZGV1eXyxGJiEi2SJ71aU0g8wveXV55Ob0DvTzc/MtR2zx89CH6w/1cUXVFBiNLP61TISI5rbCwkJqaGlpbWwFnCNR1113nclQiIuK2vsEQu0/uTuyvrVyT8Rg2LLqep07u4vHWxznec5w1sZqOs31n2Nb6BPs6/sgzXc9QU7KQ9TXPyXh86aSeChHJeclDoFRXISIiAE+deor+SD8AlUVVVBZXZTyGQl8hW9b+OcF5QZ499yy/bH4QgGe6nuFnR37KM13PcEnpJbztstvGLebOdrkdvYgIUFdXx7Ztzuwezc3NhEIhioqKXI5KRETclLyK9mUZLtBOVj6nnHetezeHzjRy6EwjnaFOItEo5XPKWVmxijWBNXg8HtfiSxclFSKS80pLSwkEAnR2dhKJRDh8+DCXX575sbMiIpIdwtEwT7ZtT+xfXuX+vwkrK1axsmKV22HMGA1/EpG8oNW1RUQkrrGzka5+Z+KOEn8JtaV1LkeU/9RTISJ5ob6+nj179gDQ1NREOBzG5/O5HJWIiLgheRXtlfNX4fW4/z16JBrh/MB5BqOjr1sxf878DEaUXkoqRCQvVFRUUFJSQm9vL319fRw9epRly5a5HZaIiLggeSrZyyvdHfp07Nyz/OrZX3G0u3nMhfA8ePjH538yg5Gll5IKEckLHo+HYDCYWACvsbFRSYWIyCzUcu4Yx3uOA1Dg9bO84lLXYjna3cy39n+TcCQMQFFBEUW+/JxIREmFiOSN5KSioaGBTZs25cWMGiIiMnHb2oZmfVpevgy/1+9aLL9+9leEI2GeU3MtL1v8Mkr8pa7FMtPcH2AmIpImCxcuxO93/vHo7u6mvb3d5YhERCTTkusp1ro89Kmlp4Xq4mpuufQ1eZ1QgJIKEckjXq+XurqhGT7ivRYiIjI7nAmdobHT+dvvwcNqF9enAIhGoywsWehqDJmipEJE8oqmlhURmb12tG0nShSAunl1lPhLXI1nYclCzvX3uBpDpqimQvKCtbYZWDzK6XZjzEVfE1hrnwd8DNgAFAGHgW8BXzbGhEd5zm3AHcAaIAw8BdxtjPn5dN+DpEdtbS1er5dIJEJbWxtdXV2Ul5e7HZaIiGTA9qR6ijWBtS5G4rh+0fO579APOdFzgktKL3E7nBmlpELySRfwxRTHL/qKwFr7auDHQAj4IdAJ3AR8AXg+sDnFNXcDHwBagK8DhcCtwM+stXcaY+5Jz9uQ6SgsLKSyspJTp04B8MUvfpHCwkLWrVvH9ddfTyAQcDlCERFJp9beVh44fD9bjz3ChcELieO1pbUuRuVYV72Okxfa+fb+b/HS+peyKrA6p9eiGIsnGo26HYPItMV6KjDGLJlA2zKcXoly4PnGmCdjx4uA3wDXA28yxtybdM3zgD8ATwPXGmPOxI4vAXYCJcBqY0zzJOPeCmxcvHgxW7Zsmcylk3Lw4EHmzJmD15v/Ix5bWlp45JFHiEQiw457vV58Ph+bN29mxYoVLkUnIiLptLP9ST6z/VMMRgYJR4cPMvB7/bxp9VtYVbHKpejgY3/4yITbTnedijN9Z1hXfWUmkpaU0yrm/ycMkYu9HqgG7o0nFADGmBDOcCiAd4+45vbY9pPxhCJ2TTPwFWAO8PaZClgmpru7m0cfffSihAIgEokwMDDAfffdR2dnpwvRiYhIOrX2tvKZ7Z+iL9x3UUIBMBAZ4AcN36PjQocL0U1evBYkV2n4k+STOdbatwL1QC+wF/htivqIl8S2v0xxj98C54HnWWvnGGP6JnDNg8Dfx9qYacQv03TgwAHC4ZTlMAnhcJgnnniCG2+8MUNRiYjITHjg8P1jrlANEI6E+cOJ33Pz8ldnKKrhPvH8T7nyXDcoqZB8shD4zxHHnrHWvt0Y82jSsXg/6KGRNzDGDFprnwHWAsuAg9baEqAW6DHGtKZ4blNsu3K0wKy1W4AtKU5dNdo1MnlHjhxhvCGdkUiEvXv3KqkQEclxW489krKHIlmECLtPPeVaUjGbaPiT5ItvA3+Ck1iUAFcA/w4sAR601l6Z1DY+FVDXKPeKH48PSpxs+1SWABtT/GhaojQaGBiYULv+/v4ZjkRERGZaaDA0oXb9Yf3NzwT1VEheMMbYEYf2Abdba3twZmz6B+A1E7xdvABpsoMbx2rfDDya4vhVKLFIG7/fP6HEorCwMAPRiIjITCoqKBo229NoCn36m58JSiok330VJ6l4UdKxeM/CaB/my0a0G6/9eD0ZGGO+A3xn5PH47E+jXSeTs2zZMg4dOjTmECiv18u6desyGJWIiMyEG4Iv5uHmh8YcAuXFy1XVV2cwqosNRgZ5/MRj7Ov4I6cvnKYv3Jey3XRnf3Kbhj9JvjsZ2yYvqRlfZvmiGghrbQGwFBgEjgAYY3qB40CptXZRimfE5ye9qEZDMmvNmjX4fL4x2/h8PjZs2JChiEREZKbcculr8XrG/ijr8/p4/iUvyFBEFxuIDPCNfV/joaO/5HjP8VETCsj92Z+UVEi+uz62PZJ07Dex7aYU7V8EzAUeS5r5abxrXjGijbikrKyMjRs3UlBQgMeTchptNm3apAXwRETywKKSRSwpW5rynBdvYp2KyuLKDEc25A/Hf0/LuRZWVKzkfde8n6sWOL0m9vp/5K+v/hteVLeRAm8BG+tuyPmZopRUSM6z1q611l70KdFauxiIr3L9X0mnfgScBm611j4nqX0R8InY7r+NuN1XY9uPWmsrkq5ZAtwB9OEUi4vL6urquOmmm1i5ciV+vx9gWIJx/Phxt0ITEZE0eqbrCE1nhwYJFHoL8eBhjm8O1y68jjuveq+rC98B7OvYxxzfHN648lYqi6vwxMo2fV4fC+Yu4E8Xv5w3r34Lj7ZsZe+pPa7GOl2qqZB8sBm4y1r7CPAMcA5YDrwSKAJ+Adwdb2yM6bbW/iVOcrHVWnsv0AncjDPd7I+AHyY/wBjzmLX288D7gb3W2h8BhcAbgQBw52RX05aZU1ZWxoYNGxLDnFpbW3n44YcB2L17Nxs3bqSsrGysW4iISJa779B/J16vqljN29bc5mI0qXVcOE192WKKCoqGHY9EI4mhWysrVlFXWscTrY+zrvrKVLfJCeqpkHzwCPATnFqIN+N88N8I/B64DXiVMWbYfHLGmAdibX4LvA64ExiIYhknjwAAIABJREFUXXurMeaigY3GmA/grDXRBrwTeBuwH7jJGHPPyPaSPRYuXEh1dTXgrFPx2GOPuRyRiIhMR8u5Fv5w/PeJ/T8JvtTFaEYXJcrcgrmJfb/X6UEPjZi1KlAUoP18e0ZjSzf1VEjOiy1sl2q61vGu+wMwqRXQjDHfBb472WeJuzweD+vWrePXv/41ADt37uSFL3whJSUl41wpIiLZ6MdN9yUKm5eVL6d2Xq3LEaVWVljGuf7uxH75HGfCyLbeNpbNX544fqbvbMZjSzf1VIjIrFBbW5so0B4cHOSJJ55wOSIREZmKk+dPsvXYI4n9bO2lAFgwt4ZTF04n9peULQHg18d+Td+gMx/MnlO7OXbuWRbMrXEjxLRRUiEis4LH4+GKK65I7O/YsYNQaGKrsYqISPa4v+lHibUpgvPqWVK+xN2AxrCyYhW9Az0c6XImoVxctoTgvHqOdjfzye3/yCe2fTxRG/L/27vvMLnK8+7j39muuup9VUBCXQhEkRCglYQpptnGsokLOInj4Dh2HKe4JPbD/TouiZ3EJjgQV9wSg+gdGwwrrRASQl0CSQgVJK16l1bbZt4/njOj0bLaXe3M7pmZ/X2ui2v2zJwzz312xTnnfuqVQ68KM9SUKakQkU5jxIgRlJb6pueamhqWLl0ackQiInIuDp46yB+2/T6xPadsbojRtOzC/hfyF5M/Q9+S09PafnzcJ7ig91hisRin6k9RUlDC9SNvYGLfiSFGmjqNqRCRTiPeWlFZ6Qf3vfbaa0yfPp2ioqKQIxMRkdZ44u3HqIvWAX6dijG9xrRwRLiK84sZEXR5iute1J07JtxJbUMtpxpO0b2we4uL+GWD7D8DEZFzMGrUKLp37w5AdXU1b7zxRsgRiYhIaxytPcpzW55NbM8um3PWhU6zQVF+ET2LeuZEQgFKKkSkk8nLy2PSpEmJ7VdffZX6+voQIxIRkdZ4evOTnGrwY+H6denP+D4TQo5Ikqn7k4h0OqNHj2bVqlVUV1dz/PhxVq5cySWXXNLygSIiEoqTdSd56p0nE9uzh83OyBr+FXuXp3T8RQMuTlMkHU9JhYh0Ovn5+UycOJFly5YBUFlZyUUXXUR+fn7IkYmISFOe2/IMJ+pOANCruHfGrjz9yKaHUzpeSYWISJa54IILWLNmDTU1NRw5coQ1a9YwderUsMMSEZFGahpqeHzz44ntWUNnZWQrBcDUARcRIXvHeaRCSYWIdEqFhYWMHz+elStXAr61YsqUKeTlZeaNSkSks/rD1hc4Eqw43aOwBxcPnBZyRGf34THzwg4hNLp7ikinNX78eAoLCwE4cOAAb775ZsgRiYhIsrpoHY++/Uhi+8qhV1OQpzrxTKSkQkQ6raKiIsaNG5fYXrhwIbFYLMSIREQk2Svvvsz+6v0AdC3oyuWDLg85IjkbpXoi0qlNmDCB9evX09DQwJ49e9i0aRMXXHBB2GGJiHR6DbEGHtk4P7F9xZCZFOYXhhhR2+05sZvFVYvZcuQdjtQeIUKEHkU9OK/0fKYPns6gboPDDjFlSipEpFMrKSnhggsuSHR9WrhwIWPGjMnqBZVERHLBop2V7DqxC/ArU88YfEXIEbXNol2VvLD1eaKx6BnvHzx1kIOnDrJ87xtcO+I6rhx6VUgRpoeSChHp9CZOnMiGDRuIRqPs2LGDrVu3MmrUqLDDEhHptKKxKPM3PpTYvnzQdEoKSkKMqG3ePPgmz215lrxIHlMHXMRF/S+iV3FvAA7XHGLlvpWs2reS57c+R98u/RjfZ3zIEbedkgoR6fS6devG6NGj2bhxI+BbK5RUiIiE5/XdS9l2dCsAhXmFXJWltfgLdy4A4GPjPsG4PuPO+Kxvl76c32s0k/pO4tdv/orKnQuyOqnQQG0REWDSpEmJLk9btmxhx44dIUckItI5xWIx5m98MLF9ycBL6VrYLcSI2q7q+C6G9xzxnoQi2dg+4xjecwS7ju/qwMjST0mFiAjQo0ePM1onFi5cGGI0IiKd16p9K9l4yLcc50fyuXrYrJAjarv8vHx6Ffdqcb9eRaUZu6Bfa2V39CIiaTR58uTEzxs3bmT37t0hRiMi0jklt1Jc1P8iehb1DDGa1AzpNoQ9J/e0uN+e6r0M7T60AyJqP0oqREQCvXr1Yvjw4YntysrKEKMREel83jywnjX71wCQRx7lZXNCjig15cNms/fEHhbtPPv9ZNGuSvae2MOsYbM7MLL000BtEZEkU6ZMYfv27QCsW7eO8vJy+vXrF3JUIiKdQ3IrxaR+k+ld0jvEaFIXieQxffB0ntv6LKv3r+LC/lPpXdIHgMOnDrFq30p2HN/BjMFXkBfJY8uRLWccP6o0eyYNUVIhIpKkb9++DB06lJ07dwKwaNEibr311pCjEhHJfZsPb2bZnmWJ7Tllc0OMJj1+tvYniZ93Ht/JzuM7m9xvcdWrLK569Yz3IkT45sxvtWt86aSkQkSkkSlTpiSSitWrVzNr1ix69Wp5oJ2IiLRdcivF+D7j6d+1f4jRpMfIniOBzrGYqpIKEZFGBgwYwMCBA9mzZw/RaJRFixZx4403hh2WiEjOevfYdhbvOl1TP6fsmhCjSZ9PT/5M2CF0GA3UFhFpwpQpUxI/r1ixgmPHjoUYjYhIbnt448PEiAEwunQ0Q7oPCTkiOVdKKkREmjB48GD69u0LQENDA4sXLw45IhGR3LT7xG4qdryc2J4zPDdaKc7mZN1JDtccDjuMtFNSISLShEgkckZrxbJlyzh58mSIEYmI5KZHNz1CNBYFYHiPEYzoOSLkiNrXc1uf5d+XfS/sMNJOSYWIyFmUlZUlBmjX1dWxZMmSkCMSEcktB6oP8OL23ye25+bAjE+tEe/qlUuUVIiInEUkEjljle2lS5dSU1MTYkQiIrnl8bcfoz5aD8DgbkM4v9fokCOStlJSISLSjJEjR9KjRw8ATp06xeuvvx5yRCIiueFozRGe3/psYntO2Rwikc4x/WouUlIhItKMvLy8M1orFi9eTF1dXYgRiYjkhic3P0lNg2/97d+lP+P7TAg5IkmFkgoRkRacd955dOvWDYCTJ0+yfPnykCMSEcluJ+pO8Mw7TyW2Z3eiVooRPUdw0YCLww4j7ZRUiIi0ID8/n4kTJya2Fy1aRENDQ4gRiYhkt2e3PMOJ+hMA9C7uw+R+U1o4IndcMvBSbhvz4bDDSDslFSIirTBmzBhKSkoAOHbsGKtWrQo5IhGR7FRTf4on3348sT1r2CzyInokzXYFYQcgIpINCgoKmDhxIm+88QYAlZWVTJ06lbw83QhFRM7FC9te4EjtEQB6FvXk4gHTQo6o/dVF69h5fCfHao8mZrtqSjZ3i1JSISLSSmPHjmXNmjXU1tZy6NAh1q1bd8YgbhERaV5dQx2PbXoksX3l0KvJz8sPMaL2t2hnJX9896XEoPTmKKkQEekECgsLGT9+fKLr08KFC5k0aVKnGVwoIpKqP777EgdOHQCga0FXLht4WcgRta9le5bxXDBtbv8u/enftT/F+SUhR9U+lFSIiJyD8ePHs27dOurr69m3bx8bNmxg3LhxYYclIpLxGqINPLJxfmJ75pCrKMwvDDGi9re46lUA5l3wES7sPzXkaNqXOgOLiJyD4uJixo4dm9heuHAhsVgsxIhERLLDwp0L2H1yNwAl+SXMGDwj5Ija34Hq/QzvOSLnEwpQUiEics4mTpyYGKC9a9cu3nnnnZAjEhHJbNFYlPkbH0psTx88g+KC4hAj6hiFeYX0KioNO4wOoaRCROQcdenShTFjxiS2FyxYEGI0IiKZb0nVa7x7bDvgH7RnDrky5Ig6xvAeI9hzck/YYXQIJRUiIm2QPEB7+/btbNu2LeSIREQyUywWY/7GBxPblw68jK6FXUOMqOPMGT6XfdX7WL73jbBDaXcaqC0i0gbdu3fn/PPP5+233wb82IoRI0aEHJWISOZZsXc5bx/218qCSAGzhs0KOaKOU9tQy8whV/LopkfYeHADY/uMo7S4FxGanjVwVOmoDo4wfZRUiIi00aRJk9i8eTOxWIzNmzeza9cuhgwZEnZYIiIZ5aGkVoqLBlxM96IeIUbTsX629ieJn9ceWMvaA2vPum+ECN+c+a2OCKtdKKkQEWmj0tJSRowYwdatWwHfWvHRj3403KBERDLIuv1rWX9gHQB55FFeNjvkiDrWyJ4j4SytErlGSYWISAqmTJmSSCreeust9u7dy4ABA8INSkQkQyS3UkzuP4Vexb1CjKbjfXryZ8IOocNooLaISAp69+5NWVlZYruysjLEaEREMsemQ5tYsXc54Lv2zCmbG3JE0p6UVIiIpGjy5MmJn9euXcvBgwdDjEZEJDMkz/g0vs8E+nXpF2I00t7U/UlEJEX9+/dn8ODBVFVVEYvFWLRoETfffHPYYYmIhGb70e28VrU4sT13+DUhRtNxDtccBqBnUU/yInmJ7dbK5u5hSipERNJgypQpVFVVAbBy5UpmzZpFz549Q45KRCQcDyetnj2m1xgGdRsUYjQd5/vL/o0IEf7m4i/Sr0t/vr/s31p9rGZ/EhERBg4cSP/+/dm3bx/RaJRXX32V66+/PuywREQ63O4TVSzYWZHYnlPWOVopAEqLS4kQIS+Sf8Z2Z6CkQkRa5ciRI6xfv57du3dz4sQJAEpKSujatSv9+/dn6NChZ12jYceOHWzZsoV9+/ZRXV1NNBqlpKQkMcj5vPPOo7CwsCNPJ+0ikQhTpkzhpZdeAuCNN97gqquuolu3biFHJiLSsR7Z9DDRWBTwU6oO7zk85Ig6zj9c8uVmt3OZkgoRadGWLVuorKwkGo3StWtXBg0aRFFREadOneLgwYPs27ePPXv2vCepqK6upqKigj179gB+XYchQ4aQl5fHyZMnqaqqYufOnaxYsYKbbrqJ7t27h3F6aTN06FD69OnDwYMHqa+vZ/HixVxzTeepoRMROVC9n5e2v5jY1oxPnYeSChFpVnV1Na+++irRaJRLLrmE8ePHk5d3euK4WCzGnj172Lt37xnH1dbW8txzz3Hs2DH69+/P9OnT6dOnzxn71NXVsWHDBlavXk1tbW2HnE97ikQiTJ48mYoK3+z/+uuvM3PmTLp06RJyZCIiHeOxtx+lPloPwJBuQzmv9PyQI5KOoqRCRJr17rvvUl9fT//+/Zk4ceJ7Po9EIgwaNIhBg84chLdkyRKOHTtGv379uO6668jPz3/PsYWFhUyaNInhw4dTUJAbl6MRI0ZQWlrKkSNHqK2tZenSpcyaNSvssERE2t2RmiM8v/X5xPacsjlEIp1jPIFonQoRacGpU6cAP36itY4ePcqWLVsAmD59epMJRbKePXvStWvXtgeZQeKtFXFLlizJiVYYEZGWPLn5cWobagAY0HUg4/qMDzki6UhKKkSkWfGBxlVVVRw6dKhVx+zYsYNYLEbv3r3p27dve4aXkUaNGpUYH1JdXc2yZctCjkhEpH0drz3OM+88ndiePWy2Wik6GSUVItKs4cOH06VLF+rr63nqqad48cUXWbt2LVVVVWetgT9w4ABAp0woAPLy8pg0aVJi+9VXX6W+vj7EiERE2tezW57mZP1JAPqU9GFSv8ktHCG5Jjc6MYtIuyksLOTaa6+lsrKSAwcOsHPnTnbu3An4rj79+vVj/PjxjBo1KnFMTY1v/j6XLlO5ZvTo0axatYrq6mpOnDjBihUruPTSS8MOS0Qk7U7Vn+KJzU8ktmcNKycvonrrzkZ/cRFpUa9evbjpppu44YYbmDx5MoMHD6aoqIhYLMa+fftYsGABlZWVYYeZUfLz888Y2L5o0SIaGhpCjEhEpH28sPU5jtUeBaC0qJSL+l8cckQSBrVUiEirDRgwgAEDBgAkEopVq1axa9cuNm/ezLBhwxg5ciTFxcXA6UHendUFF1zAmjVrqKmp4ciRI6xZs4apU6eGHZaISNrUNdTx2NuPJbavGno1+XnNT84huUktFSLSJpFIhAEDBjB37tzE+hPbt28HTo+liI+t6KwKCwuZMGFCYju+gKCISK54afuLHDzlr/XdCrtxySB18+yslFSISEry8vIYPHgwcLplYtiwYUQiEQ4dOtTpE4tx48ZRWFgI+CTrzTffDDkiEZH0aIg28Mim+YntmUOuojCvMMSIJExKKkSkWbFYrMV9Tpw4AZyefrZnz56MHDkSgNdee63FsQRHjx7l5MmTqQWaoYqKihg3blxie+HCha36nYqIZLoFOyrYc3IPACX5JUwfPD3kiCRMSipEpFkbNmygsrKSffv2veezaDTKxo0b2bZtG0AikQC4/PLL6d69O/v37+eFF15oco2Luro61q1bx9NPP53T4y8mTJiQWDF8z549bNq0KeSIRERSE41FeXjTQ4ntGYOvoDi/OMSIJGwaqC0izYpGo2zevJnNmzfTpUsX+vTpQ1FREbW1tRw8eJDq6moAJk2axNChQxPHFRcXc8MNN1BRUcHevXt58sknKS0tpbS0lLy8PE6ePMn+/fuJRqOUlJRQVFQU1im2u5KSEsaMGZPo+rRgwQLGjBmjhaFEJGu9tmsx7x57F4CivCJmDr0y5IgkbEoqRKRZY8aMoXv37uzatYv9+/dz6NAhTp06RV5eHl27dmXIkCGMGTOGgQMHvufYrl27csMNN/Duu++yZcsW9u3bx65duxKJxJAhQygrK2PUqFGJcQe5auLEiWzYsIFoNMrOnTvZunXrGWt7iIhki1gsxkMbH0xsXzroMroUdAkxIskESipEpFmFhYUMHz6c4cOHt/k7ysrKKCsrS2NU2adbt26MHj2ajRs3Ar61QkmFiGSj5Xvf4J0jmwEoiBRw9dBZIUckmUBjKkREOsikSZMSXZ62bt3Kjh07Qo5IROTcxGIxHtpwupXi4gHT6F7UPcSIJFMoqRAR6SA9evQ4o3ViwYIFIUYjInLu1h1Yy5sH1wOQF8mjvGx2yBFJplBSISLSgSZPnpz4edOmTezevTvEaEREzk1yK8WF/S6ktLg0xGgkkyipEBHpQL169WLEiBGJ7crKyhCjERFpvU2HNrJy3woAIkSYXTYn5IgkkyipEBHpYMmtFevWrWP//v0hRiMi0jrJrRQT+k6kb5d+IUYjmUZJhYhIB+vbt+8Za3osWrQoxGhERFq29chWlux+LbE9t2xuiNFIJlJSISISgilTpiR+Xr16NYcPHw4xGhGR5iWvnn1B77EM7DYoxGgkEympEBEJwYABAxILBkajUbVWiEjG2nV8F5U7Fia21UohTVFSISISkuTWihUrVnDs2LEQoxERadojm+YTJQrAqJ6jGNajcy9mKk1TUiEiEpLBgwfTr58f6NjQ0MDixYtDjkhE5Ez7Tu7j5e1/TGzPUSuFnIWSChGRkEQikTNmglq2bBknT54MMSIRkTM99vYj1MfqARjafRijSs8LOSLJVEoqRERCVFZWRu/evQGoq6tjyZIlIUckIuIdOnWI3299IbE9p2wOkUgkxIgkkympEBEJUePWiqVLl1JTUxNiRCIi3pObH6c2WgvAwK6DGNt7XMgRSSZTUiEiErIRI0bQs2dPAE6dOsXrr78eckQi0tkdrz3Gs1ueSWzPLputVgpplpIKEZGQ5eXlMWnSpMT24sWLqaurCzEiEensnn7nKarrqwHoW9KXiX0ntXCEdHZKKkREMsB5551Ht27dADh58iTLly8POSIR6ayq66t5avOTie1Zw8rJi+iRUZqnfyEiIhkgPz+fiRMnJrYXLVpEQ0NDiBGJSGf1/JbnOFbn180pLSpl6oCLQo5IsoGSChGRDDFmzBhKSkoAOHbsGKtWrQo5IhHpbGobann87UcT21cPm0V+JD/EiCRbKKkQEckQBQUFZ7RWLFy4kGg0GmJEItLZvLj9DxyqOQRA98LuXDLw0pAjkmyhpEJEJIOMHTuWoqIiAA4fPszatWtDjkhEOov6aD2Pbnw4sT1zyFUU5BWEGJFkEyUVIiIZpLCwkPHjxye2Fy5cSCwWCzEiEeksKna8wt7qvQB0KejC9MHTQ45IsomSChGRDDN+/HgKCnzt4P79+3nrrbdCjkhEcl1DrIGHN85PbM8YfAVF+UUhRiTZRkmFiEiGKS4uZty40yvXqrVCRNrb4l2vsvP4DgCK8ou4YsjMkCOSbKOkQkQkA02YMIH8fD/jSlVVFZs3bw45IhHJVbFYjPkbHkxsXzbwcroUdAkxIslGSipERDJQly5dGDNmTGJ74cKFIUYjIrls2Z7X2XJ0CwAFeYVcPezqkCOSbKSkQkQkQ02cOJFIJALA9u3b2bZtW8gRiUiuicVizN94upVi2oBpdCvsHmJEkq2UVIiIZKju3btz/vnnJ7bVWiEi6bZm/2reOugng8iP5DNrWHm4AUnWUlIhIpLBJk+enGit2Lx5M7t27Qo5IhHJJcmtFBf2v5DS4tIQo5FspqRCRCSD9ezZkxEjRiS21VohIumy4eBbrNq3CoAIEWaXzQ05IslmSipERDLclClTEj+/9dZb7N27N8RoRCRXJLdSTOw7iT4lfUKMRrKdkgoRkQzXu3dvysrKEtuVlZUhRiMiuWDLkS0s3b00sT13uFopJDVKKkREskBya8XatWs5ePBgiNGISLZ7eONDiZ/H9h7HgK4DQ4xGckFB2AGIpMrM+gIfBG4EJgNDgVpgDfAL4BfOuWjS/iOBLc185YPOudvPUtadwOeACUADsAL4vnPu6ZRPRKQZ/fr1Y/DgwVRVVRGLxaisrOSWW24JOywRyUI7j++kcufp8VlzNJZC0kBJheSCecB9QBXwMrAdGAh8CPgpcIOZzXPOxRodtwp4vInvW9tUIWb2feDvgB3AT4Ai4HbgKTP7vHPu3jSci8hZTZkyhaqqKgBWrFjBunXrqK2tpaioiClTpjBjxgz69FGfaBF5r6oTVTz+9qO88u7LVNdXJ94v617GsB7DQoxMcoWSCskFG4FbgGcatUh8DVgK3IZPMB5pdNxK59zdrSnAzK7AJxSbgUudc4eC978HvAF838yeds5tTe1URM5u4MCBlJaWcuTIEQBqa2sTr8uXL2fVqlXMmzfvjJW4RUTe2LOM7y79NvXRehpiDWd8VnWiig2HNjC299iQopNcoTEVkvWcc390zj2VnFAE7+8G7g82y1Ms5q7g9VvxhCIoYyvwI6AY+NMUyxBp1rFjxzh27FiTn0WjUerq6pg/f77GW4hIQtWJKr679NvUNNS8J6EAqI/V839v/ZYD1QdCiE5yiVoqJNfVBa/1TXw2xMz+EugLHAAWO+dWn+V75gSvzzfx2XPA14N9XAqxijRr/fr1xGKNe/GdqaGhgddee433v//9HRSViGSyx99+lPpoU7fA0xqiDSzaVckt59/aQVFJLlJSITnLzAqAO4LNppKB9wX/JR/zCnCnc2570nvd8IO/jzvnqpr4nk3B6wXNxPIp4FNNfDT1bMekWywWa/GBVDLbO++80+LfMBqNsnr1aiUVIgLAK+++3GQLRbIoUVbuW8FN593cQVFJLlJSIbnsu8Ak4Fnn3AtJ758EvokfpP1O8N4U4G5gNvCSmU11zp0IPisNXo+cpZz4+72aiWUkMOtcgk+nkpISTpw40fKOktHq6upa3onTYy1ERE7Vn2rVfjUNNRytPdrO0Uh7KswrpCCSH1r5SiokJ5nZF/ADq98CPpn8mXNuL/CNRocsMLNrgUrgcuDTwA/PsdjmqpC3AhVNvD+6b9++QwcNGnSORZ2bUaNGtev3S8d46qmnWpUwFBUVdUA0IpINSgpKzpjt6Wy6FnTlqmFXd0BEkquUVEjOMbPP4ROC9cBc51yrRq065+rN7Kf4pOJqTicV8ZaI0iYPbLklA+fcA8ADZ/lYfZKkVaZMmcLy5cuJRqNn3ScvL++MhfJEpHMrL5vN77e+0GwXqPxIPuVlszswKslFmv1JcoqZfRG4F7/WxOxgBqhzsS947RZ/I+gGtRPobmaDmzgmPn/nxnMsS+SczJgxg/z85pu28/PzmT59egdFJCKZ7gOjP0RBXvN1yAV5Bdw6+oMdFJHkKiUVkjPM7MvAfwIr8QnF3jZ8Tfxp7J1G7/8xeL2+iWNuaLSPSLvo06cP8+bNo7CwkLy8My/feXl5FBYWMm/ePC2AJyIJg7sN5iuXfY3i/GLyG/W3z4/kU5xfzFcu+xqDuzVVZybSekoqJCeY2dfxA7PfwHd52t/Mvpeb2Xs6nZvZHOBvg83fNPo4vt7FP5lZ76RjRgKfA2qAX7Q1fpHWGjNmDHfddRfTpk2juLiYSCRCcXEx06ZN46677tLCdyLyHtMGXsI9c37EdSOvp2tBVyJE6FrQletGXs89c37EtIGXhB2i5ICIppiUbGdmd+LHKzQA/0XTYxu2BuMa4tPGTgReAXYEn0/h9FoUX3fO/UsT5fw78KXgmIeBIuCj+HUuPu+cu7eNp6D/CUVERCRbRJp6UwO1JRfEpzbKB754ln0qOD1Q+tfAB4FL8V2XCoE9wEPAvc65hU19gXPu78xsNfDXwGeAKLAc+J5z7unUT0NEREQkO6mlQiR8+p9QREREskWTLRUaUyEiIiIiIilRUiEiIiIiIilRUiEiIiIiIilRUiEiIiIiIilRUiEiIiIiIilRUiEiIiIiIilRUiEiIiIiIinR4nciOe75559n9+7dYYchIiIi7WzQoEFcf/31oZStpEIkfE0uIpMuS5YseQsY255liIiISPi2bdu24frrrx8XRtlKKkRyX/fg9Qiwsp3LmgqUdlBZrZWJMaVLLp+biLSPXL5uZNq5dWQ88bK6t7Rje1FSIZL73gaGAiudc+XtWZCZvQLM6oiyWisTY0qXXD43EWkfuXzdyLRz68h4ksp6uz3LaY4GaouIiIiISEqUVIiIiIiISEqUVIiIiIiISEqUVIiIiIiISEo0UFustfQWAAAfSklEQVQk9z0AvAJszbGyWusBMi+mdHmA3D03EWkfD5C7140HyKxze4BOdP+NxGKxsMoWEREREZEcoO5PIiIiIiKSEiUVIiIiIiKSEiUVIiIiIiKSEiUVIiIiIiKSEiUVIiIiIiKSEiUVInJWZhZpx+/u3V7f3RaZFk865fK5iYhIZlBSISIAmNl4M5tjZnPNbASAcy7WHomFmf0c+JKZDU73d7dFpsWTTrl8biKSXmbWI+wYpP21V4WhkgoRwczuBZ4FXgT+ALxsZj82s27OubQuZmNm9wCfAu4C7jSzgen8/myPJ51y+dxEJL3M7GXgSTPrF3Ys7cHM5oYdQ7Iw4jGzAvAVhsF2WpMLLX4n0smZ2ePA9fhk4iVgMHAHMBBYDHwNWOycq01DWYXAj4HbgDeBycA3gZ875/ak+v3ZHk865fK5iUh6mdlXgW8Fm08Df+ac2x9iSGllZn8A5gJ/6Zz7SWeLx8zuAKYBw4AdwJPACufcQTPLc85F01GOWipEOjEz+xpwC/Bt4E7n3A+cc18G5gBVwAzgHmC2meWnWp5zrg5YBkSBXwCb8UnLn8Vr0dtzHEemx5NOuXxuItJuXgVuAn6WKy0WZnYz/gG+BrjfzP6yM8VjZvOBnwJ/AVwLfB54Avi1mY10zkXNLC35gJIKkU7KzLoA5fhai/uCGouImeU7597E11rV4mu4/x24IDgu1evGHqAOeAH4J2Abpx92hwXjOErNbEiK5WRrPOmUy+cmIilKqlh4DV/x8J/4FuubSUos0lGpFKL1wBGgAtgF3Gdmn+kM8ZjZL/FJ4veB0cD5wMeAt4EbgMVmdmG6EgslFSKd1wDgIuCAc25f0vvxPpHbgSL8hW8C/mZDGppJXwOKgcucc0/iu+RsxT/0ftDMpgELgM+ZWfcUy8rGeNIpl89NRFKUNGZuI/6B8wjwac5MLAY55xrMrK+ZTQwp1DYJHpSP4CtYHgO+GGzfH3+Qj48zSFdtfabEY2Y3AR8CHgb+wzm3yzm3F3gU+AawE9/N+SUzG5eOxEJJhUjndRDYB4wwsyvA32CSkoargNXAZ/F98q81sxvTUG41cAyYEmzPx7eKbAS+ix8sfgHwpnPueBrKy7Z40imXz01E0iBohTiGb8mc7pzbBvwNpxOLe8zsQnzt9t+bWd/Qgj1HzrloMDZkB3C9c+4R4B+BQ/gH+c865+rNbCjw52bWJ4fiuQDoBvzOObc/njAE4yMXAaeA40Af4BEzG5JqpaGSCpFOKLiJnAKeA3oBf2NmU5M+/xNgHrDHOfcWvssM+K5QqZSb55w7AKwEpgZdraLOud8BPwEKgB747jovpVJWNsbTVmY2IHiNJL2XE+cmIunVuDbaOdfgnDuKr0S6JrhWrMfXoj8LfBioxD8zvoGvkMoKSee6maALbzAwOv4g/yMz+zKwFvg6MDSH4hkevA4IXiNJicUB4ATw3/iB+ePxMwRGGv/7OBdKKkQ6oeAmUgc8iB/MOw940MyeNLPf4x86C/EDu8A3kwKUtaW8+MNuUi3I28Ak/EMtZtYf3yWnFtgNXAP8iZkNa0t5rZVp8bSFmT0N3A1ndGXIiXMTkfQys+FBN5fkCoj4z5uB4UFXpwLn3Dp8X/wafI33O8BDwVisbHt+fBEYEu++5Zz7GfAZfNej7wAR4Hv4h/lciWd18Hp7kCg2BH/7fDP7FL672+v4+8F+4H2Neiucs2z7RyEibWBmU83sDjP7rJldE3/fObcU38z9v/iHzpuAsfjpZWc457YHu27Bj7WoaUVZw8xslpldaGbnB+XEGtWArAL6AnVBM+9KoAvwZeDvgLfwN7N5qQ4QNLPLzezjZna7mc1q9FlhR8eTTuanA34/vpl8RqPPOvx3LSKZy/w0puuDMRLJFRDxnyuAoWZ2UdAFZwTwK/x1fwNwIXBvcHxapiBNp+REp4mKrG1AKZA8o9XL+PtaDOgJ1KYzYWrqetqe8dh7Z/N7Af93ex/whJldY2Zj8Nf9r+O7YC0A1uGTl6vNbHgT39NqSipEcpyZ/QB4BngA+BHwezP7dPxz59xi/BRzVwA3ArOBTzjndiR9zZ8D9cAfWyjrO8Dz+IvjIuBxM/tQUE78Ygl+/YsG/IDARUAJ8HXn3H875x7ET2O7GHjOOdeQwrn/En9h/TU+cXrZzH5jZrcEMdV1ZDzpZGbPAdfhuyXkA5cH78ebt+M3r6w7NxFJr6BFcy5+iumZwXuNH3qr8C3UETMrxV8vuuHvDx/idFeof8/QlorEZBPxiixInOcWfPeiacF75+MrXKL4e8MhfML0xTQmTGc8nMd/Z8Fre8RzxhTAzrmdwK34BOb9+G5Oq/Dj6WrwYzr2Bd+/Ap8TFJz7aZ6mxe9EclhQkz0X/6D/a2AE8EPgMHAxsC1+8U2uuUreDmaQ+Ff8GIwbnXO7z1LWE/iWjrXBf4PxU9buB25zzi1M2nckflq9EnxtybeB/2m0ymd359yxFM79QXyS9L/B+Q8F7sQPWt4N3Ad8Nzj/0fim4naLJ52ChKIc32y9HV+buBM/yPJAo31H0s6/axHJXMH1Yg7we/w18VHn3Ieb2G8AvpJiAb7Cojt+PN2Pgy5RkwEDvuGc66huQi0ys68A04HLgKX4cR//6hot2Gpmq4FX8JNVLAO6Al9xzv3EzD6Ov0ceAUY55w6nEM88YGoQzx+Bhc65yib2S0s8ZnYX/n7wfvzf70nn3P1Jn48A/hJ/76vF/35+EswEFd/nBfwYjAnJzwLnSkmFSI4ys58CH8H3z7zfOXcoeP97+ObPMc65zY2OSU4m8oL9/hzffaY86GPbVFn3AX+CTz7ud84dMrMe+L7+fwt81Tn3r42+/3P4wWk/AH6Q1MwbS+WiFnz3x4CfAfcC34pfkM1sLL7G7R/xXYD+Fbg7KPsLwfmmPZ50apRQ3Oecqw5uCO8D/so5d781WiG1PX/XIpK5kq4Xf49PFh7F96W/2Tn3TKN9I/hJG8rxlRXfJaiAMLNC51xd/LUDT6FZSV1Ad+Jnuzsf39qyEL++0kvOuRPB9e7XwNX4qdKLgK8CP3XO1Qff9QngdefchhTi+Q1wO2f2BFoJmHPuiWCfvGBsw29TjSf4jlvxLRv78QOuTwKfds49Gh9L0ULM84D78bMDfgGoa+t9IRObr0QkRWb25wRzjONvCoeSPu6Fn0o2ZmY3mFl5vBk8uckYcMBX8DUlVzeTUNyKv6g9GC8rSB6O4VftrANuDC6kie93zv0IX2uWeMgNZidKx0PuWHzT86+dc4ctmPc7uDj/Nz7ROQF8KfgZ59w9+JaW9ognLczsj8CV+NrDnzrnqoOP7sW3JF0Dp7s+ddDvWkQykJk9y+kKiP91zq0B/iv4+JJG+8YrfO4G/g9/TfmfpOtFHZzRZTR0ZvZDfIuKAZfi1126HN8yPQO/ttIdZlYaXBOfAgbhu/J+DX9+9WZWBOCc+02KCcV84IP4++5FwAfwK1lPBj6SNIYvft19IpV4zOwR4Bb8Pe1SfLe2z+HHakwOvqMh2Lcg6bj8pJ8/HJRdDXzPOVebyn1BSYVIjglaCMqBvfiHyINJn12LX0WzCN8U/gy+efY35hdCSx60933gz4BbnF9hu6myivC1Mv3xXYkONupKtQK/2Fo3ggtp8gXLObc2+SE3Decev6aNDs6xZ7CdXOYR4CF8whTFry49Pfg4rfGkk5l9EP93/SbwM+fc0aQEcA3wLvAhM7stfkx7/q5FJHOZWQV+fFy89jtesbQc/xD790F3JuCMa8WrwD8A/57J1wvza2Vcj+/u81/Or/0Qdc6txM+i9D18BdpX8Q/0XfBTqN8F/Au+RT1+frVNFnJu8fwT/vf9HXzL/CrnFxy9B9iEH4syDs74Xb+I75Z0zvGY2beD8v4Nf+/d7Zw7iW+hqcEnFglBshKvZGows0IzewZ/n++LH19xRs+FtlBSIZJjghaCH+MHW29LGqw2E18LNQB/EbsLn2A8gb/g3RX/jqDJ9Jhz7gnn3J5myqrFD/z6sXNuS3Bcci1HA74GvYjgetN4gF+QhKTrphUve0Hwel0QZ0PSAzjBxfcx/O9pAr5GKXGxz8SbqHPuMXzt4v/EE4qkeLfiby7g+xY3NRNI/Hsy7txEJH2CSpI8fA3+z4PrRXwCh0r8lOHd8A+lZ9RcO+fqnV95OZbma3O6lQFj8At3HjWzoqB7VsT5SUb+M/ivJ75FelpQofQ759x9aa7MGgd8Ej+T3s+CyrV46/9afMtJIacruQg+Owj89lzjMbM5+OneX8Dfe5PXDbkSf7+Nmdl8M3vOzL5nforgWNK/gzr82MolwByXpjEyGlMhksPiD55m1gufSPwFcKtz7vmkfS4EfofvMnRh0ER+LmWUAL2dc1Vn+bwSXxNyEX6KvHjXnDLn3LttOa9WxDQNX+NWCHzUOTc/eL/xgPRL8BfmCDAR2J0NXYIan0fw3hR861N34PKzdVcTkdwWtCAPwy9eeiLpPhDvy38t8Dh+Qo0ZLgtnfTOzIfgJKJY5564J3oufZ/y1P76l4ovAs865m9opluvw4xE+6Zx7Iqn8gqCF4Ev4FoHbnXMPJcfaxvKG4SvObnPOrUh6/2r8RCwX4ltB8vCDs/vhB29/INgvMc7CzLoGlWxpoZYKkRyWVJN9GN/VaYZz7nkzyzO/bkS+c24VfgYK8DMEnWsZp86WUATy8OMqokkJxfXAK2b2F80c12bOuTfwA5MBvmZm7wveT55mMOKcW4ZvqekFlGRDQgFndmtKem818Ah+BpGPBn9jXeNFOpmgX/w7zrkTwXbjFthKfDeoS4BPwdlbNjPYcfxg8jnx+0ijhCLinNuH7360Bni/mX20nWLZhF/v6dV4HMH78WQtvnhsDSQGajeuFGrtWhR5QUvMBOfciniLiJldhh9YPx74GPDhINm6Cv+3vsXMvhrEl2i5T2dCAUoqRHJe0sXjOefc8uQm7aQaqjH46UY3pbnsInxrQUO8n2hQS/ZNfE3asnSWF3x//Ob4W/wguQv923Y9JG48hUkX9X748SdtnkIwbEk3pJ/hz+U6IJO7LohICIKH0pP4vv81+O4yTVZUZKrgHI7iF3A7BdxpZonzaJRYbMXfb2L4KVPTzjn3DjA/SGKS32/8O60O3o9Xrs0yszuT32tFWfH9aoLt+D28GhiJn/b9d8HvJz45yVfx42jKmoktLZRUiOS4xhePpGbw+NSun8bPp/0HgoteGsuODzirDVpGrsNP4zoWuCS56TaNZcZr5fbjp1D9DX6cwT1m9qngszoAM7sR3y1rKa1YLTxTJd1oNuO7NFwK/HV4EYlIJkq6VmzCzwJ4Z3BdzhpJ57AU33X3CuDvzOzS4PN4i3T8GXcXvotruyQVQZnHG7+XVMEVf/AvSfrsWvz96Z/NrF/jY1tRXuN1pdYA451zL8Urmez0jE9H8IvaFZ1rOedKSYVIJ5M8GMzMbsZPqXoA+BfnXFofrIOLWwP+gnYTvnn2fODKcx270RbOufX4hYX+Cz8j1M/N7Hdm5szsnuD9EuAf0t0M3NGCG8sR/OJ2J4FZIYckIhnKObcRP5AZ/MJ4re6CkymCbrf34SvEbgW+kdzVNakWfxq+0ijtLeMtiCcV8YHw8e5P1+HvhaPx4yL2p1JIUoIRb52IBveD+uD9jwRlPxuU325d3TRQW6QTCvphfgH4LNAbmJ2u2R8aldMFeA0/UHs/cB4+oVid7rJaiKMQf2F1wECgB3AQP1vHZ4LkI6O0dWYSMxuEXzG1HzDQpbAyrIhkrkYVRK0e+JvUPehC/JiyUnwt9+52DLfdBDMbfhU/xeyb+CnD78FXaF2Pv+4X4Wc52nm272nH+O4AHsAnbw1BbOcDM9ujcq3Rv4sP4CvPtuDHWext9uAUZVVWKiJeKjUNZlaGf+j8Dr6F4qrmEooUazWiQC0wBD+GIuWEoi3xOOfqnHO/xS8OdyXwCfwF/tZMSSiCgdUDzK8z8p4F7ForeDC4G7hUCYVITusa/yF5EoqWJHURXYWfQakUKG6XCNtR0njBRcA/47sTjcJPpbsCP0D7Z/hKrdvCSCgC8b/L9fhVvtu1tT7p3vFJ/HiSrvjKs3ZNKEAtFSJZxcymOr+4T5unpDOzbvgFd0qAB5xzu9qrrODY/wT+HJieygN8KvGkEn9HMLP/h1/YbhqwG3gSPxZkjXOutrWtFpl+niKSOjP7R/zK0Zfi1xl4Hb9YXXya0BavA/FpRc2vsVAbDDbOGG255pmf3nwyvkvvCPzg7KXAvameX1tajpOm8P00fk2kk0FMM1uqXEuhpTqCb6X+Hr4LbAy/gG3aeyI0RUmFSJYwsyeAm4EbnHMvBO+l8rBfkNTnst3KMrMBAKnUkqT73DNJcG7X4gdZbwVm4LukbcAnFj9wfq75jFzZVkQ6jpk9DrwfqML3kz8P3+vkJfwYiZedc9XZen00s48DT7lgwb5zueY1mvUpLeeeSjxJ3zEPeBCfVDS7hlCq5ZlZb3y35r8HXga+7Jx7+1xjbit1fxLJAmZ2L/6hGuC3ZnYNtL7J28xGmNnk5PeaSSjSWpZzbm+KCUXazz1TmNm38Kua343v73sTvsXi3/CJhQP+1cy6BzVejVcjz9hzE5H0CiaXuA74f/g1Ji4EZuITinJ8UvEJM+vW3EN10qxAGSVImH4FfPls17zmxGc2bPSdqXQVTimeJOvx4xqmtZBQpFyec+4Q8Gt8V98/68iEApRUiGQ8M/sT4E+BRcC9QB9gfmsfroPp6h4FVpnZjEwpqzUyLZ50MrPu+HEda4AfOef2Bl0S1uCn3f0CftGkvwK+aX7l02jS8Rl7biKSXkGL7w34lZTvcX5NhHrn3BLg0/iEYiB+wPI8MytudPxoM7sLzl6hFCYz+y5wC37dic8DXzmXB+ug69N71ntIoSU/LfEEMawD/tH5NSM6orx3nXPLg9kAO5SSCpEMZmYDgduBLsBnnXNfwA+wLqWVD9fBdHXxKev2NbVPR5fVGpkWTzsYBFwM7HPOHQ+6ozVAorbpcXxi8S5+TMqnLFg9Ndgnk89NRNKrDD/Ad23QNabIBevtOOe24QcA/xDfn/5L+PV3MLN887Pw/QD4bzP7ZijRN8P8DEWfwc/Gdxd+XNmXaOWDtZmNwbdi3wKpL+yW7niCmM46XXt7lBcWJRUima0Wv0jRp+MDrZxz/4Rfe6HJh+vkB+z4hcg5dx0wpIWm0I4sK9POPQw78eMohgR9Z+uTbxzOLxz4B3wXqHrgY/guUYnuCxl8biKSXvuAE8A48NeH5Oudc24Pfs2GXwGTgL8L3m9wzlUDvwV24BeLyxhBDftH8ZVHf+qc+zW+MqUKfw6tebB+P/BB4Htm1jXFLk8dGk+mnX+qlFSIZLCgxvqb+Hm34+tL4Jz7Ok08XAPJK2XHZ56IP4A2Owd5R5aVaefe0ez0aq8b8Q8A/wyJRYuSE4tTwPPA7/Grxt4evF+f9PvIqHMTkXZxHF8RcYOZ3QnvbaUNrgU/xF9XbjOzD0FiAPP/4deiOGuf/jAE17h/w3cPWhK8/SK+xn4XTTxYN/HQ/BN8S81tzrmTqbRUdHQ8mXb+qdLsTyJZJuh3H5868JvAPwFHgNvd6ZmRPoufr/sbwUUr48vKxnhSZWZXABX4B4bPO+d+E7x/xqwf5leJfQH4b+fcX4cSrIiEysw+gh+E+yrwVefca8H7Z8x6ZGafAH4JfMk598MQQ241MyuMd+cKtvPxY87uA4biH5q/65w7nrTPANdOay90dDyZdv5tlX/33XeHHYOInIPy8vKYmeWXl5fHysvLX66oqCgA3gfcVFFR8XpFRcVU4PvBe/eVl5cfy4aysjGeVAQPAO9WVFRUAzcCEyoqKvaWl5evj59nRUVFXnl5eayioqIG3yS+qby8/LFwIxeRMFRUVLyLrzC5GehZUVGxuby8fHd5eXmi9TO4XvQGPgW8VV5e/kJ4EbdeeXl5tNF2rKKiYht+5qRZ+FmvCisqKirKy8vjaz/8Z0VFxary8vK0L2rX0fFk2vm3lZIKkSzUxMM1+NU6bwU+FOx2uXNuczaVlY3xtFV5eTkAwY0jH59YTK2oqKguLy9fEZxfLNhnHnAT8PPy8vKlIYUsIiEqLy+vqaioeB0/CPtGYEBQEbG1vLycpOvFB/BTzN5fXl7eLqs2d4SkB+t1+Afr9wFFFRUVY4GvA8OBH5aXlx/IxXgy7fxbQ92fRLJYMANIbfDzY/gH60PA1enuO9uRZWVjPOcquYuTmY0E/hq/EmwE3y/6p/jBejfiZwIpBcqdc9vDiFdEMkNwvfgxMBdYDfwffspt8NPOGr6i4hrnXMbUYreVmRXhx5T9FD9rXhfgKHCV66CVosOMJ9POvzkaqC2SwRrNZtSt8edJD9WfAKYBh4Er2/JQ3ZFlZWM86RR0fYoGM1Z1dc5txQ8+/wx+hpe/AZbiZ4f6KdAXuEUJhYgE14tPAT8CxgPfBVbgE4yf4a8X83IkocgLrvUV+HV5unL6Wh9GQtGh8WTa+bdELRUiGSo+6C74+Tb8oK0fOOc2NdrvZmA+cBJfS3/OF5qOLCsb40mnJs5tLvAf8WlhzWwC8AHgUiAKrAR+5fxc9CIigB/cC1wOfBEYATTgKyN+mOndP8+Vmf0p8C/4h+qZzrn1nSmeTDv/s8nIpdpFOrtGD543A9/G3zSsid334m8kn09DQtGuZWVjPOnUzLndnfT5evzgPBGRswpmC6o0s8VJs+IlrjG5wsyuxF8j+wCXhP1A3dHxZNr5N0fdn0QyUNKD5634pu0ewDjn3N4mFsBZBlzvnFuV6WVlYzzp1NK5Ja+zET+miTnJRUSSRVveJattAp7FP1BnQvfWjo4n087/rNT9SSRDmVk/4E38wN1LnHNbk9dpyNaysjGedMrlcxMRaQ9mVuCcqw87jriOjifTzv9slFSIZDAzmwnsds5tbu8Hz44sKxvjSadcPjcREemclFSIZIGOrKXItBqRTIsnnXL53EREpHNRUiEiIiIiIinRQG0REREREUmJkgoREREREUmJkgoREREREUmJkgoREREREUmJkgoREREREUmJkgoREREREUmJkgoREREREUmJkgoREREREUmJkgoREREREUlJQdgBiIiISOuY2SvArEZvz3bOvdLx0TTNzA4DpcnvOeciIYUjIh1ESYWIiEgamNlWYARgzrm707XvWRwFqoOfa9twfON4ZgN/DDYvd84tbcUxvYHdQBHwWefc/cFHe4BTQD7QL9XYRCQ7KKkQERHJPn/jnHsgjd/3CrANn+jcAbSYVAC34xOKGuDB+JvOubEAZjYS2JLGGEUkg2lMhYiISCfnnIsBvwo2bzezwlYcdkfw+qRz7lD7RCYi2UJJhYiIiMDppKIv8P7mdjSzMcD0YPOX7RmUiGQHdX8SERHJQWaWB3wc36IwFT94ej+wEPgP59yS5P2dc2+b2SJgZnDME818fbyVYg/wQppDF5EspJYKERGRHGNmPfAP+78CrsG3PlQDg4GPAK+a2V83cWi81eGmYCB2U98dAT4RbP7WOVefzthFJDspqRAREck98WRiNXAj0M05Vwr0Br4G1AM/NLOZjY57CD9zUxHw0bN899XAyKRyRESUVIiIiOQSM7sG+ACwFb+GxbPOuWoA59xh59x3gK/jnwG+mnysc+4I8HiweQdNi7+/0jm3Ks3hi0iWUlIhIiKSW+4MXh9wzh08yz7/G7zONrP8Rp/Fu0DNMLPRyR+YWRfgw432ExHRQG0REZEcc0Xw+rdm9tkW9u2KH2+xN+m9PwC7gCHAJwGX9NkHgJ747lP/i4hIQC0VIiIiuWVw8FoKDGzmv7iuyQc75xqA3wSbnwwGZsfFuz4975xLTkREpJNTS4WIiEh6nApeu7Ri3/iDfHU7xBGvMLzVOfdkG7/jl8A/AqOAK4GFZjYIeF/S5yIiCWqpEBERSY8Dwevg5nYys2KgT6Nj0mlP8DqhrV/gnFsPLAs2Pxm8fhzIBw4BT7U5OhHJSUoqRERE0mNF8HpFs3vBZfiH8+Rj0mlx8Hpbit8Tb434iJmVcLrr0++cczUpfreI5BglFSIiIunxSPB6vpnd2sx+Xwpet9A+ScUDweslZna2aWEBONsCd4H/A2rxYzP+GZgSvK+uTyLyHkoqRERE0sA59zJ+5iSA35jZX5pZafxzMxtrZr/Bz6AE8M/OuWg7xPE88Giw+XPzEl2yzKy3md1qZk8A/9HM9xwAngk24+tZbHDOLUl3zCKS/TRQW0REJH0+BjyB7wJ1P3CfmR3Gr1DdLdgnBnzdOdeeU7Lega84/ADwDeAbZnYEiOCnhI17oIXv+SXwQU5XQqqVQkSapJYKERGRNHHO7Qdm4Qc3P4MfNN09+HgD8BPgYufct9o5jhPOuQ8CN+FbLXbiZ6UqAt7GrzHxYeCvWviqZ4F9wc9RTk81KyJyBrVUiIiIpJFzrh7/8B36A7hz7hlOd2Fqy/F1wID0RSQiuUotFSIiIiIikhK1VIiIiGSfX5jZL4KfZzvnXgkzmGTBGJLSFncUkZyipEJERCR7HOT04nZxtWEE0ow9nF5dXEQ6iUgsFgs7BhERERERyWIaUyEiIiIiIilRUiEiIiIiIilRUiEiIiIiIilRUiEiIiIiIilRUiEiIiIiIilRUiEiIiIiIin5/8oXhjgqZjSKAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(10,7))\n", + "\n", + "ax_pd = plt.subplot(111)\n", + "\n", + "ax_pd.plot(U_spin_cs, Ts, \"o\", ls=\"-\", color='C2')\n", + "ax_pd.fill_between(U_spin_cs, Ts, [Ts[-1]]*len(Ts), alpha=0.25, color='C2')\n", + "\n", + "ax_pd.plot(U_sc_cs, Ts, \"o\", ls=\"-\", color='grey')\n", + "ax_pd.fill_between(U_sc_cs, Ts, [Ts[-1]]*len(Ts), alpha=0.25, color='grey')\n", + "\n", + "ax_pd.set_ylabel('Temperature\\n[Kelvin]', rotation=0, ha='right', multialignment='center')\n", + "ax_pd.set_xlabel('U [eV]')\n", + "\n", + "ax_pd.set_yticks(Ts)\n", + "ax_pd.set_xticks([np.round(ele,2) for ele in U_spin_cs+U_sc_cs])\n", + "ax_pd.set_xticklabels([np.round(ele,2) for ele in U_spin_cs+U_sc_cs], rotation=45)\n", + "\n", + "ax_pd.spines['left'].set_bounds(Ts[-1], Ts[0])\n", + "ax_pd.spines['bottom'].set_bounds(min(ax_pd.get_xticks()), max(ax_pd.get_xticks()))\n", + "\n", + "ax_pd.text(0.9, 0.2, \"in-plane AFM\", transform = ax_pd.transAxes, size=22, color='C2', rotation=90)\n", + "ax_pd.text(0.07, 0.15, \"SC\", transform = ax_pd.transAxes, size=22, color='grey')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Not at half-filling\n", + "\n", + "If we are not at half-filling in the repulsive Hubbard model we have to take the Zeeman term into account in the attractive model.\n", + "Because the implementation of the linearized Eliashberg equation is right now limited to $\\mathrm{SU(2)}$ symmetric systems and the Zeeman term breaks this symmetry we will apply the Zeeman term in the repulsive model.\n", + "This means, that \n", + "\n", + "$$\n", + "\\langle S^z S^z \\rangle \\neq \\langle S^x S^x \\rangle\\,,\n", + "$$\n", + "\n", + "and the CDW will therefore no longer be degenerate with the superconducting phase.\n", + "\n", + "The Zeeman term is already included in the `SquareLattice` class, but to use it we have to input a Hubbard model that carries spin explicitly.\n", + "We therefore create the `hubbard_spin_dependent` variable which is a copy of `hubbard` but with `spin=True`." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "hubbard_spin_dependent = hubbard.alter(spin=True)\n", + "\n", + "H = create_square_lattice(**hubbard_spin_dependent.alter(zeeman=1.0))\n", + "e_k = H.on_mesh_brillouin_zone(n_k=(hubbard_spin_dependent.nk, hubbard_spin_dependent.nk, 1))" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.52, 0.6, '$|\\\\downarrow \\\\rangle$')" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaMAAAFOCAYAAAArT3KoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3xT5ffA8c9N0nRvCkjZewsoS0VRBCdOUBFUVPwqivvnFkNcgHuhIjIEwQEoIuLCzRQQZMosq4y2dCYdaZP7++OW21YZbTNum57368WLPmnzPAdtc3pvnuccRVVVhBBCCCOZjA5ACCGEkGQkhBDCcJKMhBBCGE6SkRBCCMNJMhJCCGE4SUZCCCEMJ8lICCGE4SQZCSGEMJzF6ACEELVTanKTcCAqOXV/ejWfnwQ8B6xPTt3/vk+DE7WOXBkJUQelJjfpn5rcRE1NbjKjms+PB5YBB1OTm1xTzTAygMuB51KTm5irOYcIEpKMhBBVUpqIfgK6o91d+TQ1ucnVVZ0nOXW/CiwE6gFn+TRIUetIMhJCVNq/EtGxwpYW4LPU5CZXVWPKr0r/vtIH4YlaTJKREKJS/pWI5gE/lH7qPrTE9HlqcpMrqjjtL0AukozqPElGQojKagI0R0tEw4CS0scXAUPQElLPqkyYnLrfBXwHtE5NbtLJZ5GKWkeSkRCiUpJT928A+gDDklP3l/zrc18D3ZNT94+txtQLSv+Wq6M6TJKREKLSklP3b/93Iir3uS3VnHYxUIwkozpNkpEQwlDJqftzgN+AnqnJTRoZHY8whiQjIURN8BWgAIONDkQYQ5KREKIm2F/6dxNDoxCGkWQkhKgJLi/9e5GhUQjDSDISQhgqNbnJsdtzR4BVBocjDCLJSAhhtD5AA2BhaYkgUQdJMhJCGO3Ylu6vTvpVIqhJMhJCGO0qwIlWakjUUZKMhBCGSU1u0g5oB3yXnLq/0Oh4hHEUVZVbtNUg/9FErVa0fAUZQ68jYugQ4t943bA48t59j9wXXiT+zTeIGHKtYXGIgFFO9Am5MhJCGKbw+x/AbCZswAVGhyIMJslICGEId0YGrr/+wtqrF6b4eKPDEQazGB2AEKJuMterR/L+vUaHIWoIuTISQghhOLkyEqIOMjdpTPRDDxLSqaPRoQgB1IHddHa7fQ/Q7ASfPmKz2RpWY9rg/o8mhBD+ccLddHXlyigHeOM4jzsCHYgQQoj/qivJKNtms40zOgghhBDHJxsYhBBCGK6uXBmF2u32EUBTtBpYG4DfbTab29iwhKgdVI8Hd2oqJdu2U7xtGyV79mBu0ABr795Yz+iBKSLC6BBFLVeXNzCkALfabLbfTvC8kcDI43yqdWJiYnLr1q25+OKLfRWmEDWOJzsbx/QZFP70MyXbt6M6ncf/QouFkK5dCe3TG2uvXoT2PBNTXFxggxW1RZ3ewDAd+APYDOQBLYExwP+Ab+12e1+bzfb3cZ7XHDjveBMePXqUqKgo/0QrhMHcmVk4p0zBMW06qqMSe3xKSij+6y+K//oL3n0PFIWQTp2IuuduwgdfjqKc8PVHCF3QJyObzWb/10ObgLvsdrsDeBgYB1x9nKfuAY531dQNiPVhiELUCO7MTByTP8A5fcZxr4KUuDhC2rcjpF07LC1aULJ7N0WrVlGybXvFL1RVijdtImv03RR8vYi48S9grlcvQP8KUVsFfTI6iffRktG5x/ukzWabAcz49+N2u/1XTnDFJERtlf/Fl2Q//sR/kpCldWui7x1D6Ln9MCUlHfcqx52ZiWv1alwrV1G0ahXFmzaDW3s7tnDxYtJWriTu1VcIHzQwIP8WUTvV5WSUVvp3pKFRCGEgtaSEnOdfwDnlwwqPW9q1Jfr++wm//DIUs/mkc5gTEgi/6CLCL7oI0N5rynlxAvmzZ2vjzEwyb72NyJtvIuaZsZjCw/3zjxG1Wl3e2t239O/dhkYhhEHcR4+SMWx4hURkbtGChMnvU3/Jj0RcecUpE9HxmOLiiH9pAomzZ2Fq2EB/3DlzFumXXIZr02afxC+CS1AnI7vd3slutycc5/FmwDulw48DG5UQxnNt2qQlhuXL9cfCLhpE/W+/0a6GTN6/NIT170/9H38k7JKyXaclO3aQPvgK8iZ/QLDv5BVVE+y36YYCj9vt9l/QtnLnAa2Ay4AwYDHwinHhCRF4+Qu/JvvBh1ALy7p8R//fw0Tff59PklB55oR4EqZ8QP4nn5LzjA21oABcLnKffQ73vn3EPv+c7LYTQPAno1+AdkB3tNtykUA2sBSYBcyy2Wzy65moMwq+/Zase8aAxwOAEh1N/NtvET7wQr+tqSgKkTcOw9qrF1n33kvxho0AOGd8hGK1Emt7xm9ri9ojqJNR6YHW4x5qFaKuKfxjKZl3lyUiS6tWJEybSkjrVgFZP6R1K5K+WkDWAw9S8NVCABwfTMHcrClRI0cGJAZRcwX1e0ZCCI1r3Toyb7sdXC4AzM2bU2/+3IAlomMUq5X4t94k7NJL9Mdyxtoo+HFJQOMQNY8kIyGCXPH27WSMuBk1Px8AU8OG1Pt0DuakJEPiUSwW4t96k5Du3bQHPB6y7r4H16ZNhsQjagZJRkIEsZL9+8kYdiNqdjYApvh46n0yG0uTJobGZQoPJ3H6NMylcaj5+Ry9ZSTug4cMjUsYR5KREEHKnZlJxg034jl8BAAlMpLEj2cS0ratwZFpzElJJM76CCVWq67lOXyEjJtvwZOXZ3BkwgiSjIQIQqrHQ9a99+Hes0d7wGolcdpUrN26GRrXv4W0aUPilA/Aou2lKtm6lczRd6OWlBgcmQg0SUZCBKG8N9+i6NeyjaQJk94h9JyzDYzoxELPPou4l1/Sx0W//ErO02MNjEgYQZKREEGm8I+l5L36mj6OGnMP4eV2r9VEkdcNJfqB+/Wxc9bHOD+fa2BEItAkGQkRRNyHD5M15l4oLbVj7duHmEf+z+CoKif6/x4m/Kor9XHOk09RvHOXgRGJQJJkJESQUEtKyLxnDJ6MDABMSUkkTHoHxVI7zrYrikLcyy9hadMGALWggOzHHkMtPaQrgpskIyGCRO5LL+NauUobmEwkTHoHc4MGJ39SDWOKiCBh0jv6hgbXylXkf/KpwVGJQJBkJEQQKPhxCY5J7+rjmP97mNCzzzIwouoL6dSRqLvu1Mc5z7+A+8gRAyMSgSDJSIhazp2ZSfb/PaKPQ8/vT9S9YwyMyHsxD9yPuXkzANTcXHKeGWdsQMLvJBkJUcvlPD227H2ihg2If+tNn7eCCDQlPJy4CRP0ccGiRRT88KOBEQl/q93fsULUcQWLv9UrYAPET5yIOeE//SRrpbB+5xBx3VB9nPPkU3gcDgMjEv4kyUiIWsqdmUX2E0/q44ihQwi7cICBEflezNixmBITAXAfOkTuxJdO8QxRW0kyEqKWynnmmQq352LH2QyOyPfMCfHE2sv+Xc7pM3Ct/cvAiIS/SDISohYq+O47Cr5coI/jJ07EFBdnYET+E37VVYSe318bqCpZjz6KWlxsaEzC9yQZCVHLeLKyyH687PZc+JDguz1XnqIoxI1/ESU8HICSf7bheO99g6MSvibJSIhaJvuZcXjS0wEwNahPnD34bs/9m6VJE6LLlTXKfeNNinftNjAi4WuSjISoRQp/+YWCL77Qx3ETJgTt7bl/i7r9NkK6dtEGRUVkP/4EamkNPlH7STISopZQCwrIfuppfRx+zdWEDxpoYESBpVgsWqsJsxkA1/LlFP38i8FRCV+RZCRELZH3ziTce/cBoMTFEmt7xuCIAs/auTORI4br49wJE6WQapCQZCRELVC8cxd5776nj2MffxxzvXoGRmSc6PvvQwkLA6B4yxYKvl5kcETCFyQZCVHDqapKzpNPgcsFQEiPHkQMv9HgqIxjbtCAyFG36+Pcl1+Rrd5BQJKREDVcwYIFFC1bpg1MJm2bcy2vPeet6NF3ocTEAOBOSSF/7jyDIxLeqtvf0ULUcB6Hg5xnn9fHkbfdirVzJwMjqhlMcXFEj75LH+e99jpqYaGBEQlvSTISogbLe+ttPGlpgHamqLa0EA+EyNtvw1T6vpn70CGcM2cZHJHwhiQjIWqokt0pOD6Yoo9jn3wSU1SUgRHVLKbISKLvv08f5739jlT1rsUkGQlRQ+XYn4XSN+atZ5xB+DVXGxxRzRM5/EbMjRsD4MnMxDHlQ4MjEtUlyUiIGqjw518oXLJEGygKsc/Z6/ymheNRQkOJfuhBfex4fzLuzCwDIxLVJd/dQtQwqstFjm2cPo644Xqsp59uXEA1XMS112Bp3RoA1eHAMWmSwRGJ6pBkJEQN45g2nZLdWhFQJTqamMcfMziimk2xWIh59BF97JgxA/ehQwZGJKpDkpEQNYg7LY2819/QxzEPPVhnKy1URdill5QVUS0sIveNt4wNSFSZJCMhapDcCRNRS3eEWVq3JvLWkcYGVEsoilLhCjL/008pSUkxMCJRVZKMhKghXOvWkf/Z5/o49tlxKCEhBkZUu4Seey7Wvn21QUmJXB3VMpKMhKgBVI+H7LFlTfLCBg0k7LzzDIyo9lEUhZjHHtXHBQsW4D4o7x3VFpKMhKgB8ufNp3jdOm1gtdbJ9hC+ENrzTKy9e2mDkhIcU6caG5CoNElGQhjMk5dH7vgJ+jjqf3dgad7cuIBquai77tQ/dn48G09uroHRiMqSZCSEwfLefKus/lzDBkTfd6/BEZ2cs6iE7YdyyXK6jA7luMIuvLDCuSPnnDkGRyQqw2J0AELUZcW7duP4sOxWUuxTT2GKjDQwoorScwtZk5LJriN57E5zsDvdweHssurYzepF0r1ZPKc3i6d7s3gaxoUbGK1GMZmIuvN/ZD+ivX/kmDKVqNtuQ7FaDY5MnIwkIyEMVKH+3JlnEn71VQZHpDmcXcBHf6SwaN0Bit3qCb9ub4aTvRlOFqw9AEDDuDC6NY2nR/MELuzckIhQY15iIq65mtyXXsaTno7n8GEKvlpIxNAhhsQiKkdu0wlhkMKffqbop5+0wbH6c4piaEwHswoYv3AzQ976gy/X7D9uIjKbFBonRGAx/zfWw9mFfLfhEC8u3MyN7y5jze6jgQj7P5SwMKJuu1Uf502ejKqeOKkK48mVkRAGUF0ussvXnxt2A9auXQ2LJyffxTs/bmfx+oO4PRVftDs1jqVXy0RaNoiiZVIUTRMjCbGYKCx2syU1h/V7sli3N4uN+7MpLHbrzzucXciYj9Zwbc8mjBnUlnBrYF9uIm8aQd7b76Dm51Oy9R+Kfv2VsPPPD2gMovIkGQlhAMfUabhLKwQoMTEVzscE2o7DeTz26ToOZhVUePz0pnHc3r81PVsmHPeKLSzETI/mCfRongBAidvDtkO5rE3J5ONlKeQWlAAwf/V+1qRk8uyQrrQ7Lcb//6BSpvh4IobdgHPqNAAc702WZFSDyW06IQLMnZZG3htv6mMj68/9uOkQd3y4qkIi6tE8nkkjz+T923rRq1VipW8dWswmOjWO4+Z+LZlzzzn0a5ekf25vhpPbp6xk9rIUPJ7A3S6LumMUmM0AFC1bhmvjxoCtLapGkpEQAZbzwviy+nNt2hA58paAx+D2qLz9wzbGzt2g31qLsJoZf3033r21F2e0qHwSOp560aG8NKw7T13ZiXCrlgxK3Cpv/7Cd+2atIS238BQz+IalSRPCL79MHzvenxyQdUXVSTISIoCKVq+hYN48fWxE/bmcfBcPfryW2cv26I81SYxg6h19OL9jA5+toygKg3s05qO7+tKhUdntuTW7M7npveVs2p/ts7VOpvwh2IKvF1Fy4EBA1hVVI8lIiABR3W5ynh6rj8MuvYSwc88NaAzZThd3TvuTP3eV7XI7u20S0+7oQ4v6UX5Zs2liJFNG9eaWfi04drGVk1/MfbPWBCQhWbt2xXrWWdrA7cbxgbQmr4kkGQkRIPmz51C8aZM2CAsNeP05Z1EJD368lj3pTv2x285rycvDuhMd7t+rM4vZxOgL2zJpZE/iI7XDp/lFbh6e8xf7jzpP8WzvRY++S/84/5NP8GQH5qpMVJ4kIyECwJ2ZRc7El/Rx9JgxWBo3Dtj6RcVuHv1kHVsPanXaFAXGXduF/13QBpMpcGebejRPYNLInsRFaMkvJ7+Yh2b/RU6+f0sLhZ7fH0v7dgCo+fk4Z33s1/VE1UkyEiIAcie+hFr627i5aVOiy72P4W8lbg9j521gbUqm/tijl3Xk4q6NAhZDeS3rR/HKjT0ItWgvP/uP5vPYp+txlXj8tqaiKETdWfbf3DFtOmpRkd/WE1UnyUgIP3Nt2ED+7Nn6ONZuQwkPTA03j0flxYWb+f2fNP2x0QPacHXPJgFZ/0Q6N4nDdk0Xfbx+bxbPL9jk1yoJEVddiamhtkHDk5ZG/hdf+m0tUXWSjITwI9XjIefpZ6D0RTb0gvMJGzgwMGurKm/9sI3F6w/qjw0/qzk392sRkPVP5YJODRkzsK0+/mHjIab8stNv6ylWK1G3366PHe9PRvX472pMVI0kIyH8KH/efFxr12oDq5U4e+Dqz3255gCfrtirjwf3SGbMoLaG178rb/jZzbn6zLL3zqb9tptv1qf6bb3IEcNRorRdgyU7d1K45Ce/rSWqRpKREH7iyc0l94UX9XHU/+7A0jIwVyX/HMzh9W+36uPzOzbg8cGdalQiAu29nIcv7UCf1mUVKMYv3MzaFP8UWDXFxBA5/EZ9fKxUkDCeJCMh/CT31dfwZGQAYGrYMGBN83ILinny87/1itttGkZju6YL5gDumqsKi9nEC0NPp3WD0isWt8rjn67/T608X4m8/TYwaS99RUuXUrxjh1/WEVUjyUgIPyj+5x+c02fo49hnxgakaZ6qqjy/YJP+Qh4RauaF604nLMTs97W9ERlm4bXhZ5AUHQpAXmEJT8/9m2I/7LCzJCcTNqjsfTvnRzN9voaoOklGQviY6vGQ/cST4NZqvln79iX8isEBWXvO8j0Vds49fVVnmibWnM6xJ1M/NozxN3TTr+C2pOYwc+luv6wVOXKk/nH+53Px5OX5ZR1ReZKMhPAx56yPcf25WhtYLMQ9/2xA3qtZvzeLd5eU3XK6vk9TLujY0O/r+lLnxnHcfWEbfTzj992kpDt8vk7oOWdjad0aANXpJH/+fJ+vIapGkpEQPuQ+eIjcF8fr46jRdxHSvr3f1810FDF27t96Y7zOjWMZM7Cd39f1hxv6NqdT41gAit0qE7/e4vO2E4qiVKiW7pwxUzrBGkySkRA+oqoq2U88WdYeolUrYh64PyDrPr9gE+l5WkWBmPAQnh96OiGW2vnjbTYpPD64k367bv3eLBb+5ftK2xFDrkUpfR+vZMcOXMuW+3wNUXm187tViBqoYOFCCpcs0cdxL09ECQvz+7rfrD/I8h0Z+njctV1oGBeYCg/+0qZhNCPObq6P3/lxOxl5vi3fY4qOJmLoEH3smDHDp/OLqpFkJIQPuDOzyBlr08eRN99EaO/efl83LbeQN777Rx9f17spZ7VJOskzao9bz2tF44QIAByFJby2eOspnlF1kbfcrH9c+P0PlKT678CtODlJRkL4QI79WTxHtYOa5tNOI+bJJ/y+pqpq76c4CksASI4PZ3S5N/9ru7AQM48P7qiPf95ypMJOQV8IaduW0LPP1gYej1TzNpAkIyG8VPjrrxW7t45/EVN0tN/X/fbvgyzbnq6Pn7qqM+FWi9/XDaQzWyZyefdkffzyN1twliZfX4m8tWwjQ/7sOaiFgWmJLiqSZCSEFzy5uWQ/VnYVFH7lFYQPvNDv66bnFvL6t2W354b2bkqP5gl+X9cI9w5qqzfkS88t4r2ffFsxIWzgQMyNtHYansxMChZ949P5ReVIMhKimlRVJfuxx3Ef0HZ6KXFxxD5rD8i6E77eQl6523N3B9HtuX+LjbDy4CVl2+Pnr97HRh+2K1csFiJvvkkfO2Z85LO5ReVJMhKimvI/+4yChV/r4/gJ4zHXq3eSZ/jGdxsOVbg99+SVwXd77t8Gdm5I3zbaf1tV1Yqp+rJUUMSNw8CqXX0Vr1uHa/16n80tKkeSkRDVULxzp9anqFTE8BsJH3y539c96iiqUI17SK8mnNEiOG/PlacoCo9c1lGvsbc7zcHHy1J8Nr85MZHwwWUlm5xydRRwkoyEqCK1sJCs0fegFmjFSC1t2hBrHxeQtd/+fhu5BdrtuUbx4dx9YdtTPCN4NIoP584LWuvjGb/vJi3Hd5sNospvZFj4Ne7MzJN8tfA1SUZCVFHOi+Mp3rJFG4SGkvDuJEwBaCO+NuUo3204pI8fu7wjEaHBfXvu367r04y2p2k7FYtKPEz/fZfP5rZ2705It9O1QVER+Z986rO5xalJMhKiCgp++LFCQ7bYZ54mpGMHv6/rKvHw0qKy23MXdm5I79b+f3/qZErcHoqK3dWu6ZbldDHx6818sXp/pZ9jNincU+5qcOFfqew/6qzW+scTeUu5enUfzUQtrbwu/E+SkRCV5D50iOyHHtbHYRcNqvDi5U+zl6WwN0N70Y0INXP/Rd4VQV2bkkkf2/c8++XGas/x2KfrOe/5JRzKrt6tsriIEJZuT+eDn3foBV4ro1erRHo0jwfA7VGZ8ovvro4irhiMKb507tTUCuWdhH9JMhKiElS3m8z7HsCTlQVonVvjXnklIK0hUjPzmfF7WV+fOy9oQ1KM/2ve+ZuiKPRrV5/s/OIqbdVWFIXR5a6Oftx0iB2HfdOPSAkLI6J8W3LZyBAwkoyEOAVVVcmxjcO1vLSqs8lEwjtvYU6ID8j6r337D0Wl25jbnhbNtT2bBGTdQDi3fX2AKpf56dIkjnPaaTX4VBUm/+y7g7CRN40oa0v++x8U79zps7nFiUkyEuIUHJPerdBCPPr++wjt2zcgay/fnq6fKVIUbdOCxRw8P7ZnNE8gMtRSrZpzd17QhmMXpku3pbNhX5ZPYrI0bkxYuSoazpmzfDKvOLng+a4Wwg+cn31O7vgJ+jh88OVEP/RgQNYuLvHwermK3IO7J9OpcVxA1g6UEIuJPq3rcSAzn91pVevo2qZhNAM7n6aP3/tph88a5JVvvJc/dx6e/HyfzCtOTJKRECdQ+PMvZD/yqD629u1L/JtvoJgC82Pz2cq97D+qvQhGhVm4a0Bwlvw5r0P1btUB3HF+K70J37o9Wfy566hPYgo95xzMLVoAoObmUrDgK5/MK05MkpEQx+Fat47M/90JpVt7Qzp2JHHahyihoQFZ/2heEdPKnaEZ1b8VCVGBWTvQzmpTD4tZqVYyapIYyRU9yqp6++rqSDGZtPeOSjlnzpK25H4myUiIfyneuYujN4/UKyyYGzcm8eOZmGJiAhbDu0u2k1+kJcLmSZEM6dU0YGsHWlRYCN2bJbD1YA7puVXfJn7rea0ILW2x/s/BXH7ZesQncUVeNxTCtF8AijdupFjq1fmVJCMhyin6808yrroaT2kpGFN8PImzP8bcoEHAYth0IJtv1h/Uxw9e0j6oNi0cz7ntk1BVbSNCVdWPCauQrCf/tLNK55ZOxBQfT8QVV+hj50czvZ5TnFhwf4cLUQX5c+eRcf0w/SyREhZG4syPCGndKmAxeDwqry0u27Rwbvv69G5lbKWFQGgQq5VTOlKNKyOAm85pQUSoVkR1b4aT7zYcPMUzKqd8a4n8r7/WvzeE70kyEnWe6vGQO/Elsh54EFwuAEyJiSR++gnWHt0DGsvivw+yJTUHAKvF5HWlBV9LSXNQ4j5+64bth3KrPe/Sbdr7Ree0TarW8+MirQw/q7k+nvLLTlw+aDER0q0bIV26aIPCIpyfz/V6TnF8koxEneZxOMi8627y3npbf8zSri1J33xNaM8zAxqLs7CEd5ds18fD+jYnOSEioDGczPZDudwxdRVPfLb+Pwnply1HuPWDlbzzw7Yqz6uqKku3p5MQZaVT49hqx3dD3+bERYQAcDi7kK/WVr7m3YkoikLkLTfrY+fMWage3/VREmUkGYk6q3jLVtIvvZzCb8raTIee35+krxZgaRL4KgfTfttFpkO7MkuKCeWWfi0CHsPJNIoPp2liJH9sS6+QkH7deoSn5/6N2aRUq7fSpgM5ZDpc9GtX36vySpGhFm7p11Ifz16254RXcVURfuUVKKWbV9x79lC0dKnXc4r/kmQk6pziXbvJvPc+0i66mJJdZdunI28dSeKM6ZiiowMe094MJ5+t2quPxwxsW+PaQ0SFhfDWzWfQMTmWP7als6r0TM9b32/DbFKYcH03+rap+m22Y1u6j5UG8sbVPZsQH6l1bD2cU8hPmw97PacpIoKIoUP0sVRk8A9JRqLOKN6+XUtC/c+n4IsvofR2ixIeTvwbrxP3/HMoFmMSwBvf/UOJW9sB1rVpHIO6nHaKZxijfEI6JsSsMP76bpxVzfd7fv8njXCrmTN90LE2LMTMkF5lV7Wzl+3xyfmg8hsZCr//AffBQyf5alEdkoxEUFKLiynevp2CrxeR+8qrZIy4ibTzB1RIQgChF5xP0uJFFX7zDbRl29NZsSMD0OrPPXRJh4BUA6+u8gnpWCI6u5qJaG+Gk70ZTvq0rkdoaUtxb13bsymhIdpL2/bDeaze7X3H1pDWrbGedZY28Hhwzpnj9Zyiopp1H0CIKlLdbtz79lG8bRsl27ZTvG2b9vGu3VBcfMLnhZ53LjEPP4z1jB4BjPa/XCUeXv+2bCv3FT0a075R4A7XVldUWAiTb+uFq8RDZFj1X0Z8eYvumLhIK5d3S2Z+adO+OctT6NUq0et5o26+iczSyu3OOXOIvv8+lJAQr+cVGklGolYqWrGCvEnv4lqxErWw8mdTwgZeSPT992HtHtgt2yfy2cq9HMisnfXnQiwmQize3Vz5/Z80zCaFs9r49izVsLOa8+Wa/XhUWLnzKDsO59GmoXfvBYZdfBGm+vXxpKXhOZJG4fc/EH75ZT6KWEgyErWGqqq4li0n9/XXca1cdcqvNzdqhKV9O0LatsXSrh3WM84gpFXLUz4vUDLyipj+W9kGijv6t9bffK8LMh1FbD6QTbdm8cRG+Pbf3Tghgv4dGvDzFq000Jzle7Bd08WrOfb2NC4AACAASURBVJWQECJvHEbeG28C2kYGSUa+I8lI1HiqqlL0x1LyXn8d15+r//N5U1ISIe3aYWnXjpB2WuIJadsmoLXkquPdH7eT79Lqz7VIiuTaXsHTNK8yEqJCWT7uIr/Nf+PZzfVk9MPGQ9w1oLVe6aG6Im68UTuT5vFQtGwZxTt3EtK6tS/CrfO8TkZ2uz0SaADUA8KBo0CGzWbzfk+lqPPUggKyHnuCgvnzK37CYiFi6BCi77kbS4uadR6nMjbtz2bx3+Xrz3UI+vpzgda5cRzdmsWzfm8Wbo/KZyv3cZ+XFS0syY0IGzSQwu++B8A582Pinh3ng2hFlZOR3W43A5cDg4B+QEfgP1t/7HZ7DrAM+AOYa7PZUrwLVdQ1JQcOkHn7HRRv2lT2YEgIEdddR/SYu7E0rZ2VrD0elde+3aqPz+tQ3ydvsFfFaXHh3N6/FW29fB+lpht+dnPW79XqyS1Yu5/bzmtJVJh3mw4ib75JT0b5c+cS8/ijmCJqTqWM2qrSychutzcDxgA3AUkcJwH9SxxwGXAp8KLdbv8FmGKz2T6vZqyiDilatpzMu0br1bMBwq+5mpjHHsXSuLGBkXnvm/WpbEnV6rgZVX+uUXw4d5wf/LeXzm6TRLN6kezNcJJf5GbBmgOMOMe7K+nQfv0wN2+Ge89erfHeVwuJHHaDjyKuu055X8ButyfZ7fa3gG3Aw0B9YAPwLnAbcAbQDIgBrGi37NoDFwNjga8BJzAA+MRut2+w2+2Dff9PEcFAVVUcUz4kY9iNZYnIYiH2xReIf+vNWp+I8gqKeXfJDn1841nNaRQvv1X7i8mkVCig+tmqvRR7WUBVa7xXdgjWOVNaS/hCZa6MdgORQArwEfCJzWbbcZKvTy/9sx34AcBut4ei3dq7EbgCWGC32x+x2WyveRG7CDKq2032I4+S/1nZxbMpKYmED94ntFcvAyPznSm/7CTLqdWfaxAbVuPqzwWji7qexvs/7yDT4SI9t4gfNh3ism7Jp37iSURcdx25L70MRUUUb9iIa/16rN26+SjiuqkyyegAMB6YbbPZ3NVZxGazFQHzgfl2u7018DjaVZQQgHZFlP3EUxUSUUj37iROmYz5tJpZGqeqdhzOY96f+/TxfRe1I9wqG1r9LTTEzHW9m/H+T9rv0HOW7eHS0xt5VeXCnBBP+ODBFMybB2iN9yQZeacy23c62my2mdVNRP9ms9l22my2UcBEX8wngkPuhInkz56tjyOGDiFp/tygSUSqqvLa4q0ca0B6ZosELugYuO6xdd01PZsQbtXKDe1Kc7BiZ4bXc0aVay2Rv3ChNN7z0imTkc1m877KIGC32xv5Y15R++W99z6Odybp4/BrriHutVdRQkMNjMq3lmw6zLrSXV1mk8LDl9bs+nPBJiY8hCt6lN2am7Nsj9dzhnTvRkjnztqgsIj8ufO8nrMuq9bBBrvd/lAVv74dsLw6a4ng5pzzCbnPv6CPwwZeSPxrr6CYgufMTX5RCW99X9Z07rreTWlRP8rAiOqm6/s0x2zSfgFYk5LJPwer35kWShvvlavm7ZDGe16p7k/8K5VNSHa7vSewFKhbx8vFKRUs+obsxx7Xx9a+fUh4792gKz45/ffdpOcVAZAQZWVU/+DfUl0TNYoPr3BrdPYy748+hl99FUpp/yt3SgpFS5d5PWdd5c2vny+fKiHZ7fZBwE9AYE/0iRqvaMUKMsfcq7dzCOnShcTp01DCvSvXUtPszXDyyYo9+njMwLZeVbkW3hl+dtnuxZ+3HOFgVoFX8/2n8d4sabxXXd4kIwUtIT18vE/a7fYbgIVo28KF0LnT0sgcfY/e4sHSqhWJs2cZ0mHVn1RV5fVvt+pN87o0iePiro1O8SzhT+0bxehN/Nwelc9X7j3FM04t8qYR+seF3/+A+5A03qsOb5KRipaQXrLb7f9X/hN2u/1+4GMqbt/2fvuKqPXUkhIy7x6DJz0dAFNiIomfzMacGHwXz39sS2flTq01t6LA/13WAZNJNi0Y7cazm+sfL1qfSoGrxKv5Qtq2xdq3rzZwu3HO+cSr+eqq6iajO9GS0bGENPFYQrLb7S8Cr5XOfezzu4CzvY5W1Hq5r7yKa8UKbaAoxL/zNpZk7w4g1kSFxe4KTfOuOqMJ7U6r2VXE64o+rerROEGreuEoLOH7Dd5fyZTfyOCcMwf1JI0dxfFVKxnZbLYpwHCghIoJaTnwWOn42OOrgL42m22nTyIWtVbhTz/jePsdfRz98EOEndvPwIj8Z9YfKRzK1t6PiAkP4a4BsmmhpjCZFIaUa9cx9899qKp3J03CL74IU5LWet1z+AiFP/zo1Xx1UbVv09lsts+Aq4FCyhJPbyomogXA+TabTW7R1XElqalk3ne/Pg49tx/R991rYET+szvNwUdLd+vj0QPa+Lx5nPDOZd2SCQspPQR7xKFX9q4uxWol8sZh+tg5UzYyVJVXhzlsNtti4BIgDy0BHaMAbwHX2my2yveEFkFJdbnIvHM0anY2AKaGDYl/520Us9ngyHzP7VF58atN+qaFTo1jueKM2l3cNRhFh4dwcdey6h7z/tzv9ZwRw4dD6fm4oqVLKd656xTPEOWdco+p3W4/txLzPIdW3ufYVdFXwBdAP7vdrn+RzWb7vXphitos58XxFK9bpw3MZhLefzcoNywAzPtzH5sO5ABgMSs8dWVn/aClqFmu7dWUBWsPAPDr1iOk5RZSPyas2vNZkhsRduEA/Radc9Ys4uzjfBFqnVCZAw+/UvGq52SO/dRdWfqnPLWS64kgUrR8Bc4pH+rjmCefILRnTwMj8p9D2QV6MU6AW/q1pKVUWqix2jSMpnuzeNaVdoL9as0B7rjAu/f2Im+5WU9G+XPnEfP4Y5iC7Oycv1TlNp1SiT+n+lpRh3jy88l6uGzXf+gFFxB15/8MjMh/VFVl4tebKXBp9YRbJEVyS7+WBkclTuXaXmXdghes3e91r6PQc8/F3LwZAGpODgULF3o1X11SlWSkevFH1EG54yfg3qe1TFBiY4l/eWLQFgf9bsOhCmeKnryyM1ZL8NTXC1b9O9SnXrRWkPeow8WvW494NZ9iMhE5ouwQrPMjabxXWZX9aanMVVFlrphEHVG0YgXOadP1cZx9HOaGDQ2MyH+ynC7e+K7sTNHQXk3p0iTOwIhEZVnMJq4+s2yDydxy/aaqK+L666C04nzx3xtw/f2313PWBad8D8dms8mvd6JK/nN7bsAAwodca2BE/vX6t1vJydcOOTaMC+OuAW0MjkhUxVVnNGH677spcats2JfN9kO5tPXigLI5IYHwyy+nYP58QNvmbX31dF+FG7Qk0Qify50wEffe0ttzMTHETxwftLfnvt9wkB82HtbHjw/uRESo7NOpTRKjQzm/Q1k173k+uDoqX5Ehf8EC3JnSeO9UJBkJnypauRLn1Gn6OHacLWi6tf7bgcx8Ji7aoo8v7daIPq3rGRiRqK4hvcs2Mny/8RA5+S6v5rOe0aNi471PpF7dqUgyEj7jKSj4z+65iOuGGhiR/xSXeHhm3t/kF2m75xonRPDwpR0MjkpUV9cmcbRtqFWNLyr2sGjdQa/mUxSFyNtu1cfOGR+hlnhXkDXYnTIZ2e12n+9PtdvtJrvd3vTUXylqk7w33sS9RyvJr8TEEP/ShKC9PTf55x1sSdU6hVrMCs8N6Uqk3J6rtRRFqbDN+4vV+/B4vNsIHHHlFZhKD3e7Dx6k8LvvvZov2FXmyugfu93+UWnrcK/Y7fYQu93+P2AHMNLb+UTNUbxtG473J+vj2GfGBu3tuVU7M/h42R59PHpAWzokxxoXkPCJi7qcRnRp48PUrAJW7vSupKYSFkbkiOH62DF1qlfzBbvK/Cr3J3ATMNxut/8BfArMs9lsRyuzgN1uV4D+wA3ANUAC4ARkv2OQUFWV7CefgtLbENZePbXtrUHoqKMI+5cb9XGf1okM69vMwIiEr4RZzQzu0Zg5y/cA2jbvs9omeTVn5M03kTfpXSgpwfXnalwbN2Lt0sUH0QafymztPsdut18BvAicB5wLTLLb7TuAtcAGtMZ5WYALiAPigRbAmUB3tG6vClAMTAKes9ls6T7/1whD5M+dh2vlKm1gsRA3/kUUU/C9HenxqDz35SYyHdqb2wlRVsZe3UUa5gWRa3o24ZMVe1BVWLEjg/1HnTRJrH6zanPDhoRffhkFC74CwDl1GtY3XvdRtMGlUq8YNpttIdAFuAytLYQbaAfcCIwHpgDz0NqMzwTeBB4A+gFRQArwNNDcZrPdJ4koeLgzs8h97nl9HHXHKELatzcwIv/5dOXeCrdubFd3ITEq1MCIhK81Toigb7kdkV+s9r6ad9Ttt+sf53+1EHe6vPwdT6XfcbXZbCrwLfCt3W5PAM5H697aCzgNqAeEAploV0rbgGXAUpvNtsbHcYsaInfCBDyZmQCYk5OJfuhBgyPyj/V7s3h3yXZ9PPzs5vSWbdxBaUjvpizfof3SsWhdKv+7oDXh1upvTrH26E5I9+5a5XqXC+fHs4l58AFfhRs0qvVf2GazZQLzS/+IOsr199/kzyk7PxH7nB1TRISBEfnH7jQHj8z5S+9R1DE5hrsukCoLwUprSx7OgcwC8krbkl91ZpNTP/EkokbdRtY9WjNJ58xZRN9zN4pVGi6WV60b+3a7Xe5N1HGqqpIz1gal7ZpDBwwg/KKLDI7K99JyCnlg1lryCrXNGfGRVp4fejohUgQ1aJlMCtf0LL/Ne7/3bckvvRRTg/oAeNLSKPh6kVfzBaPq/kQ9b7fbj9rt9sE+jUbUGgVffIlr7VptEBJC3DibsQH5QW5BMQ98vJa0XK1ZcYTVzOsjetAoPviu/kRFl3VrRGjpLxzbD+exubRhYnUpViuRN9+sjx1Tp3qd4IJNdZPRmWi75k5ZxMlut19rt9svtNvt8hMcJDwOBzkvvKCPo+4YhaVlCwMj8r3CYjePfrKO3WkOAMwmhfE3dKN9IzlPVBfERlgZ2KXsnJwvNjJE3jSiYjXvtX95PWcwqW4yaoXWp2jjqb4Qbdfd98Bd1VxL1DB5b7+D50gaAKb69Ym+/z6DI/Itt0fFNn8D6/eWFbcce3VnereSDQt1yTU9y94nWrL5sNf16syJiURceYU+dsoh2Aqqm4ySgFybzaa3RbTb7TvsdvuK43ztfLQzRv2ruZaoQUpSUnB8MEUfxz75BKao4Gmt7Srx8OyXG/lta5r+2L2D2nFx10YGRiWM0DE5lvaNtFYSrhIPi9alej1nZLlt3gXfLMZ98JDXcwaL6iYjB//diReFts3731LQrqI6V3MtUYPk2J8Fl/YbYkj37oRfe43BEflOttPFvR+t5vsNZS8Qw/o2Y/jZzY0LShjq2nJXR1+u2e91vTpr505Y+/TWBm43jmnTTv6EOqS6yWg/EGm325PLPRYHYLfbKxxXttlsLiAb7WpK1GKFv/5K4Y9L9HHc888GTaWFlHQHt09Zyd/7svXHrjyjMfcO8roko6jFBnYuq1d3ILOA1bsrVQXtpKLuGKV/7Px4Np7cXK/nDAbVfSX5tvTvOwHsdns/tAOvABWO39vtdgsQSzXPNImaQXW5yHlmnD6OuP46rN26GReQD63alcEdH64iNasAAEWBewe15fHBHaXUTx0XZjVzabeyW7TzfbCRIWzQICwttWYIal4eztlzvJ4zGFQ3GU0GCoEn7Xb7F2jFU1W0OnX3/utr+5euk4aotRzTZ1CyaxcASnQ0MU88bnBE3vN4VD76fTcPzlqLo/QcUViImQnXd2P42S2Ctv2FqJryZ46WbkvjSE6BV/MpJhNRo8v2czk+/BC1qMirOYNBtZKRzWbbh1bJuwi4Cq0c0HbgFrTq3m/Y7fYOdrv9XOAdtET1p29CFoHmTk8n7/U39HH0A/djTqrdd1037s9mzEeree+nHRx7GyApJpTJt/fivHItqIVoVi+SM1skAOBR4au1B7yeM+KaqzHVLz0Ee/gI+QsWeD1nbVftG/42m+0LoA3alu0xwNk2m20D8BpwH7AJ+AVoW/qU97wLVRgld8JE1Lw8ACytWhFVroNlbbNxfzYPzFrDHR+u4q89ZVu3uzaNY9odfWh3WoyB0Ymaqvw276/WHqDE7TnJV5+aEhZG1O236WPHe5NRPd7NWdsp/jgFbLfbHwHuBxoBh4CnbTbbdJ8vZAC73f4rcF6zZs0YOXKkwdH4n+vvv0m/bLBe9ifx45mEnX++wVFVTaajiC2pOXy6Yi9rUjIrfM6kwLCzmjN6QBss5uDYjCF8r8Tt4arXfycjT7ud9sJ1pzOgU0Ov5vTk5HC4Z29UpxOAhOnTCB800OtYa7gT3vv2y6YCm832MvCy3W4PtdlscjO0llI9ngr158IuvLBGJ6LcgmJ2pznK/ckjJd1JlvO/hxVNClzUtRG3nteSpl70qxF1g8Vs4soejZn6m/a+6Rer93udjEyxsUSOGI5j8gcAON57ry4koxPy6w43SUS1W4X6c1YrseOeMTagcjweleU70lmbkqknn/S8U3+7mU0KF3U5jVvObUmzepKEROVdeUZjZvyxG7dHZW1KJinpDlokeXfgO2rUKBxTp+mdYItWryG055k+irh2ke3W4rg8Dgc5L76oj6PuGIWlhfH15zwelV+2HmHab7vYdcRRqeeEhZhpWT+SLk3iuK53M5ITpEyiqLr6sWGc0y5Jr87x5er9PHRpB6/mNDc6jYirryJ/7jwAHO+/T2jPD72OtTaSZCSOK++tt8vqzzWoT/R9/96xH1huj8rPmw8z7bddpKQ7j/s1VouJZvUiaVk/ipZJUbRsEEWr+lE0jA2X80LCJ67p2URPRov/PsjoC9t41XgPIOquO/VkVPj9DxTv3ElI69Zex1rbSDIS/1GSkoJjStlvZ7FPPmlo/bn1e7MYv3AzezMqJqFwq5krezSma7M4WtWPJjk+XDYhCL/q2SKRxgkRHMjMx1FYwg8bD3PlGY29mjOkfXtCBwyg6KefQFVxTP6A+Jdf8lHEtYf85Ir/qFB/rkcPwq+52pA4VFVl7qq93DNjdYVEFGE1c0u/Fnz5wLk8cEl7LujYkGb1IiURCb/TGu+VbfOev3qfT/oSRd9ddgg2f9583EeOeD1nbSM/vaKCwl9+Kas/pyjEPWc3pP5cUbGbF77azKuL/8Fdeio1ItTMree25MsHz2X0hW2Ji5S2zSLwKjTeO5TH5lTvGu8BWHv3JqR7d23gcmmbGuoYSUZCpxYVkT22rGOrUfXn0nIKGT39zwol+9s3imHO3Wdz54A2xEZIEhLGiY2wMqBz2bZuXzTeUxSF6LtH62Pn9Bm4MzK8nrc2kWQkdI4Pp+JOSQFK6889/ljAY1i/N4tbJq9gS2pZJeNLT2/E+7f1omFceMDjEeJ4yreW+GmT9433AMIuGoSlvVYlXs3PJ++td7yeszaRZCQAcB86RN4bb+rjmP97OOD15/7ak8n9M9foh1TNJoUHL2nP2Ks7ExZiDmgsQpxMx+RYvXRUUYmHResOej2nYjYT8+gj+tg5axYlqd439KstJBkJAHKefwE1Px8AS/t2RI68JaDr/3Mwl/+b8xdFJVp9rvhIK2/fcibX92km1bNFjaMois8b74HWXiKkRw9t4HKR99rrXs9ZW0gyEhStWEHBgq/0cdxzz6FYArfrf0+6gwdmrSG/yA1AvehQpozqTY/mCQGLQYiqGtilIVF64718Vqd433hPURRiy90ez/98LsU7d3k9b20gyaiOU0tKyH56rD4Ov/IKQs/qG7D1D2cXcP+stWTnFwMQE27hzZvOoLFUSRA1XLjVwqWnlzXe++JP7zcyAISefRah/fppA4+HvJdf8cm8NZ0kozrO+dFMSv7ZBoASHk7s008HbO0sp4v7Z63lSE4hoJXteW34GbRqEB2wGITwRvkzR39sSyOt9HvZWzGPP6p/XLBoEa6NG30yb00myagOc2dkkPvKq/o4+oH7MTc6LSBrOwtLeGDWWv0wq8WsMHFYNzo3iQvI+kL4QvOkKM7wceM9AGu3boRdcrE+zn3pZZ/MW5NJMqrDcsdPQM3VtlCbW7Qg6o5RAVlXVVWeXbCRbYe0tU0KPHttV3q3qheQ9YXwpQqN9/7yvvHeMTGPPgKlm3eKfv6FolWrfDJvTSXJqI5y/bWO/E8/08dxz9lRQkMDsvanK/bqxSYBHhvciQu87A0jhFHOa1+fxCjtIHZGXhG//5N2imdUTkjbtoRfe60+zp0w0Selh2oqSUZ1kOp2k/3UU/o47KJBAWuat3F/Nu/8uF0fD+3d1OtCk0IYyWI2Vfge9kVFhmNi/u8hCAkB0Pod/fyLz+auaSQZ1UH5n35G8YbSN0RDQ4kdZzv5E3wk2+niqc//1mvNdUyO4d5B7QKythD+dOUZjTnWpWRNSiZ70ivXa+tULE2aEDliuD7OnfgSqsc3twFrGklGdYw7Pb1C07zoe+7G0rSp39f1eFTGfbGBtFxtt1FMuIUXruuG1SLfgqL2axAbTr929fXxl2t8d3UUfd+9KOFaKazizZsp+HqRz+auSeSVoI7JGfsMarZWZdjctGmF4oz+NOOP3azcWXYo0HZNV06TWnMiiJTfyPDN+oMUuEp8Mq+5fn0ib79NH+e+/ApqiW/mrkkkGdUhBT/8UOG3qriJE/TfuPxpze6jfPjLTn188zktOLttYOveCeFvPVsm0jhB+3lyFJbw48bDPps7evRdKLGxALhTUnDO+thnc9cUkozqCE9uLtlPPKmPI64bSti5/fy+bm5BMeO+2Mixsl3dm8XzvwvqXktlEfxMJoWrzyy75f2FD2/VmeLiKtzFyJ34Eu7Dvkt2NYEkozoi54XxeA5r3SNN9eoR+8zYUzzDN9749h8y8ooArfjps0O6SkdWEbQu795Ifx/0n4O5bPFB471jou4YhaVlSwDUvDxybHafzV0TyKtCHVC0YgX5H5dd1sc+9yym+Hi/r7t0WxqL/y4rrf/44I4kxYT5fV0hjBIbYeXCcmfm5v+5z2dzK6GhxE2coI8LFi2icMlPPpvfaJKMgpxaWEjWI2VVgMMGDSR88OV+Xze3oJiJX2/Rx4O6NOS8Dg38vq4QRrumV9lGhiU+arx3TOhZfYm4bqg+zn7qaTxOp8/mN5IkoyCX+/obFbq3xr34QkD6A7353T+kl7s99/ClHfy+phA1QafkWNqephX7LSrxsHi99433yosZ+7R+Z8N94EDQ1K2TZBTEXOvW4XjvfX0c+9STmE/zfyHUZdvT+abcD+BjgzsSG2H1+7pC1ASKonDNmWVXR1/4qPHeMeaEhAoH1Z1Tp+H6a53P5jeKJKMg5cnLI/OeMeDWGtZZ+/QmYviNfl83r6CYCQs36+OBnRvSX27PiTrmoq6n6Y339h/NZ9WuDJ/OH37tNYSed642UFWyHn0U1eW724FGkGQUhFRVJfvxJ3Dv1d48VaKjiX/9NRST//93v/n9Nrk9J+q8cKuFy7sl6+PPVvpuIwNoV19xE8br5wRLtv5T4S5IbSTJKAjlfz63YhvxiRMCUvJn1c4MFq1L1cePXt6RuEi5PSfqpqG9mx7rAMHKnRk+q1d3jKVpU63NRKncN96keOfOkzyjZpNkFGSKd+4i56mybq0Rw24g4sor/L5uUbGbl7/Zqo8HdGrI+R3l9pyou5ITIjinXKWRuat8e3UEEHn7bYR0O10buFxkP/JorS2kKskoiKhFRWTdfQ9qQQEAltatiX02MAfjZi5N4UBmPgDRYRYeurR9QNYVoia7rk8z/ePFfx8kr6DYp/MrZjPxL70EFu39Kdefq8n/eLZP1wgUSUZBJOeF8RRvLt08EBpKwruTMEVE+H3dfRlOZv6xWx/fNaANiVGBadQnRE12ZosEWtWPAqDA5ebrcrexfSWkU0eiRt+lj3Oef4GS3Sk+X8ffJBkFiYIfl+CcOlUfx459mpBOHf2+rqqqvPzNVordx3oUxXJVuW2tQtRliqIwtHfZ+7VzV+3T+3n5UswD95eVCnI6yRx9N2phoc/X8SdJRkHAfegQ2Q89rI/DBg0kcuQtAVl7yabDrN6ttYYwKdqZIrPJ/4dqhagtLu7aiJhwrVvroewClm7zTVvy8pSwMOInvQ1WbcNQ8aZNZD3wYK16/0iSUS3nyc3l6M0j8WRmAmBq2JC4V18NSJUFZ1EJb36/TR8P6dWUdqfF+H1dIWqTMKu5Qlvyz/2wkQHA2rVrhcOwBV8vInfiS35Zyx8kGdVialERmaP+R/GW0hpwZjMJb7+FOcH/RVABZvy+W6/IXS86lDsvaBOQdYWobYb0aqLfMVibksmOw3l+WSfqlpuJvO1Wfex4ZxLO2XP8spavSTKqpVSPh6wHHqRo2TL9sbiXJxJ6Vt+ArL/vqJNPVuzRx/cMbEtk6YlzIURFDWLD6d+hrC3556v2+m2t2HE2wgZeqI+zn3iSwt9+89t6viLJqBZSVZWccc9SsPBr/bGYxx4l8vrrAxbDm99to6R000KXJnFc1MX/Ne+EqM2G9i7b5v3DhkNkO/1Tvkcxm4mf9A4hnTtrD7jdZP7vLoq3bj35Ew0myagWcrw/ucLOuciRtxB175iArb98RzrLtqcDoCjw0CXtMcmmBSFO6vSmcfp7qkUlHhasPeC3tUyRkSR+NB1zo0YAqA4HR28eWaO7w0oyqmWcn31O7vMv6OOwSy8l9ll7QDYsABSXeHjj23/08eXdk+mQHBuQtYWozRRF4fo+Zdu856/eR4nbf7vdzA0bkjhzBkqUds7JffAgR0feVmP7H0kyqiVUVSX39TcqbOG29ulNwttvopjNAYvj81X72HdUq7QQGWph9ADZtCBEZV3Y+TTiS+s1pucW8fOWI35dL6RDBxImvwelrxHFGzeSedsoPKVVWmoSSUa1gFpYSNaYaTZmFQAAEw9JREFUe8l75VX9MUuH9iROm4oSFrg23kfzipj6W1khxtv7tyJBKi0IUWlWi4lrepYdCp+9bA+q6vtDsOWF9e9P3Itld1OKli4lY+h1lKTUrCoNkoxqOHd6OhnX3VChCnfoOeeQNG8uptjA3h5776cd5Bdp/ZGa1YtkaC//VwIXItgM6dWUUIv20rvtUC5rUjL9vmbkiOHEPPaoPi5et560QRfjnPOJ35NhZUkyqsFcGzeSfvkVuNau1R+LGDGCxI9nYoqLC2gsmw9kV2gP8eAl7QmxyLePEFUVH2nl8u5lvY4+XhqYK5To++4l1j5OL6qq5ueT/cijZN52O+4M3zb/qw55NamB1OJiHNNnkH7l1bgPlO64URRix9mIm/AiSkhIQOPxeFReK7dpoV+7JPq0rhfQGIQIJsPOas6xDairdh1l+6HcgKwbNep2kr7+Ckvr1vpjhT/8SNqAgRT8uCQgMZyIJKMaRC0pwfnZ5xzpfz45T4+FIq26gRIVRcL0aUTdMSpgu+bK+27DQTYfyAEgxKxw/8XSHkIIbzROiOD8jg318cfL9gRsbWvXriR9t5jIW0fqj3kyMsgceStZjz6OJz8/YLGUJ8moBlBdLpxzPuHIueeR/dDDuPeUnc62dOhA0uJvCC93ojqQnEUlTPpxuz4e1rc5jRP835ZCiGA34uzm+sc/bT7MwazA7XAzhYcT9/xzJM6ehalBWWWI/NmzSRswkJwXx1O45Cc8OTkBi0nqtwSYWlREyc5dFG/fRvE/2yjZvh3XuvV40tMrfJ0SF0v0nXdqV0Olfe6NMP23XRx1aCfFk6JDGXluS8NiESKYdEiO5cwWCaxJycTtUflkxR4evrRDQGMI69+f+kuWkP3Y4xQuXgyAe98+HJPexTHpXVAUQjp2xNqnN6G9e2Pt3QtzPf/copdkFCCuTZvJumeMtp3S7T7h1ylxsUSNGkXUqNsxRUcHMML/2nfUyacry67S7h7YlohQ+ZYRwldGnNNC30238K8D3H5eK+JKzyEFijkhnoQP3qdg3nyyxz6DmleuiKuqUrx5M8WbN+OcOg0AS6tWRD/8IBFXXunTOOSVJUDMCQmU7Nx5ws+b6tUj6q47ibxpBKbSE9NG+3f9uYu7Sv05IXypd6tEWjeIYucRB0XFHuav3sft/Vuf+ok+pigKEUOHEDZoIEXLl1O06k9cq1ZRvGkz/KsnUsmuXShm36cOSUYBYjqtIUp0NGpeHuZmTQlp1w5L27aEtG9HSNt2WNq2CfguuZNZvr1i/bmHL21vyOYJIYKZoiiMOKcF4+ZvBLROsMPPakGYNXBVVcozxcYSfsklhF9yCQCevDxca9dStHIVrlWrcK3/G1wurL17+XxtSUYBoigKSV9/hTk5GVNEzd4AUFzi4Y3vKtafa99I6s8J4Q8XdmrI+0t2cDinkOz8YhatT2VIDTlQboqOJqx/f8L69we0ajDFm7dgTkry/Vo+n1GcUEibNjU+EYHWa0XqzwkRGBaziWF9m+vjT5bv8WsBVW8oYWFYz+jhl7klGYkKtPpzu/TxKKk/J4TfDe6RTEy4dqMqNauAX7emGRxR4EkyEhW8u2S7Xn+ueVIkQ3vXjNsFQgSziFAL1/Ys+1mb8fsuPJ6aUTMuUCQZCd3G/dl8s/6gPn7w4vZYzPItIkQgDO3dlNAQ7edt5xEHP22uuY3w/EFeaQQAbo/KK9+UtSU+r0N9ekv9OSECJiEqlOvLtSaf/PPOGvvekT9IMhIALFx7gG2lxRpDLSbuv0jqzwkRaCPOaUFUmPbe0YHM/AqV8oOdJCNBTr6L937aoY9vOqcFjeKNK0EkRF0VEx7CiLNb6OOpv+2iqPjEFVuCiSQjweSfd5JbUAzAaXHhjDinxSmeIYTwl+v7NK3QmvyL1fsNjigwJBnVcf8czOXLNWXf7A9e0p6wEGNOfwshINxq4dZyBYk/+mM3zqISAyMKDElGdZjHo/Lq4q0c6zrcp3U9+rXz/clqIUTVXHVmExrGhQGQnV/Mpyv2GBpPIEgyqsO+23CQjfuzAbCYFR66ROrPCVETWC0mRpUrmDp7+R6ynS4DI/I/SUZ1lKOwmHfKNc27sW9zmtaLNDAiIUR5l5zeiOZJ2s9kfpGbWUtTDI7IvyQZ1VFTf91F5rGmeTHSNE+ImsZsUvjfBWVXR/P+3EdabqGBEfmXJKM6aHeag89X7dPH9w1qJ03zhKiBzu/QgPaNYgAoKvEwvVzdyGAjyaiOUVWVV77Zgru07lX35vFc2LmhwVEJIY5HUZQKVfMX/pXK/qNOAyPyH0lGdczCv1L5a08WoN0GePjSDrJpQYgarFerRHo0jwe0sl1TfgnOqyNJRnVIem4hb/+wTR8P69uM1g2iDYxICHEqiqIw+sK2+vjHTYfYXlq6K5hIMqpDXlm8FUehdniucUIEo85vfYpnCCFqgi5N4jin9AygqsLL32wNuhYTkozqiJ+3HOa3cg27nriio1RaEKIWuWdgWyxm7Zb6xv3ZfLX2gMER+ZYkozogt6CYV8u1h7iiRzJntEg0MCIhRFW1SIri5nJ1Iyct2c7RvCIDI/ItSUZ1wP+3d+/BUZV3GMe/uROSSC4CkcQEolxEwKACSmkVHWlA0VK8i4KItdbWlqkjraO8vnhnvNRqpRrHpgLaUrwhKraKKBWLiEIkFCoQCEEhCOGSAIFc+scum+CAkLDZd/fk+czshHP27OE3ZzP7ZM9539956t3VbPPPKToxJYFfDevpuCIRaYmxP8wjO709AFX7anli3irHFQWPwsjjlqzbxptN7olyx8WnkZIY57AiEWmphLgYJo3sHVh+b8VmPv7fVocVBY/CyMP27q/l4TklgeWhvTtz/mmdHVYkIsdrQF4GI87oElieOnelJ7p6K4w87PG3V7Gpci8AKe1iuWPEaY4rEpFg+HVBz8A9j7bs3Me09746yivCn8LIo/715TeHnJ6bOLwXGSkJDisSkWDp0D6eicN7BZZfWVJGcVmlw4qOn8LIgzZt38PDb64MLA/rexLDm3ytF5HId1GfTAZ3PxHwzT16cE4J+2vrHVfVcgojj6mtq2fyK8WBc8hZaYlMuqS3Wv6IeExUVBR3XtKbxHjffMH1W6t5ceE6x1W1nMLIY56bv4aS8p2Ar/fclMv7kdROHblFvCgzNfGQRqpFC9dRWlHlsKKWUxh5yKdrtzH948YbcN16YXdOz051WJGItLbRA3Pok90BgNq6Bh54YwW1dZF3uk5h5BHbq2qwrxbT4G9XNeiUDK4d3NVpTSLS+mKio7jrsj6BVkEryndGZGdvhZEH1Nc3cN/rKwJdFtKS4pk8qi/R0bpOJNIW5HVKZsL5jY2P/7pwHQv+u8VhRc2nMPKAFz5cyydffRtYNj/tq2HcIm3MDUO6MfCUxp6T5pViSsp3OKyoeRRGEe6NpeU8v6DxK/l1g7tyzqknOqxIRFyIjo5iyuh+gd51NQfqueOlL/jaP/E93CmMIthHqyp45M3Gdj8D8jL4eZORNSLStqQmxfP4mDM5wd9/srJ6P7+duZTdew84ruzoFEYRqrisknv+sZyD99fqedIJPHx1PnGxektF2rKcjCSmXtOfOP+AhtKt1fx+1jIOhPmEWH1yRaDSrVXc8dIX1Ph/ubLSEnl8zJkkJWg+kYhAfm4a94zqG1j+bN12Hpm7koaG8L07rMIowlTs2sfE6UvZ5f/anZYUzxPXn0VGsgYsiEijYX1P4pYLGkfYzf1iE0UfhW+HBoVRBCn7tprbipaweec+ABLjY3jsujPJyUhyXJmIhKNxP8rj4vzGvpTPzl/DW8s2fc8r3FEYRYilpduY8Px/2LhtD+Cb6PbglWfQO6uD48pEJFxFRUXxu5Gnc3a39MC6+19fwWtLNobdKTuFUQSYs7Sc219cyq69vuanCbHR3H/FGZzbvaPjykQk3MXFRvPQVfmc2jkZ8HX4fmTuSu6atZyde/Y7rq6RwiiM1dU38NQ/V/PgnBLq/MPmMpLjmTZ+IEN7646tInJsUhLjeHrsAHpkpgTWfbByC9c9s4hPvgqP25Z7dviVtbYrUPo9m/zdGHN1aKppvu1VNUx+pZjP1m0PrOuemcKj1/anc4dEh5WJSCRKTYrn2ZsG8sd3V/PaZ+UAfLu7hokzPufygSfzy4t60s5/OwoXPBtGTSwHXj/M+hWhLuRY7N1fy+xPNzLz41J27GmcqDakZ0emjO5Hew3fFpEWSoyPZdLI0/lBj4488EYJldW+03SzP93IknXbsaP70quLm+vQbeGTbZkx5l7XRRxNdU0try3ZyMxF6wO/IABRUTDuh3lMGHoqMWp8KiJBMKRnJ2b+ogMPzSlh4WrfaboN31ZzU+Fixp+XxyX9s0J+BqYthFFYamhoYOvuGkorqlheVsnsTzcG5g4ddFJqIpNG9lavOREJuvTkBKZe0585n2/iD/NWsXd/HXX1DRR+sJbCD9aSmdqO/rnp5Oem0T83jZMz2rfqHaPbQhh1sdbeAmQA24BPjDHFoS5iW1UN80s2s66iKvDYva/2sNtmdmjnnx+QpfY+ItJqoqKiuOysbM7qlo599Uu+3NjY5Xvzjn28s+Nr3ln+NQDpyfHk56SRn5vG4B4dAw1Zg6UthNFF/keAtXYBMNYYU3akF1lrxwHjDvNUfkuK2F5Vw2Nvr/rebbLSErl+SDdG5GcRrxASkRDJTm/PtBsH8Ppn5SxYtYUVG3ey70DdIdtsr9rP/JVbmL9yCw3AVefkBrUGL4fRHuA+fIMXDvbA6AfcCwwF3rfW5htjqo/w+q7AecEqJicjiZjoqMAQbYCkhFjyOiWT1ymZs7ulM7R3Z2JjFEIiEnqxMdFcPiiHywflUFtXz6pvdrFsfSXLyipZvqHykDM5/XPTgv//B32PQWStXQ80J35nGmPGABhjKoDJ33n+I2vtMODfwCBgAvDkEfa1HvjwMOtPzcjIyMrMzGxGWZAQF8O1g7uS2j6OvE7JnNIphY4nJLTqOVgRkZaIjYmmT3YqfbJTGUM36usbWFtRxfINlZRs2skpnVOOvpNmigq3lhBNWWvfB7Ka8ZI5xpg7j2G/E4BC4FVjzOgWlBa+B01EJHwd8a/vsP5mZIy5sJV2fXDKsTqMioiEgbZ6geIc/8/w7acuItKGeDaMrLWDrLXxh1l/ATDRvzgjtFWJiMjhhPVpuuP0CHC6fxh3uX9dP+AC/7/vMcYsclGYiIgcysthNB0YBQwAhgNxwBZgFvC0MWahw9pERKSJsB5NF8Z00EREmu+Io+k8e81IREQih8JIRESc8/I1o7Azb948Nm/e7LoMEZHjkpmZSUFBQVD3qTBqmRb18Fm8ePEqoGeQaxERCakNGzasLigo6BXMfSqMQivZ/3MnsMxlIR6XD3RAx7k16Ri3TQff9+SjbdhcCqPQWoOv194yY8z5jmvxLP/csvPQcW41OsZtU5P3fU2w960BDCIi4pzCSEREnFMYiYiIcwojERFxTgMYQqsIWIDvLrLSeorQcW5tRegYt0VFtNL7rt50IiLinE7TiYiIcwojERFxTmEkIiLOaQBDCFhrj+XCXJoxZkerF+Mx1toJQCEwzxgz/AjbvAWMAG4zxjwTyvoiXZPf3QaguzFm7RG2+wA43794ozGmqPWrk1AI1eeXwii07Pc8ty9kVXiIMeZ5a+1I4FJr7W3GmD81fd5aeyu+IHpHQdRitfg+K24C7vruk9ba7vhaxBzcTrypVT+/9IsTQsaYe13X4FE3A+cCU6217xljVgNYa3sAjwLbgPEO64t0W4BvgButtZONMbXfeX4Cvk72c4GfhLo4CY3W/vzSNSOJeMaYCnyB1B6YYa2NtdbGAjP8635mjNGNpI5PIZAJXNJ0pbU2DhgLLAJKHNQlHqEwEk8wxrwBvACcDUz2PwYARcaYV13W5hEvA9X4vgU1dSnQGV9YibSYwki85DdAKb7rGnfhmyV+u8uCvMIYsxv4G1Bgrc1u8tTNwC5glpPCxDMURuIZ/g/MKUCM/3Grf50ERyG+4zoewFqbC1wEzDTG7HFZmEQ+hZF4hrU2EZjUZNUVrmrxImPMYuBLYLy1NhrfKbtodIpOgkBhJF4yFegFPInvVtjj/cO+JXgKgVygALgRWGqM+cJtSeIFCiPxBGvtMOA2fH+5TwKuB2qAQmvtiS5r85jpwF7gWSALeM5tOeIVCiOJeNbadOAvwAFgjDGmxhizArgH30ivP7usz0v8s+xnA9n4Rte97LYi8QqFkXjBNKALcLcxprjJ+seAhcBoa+0YJ5V5093AKODHGiAiwaIODBLRrLXXA1cCH+ELnwBjTL21dixQDDxlrV1gjCl3UKanGGPKgDLXdYi36JuRRCxrbQ7wFL55LjcYY+q/u40xphSYCKQCL1hro0JbpYgcC93pVUREnNM3IxERcU5hJCIizimMRETEOYWRiIg4pzASERHnFEYiIuKcwkhERJxTGImIiHMKIxERcU5hJCIizv0fSD25tEx3bXYAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "# -- Bandstructure\n", + "ax_bs = plt.subplot(111)\n", + "\n", + "ax_bs.bsplot(e_k[0,0], path)\n", + "ax_bs.bsplot(e_k[1,1], path)\n", + "\n", + "ax_bs.set_ylabel('$\\epsilon(\\mathbf{k})$')\n", + "\n", + "ax_bs.text(0.52, 1., r\"$|\\uparrow \\rangle$\", transform = ax_bs.transAxes, size=22, color='C0')\n", + "ax_bs.text(0.52, 0.6, r\"$|\\downarrow \\rangle$\", transform = ax_bs.transAxes, size=22, color='C1')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also define `get_chiRPA_spin_dependent` that outputs the spin-dependent general RPA-susceptibility from which we can build any kind of particle-hole susceptibility for two operators.\n", + "The function `get_phase_transition` can then find ...." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from triqs_tprf.rpa_tensor import kanamori_quartic_tensor\n", + "\n", + "def get_chiRPA_spin_dependent(p, chi0_wk=None):\n", + " \n", + " if not chi0_wk:\n", + " chi0_wk = get_chi0(p)\n", + " \n", + " U_abcd = kanamori_quartic_tensor(p.norb, p.U, 0, 0, 0) # Two time norb to take spin int account\n", + " \n", + " chi_rpa_wk = solve_rpa_PH(chi0_wk, U_abcd)\n", + " \n", + " return chi_rpa_wk\n", + "\n", + "def get_phase_transition(p, op1, op2, lower=0.0, upper=10):\n", + " \"\"\"Return U at which model p transitions to any order of op1 and op2 via root search\n", + " \"\"\"\n", + " chi0_wk = get_chi0(p)\n", + " \n", + " def one_over_chi(U):\n", + " \n", + " chi_rpa_wk = get_chiRPA_spin_dependent(p.alter(U=U), chi0_wk=chi0_wk)\n", + " chi = chi_contraction(chi_rpa_wk, op1, op2)\n", + " \n", + " # -- If any value is below zero we are already in an ordered phase\n", + " if np.any(chi.data[np.abs(chi.data) > 1e-3] < 0.0 ):\n", + " return -1\n", + " \n", + " chi_at_critical_k = np.max(chi.data)\n", + " \n", + " return 1./chi_at_critical_k\n", + " \n", + " U_c = brentq(one_over_chi, lower, upper)\n", + " \n", + " return U_c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then scan the phase space of the repulsive Hubbard model with a Zeeman term of strength $\\xi$ and an attractive model which is doped by $\\mu=\\xi$.\n", + "And as we know the in-plane AFM, defined by $\\langle S_z S_z \\rangle$, is symmetric to the CDW, defined by $\\langle nn \\rangle$, for $U=0$.\n", + "The same is true for the out-of-plane AFM, defined by $\\langle S_x S_x \\rangle$, and the superconducting phase, defined by $\\langle \\Delta \\Delta^\\dagger \\rangle$.\n", + "\n", + "The calculated phase diagram confirms this." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 2\n", + "\n", + "Approx. Memory Utilization: 0.06 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kaeser/anaconda3/envs/triqs_3/lib/python3.8/site-packages/scipy/optimize/zeros.py:776: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " r = _zeros._brentq(f, a, b, xtol, rtol, maxiter, args, full_output, disp)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 2\n", + "\n", + "Approx. Memory Utilization: 0.06 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 11.604525006165701\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 2\n", + "\n", + "Approx. Memory Utilization: 0.06 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 15.472700008220936\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 2\n", + "\n", + "Approx. Memory Utilization: 0.06 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 15.472700008220936\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 2\n", + "\n", + "Approx. Memory Utilization: 0.06 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 15.472700008220936\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 2\n", + "\n", + "Approx. Memory Utilization: 0.06 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 23.209050012331403\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 2\n", + "\n", + "Approx. Memory Utilization: 0.06 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 23.209050012331403\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 2\n", + "\n", + "Approx. Memory Utilization: 0.06 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n", + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 23.209050012331403\n", + "nk = 1024\n", + "nw = 100\n", + "norb = 2\n", + "\n", + "Approx. Memory Utilization: 0.06 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n" + ] + } + ], + "source": [ + "# Density operator\n", + "n = np.eye(2)\n", + "# Spin operator\n", + "S_z = 0.5 * np.array([[1,0], [0,-1]])\n", + "\n", + "xi = 0.1\n", + "\n", + "Ts = [1000, 750, 500]\n", + "hubbard_models_doped = parameter_scan(hubbard_spin_dependent.alter(mu=xi), T=Ts)\n", + "hubbard_models_zeeman = parameter_scan(hubbard_spin_dependent.alter(zeeman=xi), T=Ts)\n", + "\n", + "U_spin_cs = []\n", + "U_charge_cs = []\n", + "U_sx_cs = []\n", + "U_sc_cs = []\n", + "\n", + "for hubbard_model_doped, hubbard_model_zeeman in zip(hubbard_models_doped, hubbard_models_zeeman):\n", + " \n", + " U_spin_c = get_phase_transition(hubbard_model_zeeman, S_z, S_z, 0, 10)\n", + " U_charge_c = get_phase_transition(hubbard_model_doped, n, n, -10, 0)\n", + " U_sx_c = get_phase_transition(hubbard_model_zeeman, S_x, S_x)\n", + " U_sc_c = get_sc_phase_transistion(hubbard_model_doped.alter(spin=False), guess=-U_sx_c) \n", + "\n", + " U_spin_cs.append(U_spin_c)\n", + " U_charge_cs.append(U_charge_c)\n", + " U_sx_cs.append(U_sx_c)\n", + " U_sc_cs.append(U_sc_c)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Hubbard with $\\\\mathrm{Zeeman}=\\\\xi$')" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(11,7))\n", + "\n", + "ax_pd_right = plt.subplot(122)\n", + "\n", + "ax_pd_right.plot(U_sx_cs, Ts, \"o\", ls=\"-\", color='C2')\n", + "ax_pd_right.fill_betweenx(Ts, U_sx_cs, U_spin_cs , alpha=0.25, color='C2')\n", + "\n", + "ax_pd_right.plot(U_spin_cs, Ts, \"o\", ls=\"-\", color='C0')\n", + "ax_pd_right.fill_betweenx(Ts, U_spin_cs, [max(U_spin_cs)]*len(U_spin_cs) , alpha=0.25, color='C0')\n", + "\n", + "ax_pd_left = plt.subplot(121)\n", + "\n", + "ax_pd_left.plot(U_sc_cs, Ts, \"o\", ls=\"-\", color='grey')\n", + "ax_pd_left.fill_betweenx(Ts, U_sc_cs, U_charge_cs, alpha=0.25, color='grey')\n", + "\n", + "ax_pd_left.plot(U_charge_cs, Ts, \"o\", ls=\"-\", color='C1')\n", + "ax_pd_left.fill_betweenx(Ts, U_charge_cs, [min(U_charge_cs)]*len(U_charge_cs), alpha=0.25, color='C1')\n", + "\n", + "ax_pd_left.set_ylabel('Temperature\\n[Kelvin]', rotation=0, ha='right', multialignment='center')\n", + "ax_pd_left.set_xlabel('U [eV]')\n", + "ax_pd_right.set_xlabel('U [eV]')\n", + "\n", + "ax_pd_left.set_yticks(Ts)\n", + "ax_pd_right.set_yticks([])\n", + "\n", + "ax_pd_left.set_xticks([np.round(ele,2) for ele in U_sc_cs + U_charge_cs])\n", + "ax_pd_left.set_xticklabels([np.round(ele,2) for ele in U_sc_cs + U_charge_cs], rotation=70)\n", + "ax_pd_right.set_xticks([np.round(ele,2) for ele in U_sx_cs + U_spin_cs])\n", + "ax_pd_right.set_xticklabels([np.round(ele,2) for ele in U_sx_cs + U_spin_cs], rotation=70)\n", + "\n", + "ax_pd_left.spines['left'].set_bounds(Ts[-1], Ts[0])\n", + "ax_pd_right.spines['left'].set_visible(False)\n", + "\n", + "ax_pd_left.spines['bottom'].set_bounds(min(ax_pd_left.get_xticks()), max(ax_pd_left.get_xticks()))\n", + "ax_pd_right.spines['bottom'].set_bounds(min(ax_pd_right.get_xticks()), max(ax_pd_right.get_xticks()))\n", + "\n", + "\n", + "ax_pd_left.text(0.3, 0.5, \"SC\", transform = ax_pd_left.transAxes, size=22, color='grey')\n", + "ax_pd_left.text(0.07, 0.5, \"CDW\", transform = ax_pd_left.transAxes, size=22, color='C1', rotation=90)\n", + "\n", + "ax_pd_right.text(0.45, 0.5, \"in-plane AFM\", transform = ax_pd_right.transAxes, size=22, color='C2', rotation=60)\n", + "ax_pd_right.text(0.89, 0.2, \"out-of-plane AFM\", transform = ax_pd_right.transAxes, size=22, color='C0', rotation=90)\n", + "\n", + "ax_pd_left.set_title(r'Hubbard with $\\mu=\\xi$', color='grey', size=24)\n", + "ax_pd_right.set_title(r'Hubbard with $\\mathrm{Zeeman}=\\xi$', color='Grey', size=24)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(9,5))\n", + "\n", + "ax_pd_right = plt.subplot(122)\n", + "\n", + "ax_pd_right.plot(U_sx_cs, Ts, \"o\", ls=\"-\", color='C2')\n", + "ax_pd_right.fill_betweenx(Ts, U_sx_cs, np.max(U_sx_cs) , alpha=0.25, color='C2')\n", + "\n", + "ax_pd_left = plt.subplot(121)\n", + "\n", + "ax_pd_left.plot(U_sc_cs, Ts, \"o\", ls=\"-\", color='grey')\n", + "ax_pd_left.fill_betweenx(Ts, U_sc_cs, np.min(U_sc_cs), alpha=0.25, color='grey')\n", + "\n", + "ax_pd_left.set_ylabel('Temperature\\n[Kelvin]', rotation=0, ha='right', multialignment='center')\n", + "ax_pd_left.set_xlabel('U [eV]')\n", + "ax_pd_right.set_xlabel('U [eV]')\n", + "\n", + "ax_pd_left.set_yticks(Ts)\n", + "ax_pd_right.set_yticks([])\n", + "\n", + "ax_pd_left.set_xticks([np.round(ele,2) for ele in U_sc_cs])\n", + "ax_pd_left.set_xticklabels([np.round(ele,2) for ele in U_sc_cs])\n", + "ax_pd_right.set_xticks([np.round(ele,2) for ele in U_sx_cs])\n", + "ax_pd_right.set_xticklabels([np.round(ele,2) for ele in U_sx_cs])\n", + "\n", + "ax_pd_left.spines['left'].set_bounds(Ts[-1], Ts[0])\n", + "ax_pd_right.spines['left'].set_visible(False)\n", + "\n", + "ax_pd_left.spines['bottom'].set_bounds(min(ax_pd_left.get_xticks()), max(ax_pd_left.get_xticks()))\n", + "ax_pd_right.spines['bottom'].set_bounds(min(ax_pd_right.get_xticks()), max(ax_pd_right.get_xticks()))\n", + "\n", + "\n", + "ax_pd_left.text(0.3, 0.25, \"SC\", transform = ax_pd_left.transAxes, size=22, color='grey')\n", + "\n", + "ax_pd_right.text(0.35, 0.2, \"in-plane AFM\", transform = ax_pd_right.transAxes, size=22, color='C2', rotation=50)\n", + "\n", + "ax_pd_left.set_title(r'with $\\mu=\\xi$', color='grey', size=24)\n", + "ax_pd_right.set_title(r'with $\\mathrm{Zeeman}=\\xi$', color='Grey', size=24)\n", + "\n", + "fig.tight_layout()\n", + "\n", + "plt.savefig('test2.svg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also check the gap function of the superconducting phase and study its symmetry in momentum space.\n", + "There we can see, that it is constant." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "_, delta_1 = get_lambda_delta(hubbard.alter(mu=xi, U=U_sc_cs[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kaeser/my_triqs_installations/triqs_3.0.x/lib/python3.8/site-packages/triqs/gf/gf.py:323: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", + " dat = self._data[k]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "delta_plot = delta_1[Idx(0), : ].data.reshape(hubbard.nk, hubbard.nk).real\n", + "\n", + "plt.imshow(delta_plot, vmin=0.9*np.mean(delta_plot), vmax=1.1*np.mean(delta_plot))\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/c++/triqs_tprf/channel_grouping.hpp b/c++/triqs_tprf/channel_grouping.hpp index 88fc2422..6eac1d2c 100644 --- a/c++/triqs_tprf/channel_grouping.hpp +++ b/c++/triqs_tprf/channel_grouping.hpp @@ -55,7 +55,7 @@ template class channel_grouping { // Channel_t::PH // in the particle-hole channel (Channel_t::PH) the indices are grouped as -// {nu_1, a, b}, {nu_2, c, d} <=> {0, 2, 3}, {1, 4, 5} +// {nu_1, a, b}, {nu_2, d, c} <=> {0, 2, 3}, {1, 5, 4} template <> inline memory_layout_t<6> diff --git a/c++/triqs_tprf/fourier/fourier_lattice.cpp b/c++/triqs_tprf/fourier/fourier_lattice.cpp index 771c21b2..ba774118 100644 --- a/c++/triqs_tprf/fourier/fourier_lattice.cpp +++ b/c++/triqs_tprf/fourier/fourier_lattice.cpp @@ -49,8 +49,8 @@ namespace triqs_tprf::fourier { template fourier_plan __impl_plan(int fftw_backward_forward, gf_mesh const &out_mesh, gf_vec_cvt g_in) { //check periodization_matrix is diagonal - for (int i = 0; i < g_in.mesh().periodization_matrix.shape()[0]; i++) - for (int j = 0; j < g_in.mesh().periodization_matrix.shape()[1]; j++) + for (unsigned int i = 0; i < g_in.mesh().periodization_matrix.shape()[0]; i++) + for (unsigned int j = 0; j < g_in.mesh().periodization_matrix.shape()[1]; j++) if (i != j and g_in.mesh().periodization_matrix(i, j) != 0) TRIQS_RUNTIME_ERROR << "Periodization matrix must be diagonal for FFTW to work"; diff --git a/c++/triqs_tprf/lattice/chi_imfreq.cpp b/c++/triqs_tprf/lattice/chi_imfreq.cpp index 07a8aff2..32edd52e 100644 --- a/c++/triqs_tprf/lattice/chi_imfreq.cpp +++ b/c++/triqs_tprf/lattice/chi_imfreq.cpp @@ -35,6 +35,7 @@ namespace triqs_tprf { namespace { using fourier::_fourier_plan; using fourier::_fourier_with_plan; +placeholder<1> inu; } // namespace // ---------------------------------------------------- @@ -88,7 +89,7 @@ chi_wnr_t chi0r_from_gr_PH(int nw, int nn, g_wr_cvt g_nr) { t_calc.start(); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { auto &r = arr(idx); auto chi0_wn = @@ -167,7 +168,7 @@ chi_wnr_t chi0r_from_gr_PH_nompi(int nw, int nn, g_wr_cvt g_nr) { t_calc.start(); #pragma omp parallel for - for (int idx = 0; idx < rmesh.size(); idx++) { + for (unsigned int idx = 0; idx < rmesh.size(); idx++) { auto iter = rmesh.begin(); iter += idx; auto r = *iter; auto chi0_wn = @@ -216,7 +217,7 @@ gf> chi0_n_from_g_wk_PH(mesh_point> w, g_wk_cvt g_wk) { int nb = g_wk.target().shape()[0]; - auto [fmesh_large, kmesh] = g_wk.mesh(); + auto kmesh = std::get<1>(g_wk.mesh()); double beta = fmesh.domain().beta; @@ -287,7 +288,7 @@ chi0_n_from_e_k_sigma_w_PH(mesh_point> w, chi_wnk_t chi0q_from_g_wk_PH(int nw, int nn, g_wk_cvt g_wk) { - auto [fmesh_large, kmesh] = g_wk.mesh(); + auto kmesh = std::get<1>(g_wk.mesh()); int nb = g_wk.target().shape()[0]; double beta = std::get<0>(g_wk.mesh()).domain().beta; @@ -349,7 +350,7 @@ chi_wnr_t chi0r_from_chi0q(chi_wnk_cvt chi_wnk) { auto arr = mpi_view(gf_mesh{bmesh, fmesh}); #pragma omp parallel for shared(kmesh, rmesh) - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { //auto &[w, n] = arr(idx); auto w = std::get<0>(arr(idx)); auto n = std::get<1>(arr(idx)); @@ -422,7 +423,7 @@ chi_wnk_t chi0q_from_chi0r(chi_wnr_cvt chi_wnr) { t_calc.start(); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { //auto &[w, n] = arr(idx); auto w = std::get<0>(arr(idx)); auto n = std::get<1>(arr(idx)); @@ -473,7 +474,7 @@ chi_wk_t chi0q_sum_nu(chi_wnk_cvt chi_wnk) { auto arr = mpi_view(gf_mesh{wmesh, kmesh}); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { auto &[w, k] = arr(idx); for( auto &n : nmesh) chi_wk[w, k] += chi_wnk[w, n, k]; chi_wk[w, k] /= beta * beta; @@ -507,7 +508,7 @@ chi_wk_t chi0q_sum_nu_tail_corr_PH(chi_wnk_cvt chi_wnk) { auto arr = mpi_view(wq_mesh); // FIXME Use library implementation #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { //auto &[w, q] = arr(idx); auto w = std::get<0>(arr(idx)); auto q = std::get<1>(arr(idx)); @@ -614,7 +615,7 @@ chi_kwnn_t chiq_from_chi0q_and_gamma_PH(chi_wnk_cvt chi0_wnk, chi_wnn_cvt gamma_ // for (auto const &k : mbz) { #pragma omp parallel for - for (int idx = 0; idx < mbz.size(); idx++) { + for (unsigned int idx = 0; idx < mbz.size(); idx++) { auto iter = mbz.begin(); iter += idx; auto k = *iter; @@ -670,7 +671,7 @@ chi_kw_t chiq_sum_nu_from_chi0q_and_gamma_PH(chi_wnk_cvt chi0_wnk, chi_wnn_cvt g t.start(); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { //auto &[k, w] = arr(idx); auto k = std::get<0>(arr(idx)); auto w = std::get<1>(arr(idx)); @@ -776,8 +777,9 @@ chiq_sum_nu_from_g_wk_and_gamma_PH(gk_iw_t g_wk, g2_iw_vt gamma_ph_wnn, auto _ = all_t{}; auto target = gamma_ph_wnn.target(); - auto [fmesh_large, kmesh] = g_wk.mesh(); - auto [bmesh, fmesh, fmesh2] = gamma_ph_wnn.mesh(); + auto kmesh = std::get<1>(g_wk.mesh()); + auto bmesh = std::get<0>(gamma_ph_wnn.mesh()); + auto fmesh = std::get<1>(gamma_ph_wnn.mesh()); double beta = fmesh.domain().beta; @@ -904,7 +906,8 @@ chiq_sum_nu_from_e_k_sigma_w_and_gamma_PH(double mu, ek_vt e_k, g_iw_vt sigma_w, auto kmesh = e_k.mesh(); auto fmesh_large = sigma_w.mesh(); - auto [bmesh, fmesh, fmesh2] = gamma_ph_wnn.mesh(); + auto bmesh = std::get<0>(gamma_ph_wnn.mesh()); + auto fmesh = std::get<1>(gamma_ph_wnn.mesh()); double beta = fmesh.domain().beta; diff --git a/c++/triqs_tprf/lattice/chi_imtime.cpp b/c++/triqs_tprf/lattice/chi_imtime.cpp index b1c297b6..60f66e63 100644 --- a/c++/triqs_tprf/lattice/chi_imtime.cpp +++ b/c++/triqs_tprf/lattice/chi_imtime.cpp @@ -24,6 +24,7 @@ #include "chi_imtime.hpp" #include "../fourier/fourier.hpp" +#include "fourier.hpp" namespace triqs_tprf { @@ -60,7 +61,7 @@ chi_tr_t chi0_tr_from_grt_PH(g_tr_cvt g_tr) { auto arr = mpi_view(rmesh); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { auto & r = arr(idx); auto chi0_t = make_gf({beta, Boson, ntau}, chi_target); @@ -106,7 +107,7 @@ chi_wr_t chi0_w0r_from_grt_PH(g_tr_cvt g_tr) { auto arr = mpi_view(rmesh); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { auto & r = arr(idx); auto chi0_t = make_gf({beta, Boson, ntau}, chi_target); @@ -171,7 +172,7 @@ chi_wr_t chi_w0r_from_chi_tr(chi_tr_cvt chi_tr) { auto arr = mpi_view(rmesh); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { auto & r = arr(idx); auto _ = all_t{}; @@ -186,147 +187,22 @@ chi_wr_t chi_w0r_from_chi_tr(chi_tr_cvt chi_tr) { } chi_wr_t chi_wr_from_chi_tr(chi_tr_cvt chi_tr, int nw) { - - auto _ = all_t{}; - int nb = chi_tr.target().shape()[0]; - - auto tmesh = std::get<0>(chi_tr.mesh()); - auto rmesh = std::get<1>(chi_tr.mesh()); - - double beta = tmesh.domain().beta; - - auto wmesh = gf_mesh(beta, Boson, nw); - chi_wr_t chi_wr{{wmesh, rmesh}, {nb, nb, nb, nb}}; - - //for (auto const &r : rmesh) { - - /* -#pragma omp parallel for - for (int idx = 0; idx < rmesh.size(); idx++) { - auto iter = rmesh.begin(); iter += idx; auto r = *iter; - */ - - auto r0 = *rmesh.begin(); - auto p = _fourier_plan<0>(gf_const_view(chi_tr[_, r0]), gf_view(chi_wr[_, r0])); - - auto arr = mpi_view(rmesh); - -#pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { - auto & r = arr(idx); - - auto chi_w = make_gf(wmesh, chi_wr.target()); - auto chi_t = make_gf(tmesh, chi_wr.target()); - -#pragma omp critical - chi_t = chi_tr[_, r]; - - _fourier_with_plan<0>(gf_const_view(chi_t), gf_view(chi_w), p); - -#pragma omp critical - chi_wr[_, r] = chi_w; - - //chi_wr[_, r] = fourier(chi_tr[_, r]); - } - - chi_wr = mpi::all_reduce(chi_wr); + auto chi_wr = fourier_tr_to_wr_general_target(chi_tr, nw); return chi_wr; } chi_tr_t chi_tr_from_chi_wr(chi_wr_cvt chi_wr, int ntau) { - std::cout << "WARNING: chi_tr_from_chi_wr is not parallellized. FIXME\n"; - - auto wmesh = std::get<0>(chi_wr.mesh()); - double beta = wmesh.domain().beta; - - if( ntau <= 0 ) - ntau = wmesh.size() * 6; - - auto tmesh = gf_mesh(beta, Boson, ntau); - - auto chi_tr = make_gf_from_fourier<0>(chi_wr, tmesh); - + auto chi_tr = fourier_wr_to_tr_general_target(chi_wr, ntau); return chi_tr; } chi_wk_t chi_wk_from_chi_wr(chi_wr_cvt chi_wr) { - - auto _ = all_t{}; - - // auto target = chi_wr.target(); - int nb = chi_wr.target().shape()[0]; - - auto wmesh = std::get<0>(chi_wr.mesh()); - auto rmesh = std::get<1>(chi_wr.mesh()); - - auto kmesh = gf_mesh{brillouin_zone{rmesh.domain()}, rmesh.periodization_matrix}; - - chi_wk_t chi_wk{{wmesh, kmesh}, {nb, nb, nb, nb}}; - - auto w0 = *wmesh.begin(); - auto p = _fourier_plan<0>(gf_const_view(chi_wr[w0, _]), gf_view(chi_wk[w0, _])); - - auto arr = mpi_view(wmesh); - -#pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { - auto & w = arr(idx); - - auto chi_r = make_gf(rmesh, chi_wr.target()); - auto chi_k = make_gf(kmesh, chi_wr.target()); - -#pragma omp critical - chi_r = chi_wr[w, _]; - - _fourier_with_plan<0>(gf_const_view(chi_r), gf_view(chi_k), p); - -#pragma omp critical - chi_wk[w, _] = chi_k; - - } - - chi_wk = mpi::all_reduce(chi_wk); + auto chi_wk = fourier_wr_to_wk_general_target(chi_wr); return chi_wk; } chi_wr_t chi_wr_from_chi_wk(chi_wk_cvt chi_wk) { - - auto _ = all_t{}; - - int nb = chi_wk.target().shape()[0]; - - auto wmesh = std::get<0>(chi_wk.mesh()); - auto kmesh = std::get<1>(chi_wk.mesh()); - - auto rmesh = gf_mesh{bravais_lattice{kmesh.domain()}, kmesh.periodization_matrix}; - - chi_wr_t chi_wr{{wmesh, rmesh}, {nb, nb, nb, nb}}; - - auto w0 = *wmesh.begin(); - auto p = _fourier_plan<0>(gf_const_view(chi_wk[w0, _]), gf_view(chi_wr[w0, _])); - - auto arr = mpi_view(wmesh); - -#pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { - auto & w = arr(idx); - - auto chi_k = make_gf(kmesh, chi_wr.target()); - auto chi_r = make_gf(rmesh, chi_wr.target()); - -#pragma omp critical - chi_k = chi_wk[w, _]; - - _fourier_with_plan<0>(gf_const_view(chi_k), gf_view(chi_r), p); - -#pragma omp critical - chi_wr[w, _] = chi_r; - - //for (auto const &w : wmesh) - //chi_wr[w, _] = triqs::gfs::fourier(chi_wk[w, _]); - } - - chi_wr = mpi::all_reduce(chi_wr); + auto chi_wr = fourier_wk_to_wr_general_target(chi_wk); return chi_wr; } diff --git a/c++/triqs_tprf/lattice/common.hpp b/c++/triqs_tprf/lattice/common.hpp index 35887994..c237261d 100644 --- a/c++/triqs_tprf/lattice/common.hpp +++ b/c++/triqs_tprf/lattice/common.hpp @@ -27,17 +27,17 @@ using namespace triqs::clef; namespace { -placeholder<0> iw; -placeholder<1> inu; -placeholder<2> k; -placeholder<3> r; +//placeholder<0> iw; +//placeholder<1> inu; +//placeholder<2> k; +//placeholder<3> r; placeholder<4> a; placeholder<5> b; placeholder<6> c; placeholder<7> d; -placeholder<8> inup; -placeholder<9> tau; +//placeholder<8> inup; +//placeholder<9> tau; } // namespace diff --git a/c++/triqs_tprf/lattice/eliashberg.cpp b/c++/triqs_tprf/lattice/eliashberg.cpp index e4031688..3639852f 100644 --- a/c++/triqs_tprf/lattice/eliashberg.cpp +++ b/c++/triqs_tprf/lattice/eliashberg.cpp @@ -3,7 +3,7 @@ * TRIQS: a Toolbox for Research in Interacting Quantum Systems * * Copyright (C) 2019, The Simons Foundation and S. Käser - * Authors: H. U.R. Strand, S. Käser + * Authors: S. Käser, H. U.R. Strand * * TRIQS is free software: you can redistribute it and/or modify it under the * terms of the GNU General Public License as published by the Free Software @@ -21,37 +21,54 @@ ******************************************************************************/ #include "eliashberg.hpp" +#include +#include "../mpi.hpp" + +#include "gf.hpp" +#include "fourier.hpp" namespace triqs_tprf { // Helper function computing F = GG \Delta - -gk_iw_t eliashberg_g_delta_g_product(gk_iw_vt g_wk, gk_iw_vt delta_wk) { - auto [wmesh, kmesh] = delta_wk.mesh(); - auto gf_wmesh = std::get<0>(g_wk.mesh()); +g_wk_t eliashberg_g_delta_g_product(g_wk_vt g_wk, g_wk_vt delta_wk) { + + // Get rid of structured binding declarations in this file due to issue #11 + //auto [wmesh, kmesh] = delta_wk.mesh(); + auto wmesh = std::get<0>(delta_wk.mesh()); + auto kmesh = std::get<1>(delta_wk.mesh()); + + auto wmesh_gf = std::get<0>(g_wk.mesh()); - if (wmesh.size() > gf_wmesh.size()) + if (wmesh.size() > wmesh_gf.size()) TRIQS_RUNTIME_ERROR << "The size of the Matsubara frequency mesh of the Green's function" - " (" << gf_wmesh.size() << ") must be atleast the size of the mesh of Delta (" << + " (" << wmesh_gf.size() << ") must be atleast the size of the mesh of Delta (" << wmesh.size() << ")."; auto F_wk = make_gf(delta_wk); F_wk *= 0.; - for (const auto [w, k] : delta_wk.mesh()) - for (auto [A, B] : F_wk.target_indices()) - for (auto [c, d] : delta_wk.target_indices()) - F_wk[w, k](A, B) += - g_wk[w, k](A, c) * g_wk[-w, -k](B, d) * delta_wk[w, k](c, d); + auto meshes_mpi = mpi_view(delta_wk.mesh()); +#pragma omp parallel for + for (unsigned int idx = 0; idx < meshes_mpi.size(); idx++){ + auto &[w, k] = meshes_mpi(idx); + + for (auto [d, c] : F_wk.target_indices()) + for (auto [e, f] : delta_wk.target_indices()) + F_wk[w, k](d, c) += + g_wk[w, k](c, f) * g_wk[-w, -k](d, e) * delta_wk[w, k](e, f); + } return F_wk; } -gk_iw_t eliashberg_product(chi_wk_vt Gamma_pp, gk_iw_vt g_wk, - gk_iw_vt delta_wk) { +g_wk_t eliashberg_product(chi_wk_vt Gamma_pp, g_wk_vt g_wk, + g_wk_vt delta_wk) { + + //auto [wmesh, kmesh] = delta_wk.mesh(); + auto wmesh = std::get<0>(delta_wk.mesh()); + auto kmesh = std::get<1>(delta_wk.mesh()); - auto [wmesh, kmesh] = delta_wk.mesh(); auto gamma_wmesh = std::get<0>(Gamma_pp.mesh()); if (2*wmesh.size() > gamma_wmesh.size()) @@ -63,126 +80,171 @@ gk_iw_t eliashberg_product(chi_wk_vt Gamma_pp, gk_iw_vt g_wk, auto delta_wk_out = make_gf(delta_wk); delta_wk_out *= 0.; - - for (const auto [w, k] : delta_wk.mesh()) - for (const auto [n, q] : delta_wk.mesh()) - for (auto [A, a, B, b] : Gamma_pp.target_indices()) + + for (auto const &[w, k] : delta_wk.mesh()) + for (auto const &[n, q] : delta_wk.mesh()) + for (auto [c, a, d, b] : Gamma_pp.target_indices()) delta_wk_out[w, k](a, b) += - Gamma_pp(w-n, k - q)(A, a, B, b) * F_wk[n, q](A, B); + -0.5 * Gamma_pp(w-n, k - q)(c, a, d, b) * F_wk[n, q](d, c); - delta_wk_out /= -(wmesh.domain().beta * kmesh.size()); + delta_wk_out /= (wmesh.domain().beta * kmesh.size()); return delta_wk_out; } -std::tuple split_into_dynamic_wk_and_constant_k(chi_wk_vt Gamma_pp) { - +std::tuple split_into_dynamic_wk_and_constant_k(chi_wk_vt Gamma_pp) { auto _ = all_t{}; - auto [wmesh, kmesh] = Gamma_pp.mesh(); + //auto [wmesh, kmesh] = Gamma_pp.mesh(); + auto wmesh = std::get<0>(Gamma_pp.mesh()); + auto kmesh = std::get<1>(Gamma_pp.mesh()); // Fit infinite frequency value auto Gamma_pp_dyn_wk = make_gf(Gamma_pp); - chi_k_vt Gamma_pp_const_k = make_gf(kmesh, Gamma_pp.target()); + auto Gamma_pp_const_k = make_gf(kmesh, Gamma_pp.target()); - for (const auto k : kmesh) { + for (auto const &k : kmesh) { auto Gamma_w = Gamma_pp[_, k]; - auto [tail, err] = fit_tail(Gamma_w); + auto tail = std::get<0>(fit_tail(Gamma_w)); for (auto [a, b, c, d] : Gamma_pp.target_indices()) Gamma_pp_const_k[k](a, b, c, d) = tail(0, a, b, c, d); - for( const auto w : wmesh ) Gamma_pp_dyn_wk[w, k] = Gamma_pp[w, k] - Gamma_pp_const_k[k]; + for (auto const &w : wmesh) Gamma_pp_dyn_wk[w, k] = Gamma_pp[w, k] - Gamma_pp_const_k[k]; } return {Gamma_pp_dyn_wk, Gamma_pp_const_k}; } -std::tuple dynamic_and_constant_to_tr(chi_wk_vt Gamma_pp_dyn_wk, - chi_k_vt Gamma_pp_const_k) { +std::tuple dynamic_and_constant_to_tr(chi_wk_vt Gamma_pp_dyn_wk, chi_k_vt Gamma_pp_const_k) { + + auto Gamma_pp_dyn_wr = fourier_wk_to_wr_general_target(Gamma_pp_dyn_wk); + auto Gamma_pp_dyn_tr = fourier_wr_to_tr_general_target(Gamma_pp_dyn_wr); - auto Gamma_pp_dyn_tr = make_gf_from_fourier<0, 1>(Gamma_pp_dyn_wk); auto Gamma_pp_const_r = make_gf_from_fourier<0>(Gamma_pp_const_k); - return {Gamma_pp_dyn_tr, Gamma_pp_const_r}; + return {Gamma_pp_dyn_tr, Gamma_pp_const_r}; } -gk_iw_t eliashberg_product_fft(chi_tr_vt Gamma_pp_dyn_tr, chi_r_vt Gamma_pp_const_r, - gk_iw_vt g_wk, gk_iw_vt delta_wk) { +e_r_t eliashberg_constant_gamma_f_product(chi_r_vt Gamma_pp_const_r, g_tr_t F_tr) { - auto F_wk = eliashberg_g_delta_g_product(g_wk, delta_wk); - // FIXME - // Warning at this point if Matsubara space is too small, also dependent on input delta. - // Seems to be that there is some random fluctuation if this is used in combination with scipy. - // Does not greatly change the results but should be kept in mind. Also ugly print outs. - auto F_tr = make_gf_from_fourier<0, 1>(F_wk); - auto F_wr = make_gf_from_fourier<1>(F_wk); - - // Dynamic part - auto delta_tr_out = make_gf(F_tr.mesh(), delta_wk.target()); - delta_tr_out *= 0.; + auto _ = all_t{}; + + auto delta_r_out = make_gf(std::get<1>(F_tr.mesh()), F_tr.target()); + delta_r_out *= 0.; - for (const auto [t, r] : delta_tr_out.mesh()) { - for (auto [A, a, B, b] : Gamma_pp_dyn_tr.target_indices()) - delta_tr_out[t, r](a, b) += -Gamma_pp_dyn_tr(t, r)(A, a, B, b) * F_tr(t, r)(A, B); + for (auto const &r : std::get<1>(F_tr.mesh())) { + auto F_t = F_tr[_, r]; + for (auto [c, a, d, b] : Gamma_pp_const_r.target_indices()) + delta_r_out[r](a, b) += -0.5 * Gamma_pp_const_r[r](c, a, d, b) * F_t(0)(d, c); } - - auto delta_wk_out = make_gf_from_fourier<0, 1>(delta_tr_out); - // Constant part - auto delta_r_out = make_gf(std::get<1>(F_tr.mesh()), delta_wk.target()); - delta_r_out *= 0.; + return delta_r_out; +} + +g_tr_t eliashberg_dynamic_gamma_f_product(chi_tr_vt Gamma_pp_dyn_tr, g_tr_vt F_tr) { + + //auto [tmesh, rmesh] = F_tr.mesh(); + auto tmesh = std::get<0>(F_tr.mesh()); + auto rmesh = std::get<1>(F_tr.mesh()); + + auto delta_tr_out = make_gf(F_tr); + delta_tr_out *= 0.; + + auto tmesh_gamma = std::get<0>(Gamma_pp_dyn_tr.mesh()); + + // Test if the tau meshs of delta and gamma are compatible. If not raise an error, because + // it would lead to wrong results. + if (tmesh.size() != tmesh_gamma.size()) + TRIQS_RUNTIME_ERROR << "The size of the imaginary time mesh of Gamma" + " (" << tmesh_gamma.size() << ") must be the size of the mesh of Delta (" << + tmesh.size() << ")."; + + auto meshes_mpi = mpi_view(F_tr.mesh()); +#pragma omp parallel for + for (unsigned int idx = 0; idx < meshes_mpi.size(); idx++){ + auto &[t, r] = meshes_mpi(idx); - for (const auto [w, r] : F_wr.mesh()) { - for (auto [A, a, B, b] : Gamma_pp_dyn_tr.target_indices()) - delta_r_out[r](a, b) += -Gamma_pp_const_r(r)(A, a, B, b) * F_wr(w, r)(A, B); + for (auto [c, a, d, b] : Gamma_pp_dyn_tr.target_indices()) + delta_tr_out[t, r](a, b) += -0.5 * Gamma_pp_dyn_tr[t, r](c, a, d, b) * F_tr[t, r](d, c); } - auto delta_k_out = make_gf_from_fourier<0>(delta_r_out); - auto beta = std::get<0>(delta_wk.mesh()).domain().beta; - delta_k_out *= 1. / beta; + return delta_tr_out; +} +g_wk_t eliashberg_product_fft(chi_tr_vt Gamma_pp_dyn_tr, chi_r_vt Gamma_pp_const_r, + g_wk_vt g_wk, g_wk_vt delta_wk) { + + auto F_wk = eliashberg_g_delta_g_product(g_wk, delta_wk); + auto F_wr = fourier_wk_to_wr(F_wk); + auto F_tr = fourier_wr_to_tr(F_wr); + + auto delta_tr_out = eliashberg_dynamic_gamma_f_product(Gamma_pp_dyn_tr, F_tr); + auto delta_r_out = eliashberg_constant_gamma_f_product(Gamma_pp_const_r, F_tr); + + // FIXME + // This raises warnings when used with random delta input, e.g. eigenvalue finder + auto delta_wr_out = fourier_tr_to_wr(delta_tr_out); // Combine dynamic and constant part - for (const auto [w , k]: delta_wk_out.mesh()) - delta_wk_out[w, k] += delta_k_out[k]; + auto _ = all_t{}; + for (auto const &w : std::get<0>(delta_wr_out.mesh())) delta_wr_out[w, _] += delta_r_out; + + auto delta_wk_out = fourier_wr_to_wk(delta_wr_out); return delta_wk_out; } - -chi_wk_t gamma_PP_singlet(chi_wk_vt chi_c, chi_wk_vt chi_s, \ - array_view, 4> U_c, array_view, 4> U_s) { - auto [wmesh, kmesh] = chi_c.mesh(); +// optimized version if there is only a constant term +g_wk_t eliashberg_product_fft_constant(chi_r_vt Gamma_pp_const_r, + g_wk_vt g_wk, g_wk_vt delta_wk) { - auto Gamma_pp_wk = make_gf(chi_c); - Gamma_pp_wk *= 0; + auto F_wk = eliashberg_g_delta_g_product(g_wk, delta_wk); + auto F_wr = fourier_wk_to_wr(F_wk); + auto F_tr = fourier_wr_to_tr(F_wr); - for (const auto [w, k] : Gamma_pp_wk.mesh()) - for (auto [a, b, c, d] : Gamma_pp_wk.target_indices()) - for (auto [A, B, C, D] : chi_c.target_indices()) - Gamma_pp_wk[w,k](a, b, c, d) += - 1.5 * U_s(a, b, A, B) * chi_s[w, k](B, A, C, D) * U_s(D, C, c, d) \ - - 0.5 * U_c(a, b, A, B) * chi_c[w, k](B, A, C, D) * U_c(D, C, c, d) \ - + 0.5 * (U_s(a, b, c, d) + U_c(a, b, c, d)); + auto delta_r_out = eliashberg_constant_gamma_f_product(Gamma_pp_const_r, F_tr); + auto delta_k_out = make_gf_from_fourier<0>(delta_r_out); - return Gamma_pp_wk; + auto delta_wk_out = make_gf(F_wk); + delta_wk_out *= 0.; + + auto _ = all_t{}; + for (auto const &w : std::get<0>(delta_wk_out.mesh())) delta_wk_out[w, _] += delta_k_out; + + return delta_wk_out; } -chi_wk_t gamma_PP_triplet(chi_wk_vt chi_c, chi_wk_vt chi_s, \ - array_view, 4> U_c, array_view, 4> U_s) { +chi_wk_t construct_phi_wk(chi_wk_vt chi, array_view, 4> U) { + + using scalar_t = chi_wk_t::scalar_t; + + size_t nb = chi.target_shape()[0]; - auto [wmesh, kmesh] = chi_c.mesh(); + auto phi_wk = make_gf(chi); + phi_wk *= 0; - auto Gamma_pp_wk = make_gf(chi_c); - Gamma_pp_wk *= 0; + // PH grouping of the vertex, from cc+cc+, permuting the last two indices. + auto U_matrix = make_matrix_view(group_indices_view(U, {0, 1}, {3, 2})); - for (const auto [w, k] : Gamma_pp_wk.mesh()) - for (auto [a, b, c, d] : Gamma_pp_wk.target_indices()) - for (auto [A, B, C, D] : chi_c.target_indices()) - Gamma_pp_wk[w,k](a, b, c, d) += - - 0.5 * U_s(a, b, A, B) * chi_s[w, k](B, A, C, D) * U_s(D, C, c, d) \ - - 0.5 * U_c(a, b, A, B) * chi_c[w, k](B, A, C, D) * U_c(D, C, c, d) \ - + 0.5 * (U_s(a, b, c, d) + U_c(a, b, c, d)); + auto meshes_mpi = mpi_view(phi_wk.mesh()); + +#pragma omp parallel for + for (unsigned int idx = 0; idx < meshes_mpi.size(); idx++){ + auto &[w, k] = meshes_mpi(idx); + + array phi_arr{nb, nb, nb, nb, memory_layout_t<4>{0, 1, 2, 3}}; + array chi_arr{chi[w, k], memory_layout_t<4>{0, 1, 2, 3}}; + + // PH grouping of the vertex, from cc+cc+, permuting the last two indices. + auto phi_matrix = make_matrix_view(group_indices_view(phi_arr, {0, 1}, {3, 2})); + // PH grouping of the susceptibilites, from c+cc+c, permuting the last two indices. + auto chi_matrix = make_matrix_view(group_indices_view(chi_arr, {0, 1}, {3, 2})); + + phi_matrix = U_matrix * chi_matrix * U_matrix; + + phi_wk[w, k] = phi_arr; + } + phi_wk = mpi::all_reduce(phi_wk); - return Gamma_pp_wk; + return phi_wk; } } // namespace triqs_tprf diff --git a/c++/triqs_tprf/lattice/eliashberg.hpp b/c++/triqs_tprf/lattice/eliashberg.hpp index ce6ffd05..98136bd1 100644 --- a/c++/triqs_tprf/lattice/eliashberg.hpp +++ b/c++/triqs_tprf/lattice/eliashberg.hpp @@ -3,7 +3,7 @@ * TRIQS: a Toolbox for Research in Interacting Quantum Systems * * Copyright (C) 2019, The Simons Foundation and S. Käser - * Authors: H. U.R. Strand, S. Käser + * Authors: S. Käser, H. U.R. Strand * * TRIQS is free software: you can redistribute it and/or modify it under the * terms of the GNU General Public License as published by the Free Software @@ -25,119 +25,173 @@ namespace triqs_tprf { - /** Linearized Eliashberg product + /** Linearized Eliashberg product via summation - Computes the product + Computes the linearized Eliashberg product in the singlet/triplet channel given by .. math:: - \Delta^{(out)}_{\bar{a}\bar{b}}(\mathbf{k},i\nu) = -\frac{1}{N_k \beta}\sum_{\mathbf{k}'} \sum_{i\nu'} - \Gamma_{A\bar{a}B\bar{b}}(\mathbf{k}-\mathbf{k}', i\nu - i\nu') - \\ \times - G_{A\bar{c}}(\mathbf{k}', i\nu') - \Delta_{\bar{c}\bar{d}}(\mathbf{k}', i\nu') - G_{B\bar{d}}(-\mathbf{k}', -i\nu') - - @param chi_pp particle-particle vertex :math:`\Gamma^{(pp)}_{a\bar{b}c\bar{d}}(\mathbf{k}, i\nu_n)` - @param g_kw single particle Green's function :math:`G_{a\bar{b}}(\mathbf{k}, i\nu_n)` - @param delta_kw pairing self-energy :math:`\Delta_{\bar{a}\bar{b}}(\mathbf{k}, i\nu_n)` - @return Gives the result of the product :math:`\Delta^{(out)} \sim \Gamma^{(pp)}GG \Delta` + \Delta^{\mathrm{s/t}, \mathrm{out}}_{\bar{a}\bar{b}}(i\nu,\mathbf{k}) + = + -\frac{1}{2N_\mathbf{k} \beta}\sum_{i\nu'}\sum_{\mathbf{k}'} + \Gamma^{\mathrm{s/t}}_{c\bar{a}d\bar{b}}(i\nu - i\nu',\mathbf{k}-\mathbf{k}') + \\ + \times + G_{c\bar{e}}(i\nu',\mathbf{k}') + G_{d\bar{f}}(-i\nu',-\mathbf{k}') + \Delta^{\mathrm{s/t}, \mathrm{in}}_{\bar{e}\bar{f}}(i\nu',\mathbf{k}')\,, + + by summation. + + @param Gamma_pp particle-particle vertex :math:`\Gamma^{\mathrm{s/t}}_{a\bar{b}c\bar{d}}(i\nu_n,\mathbf{k})` + @param g_wk single particle Green's function :math:`G_{a\bar{b}}(i\nu_n,\mathbf{k})` + @param delta_wk superconducting gap :math:`\Delta^{\mathrm{s/t}, \mathrm{in}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{k})` + @return Gives the result of the product :math:`\Delta^{\mathrm{s/t}, \mathrm{out}}` */ - gk_iw_t eliashberg_product(chi_wk_vt Gamma_pp, gk_iw_vt g_wk, gk_iw_vt delta_wk); + g_wk_t eliashberg_product(chi_wk_vt Gamma_pp, g_wk_vt g_wk, g_wk_vt delta_wk); /** Linearized Eliashberg product via FFT - Computes the product + Computes the linearized Eliashberg product in the singlet/triplet channel given by .. math:: - \Delta^{(out)}_{\bar{a}\bar{b}}(\mathbf{k},i\nu) = -\frac{1}{N_k \beta}\sum_{\mathbf{k}'} \sum_{i\nu'} - \Gamma_{A\bar{a}B\bar{b}}(\mathbf{k}-\mathbf{k}', i\nu - i\nu') - \\ \times - G_{A\bar{c}}(\mathbf{k}', i\nu') - \Delta_{\bar{c}\bar{d}}(\mathbf{k}', i\nu') - G_{B\bar{d}}(-\mathbf{k}', -i\nu')\,, + \Delta^{\mathrm{s/t}, \mathrm{out}}_{\bar{a}\bar{b}}(i\nu,\mathbf{k}) + = + -\frac{1}{2N_\mathbf{k} \beta}\sum_{i\nu'}\sum_{\mathbf{k}'} + \Gamma^{\mathrm{s/t}}_{c\bar{a}d\bar{b}}(i\nu - i\nu',\mathbf{k}-\mathbf{k}') + \\ + \times + G_{c\bar{e}}(i\nu',\mathbf{k}') + G_{d\bar{f}}(-i\nu',-\mathbf{k}') + \Delta^{\mathrm{s/t}, \mathrm{in}}_{\bar{e}\bar{f}}(i\nu',\mathbf{k}')\,, by taking advantage of the convolution theorem. We therefore first calculate .. math:: - \Delta^{(out)}_{\bar{a}\bar{b}}(\mathbf{r}, \tau) = - -\Gamma_{A\bar{a}B\bar{b}}(\mathbf{r}, \tau) F_{AB}(\mathbf{r}, \tau) \,, + F^{\mathrm{s/t}}_{ab}(i\nu,\mathbf{k}) + = + G_{a\bar{c}}(i\nu,\mathbf{k}) + G_{b\bar{d}}(-i\nu,-\mathbf{k}) + \Delta^{\mathrm{s/t}, \mathrm{in}}_{\bar{c}\bar{d}}(i\nu,\mathbf{k})\,, - where + which we then Fourier transform to imaginary time and real-space .. math:: - F_{AB}(\mathbf{r}, \tau) = - \mathcal{F}\big(G_{A\bar{c}}(\mathbf{k}', i\nu') - \Delta_{\bar{c}\bar{d}}(\mathbf{k}', i\nu') - G_{B\bar{d}}(-\mathbf{k}', -i\nu')\big)\,. + F^{\mathrm{s/t}}_{ab}(\tau,\mathbf{r}) + = + \mathcal{F}^2 + \big( + F^{\mathrm{s/t}}_{ab}(i\nu,\mathbf{k}) + \big)\,. + + We then calculate first the dynamic gap + + .. math:: + \Delta^{\mathrm{s/t}, \mathrm{dynamic}}_{\bar{a}\bar{b}}(\tau,\mathbf{r}) + = + -\frac{1}{2} + \Gamma^{\mathrm{s/t}, \mathrm{dynamic}}_{c\bar{a}d\bar{b}}(\tau, \mathbf{r}) + F^{\mathrm{s/t}}_{cd}(\tau, \mathbf{r})\,, + + and then the static gap + + .. math:: + \Delta^{\mathrm{s/t}, \mathrm{static}}_{\bar{a}\bar{b}}(\mathbf{r}) + = + -\frac{1}{2} + \Gamma^{\mathrm{s/t}, \mathrm{static}}_{c\bar{a}d\bar{b}}(\mathbf{r}) + F^{\mathrm{s/t}}_{cd}(\tau=0, \mathbf{r})\,. - Then we Fourier transform + We then Fourier transform the dynamic gap to imaginary frequencies .. math:: - \Delta^{(out)}_{\bar{a}\bar{b}}(\mathbf{k},i\nu) = - \mathcal{F}\big(\Delta^{(out)}_{\bar{a}\bar{b}}(\mathbf{r}, \tau)\big)\,, + \Delta^{\mathrm{s/t}, \mathrm{dynamic}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{r}) + = + \mathcal{F} + \big( + \Delta^{\mathrm{s/t}, \mathrm{dynamic}}_{\bar{a}\bar{b}}(\tau,\mathbf{r}) + \big)\,, + + and then add both component together + + .. math:: + \Delta^{\mathrm{s/t}, \mathrm{out}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{r}) + = + \Delta^{\mathrm{s/t}, \mathrm{dynamic}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{r}) + + + \Delta^{\mathrm{s/t}, \mathrm{static}}_{\bar{a}\bar{b}}(\mathbf{r})\,, + + and then finally Fourier transform to :math:`\mathbf{k}`-space + + .. math:: + \Delta^{\mathrm{s/t}, \mathrm{out}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{k}) + = + \mathcal{F} + \big( + \Delta^{\mathrm{s/t}, \mathrm{out}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{r}) + \big)\,. - to get the same result, but with far less computational effort. - @param chi_rt dynamic part of the particle-particle vertex :math:`\Gamma^{(pp)}_{a\bar{b}c\bar{d}}(\mathbf{r}, \tau)` - @param chi_r constant part of the particle-particle vertex :math:`\Gamma^{(pp)}_{a\bar{b}c\bar{d}}(\mathbf{r})` - @param g_kw single particle Green's function :math:`G_{a\bar{b}}(\mathbf{k}, i\nu_n)` - @param delta_kw pairing self-energy :math:`\Delta_{\bar{a}\bar{b}}(\mathbf{k}, i\nu_n)` - @return Gives the result of the product :math:`\Delta^{(out)} \sim \Gamma^{(pp)}GG \Delta` + @param Gamma_pp_dyn_tr dynamic part of the particle-particle vertex :math:`\Gamma^{\mathrm{s/t}, \mathrm{dynamic}}_{c\bar{a}d\bar{b}}(\tau, \mathbf{r})` + @param Gamma_pp_const_r static part of the particle-particle vertex :math:`\Gamma^{\mathrm{s/t}, \mathrm{static}}_{c\bar{a}d\bar{b}}(\mathbf{r})` + @param g_wk one-particle Green's function :math:`G_{a\bar{b}}(i\nu_n,\mathbf{k})` + @param delta_wk superconducting gap :math:`\Delta^{\mathrm{s/t}, \mathrm{in}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{k})` + @return Gives the result of the product :math:`\Delta^{\mathrm{s/t}, \mathrm{out}}` */ - gk_iw_t eliashberg_product_fft(chi_tr_vt Gamma_pp_dyn_tr, chi_r_vt Gamma_pp_const_r, gk_iw_vt g_wk, gk_iw_vt delta_wk); - gk_iw_t eliashberg_g_delta_g_product(gk_iw_vt g_wk, gk_iw_vt delta_wk); - std::tuple split_into_dynamic_wk_and_constant_k(chi_wk_vt Gamma_pp); - std::tuple dynamic_and_constant_to_tr(chi_wk_vt Gamma_pp_dyn_wk, chi_k_vt Gamma_pp_const_k); + g_wk_t eliashberg_product_fft(chi_tr_vt Gamma_pp_dyn_tr, chi_r_vt Gamma_pp_const_r, g_wk_vt g_wk, g_wk_vt delta_wk); + g_wk_t eliashberg_product_fft_constant(chi_r_vt Gamma_pp_const_r, g_wk_vt g_wk, g_wk_vt delta_wk); + g_wk_t eliashberg_g_delta_g_product(g_wk_vt g_wk, g_wk_vt delta_wk); - /** Gamma particle-particle singlet - Computes the particle-particle vertex for singlet pairing in the RPA limit + /** Split Gamma in dynamic and constant part by tail fitting + + @param Gamma_pp : particle-particle pairing vertex :math:`\Gamma(i\omega_n, \mathbf{k})`. + @return Tuple of Gamma_pp_dyn_wk, the dynamic part of Gamma, which converges to zero for :math:`\omega_n \rightarrow \infty`, and Gamma_pp_const_k, the part of Gamma that is constant in Matsubara frequency space :math:`\Gamma(\mathbf{k})`. + */ + std::tuple split_into_dynamic_wk_and_constant_k(chi_wk_vt Gamma_pp); - .. math:: - \Gamma^{(\mathrm{singlet})}(a\bar{b}c\bar{d}) = - \frac{3}{2} U^{(\mathrm{s})}(a\bar{b}A\bar{B}) \chi^{(\mathrm{s})}(\bar{B}A\bar{C}D) - U^{(\mathrm{s})}(D\bar{C}c\bar{d}) \\ - -\frac{1}{2} U^{(\mathrm{c})}(a\bar{b}A\bar{B}) \chi^{(\mathrm{c})}(\bar{B}A\bar{C}D) - U^{(\mathrm{c})}(D\bar{C}c\bar{d}) \\ - + \frac{1}{2}\big(U^{(\mathrm{s})}(a\bar{b}c\bar{d})+ - U^{(\mathrm{c})}(a\bar{b}c\bar{d})\big) - - @param chi_c charge susceptibility :math:`\chi^{(\mathrm{c})}_{\bar{a}b\bar{c}d}(\mathbf{k}, i\omega_n)` - @param chi_s spin susceptibility :math:`\chi^{(\mathrm{s})}_{\bar{a}b\bar{c}d}(\mathbf{k}, i\omega_n)` - @param U_c charge interaction :math:`U^{(\mathrm{c})}_{a\bar{b}c\bar{d}}` - @param U_s spin interaction :math:`U^{(\mathrm{s})}_{a\bar{b}c\bar{d}}` - @return :math:`\Gamma^{(\mathrm{singlet})}_{a\bar{b}c\bar{d}}(\mathbf{k}, i\omega_n)` + /** Fourier transform Gamma parts to imaginary time and real-space + + @param Gamma_pp_dyn_wk : The dynamic part of Gamma, which converges to zero for :math:`\omega_n \rightarrow \infty`. + @param Gamma_pp_const_k : The part of Gamma that is constant in Matsubara frequency space :math:`\Gamma(\mathbf{k})`. + @return Tuple of Gamma_pp_dyn_tr, the dynamic part of Gamma, which converges to zero for :math:`\omega_n \rightarrow \infty`, but now in :math:`\tau`-space, Gamma_pp_const_r, the constant part of Gamma in real-space. */ + std::tuple dynamic_and_constant_to_tr(chi_wk_vt Gamma_pp_dyn_wk, chi_k_vt Gamma_pp_const_k); + e_r_t eliashberg_constant_gamma_f_product(chi_r_vt Gamma_pp_const_r, g_tr_t F_tr); - chi_wk_t gamma_PP_singlet(chi_wk_vt chi_c, chi_wk_vt chi_s, array_view, 4> U_c, array_view, 4> U_s); - /** Gamma particle-particle triplet + /** Computes reducible ladder vertex for the approximation of a local and static vertex. - Computes the particle-particle vertex for triplet pairing in the RPA limit + In this approximation the reducible ladder vertex in density/magnetic channel are given by .. math:: - \Gamma^{(\mathrm{triplet})}(a\bar{b}c\bar{d}) = - -\frac{1}{2} U^{(\mathrm{s})}(a\bar{b}A\bar{B}) \chi^{(\mathrm{s})}(\bar{B}A\bar{C}D) - U^{(\mathrm{s})}(D\bar{C}c\bar{d}) \\ - -\frac{1}{2} U^{(\mathrm{c})}(a\bar{b}A\bar{B}) \chi^{(\mathrm{c})}(\bar{B}A\bar{C}D) - U^{(\mathrm{c})}(D\bar{C}c\bar{d}) \\ - + \frac{1}{2}\big(U^{(\mathrm{s})}(a\bar{b}c\bar{d})+ - U^{(\mathrm{c})}(a\bar{b}c\bar{d})\big) - - @param chi_c charge susceptibility :math:`\chi^{(\mathrm{c})}_{\bar{a}b\bar{c}d}(\mathbf{k}, i\omega_n)` - @param chi_s spin susceptibility :math:`\chi^{(\mathrm{s})}_{\bar{a}b\bar{c}d}(\mathbf{k}, i\omega_n)` - @param U_c charge interaction :math:`U^{(\mathrm{c})}_{a\bar{b}c\bar{d}}` - @param U_s spin interaction :math:`U^{(\mathrm{s})}_{a\bar{b}c\bar{d}}` - @return :math:`\Gamma^{(\mathrm{triplet})}_{a\bar{b}c\bar{d}}(\mathbf{k}, i\omega_n)` + \Phi^{\text{d/m}}_{a\overline{b}c\overline{d}}(Q) + &\approx + \frac{1}{(N_\mathbf{k}\beta)^2} + \sum_{K'', K'''} + U^{\text{d/m}}\chi^{\text{d/m}}(Q, K'', K''') U^{\text{d/m}} + \\ + &\approx + U^{\mathrm{d/m}} + \chi^{\text{d/m}}(Q) U^{\mathrm{d/m}}\,, + + + where all products are particle-hole products. + The reducible ladder vertex in then only dependent on one bosonic frequency and momentum. + It can then be used in :meth:`triqs_tprf.eliashberg.construct_gamma_singlet_rpa` + or :meth:`triqs_tprf.eliashberg.construct_gamma__rpa` to construct the + irreducible singlet/triplet vertex. + + @param chi density/magnetic susceptibility :math:`\chi^{\mathrm{d/m}}_{\bar{a}b\bar{c}d}(i\omega_n,\mathbf{q})` + @param U density/magnetic local and static vertex :math:`U^{\mathrm{d/m}}_{a\bar{b}c\bar{d}}` + @return The reducible ladder vertex in the density/magnetic channel :math:`\Phi^{\mathrm{d/m}}(i\omega_n,\mathbf{q})` */ - - chi_wk_t gamma_PP_triplet(chi_wk_vt chi_c, chi_wk_vt chi_s, array_view, 4> U_c, array_view, 4> U_s); + chi_wk_t construct_phi_wk(chi_wk_vt chi, array_view, 4> U); } diff --git a/c++/triqs_tprf/lattice/fourier.hpp b/c++/triqs_tprf/lattice/fourier.hpp new file mode 100644 index 00000000..9c16b68a --- /dev/null +++ b/c++/triqs_tprf/lattice/fourier.hpp @@ -0,0 +1,172 @@ +/******************************************************************************* + * + * TRIQS: a Toolbox for Research in Interacting Quantum Systems + * + * Copyright (C) 2019, The Simons Foundation and S. Käser + * Authors: S. Käser + * + * TRIQS is free software: you can redistribute it and/or modify it under the + * terms of the GNU General Public License as published by the Free Software + * Foundation, either version 3 of the License, or (at your option) any later + * version. + * + * TRIQS is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License along with + * TRIQS. If not, see . + * + ******************************************************************************/ +#pragma once + +#include "../types.hpp" +#include "../fourier/fourier.hpp" +#include +#include "../mpi.hpp" + +namespace triqs_tprf { + + + namespace { + using namespace fourier; + } + +template +auto fourier_wr_to_tr_general_target(Gf_type g_wr, int n_tau = -1) { + + auto _ = all_t{}; + // Get rid of structured binding declarations in this file due to issue #11 + //auto [wmesh, rmesh] = g_wr.mesh(); + auto wmesh = std::get<0>(g_wr.mesh()); + auto rmesh = std::get<1>(g_wr.mesh()); + + auto tmesh = make_adjoint_mesh(wmesh, n_tau); + auto g_tr = make_gf>({tmesh, rmesh}, g_wr.target()); + + auto r0 = *rmesh.begin(); + auto p = _fourier_plan<0>(gf_const_view(g_wr[_, r0]), gf_view(g_tr[_, r0])); + + auto r_arr = mpi_view(rmesh); + +#pragma omp parallel for + for (unsigned int idx = 0; idx < r_arr.size(); idx++) { + auto &r = r_arr(idx); + + auto g_w = make_gf(wmesh, g_wr.target()); + auto g_t = make_gf(tmesh, g_tr.target()); + + g_w = g_wr[_, r]; + + _fourier_with_plan<0>(gf_const_view(g_w), gf_view(g_t), p); + + g_tr[_, r] = g_t; + } + g_tr = mpi::all_reduce(g_tr); + return g_tr; +} + +template +auto fourier_tr_to_wr_general_target(Gf_type g_tr, int n_w = -1) { + + auto _ = all_t{}; + //auto [tmesh, rmesh] = g_tr.mesh(); + auto tmesh = std::get<0>(g_tr.mesh()); + auto rmesh = std::get<1>(g_tr.mesh()); + + auto wmesh = make_adjoint_mesh(tmesh, n_w); + auto g_wr = make_gf>({wmesh, rmesh}, g_tr.target()); + + auto r0 = *rmesh.begin(); + auto p = _fourier_plan<0>(gf_const_view(g_tr[_, r0]), gf_view(g_wr[_, r0])); + + auto r_arr = mpi_view(rmesh); + +#pragma omp parallel for + for (unsigned int idx = 0; idx < r_arr.size(); idx++) { + auto &r = r_arr(idx); + + auto g_t = make_gf(tmesh, g_tr.target()); + auto g_w = make_gf(wmesh, g_wr.target()); + + g_t = g_tr[_, r]; + + _fourier_with_plan<0>(gf_const_view(g_t), gf_view(g_w), p); + + g_wr[_, r] = g_w; + } + g_wr = mpi::all_reduce(g_wr); + return g_wr; +} + +template +auto fourier_wk_to_wr_general_target(Gf_type g_wk) { + + auto _ = all_t{}; + + //auto [wmesh, kmesh] = g_wk.mesh(); + auto wmesh = std::get<0>(g_wk.mesh()); + auto kmesh = std::get<1>(g_wk.mesh()); + + auto rmesh = make_adjoint_mesh(kmesh); + //auto g_wr = gf, Target>{{wmesh, rmesh}, g_wk.target_shape()}; + auto g_wr = make_gf>({wmesh, rmesh}, g_wk.target()); + + auto w0 = *wmesh.begin(); + auto p = _fourier_plan<0>(gf_const_view(g_wk[w0, _]), gf_view(g_wr[w0, _])); + + auto w_arr = mpi_view(wmesh); + +#pragma omp parallel for + for (unsigned int idx = 0; idx < w_arr.size(); idx++) { + auto &w = w_arr(idx); + + auto g_k = make_gf(kmesh, g_wk.target()); + auto g_r = make_gf(rmesh, g_wr.target()); + + g_k = g_wk[w, _]; + + _fourier_with_plan<0>(gf_const_view(g_k), gf_view(g_r), p); + + g_wr[w, _] = g_r; + } + g_wr = mpi::all_reduce(g_wr); + return g_wr; +} + +template +auto fourier_wr_to_wk_general_target(Gf_type g_wr) { + + auto _ = all_t{}; + + //auto [wmesh, rmesh] = g_wr.mesh(); + auto wmesh = std::get<0>(g_wr.mesh()); + auto rmesh = std::get<1>(g_wr.mesh()); + + auto kmesh = make_adjoint_mesh(rmesh); + auto g_wk = make_gf>({wmesh, kmesh}, g_wr.target()); + + auto w0 = *wmesh.begin(); + auto p = _fourier_plan<0>(gf_const_view(g_wr[w0, _]), gf_view(g_wk[w0, _])); + + auto w_arr = mpi_view(wmesh); + +#pragma omp parallel for + for (unsigned int idx = 0; idx < w_arr.size(); idx++) { + auto &w = w_arr(idx); + + auto g_r = make_gf(rmesh, g_wr.target()); + auto g_k = make_gf(kmesh, g_wk.target()); + + g_r = g_wr[w, _]; + + _fourier_with_plan<0>(gf_const_view(g_r), gf_view(g_k), p); + + g_wk[w, _] = g_k; + } + g_wk = mpi::all_reduce(g_wk); + return g_wk; +} + +} // namespace triqs_tprf diff --git a/c++/triqs_tprf/lattice/gf.cpp b/c++/triqs_tprf/lattice/gf.cpp index 226f9419..985a3b16 100644 --- a/c++/triqs_tprf/lattice/gf.cpp +++ b/c++/triqs_tprf/lattice/gf.cpp @@ -22,11 +22,11 @@ #include using triqs::arrays::inverse; -#include "../mpi.hpp" -#include "common.hpp" #include "gf.hpp" -#include "../fourier/fourier.hpp" +#include +#include "../mpi.hpp" +#include "fourier.hpp" namespace triqs_tprf { @@ -47,7 +47,7 @@ g_wk_t lattice_dyson_g0_wk(double mu, e_k_cvt e_k, gf_mesh mesh) { auto arr = mpi_view(g0_wk.mesh()); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { auto &[w, k] = arr(idx); g0_wk[w, k] = inverse((w + mu)*I - e_k(k)); } @@ -97,7 +97,7 @@ g_wk_t lattice_dyson_g_wk(double mu, e_k_cvt e_k, g_w_cvt sigma_w) { auto arr = mpi_view(g_wk.mesh()); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { auto &[w, k] = arr(idx); g_wk[w, k] = inverse((w + mu)*I - e_k(k) - sigma_w[w]); } @@ -143,225 +143,29 @@ g_w_t lattice_dyson_g_w(double mu, e_k_cvt e_k, g_w_cvt sigma_w) { } // ---------------------------------------------------- +// Transformations: real space <-> reciprocal space -#ifdef TPRF_OMP - -g_wr_t fourier_wk_to_wr(g_wk_cvt g_wk) { - - auto _ = all_t{}; - auto target = g_wk.target(); - - //const auto & [ wmesh, kmesh ] = g_wk.mesh(); - auto wmesh = std::get<0>(g_wk.mesh()); - auto kmesh = std::get<1>(g_wk.mesh()); - auto rmesh = make_adjoint_mesh(kmesh); - - g_wr_t g_wr({wmesh, rmesh}, g_wk.target_shape()); - - auto w0 = *wmesh.begin(); - auto p = _fourier_plan<0>(gf_const_view(g_wk[w0, _]), gf_view(g_wr[w0, _])); - - auto arr = mpi_view(wmesh); - - #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { - auto & w = arr(idx); - - auto g_r = make_gf(rmesh, target); - auto g_k = make_gf(kmesh, target); - - #pragma omp critical - g_k = g_wk[w, _]; - - _fourier_with_plan<0>(gf_const_view(g_k), gf_view(g_r), p); - - #pragma omp critical - g_wr[w, _] = g_r; - - } - - g_wr = mpi::all_reduce(g_wr); - return g_wr; -} - -#else - g_wr_t fourier_wk_to_wr(g_wk_cvt g_wk) { - - auto [wmesh, kmesh] = g_wk.mesh(); - auto rmesh = make_adjoint_mesh(kmesh); - - g_wr_t g_wr({wmesh, rmesh}, g_wk.target_shape()); - - auto _ = all_t{}; - for ( auto const &w : mpi_view(wmesh) ) - g_wr[w, _]() = triqs::gfs::fourier(g_wk[w, _]); - - g_wr = mpi::all_reduce(g_wr); - + auto g_wr = fourier_wk_to_wr_general_target(g_wk); return g_wr; } - -#endif -// ---------------------------------------------------- - -#ifdef TPRF_OMP - g_wk_t fourier_wr_to_wk(g_wr_cvt g_wr) { - - auto _ = all_t{}; - auto target = g_wr.target(); - - //auto [wmesh, rmesh] = g_wr.mesh(); - auto wmesh = std::get<0>(g_wr.mesh()); - auto rmesh = std::get<1>(g_wr.mesh()); - auto kmesh = make_adjoint_mesh(rmesh); - - g_wk_t g_wk({wmesh, kmesh}, g_wr.target_shape()); - - auto w0 = *wmesh.begin(); - auto p = _fourier_plan<0>(gf_const_view(g_wr[w0, _]), gf_view(g_wk[w0, _])); - - auto arr = mpi_view(wmesh); - - #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { - auto & w = arr(idx); - - auto g_r = make_gf(rmesh, target); - auto g_k = make_gf(kmesh, target); - -#pragma omp critical - g_r = g_wr[w, _]; - - _fourier_with_plan<0>(gf_const_view(g_r), gf_view(g_k), p); - -#pragma omp critical - g_wk[w, _] = g_k; - - } - - g_wk = mpi::all_reduce(g_wk); + auto g_wk = fourier_wr_to_wk_general_target(g_wr); return g_wk; } -#else - -g_wk_t fourier_wr_to_wk(g_wr_cvt g_wr) { - - auto [wmesh, rmesh] = g_wr.mesh(); - auto kmesh = make_adjoint_mesh(rmesh); - - g_wk_t g_wk({wmesh, kmesh}, g_wr.target_shape()); - - auto _ = all_t{}; - for (auto const &w : mpi_view(wmesh)) - g_wk[w, _]() = triqs::gfs::fourier(g_wr[w, _]); - - g_wk = mpi::all_reduce(g_wk); - - return g_wk; -} - -#endif - // ---------------------------------------------------- // Transformations: Matsubara frequency <-> imaginary time g_wr_t fourier_tr_to_wr(g_tr_cvt g_tr, int nw) { - std::cout << "WARNING: fourier_tr_to_wr is not parallellized. FIXME\n"; - - auto tmesh = std::get<0>(g_tr.mesh()); - double beta = tmesh.domain().beta; - auto S = tmesh.domain().statistic; - - if( nw <= 0 ) nw = tmesh.size() / 4; - - auto wmesh = gf_mesh(beta, S, nw); - - auto g_wr = make_gf_from_fourier<0>(g_tr, wmesh); - + auto g_wr = fourier_tr_to_wr_general_target(g_tr, nw); return g_wr; } -#ifdef TPRF_OMP - g_tr_t fourier_wr_to_tr(g_wr_cvt g_wr, int nt) { - - auto wmesh = std::get<0>(g_wr.mesh()); - auto rmesh = std::get<1>(g_wr.mesh()); - - double beta = wmesh.domain().beta; - auto S = wmesh.domain().statistic; - - int nw = wmesh.last_index() + 1; - if( nt <= 0 ) nt = 4 * nw; - - g_tr_t g_tr({{beta, S, nt}, rmesh}, g_wr.target_shape()); - - auto tmesh = std::get<0>(g_tr.mesh()); - - auto _ = all_t{}; - - auto r0 = *rmesh.begin(); - auto p = _fourier_plan<0>(gf_const_view(g_wr[_, r0]), gf_view(g_tr[_, r0])); - - auto arr = mpi_view(rmesh); - -#pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { - auto & r = arr(idx); - - auto g_w = make_gf(wmesh, g_wr.target()); - auto g_t = make_gf(tmesh, g_wr.target()); - -#pragma omp critical - g_w = g_wr[_, r]; - - _fourier_with_plan<0>(gf_const_view(g_w), gf_view(g_t), p); - -#pragma omp critical - g_tr[_, r] = g_t; - - } - - g_tr = mpi::all_reduce(g_tr); + auto g_tr = fourier_wr_to_tr_general_target(g_wr, nt); return g_tr; } -#else - -g_tr_t fourier_wr_to_tr(g_wr_cvt g_wr, int nt) { - - auto wmesh = std::get<0>(g_wr.mesh()); - auto rmesh = std::get<1>(g_wr.mesh()); - - double beta = wmesh.domain().beta; - - int nw = wmesh.last_index() + 1; - if( nt <= 0 ) nt = 4 * nw; - - g_tr_t g_tr({{beta, wmesh.domain().statistic, nt}, rmesh}, g_wr.target_shape()); - - auto _ = all_t{}; - auto r0 = *rmesh.begin(); - auto zero_tail = make_zero_tail(g_wr[_, r0], 2); - auto zero_tail_r0 = make_zero_tail(g_wr[_, r0], 2); - - zero_tail_r0(1, range(), range()) = - make_unit_matrix(g_wr.target_shape()[0]); - - for (auto const &r : rmesh) { - if(r.linear_index() == 0) - g_tr[_, r]() = triqs::gfs::fourier<0>(g_wr[_, r], make_const_view(zero_tail_r0)); - else - g_tr[_, r]() = triqs::gfs::fourier<0>(g_wr[_, r], make_const_view(zero_tail)); - } - - return g_tr; -} - -#endif - } // namespace triqs_tprf diff --git a/c++/triqs_tprf/lattice/gw.cpp b/c++/triqs_tprf/lattice/gw.cpp index de42fe99..f6908832 100644 --- a/c++/triqs_tprf/lattice/gw.cpp +++ b/c++/triqs_tprf/lattice/gw.cpp @@ -40,7 +40,7 @@ chi_wk_t dynamical_screened_interaction_W_wk(chi_wk_cvt PI_wk, chi_k_cvt V_k) { // MPI and openMP parallell loop auto arr = mpi_view(W_wk.mesh()); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { auto &[w, k] = arr(idx); array V_arr{V_k[k], memory_layout_t<4>{0, 1, 2, 3}}; @@ -114,7 +114,7 @@ g_tr_t gw_sigma_tr(chi_tr_cvt Wr_tr, g_tr_cvt g_tr) { // MPI and openMP parallell loop auto arr = mpi_view(g_tr.mesh()); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { auto &[t, r] = arr(idx); //for (const auto &[t, r] : g_tr.mesh()) { diff --git a/c++/triqs_tprf/lattice/lindhard_chi00.cpp b/c++/triqs_tprf/lattice/lindhard_chi00.cpp index 66293451..a6223748 100644 --- a/c++/triqs_tprf/lattice/lindhard_chi00.cpp +++ b/c++/triqs_tprf/lattice/lindhard_chi00.cpp @@ -50,7 +50,7 @@ chi_wk_t lindhard_chi00_wk(e_k_cvt e_k, int nw, //for (auto const &q : kmesh) { // can not do range-based for loops with OpenMP #pragma omp parallel for - for (int qidx = 0; qidx < kmesh.size(); qidx++) { + for (unsigned int qidx = 0; qidx < kmesh.size(); qidx++) { auto q_iter = kmesh.begin(); q_iter += qidx; auto q = *q_iter; diff --git a/c++/triqs_tprf/lattice/rpa.cpp b/c++/triqs_tprf/lattice/rpa.cpp index a33544f4..3de723f7 100644 --- a/c++/triqs_tprf/lattice/rpa.cpp +++ b/c++/triqs_tprf/lattice/rpa.cpp @@ -21,7 +21,8 @@ ******************************************************************************/ #include "rpa.hpp" -#include "common.hpp" +#include +#include "../mpi.hpp" namespace triqs_tprf { @@ -31,18 +32,20 @@ chi_wk_t solve_rpa_PH(chi_wk_vt chi0_wk, using scalar_t = chi_wk_t::scalar_t; size_t nb = chi0_wk.target_shape()[0]; - auto wmesh = std::get<0>(chi0_wk.mesh()); - auto kmesh = std::get<1>(chi0_wk.mesh()); - chi_wk_t chi_wk{{wmesh, kmesh}, chi0_wk.target_shape()}; + auto chi_wk = make_gf(chi0_wk); + chi_wk *=0; // PH grouping of the vertex, from cc+cc+, permuting the last two indices. auto U = make_matrix_view(group_indices_view(U_arr, {0, 1}, {3, 2})); auto I = make_unit_matrix(U.shape()[0]); - for (auto const &w : wmesh) { - for (auto const &k : kmesh) { + auto meshes_mpi = mpi_view(chi0_wk.mesh()); + +#pragma omp parallel for + for (unsigned int idx = 0; idx < meshes_mpi.size(); idx++){ + auto &[w, k] = meshes_mpi(idx); array chi_arr{nb, nb, nb, nb, memory_layout_t<4>{0, 1, 2, 3}}; @@ -58,7 +61,7 @@ chi_wk_t solve_rpa_PH(chi_wk_vt chi0_wk, chi_wk[w, k] = chi_arr; // assign back using the array_view } - } + chi_wk = mpi::all_reduce(chi_wk); return chi_wk; } diff --git a/c++/triqs_tprf/types.hpp b/c++/triqs_tprf/types.hpp index 6742a0b3..3375e821 100644 --- a/c++/triqs_tprf/types.hpp +++ b/c++/triqs_tprf/types.hpp @@ -103,6 +103,10 @@ typedef gf e_k_t; typedef e_k_t::const_view_type e_k_cvt; typedef e_k_t::view_type e_k_vt; +typedef gf e_r_t; +typedef e_r_t::const_view_type e_r_cvt; +typedef e_r_t::view_type e_r_vt; + typedef gf g_w_t; typedef g_w_t::const_view_type g_w_cvt; typedef g_w_t::view_type g_w_vt; diff --git a/doc/about.rst b/doc/about.rst index 9d2e7524..d3a0a2cd 100644 --- a/doc/about.rst +++ b/doc/about.rst @@ -4,6 +4,7 @@ Authors ======= TPRF has been written by Hugo U.R. Strand with TRIQS-library support from N. Wentzell and O. Parcollet. +The Eliashberg section was contributed by Stefan Käser with support from H. U.R. Strand, N. Wentzell, O. Parcollet and P. Dumitrescu. License ======= diff --git a/doc/documentation.rst b/doc/documentation.rst index a702577f..fd41c204 100644 --- a/doc/documentation.rst +++ b/doc/documentation.rst @@ -13,7 +13,9 @@ Tutorials user_guide/Bethe-Salpeter Equation on the Hubbard atom.ipynb user_guide/Lattice BSE on Hubbard atom.ipynb user_guide/dmft_susceptibility/dmft_susceptibility - + user_guide/Linearized Eliashberg equation on the attractive Hubbard model.ipynb + user_guide/Solving the linearized Eliashberg equation in the random phase approximation limit + Python reference manual ----------------------- diff --git a/doc/reference/cpp_reference.rst b/doc/reference/cpp_reference.rst index 3e5dfb24..f328b093 100644 --- a/doc/reference/cpp_reference.rst +++ b/doc/reference/cpp_reference.rst @@ -105,8 +105,9 @@ Linearized Eliashberg equation /cpp2rst_generated/triqs_tprf/eliashberg_product /cpp2rst_generated/triqs_tprf/eliashberg_product_fft - /cpp2rst_generated/triqs_tprf/gamma_PP_singlet - /cpp2rst_generated/triqs_tprf/gamma_PP_triplet + /cpp2rst_generated/triqs_tprf/split_into_dynamic_wk_and_constant_k + /cpp2rst_generated/triqs_tprf/dynamic_and_constant_to_tr + /cpp2rst_generated/triqs_tprf/construct_phi_wk Hubbard atom analytic response functions ======================================== diff --git a/doc/reference/python_reference.rst b/doc/reference/python_reference.rst index 2cfa3568..5c7b217d 100644 --- a/doc/reference/python_reference.rst +++ b/doc/reference/python_reference.rst @@ -18,6 +18,7 @@ Random Phase Approximation ========================== .. autofunction:: triqs_tprf.lattice.solve_rpa_PH +.. autofunction:: triqs_tprf.rpa_tensor.kanamori_quartic_tensor Impurity susceptibility and Bethe-Salpeter Equation =================================================== @@ -46,7 +47,13 @@ GW approximation Linearized Eliashberg equation ============================== -.. autofunction:: triqs_tprf.eliashberg.solve_eliashberg_fft +.. autofunction:: triqs_tprf.eliashberg.solve_eliashberg +.. autofunction:: triqs_tprf.eliashberg.preprocess_gamma_for_fft +.. autofunction:: triqs_tprf.eliashberg.semi_random_initial_delta +.. autofunction:: triqs_tprf.eliashberg.power_method_LR +.. autofunction:: triqs_tprf.eliashberg.implicitly_restarted_arnoldi_method +.. autofunction:: triqs_tprf.eliashberg.construct_gamma_singlet_rpa +.. autofunction:: triqs_tprf.eliashberg.construct_gamma_triplet_rpa Hubbard atom analytic response functions ======================================== @@ -82,6 +89,8 @@ Tight binding lattice model .. autoclass:: triqs_tprf.tight_binding.TBLattice :members: +.. autofunction:: triqs_tprf.tight_binding.create_square_lattice + .. autoclass:: triqs_tprf.super_lattice.TBSuperLattice :members: @@ -107,4 +116,4 @@ Parameter collections :members: .. autoclass:: triqs_tprf.ParameterCollection.ParameterCollections :members: - +.. autofunction:: triqs_tprf.ParameterCollection.parameter_scan diff --git a/doc/theory/eliashberg.rst b/doc/theory/eliashberg.rst index c6ae1af9..e9e54a45 100644 --- a/doc/theory/eliashberg.rst +++ b/doc/theory/eliashberg.rst @@ -1,244 +1,511 @@ .. _eliashberg: Linearized Eliashberg Equation -================================ +============================== -.. note:: - References: - - - [A.A. Abrikosov, L.P. Gor’kov, et.al., Pergamon, Oxford (1965)] - - [Takimoto, et. al., PRB 69, 104504 (2004)] - - [Yanase, et. al., Physics Reports 387, 1-149 (2003)] +The linearized Eliashberg equation is a generalization of the linearized +Bardeen-Cooper-Schrieffer (BCS) gap equation to frequency dependent gaps. +It can be used to determine the critical (inverse) temperature +:math:`T_\mathrm{c}/\beta_\mathrm{c}`, +at which a transition to a superconducting state occurs, +and the symmetry of the corresponding superconducting gap function +:math:`\Delta^{\mathrm{s/t}}`. +It is given by +.. math:: + \Delta^{\mathrm{s/t}}_{\bar{a}\bar{b}}(K)= -\frac{1}{2 N_{\mathbf{k}}\beta_\mathrm{c}}\sum_{K'} + \Gamma^{\mathrm{s/t}}_{c\bar{a}d\bar{b}}(Q=0, K, K') + G_{c\bar{f}}(K')G_{d\bar{e}}(-K') + \Delta^{\mathrm{s/t}}_{\bar{e}\bar{f}}(K')\,. + :label: linearized_eliashberg_1 + +where :math:`Q/K` is a combination of bosonic/fermionic Matsubara :math:`i\omega_n/i\nu_n` +frequency and momentum :math:`\mathbf{k}`, +:math:`N_{\mathbf{k}}` is the number of momentum points, +:math:`\Gamma^{\mathrm{s/t}}` is the irreducible particle-particle vertex +and :math:`G` is the one-particle Green's function. .. note:: - All indices on this page only represent orbital degrees of freedom. - Spin is not treated explicitly and therefore only spin-independent Hamiltonians can be used for calculations. - - - - -We asssume a homogenous system with some arbitrary effective pairing interaction :math:`\Gamma`, which leads to the formation of Cooper pairs. - -Anomalous Green's Functions ---------------------------- + The bosonic Matsubara frequency and momentum in the particle-particle vertex is set to zero. + This is because we are interested in Cooper-pairs which have a zero + transfered momentum-frequency in a scattering process [#nourafkan]_. .. note:: - Explain what happens with all spin quantum numbers in the single-particle Green's function. Do we work with a particular combination of spins? :math:`G_{a\bar{b}} = G_{\alpha \uparrow \bar{b} \downarrow}`? + The current implementation is restricted to :math:`SU(2)` symmetric systems. + All indices are purely orbital and superconducting gaps :math:`\Delta` and + particle-particle vertices :math:`\Gamma` are restricted to the singlet/triplet + channel, shown by the superscripts s/t respectively. + But note, that the equations still hold for the spin-dependent case and + one would soley need to implement the spin-dependent particle-particle vertex + to use them. -With the arise of Cooper pairs we need in addition to the normal single-particle Green's function +Deriving the linearized Eliashberg equation from the normal state +----------------------------------------------------------------- -.. math:: - G_{a\bar{b}}(\tau - \tau') - \equiv - - \langle \mathcal{T} c_{a}(\tau) c^\dagger_{\bar{b}}(\tau') \rangle - = - - \langle \mathcal{T} a(\tau) \bar{b}(\tau') \rangle\,, - -and its backwards propagating counterpart +The singlet and triplet susceptibilties are given by .. math:: - \bar{G}_{\bar{a}b}(\tau - \tau') - \equiv - - \langle \mathcal{T} c^\dagger_{\bar{a}}(\tau) c_{b}(\tau') \rangle - = - - \langle \mathcal{T} \bar{a}(\tau) b(\tau') \rangle\,, - -the single-particle anomalous Green's functions :math:`F` and :math:`\bar{F}` to describe a superconducting state. -These are defined as + \chi^{\mathrm{s}} + = + - + \chi^{(0), \mathrm{PP}} + + + \frac{1}{2} + \chi^{(0), \mathrm{PP}} + \mathbf{\Gamma}^{\mathrm{s}} + \left[ + - + \chi^{\mathrm{s}} + + + \chi^{(0), \mathrm{PP}} + \right] + \,, + +and .. math:: - F_{ab}(\tau - \tau') - \equiv - \langle \mathcal{T} c_{a}(\tau) c_{b}(\tau') \rangle - = - \langle \mathcal{T} a(\tau) b(\tau') \rangle - \,, + \chi^{\mathrm{t}} + = + \chi^{(0), \mathrm{PP}} + + + \frac{1}{2} + \chi^{(0), \mathrm{PP}} + \mathbf{\Gamma}^{\mathrm{t}} + \left[ + \chi^{\mathrm{t}} + + + \chi^{(0), \mathrm{PP}} + \right] + \,. + +A transition from the normal state to a singlet/triplet superconducting one occurs +when the susceptibilties diverge. +This is the case, when the largest eigenvalue of +:math:`\mp \frac{1}{2}\mathbf{\Gamma^{\mathrm{s/t}}} \mathbf{\chi}^{(0),{PP}}` becomes unity. +For a largest eigenvalues that is smaller than :math:`1` we are still in the +normal state, +but we can calculate the corresponding eigenvectors :math:`\Delta^{\mathrm{s/t}}`. +This corresponds to the following eigenvalue equation .. math:: - \bar{F}_{\bar{a}\bar{b}}(\tau - \tau') - \equiv - \langle \mathcal{T} c^\dagger_{a}(\tau) c^\dagger_{\bar{b}}(\tau') \rangle - = - \langle \mathcal{T} \bar{a}(\tau) \bar{b}(\tau') \rangle\,. - -Fourier transforming to Matsubara frequency space then gives that + \lambda\Delta^{\mathrm{s/t}}_{\bar{a}\bar{b}}(K) + = + \frac{1}{2N_{\mathbf{k}}^2 \beta^2}\sum_{K', K''} + \Gamma^{\mathrm{s/t}}_{c\bar{a}d\bar{b}}(Q=0, K, K') + \chi^{(0),{PP}}_{\bar{f}d\bar{e}c}(Q=0, K', K'') + \Delta^{\mathrm{s/t}}_{\bar{e}\bar{f}}(K')\,. + :label: linearized_eliashberg_2 + \,, + +where we incorporate the minus sign of the singlet channel in our definition of the +singlet irreducible vertex to only keep track of one version of the Eliashberg equation. + +We can write this like Eq. :eq:`linearized_eliashberg_1` by using the definiton +of :math:`\chi^{(0),{PP}}` .. math:: - \bar{G}_{\bar{a}b}(\mathbf{k}, i\nu_n) = [ G_{b\bar{a}}(-\mathbf{k}, -i\nu_n) ]^{*} - \\ - \bar{F}_{\bar{a}\bar{b}}(\mathbf{k}, i\nu_n) = [ F_{ba}(-\mathbf{k}, -i\nu_n) ]^{*} - -Dyson-Gorkov Equations ----------------------- + \chi^{(0),{PP}}_{\bar{a}b\bar{c}d}(Q=0, K, K') + = + -N_{\mathbf{k}} \beta + G_{d\bar{a}}(K)G_{b\bar{c}}(-K')\delta_{K, K'}\,, + :label: chi_0_pp -The former properties of a superconductor are given by the Dyson-Gorkov equations +which yields .. math:: - \mathbf{G}(\mathbf{k}, i\nu_n) - = - \mathbf{G}^{(0)}(\mathbf{k}, i\nu_n) - + \mathbf{G}^{(0)}(\mathbf{k}, i\nu_n) - \ast \mathbf{\Sigma}(\mathbf{k}, i\nu_n) - \ast \mathbf{G}(\mathbf{k}, i\nu_n) - -.. math:: - \mathbf{G} \equiv - \left[ \begin{array}{cc} - G_{a\bar{b}} & F_{ab} \\ - \bar{F}_{\bar{a}\bar{b}} & \bar{G}_{\bar{a}b} \\ - \end{array} \right] - \quad - \mathbf{G}^{(0)} - \equiv - \left[ \begin{array}{cc} - G^{(0)}_{a\bar{b}} & 0 \\ - 0 & \bar{G}^{(0)}_{\bar{a}b} \\ - \end{array} \right] - \quad - \mathbf{\Sigma} - \equiv - \left[ \begin{array}{cc} - \Sigma_{a\bar{b}} & \Delta_{ab} \\ - \bar{\Delta}_{\bar{a}\bar{b}} & \bar{\Sigma}_{\bar{a}b} \\ - \end{array} \right] - -In component form this becomes, + \lambda\Delta^{\mathrm{s/t}}_{\bar{a}\bar{b}}(K)= -\frac{1}{2 N_{\mathbf{k}}\beta}\sum_{K'} + \Gamma^{\mathrm{s/t}}_{c\bar{a}d\bar{b}}(Q=0, K, K') + G_{c\bar{f}}(K')G_{d\bar{e}}(-K') + \Delta^{\mathrm{s/t}}_{\bar{e}\bar{f}}(K')\,. + :label: linearized_eliashberg_3 -.. math:: - G(a\bar{b}) = G^{(0)}(a\bar{b}) + G^{(0)}(a\bar{c})\Sigma(\bar{c}d)G(d\bar{b}) + - G^{(0)}(a\bar{c})\bar{\Delta}(\bar{c}\bar{d})\bar{F}(\bar{d}\bar{b}) +.. note:: + Our definiton of :math:`\chi^{(0),{PP}}` is different from [#bickers]_ + and [#nourafkan]_. This stems from the fact, that due to the indistinguishability + of the particles in the particle-particle channel doublecounting diagrams in the + Bethe-Salpeter equation (BSE) must be avoided. + We do this by defining the particle-particle BSE with a factor of + :math:`\frac{1}{2}`, see :ref:`vertex` Eq. :eq:`BSE_PP`. + In [#bickers]_ and [#nourafkan]_ the particle-particle BSE is defined without this + factor and they include it in their definiton of :math:`\chi^{(0),{PP}}`. + +This equation is valid for :math:`\lambda \leq 1` +and yields eigenvectors, which correspond to superconducting gap functions +that have not manifested yet. +At :math:`\lambda=1` the normal state breaks down and the superconducting +state with the corresponding gap emerges. +The size of the eigenvalues is therefore an indicator of how likely the associated gap +is to manifest. + +Relation to the BCS gap equation +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +In BCS theory the particle-particle vertex is considered to be +constant in a specific frequency range, which corresponds to gaps with +the same dependence. +For this case the summation over fermionic Matsubara frequencies in the linearized +Eliashberg equation Eq. :eq:`linearized_eliashberg_1` can be done analytically. +For a one-band case and a non-interacting Green's function with dispersion relation +:math:`\epsilon`, this yields .. math:: - \bar{G}(\bar{a}b) = \bar{G}^{(0)}(\bar{a}b) + \bar{G}^{(0)}(\bar{a}c)\bar{\Sigma}(c\bar{d})\bar{G}(\bar{d}b) + - \bar{G}^{(0)}(\bar{a}c)\Delta(cd)F(db) + \Delta^{\mathrm{s/t}}(\mathbf{k}) = -\frac{1}{2 N_{\mathbf{k}}}\sum_{\mathbf{k'}} + \Gamma^{\mathrm{s/t}}(\mathbf{q}=\mathbf{0}, \mathbf{k}, \mathbf{k'}) + \frac{\tan(\epsilon(\mathbf{k'})\beta/2)}{2\epsilon(\mathbf{k'})} + \Delta^{\mathrm{s/t}}(\mathbf{k'})\,, + :label: linearized_eliashberg_4 -.. math:: - F(ab) = G^{(0)}(a\bar{c}) \Sigma(\bar{c}d) F(db)+ - G^{(0)}(a\bar{c}) \bar{\Delta}(\bar{c}\bar{d}) \bar{G}(\bar{d}b) +which corresponds to the linearized BCS gap equation. +The non-linear BCS gap equation can be obtained from Eq. :eq:`linearized_eliashberg_4` +by substituting :math:`\epsilon` with +:math:`\sqrt{\epsilon(\mathbf{k})^2 + |\Delta(\mathbf{k})|^2}`. -.. math:: - \bar{F}(\bar{a}\bar{b}) = \bar{G}^{(0)}(\bar{a}c) \bar{\Sigma}(c\bar{d}) \bar{F}(\bar{d}\bar{b})+ - \bar{G}^{(0)}(\bar{a}c) \Delta(cd) G(d\bar{b}) -Here :math:`\Sigma` is the normal self-energy and :math:`\Delta` and :math:`\bar{\Delta}` the anomalous self-energies, which are equal in the absence of a magnetic field and will be treated as from now on. +Details for applications +------------------------ -Anomalous self-energy and particle-particle vertex --------------------------------------------------- +SPOT Condition +^^^^^^^^^^^^^^ -.. note:: - Define :math:`\Gamma`. It should be the particle-particle vertex :math:`\Gamma^{(pp)}` related to the generalized susceptibility :math:`\chi` through the Bethe-Salpeter equation in the particle-particle channel. This would give the definition of the four orbital(spin) indices and their order. - -The anomalous self-energy can be expressed with the effective pairing interaction :math:`\Gamma` and the anomalous Green's function :math:`F` as +In the general case the superconducting gap function :math:`\Delta` is dependent on +momentum :math:`\mathbf{k}`, fermionic Matsubara frequency :math:`i\nu_n`, +orbital-indices :math:`a,b` and spin-indices :math:`\alpha,\beta` .. math:: - \Delta_{\bar{a}\bar{b}}(\mathbf{k},i\nu) = -\frac{1}{N_k \beta}\sum_{\mathbf{q}} \sum_{i\nu'} - \Gamma_{A\bar{a}\bar{b}B}(\mathbf{k}-\mathbf{q}, i\nu - i\nu') F_{AB}(\mathbf{q}, i\nu')\,. - :label: anom_self_energy + \Delta \equiv \Delta_{a\alpha;b\beta}(i\nu, \mathbf{k})\,. -Linearization in :math:`\Delta` -------------------------------- - -Around the transition point to the superconducting state the anomalous self-energy :math:`\Delta` is approximately zero, and, because we are only interested in the transition point, we linearize :math:`F` in the Dyson-Gorkov equations with respect to :math:`\Delta`. This yields +Because the Pauli principle dictates :math:`\Delta` to be odd under particle exchange, +the symmetry combinations of those four degrees of freedom are constrained. +This is formalized as the so called :math:`SPOT` condition .. math:: - F & = g \Sigma F + g \Delta \bar{G} \\ - G & = g + g \Sigma G + g \Delta \bar{F} + \hat{S}\hat{P}\hat{O}\hat{T} \Delta_{a\alpha;b\beta}(i\nu, \mathbf{k}) + = + - \Delta_{b\beta;a\alpha}(-i\nu, -\mathbf{k})\,, + +with the operators :math:`\hat{S}`, :math:`\hat{P}`, :math:`\hat{O}`, :math:`\hat{T}`, +that denote permutation of electrons in spin space (:math:`\hat{S}`), +real space (parity) (:math:`\hat{P}`), +orbital space (:math:`\hat{O}`), and time (frequency) (:math:`\hat{T}`). +While :math:`\Delta` has to be odd under the combined action of the symmetry operations +:math:`\hat{S}\hat{P}\hat{O}\hat{T}`, +it can either be even (:math:`+`) or odd (:math:`-`) under each separate operation, +i.e. .. math:: - F & = (g^{-1} - \Sigma)^{-1} \Delta \bar{G} \\ - \bar{G} & = (\bar{g}^{-1} - \Sigma)^{-1} + \bar{\Delta} F + \hat{S}\Delta_{a\alpha;b\beta}(i\nu, \mathbf{k}) + &= + \pm \Delta_{a\beta;b\alpha}(i\nu, \mathbf{k})\,,\\ + \hat{P}\Delta_{a\alpha;b\beta}(i\nu, \mathbf{k}) + &= + \pm \Delta_{a\alpha;b\beta}(i\nu, -\mathbf{k})\,,\\ + \hat{O}\Delta_{a\alpha;b\beta}(i\nu, \mathbf{k}) + &= + \pm \Delta_{b\alpha;a\beta}(i\nu, \mathbf{k})\,,\\ + \hat{T}\Delta_{a\alpha;b\beta}(i\nu, \mathbf{k}) + &= + \pm \Delta_{a\alpha;b\beta}(-i\nu, \mathbf{k})\,. + +A gap function can therefore be classified as even (:math:`+`) or odd (:math:`-`) +under these four degrees of freedom. By calculating the superconducting gap in the +singlet/triplet channel, we fix the spin symmetry to odd/even respectively. +This leaves us with four symmetry combinations for both singlet and triplet gaps, +which we list in the table below. + +.. table:: + :align: center + + +-----------------------------------------------+-----------------------------------------------+ + | Spin-singlet | Spin-triplet | + +===========+===========+===========+===========+===========+===========+===========+===========+ + | S | P | O | T | S | P | O | T | + +-----------+-----------+-----------+-----------+-----------+-----------+-----------+-----------+ + | :math:`-` | :math:`+` | :math:`+` | :math:`+` | :math:`+` | :math:`-` | :math:`-` | :math:`-` | + +-----------+-----------+-----------+-----------+-----------+-----------+-----------+-----------+ + | :math:`-` | :math:`-` | :math:`-` | :math:`+` | :math:`+` | :math:`+` | :math:`+` | :math:`-` | + +-----------+-----------+-----------+-----------+-----------+-----------+-----------+-----------+ + | :math:`-` | :math:`-` | :math:`+` | :math:`-` | :math:`+` | :math:`+` | :math:`-` | :math:`+` | + +-----------+-----------+-----------+-----------+-----------+-----------+-----------+-----------+ + | :math:`-` | :math:`+` | :math:`-` | :math:`-` | :math:`+` | :math:`-` | :math:`+` | :math:`+` | + +-----------+-----------+-----------+-----------+-----------+-----------+-----------+-----------+ + +Because all other combinations are unphysical it is possible to restrict the gap to the +allowed symmetries while solving the linearized Eliashberg equation. + +.. _eliashberg_rpa: + +Random phase approximation for the irreducible particle-particle vertex +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The irreducible particle-particle vertex is given by the parquet equation, +which can be expressed in terms of the fully irreducible vertex :math:`\Lambda` +and the channel reducible vertex ladder functions :math:`\Phi`. +It is given in the singlet channel by .. math:: - F = (g^{-1} - \Sigma)^{-1} \Delta (\bar{g}^{-1} - \bar{\Sigma})^{-1} + \mathcal{O}(\Delta^2) - :label: lin_anom_gf - -We then insert :eq:`lin_anom_gf` into :eq:`anom_self_energy` and obtain the linearized Eliashberg equation + \Gamma^{\text{s}}_{a\overline{b}c\overline{d}}(Q, K, K') =& + - + \Lambda^{\text{s}}_{a\overline{b}c\overline{d}}(Q, K, K') + + + \left[ + \frac{3}{2} + \Phi^{\text{m}}_{a\overline{b}c\overline{d}} + - + \frac{1}{2} + \Phi^{\text{d}}_{a\overline{b}c\overline{d}} + \right](Q-K-K', K, K') + \\ + &+ + \left[ + \frac{3}{2} + \Phi^{\text{m}}_{c\overline{b}a\overline{d}} + - + \frac{1}{2} + \Phi^{\text{d}}_{c\overline{b}a\overline{d}} + \right](K-K', Q-K, K') + :label: singlet_gamma_no_approx + +and in the triplet channel by .. math:: - \Delta_{\bar{a}\bar{b}}(\mathbf{k},i\nu) = -\frac{1}{N_k \beta}\sum_{\mathbf{q}} \sum_{i\nu'} - \Gamma_{A\bar{a}\bar{b}B}(\mathbf{k}-\mathbf{q}, i\nu - i\nu') - \\ \times - \big({G^{(0)}}^{-1}(\mathbf{q}, i\nu') - \Sigma(\mathbf{q}, i\nu') \big)^{-1}_{A\bar{c}} - \Delta_{\bar{c}\bar{d}}(\mathbf{q}, i\nu') - \big({G^{(0)}}^{-1}_{}(-\mathbf{q}, -i\nu') - \Sigma_{}(-\mathbf{q}, -i\nu') \big)^{-1}_{B\bar{d}}\,. - -To make use of this equations it is usually interpreted as an eigenvalue equation + \Gamma^{\text{t}}_{a\overline{b}c\overline{d}}(Q, K, K') =& + \Lambda^{\text{t}}_{a\overline{b}c\overline{d}}(Q, K, K') + + + \left[ + \frac{1}{2} + \Phi^{\text{m}}_{a\overline{b}c\overline{d}} + + + \frac{1}{2} + \Phi^{\text{d}}_{a\overline{b}c\overline{d}} + \right](Q-K-K', K, K') + \\ + &+ + \left[ + - + \frac{1}{2} + \Phi^{\text{m}}_{c\overline{b}a\overline{d}} + - + \frac{1}{2} + \Phi^{\text{d}}_{c\overline{b}a\overline{d}} + \right](K-K', Q-K, K') + \,, + :label: triplet_gamma_no_approx + +with the spin diagonalized reducible vertex ladder functions given by .. math:: - \lambda \Delta = \Lambda \Delta\,, - -where the eigenvalue :math:`\lambda` is seen as a measurement for the strength of superconducting ordering and a phase transition occurs when it reaches unity. + \Phi^{\text{d/m}}_{a\overline{b}c\overline{d}}(Q, K, K') + = + \frac{1}{(N_\mathbf{k}\beta)^2} + \sum_{K'', K'''} + \Gamma^{\text{d/m}}(Q, K, K'') \chi^{\text{d/m}}(Q, K'', K''') \Gamma^{\text{d/m}}(Q, K''', K') + \,. -RPA Approach ------------- - -.. note:: - Explain what happens with momenta +Note, that the superscripts :math:`\mathrm{d/m}` indicate the density/magnetic channel. -The linearized Eliashberg equation can be studied in the RPA limit. -In this case the normal self-energy is set to zero and the effective pairing interaction :math:`\Gamma` for a singlet Cooper pairs is given by +Now, in the random phase approximation (RPA) the susceptibilities :math:`\chi^{\text{d/m}}` +are approximated by the RPA bubble susceptibility, +and all vertices are substituted by the local and static bare Kanamori interaction :math:`U^{\mathrm{d/m}}`, +given by .. math:: - \Gamma^{(\mathrm{singlet})}(a\bar{b}c\bar{d}) = - \frac{3}{2} U^{(\mathrm{s})}(a\bar{b}A\bar{B}) \chi^{(\mathrm{s})}(\bar{B}A\bar{C}D) - U^{(\mathrm{s})}(D\bar{C}c\bar{d}) \\ - -\frac{1}{2} U^{(\mathrm{c})}(a\bar{b}A\bar{B}) \chi^{(\mathrm{c})}(\bar{B}A\bar{C}D) - U^{(\mathrm{c})}(D\bar{C}c\bar{d}) \\ - + \frac{1}{2}\big(U^{(\mathrm{s})}(a\bar{b}c\bar{d})+ - U^{(\mathrm{c})}(a\bar{b}c\bar{d})\big)\,, + U^{\mathrm{d/m}}_{a\bar{b}c\bar{d}} = + \begin{cases} + U/U, & \mathrm{if}\;a=\bar{b}=c=\bar{d} \\ + -U'+2J/U', & \mathrm{if}\;a=\bar{d}\neq \bar{b}=c \\ + 2U'-J/J, & \mathrm{if}\;a=\bar{b}\neq c=\bar{d} \\ + J/J, & \mathrm{if}\;a=c\neq \bar{b}=\bar{d} \\ + 0, & \mathrm{else} + \end{cases}\,, -and for a triplet by +with the Hubbard interaction :math:`U` and the Hund's :math:`J`. +The reducible ladder vertices then beceome only dependent on one bosonic Frequence and +momentum pair :math:`Q` .. math:: - \Gamma^{(\mathrm{triplet})}(a\bar{b}c\bar{d}) = - -\frac{1}{2} U^{(\mathrm{s})}(a\bar{b}A\bar{B}) \chi^{(\mathrm{s})}(\bar{B}A\bar{C}D) - U^{(\mathrm{s})}(D\bar{C}c\bar{d}) \\ - -\frac{1}{2} U^{(\mathrm{c})}(a\bar{b}A\bar{B}) \chi^{(\mathrm{c})}(\bar{B}A\bar{C}D) - U^{(\mathrm{c})}(D\bar{C}c\bar{d}) \\ - + \frac{1}{2}\big(U^{(\mathrm{s})}(a\bar{b}c\bar{d})+ - U^{(\mathrm{c})}(a\bar{b}c\bar{d})\big)\,. - -Here :math:`\chi^{(\mathrm{s})}` is the spin-susceptibility tensor defined by + \Phi^{\text{d/m}}_{a\overline{b}c\overline{d}}(Q) + &\approx + \frac{1}{(N_\mathbf{k}\beta)^2} + \sum_{K'', K'''} + U^{\text{d/m}}\chi^{\text{d/m}}(Q, K'', K''') U^{\text{d/m}} + \\ + &\approx + U^{\mathrm{d/m}} + \chi^{\text{d/m}}(Q) U^{\mathrm{d/m}} + \,, + +and the fully irreducible vertices become .. math:: - \chi^{(\mathrm{s})}(\bar{a}b\bar{c}d) = \big(\mathbb{1} - \chi^{(0)}(\bar{a}b\bar{A}B) - U^{(\mathrm{s})}(B\bar{A}C\bar{D})\big)^{-1} \chi^{(0)}(\bar{D}C\bar{c}d)\,, - -and :math:`\chi^{(\mathrm{c})}` is the charge-susceptibility tensor defined by + \Lambda^{\mathrm{s}} + \approx + - + \frac{1}{2}U^{\mathrm{d}} + - + \frac{3}{2}U^{\mathrm{m}} + \,, .. math:: - \chi^{(\mathrm{c})}(\bar{a}b\bar{c}d) = \big(\mathbb{1} + \chi^{(0)}(\bar{a}b\bar{A}B) - U^{(\mathrm{c})}(B\bar{A}C\bar{D})\big)^{-1} \chi^{(0)}(\bar{D}C\bar{c}d)\,, - -here :math:`\chi^{(0)}` is the non-interacting particle-hole bubble. + \Lambda^{\mathrm{t}} + \approx + - + \frac{1}{2}U^{\mathrm{d}} + + + \frac{1}{2}U^{\mathrm{m}} + \,. -The spin and charge interaction tensors are given by +In this approximation the irreducible singlet/triplet vertex for :math:`Q=0` takes the form .. math:: - U^{(\mathrm{s})}(a\bar{a}b\bar{b}) = - \begin{cases} - U, & \mathrm{if}\;a=\bar{a}=b=\bar{b} \\ - U', & \mathrm{if}\;a=\bar{b}\neq \bar{a}=b \\ - J, & \mathrm{if}\;a=\bar{a}\neq b=\bar{b} \\ - J', & \mathrm{if}\;a=b\neq \bar{a}=\bar{b} \\ - 0, & \mathrm{else} - \end{cases} - + \Gamma^{\text{s}}_{a\overline{b}c\overline{d}}(Q=0, K, K') =& + \frac{1}{2}U_{a\overline{b}c\overline{d}}^{\mathrm{d}} + + + \frac{3}{2}U_{a\overline{b}c\overline{d}}^{\mathrm{m}} + + + \left[ + \frac{3}{2} + \Phi^{\text{m}}_{a\overline{b}c\overline{d}} + - + \frac{1}{2} + \Phi^{\text{d}}_{a\overline{b}c\overline{d}} + \right](-K-K') + \\ + &+ + \left[ + \frac{3}{2} + \Phi^{\text{m}}_{c\overline{b}a\overline{d}} + - + \frac{1}{2} + \Phi^{\text{d}}_{c\overline{b}a\overline{d}} + \right](K-K') + \,, + :label: singlet_gamma + +and .. math:: - U^{(\mathrm{c})}(a\bar{a}b\bar{b}) = - \begin{cases} - U, & \mathrm{if}\;a=\bar{a}=b=\bar{b} \\ - -U'+2J, & \mathrm{if}\;a=\bar{b}\neq \bar{a}=b \\ - 2U'-J, & \mathrm{if}\;a=\bar{a}\neq b=\bar{b} \\ - J', & \mathrm{if}\;a=b\neq \bar{a}=\bar{b} \\ - 0, & \mathrm{else} - \end{cases} + \Gamma^{\text{t}}_{a\overline{b}c\overline{d}}(Q=0, K, K') =& + - + \frac{1}{2}U_{a\overline{b}c\overline{d}}^{\mathrm{d}} + + + \frac{1}{2}U_{a\overline{b}c\overline{d}}^{\mathrm{m}} + + + \left[ + \frac{1}{2} + \Phi^{\text{m}}_{a\overline{b}c\overline{d}} + + + \frac{1}{2} + \Phi^{\text{d}}_{a\overline{b}c\overline{d}} + \right](-K-K') + \\ + &+ + \left[ + - + \frac{1}{2} + \Phi^{\text{m}}_{c\overline{b}a\overline{d}} + - + \frac{1}{2} + \Phi^{\text{d}}_{c\overline{b}a\overline{d}} + \right](K-K') + \,. + :label: triplet_gamma + +Note, that in both the singlet :eq:`singlet_gamma` and the triplet vertex +:eq:`triplet_gamma` the density and magnetic ladder vertices +:math:`\Phi^{\text{d/m}}` appear twice. Once with an index flip and with a :math:`K-K'` +dependence, :math:`\Phi_{c\overline{b}a\overline{d}}(K-K')`, and once without an index flip +and a :math:`-K-K'` dependence, :math:`\Phi_{a\overline{b}c\overline{d}}(-K-K')`. +In the linearized Eliashberg equation :eq:`linearized_eliashberg_3` those two terms can be +transformed into each other by abiding the frequency, momentum and orbital +symmetry of the gap. +For example :math:`\Phi_{a\overline{b}c\overline{d}}(-K-K')` transforms into +:math:`\pm\Phi_{c\overline{b}a\overline{d}}(K'-K)=\pm\Phi^*_{c\overline{b}a\overline{d}}(K-K')` +for a singlet/triplet gap. +We can therefore write Eq. :eq:`singlet_gamma` and :eq:`triplet_gamma` as -where :math:`U`, :math:`U'`, :math:`J` and :math:`J'` are the usual Kanamori interaction parameters. +.. math:: + \Gamma^{\text{s}}_{a\overline{b}c\overline{d}}(Q=0, K, K') \equiv + \frac{1}{2}U_{a\overline{b}c\overline{d}}^{\mathrm{d}} + + + \frac{3}{2}U_{a\overline{b}c\overline{d}}^{\mathrm{m}} + + + \Re + \left[ + 3 + \Phi^{\text{m}}_{c\overline{b}a\overline{d}}(K-K') + - + \Phi^{\text{d}}_{c\overline{b}a\overline{d}}(K-K') + \right] + \,, + :label: singlet_gamma_2 +.. math:: + \Gamma^{\text{t}}_{a\overline{b}c\overline{d}}(Q=0, K, K') \equiv + - + \frac{1}{2}U_{a\overline{b}c\overline{d}}^{\mathrm{d}} + + + \frac{1}{2}U_{a\overline{b}c\overline{d}}^{\mathrm{m}} + + + \Re + \left[ + - + \Phi^{\text{m}}_{c\overline{b}a\overline{d}}(K-K') + - + \Phi^{\text{d}}_{c\overline{b}a\overline{d}}(K-K') + \right] + \,. + :label: triplet_gamma_2 + +Note, that this simplification is only allowed if the solutions of :math:`\Delta^{\mathrm{s/t}}` +are restricted to the allowed symmetries, otherwise unphysical solutions can occur. +Also note, that the RPA particle-particle vertices in +Eq. :eq:`singlet_gamma_2` and :eq:`triplet_gamma_2` only depend on the difference +between the two fermionic Matsubara frequencies, i.e. a bosonic Matsubara frequency and one momentum. +We can therefore write the linearized Eliashberg equation +:eq:`linearized_eliashberg_3` as +.. math:: + \lambda\Delta^{\mathrm{s/t}}_{\bar{a}\bar{b}}(K)= -\frac{1}{2 N_{\mathbf{k}}\beta}\sum_{K'} + \Gamma^{\mathrm{s/t}}_{c\bar{a}d\bar{b}}(K-K') + G_{c\bar{f}}(K')G_{d\bar{e}}(-K') + \Delta^{\mathrm{s/t}}_{\bar{e}\bar{f}}(K')\,, + :label: linearized_eliashberg_5 +which is the **form it is implemented as now** in :meth:`triqs_tprf.eliashberg.solve_eliashberg`. + +This allows us to get rid of the summation by using the convolution theorem +.. math:: + \lambda + \mathcal{F}\left[\Delta_{\bar{a}\bar{b}}^{\mathrm{s/t}}(K)\right]= -\frac{1}{2} + \mathcal{F}\left[\Gamma_{c\bar{a}d\bar{b}}^{\mathrm{s/t}}(K-K')\right] + \mathcal{F}\left[ + G_{c\bar{f}}(K')G_{d\bar{e}}(-K') + \Delta_{\bar{e}\bar{f}}^{\mathrm{s/t}}(K') + \right]\,, + :label: linearized_eliashberg_5 + +making the calculation computationaly more efficient for large numbers of frequencies +and momenta. +But note, that for small numbers of frequencies and/or momenta using the sum +instead of the convolution theorem can be more effecient. +.. note:: + It is possible to expand the current implementation of the Eliashberg equation to + also allow for irreducible vertices to be explicitly dependent on two fermionic + frequency and momenta pairs. + For an idea on how to tackle such a task see the following draft + `here `_ + and + `here `_. + + +.. rubric:: References + +.. [#abrikosov] A. A. Abrikosov, L. P. Gor’kov, and I. E. Dzyaloshinski, Pergamon, Oxford (1965) +.. [#yanase] Y. Yanase, T. Jujo, T. Nomura, et. al., Physics Reports 387, 1-149 (2003) +.. [#takimoto] T. Takimoto, T. Hotta, and K. Ueda, PRB 69, 104504 (2004) +.. [#bickers] N. E. Bickers, Self-Consistent Many-Body Theory for Condensed Matter Systems. Theoretical Methods for Strongly Correlated Electrons, 237–296. 6 (2006) +.. [#rohringer] G. Rohringer, New routes towards a theoretical treatment of nonlocal electronic correlations (2013) +.. [#nourafkan] R. Nourafkan, G. Kotliar, and A. M. Tremblay, Physical Review Letters 117, 1, (Supplementary) (2016) +.. [#linder] J. Linder and A. V. Balatsky, Reviews of Modern Physics 91, 45005 (2019) diff --git a/doc/theory/notation.rst b/doc/theory/notation.rst index 1d82b498..f2dd8147 100644 --- a/doc/theory/notation.rst +++ b/doc/theory/notation.rst @@ -278,6 +278,7 @@ Crossed-Particle-particle channel (:math:`PPx`) \chi^{(0), pp}_{\bar{a}b\bar{c}d}(\omega, \nu, \nu') = - \beta \delta_{\nu, \nu'} G_{d\bar{a}}(\nu) G_{b\bar{c}}(\omega - \nu) + :label: bare_pp_sus_def .. math:: \chi^{pp}_{\bar{a}b\bar{c}d}(\omega, \nu, \nu') diff --git a/doc/user_guide/Linearized Eliashberg equation on the attractive Hubbard model.ipynb b/doc/user_guide/Linearized Eliashberg equation on the attractive Hubbard model.ipynb new file mode 100644 index 00000000..0b2f1314 --- /dev/null +++ b/doc/user_guide/Linearized Eliashberg equation on the attractive Hubbard model.ipynb @@ -0,0 +1,861 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Starting run with 1 MPI rank(s) at : 2020-08-18 10:41:49.147374\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "import numpy as np\n", + "\n", + "from triqs.plot.mpl_interface import plt\n", + "from triqs_tprf.tight_binding import create_square_lattice\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "plt.style.use('notebook.mplstyle')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Linearized Eliashberg equation on the attractive Hubbard model\n", + "\n", + "A simple example for the usage of the linearized Eliashberg equation is the attractive Hubbard model on a square lattice.\n", + "It is not only fast and simple to setup, but the particle-hole symmetry of the Hubbard model also serves as a benchmark for the correctness of such a calculation.\n", + "\n", + "In the following we will first introduce the Hubbard model and present the semi particle-hole transformation and its usage.\n", + "Then we will show how to solve the linearized Eliashberg equation for this model to find the superconducting phase transition using TRIQS and TPRF routines.\n", + "\n", + "If you want a more detailed study of this problem, checkout this [notebook](https://github.com/TRIQS/tprf/blob/eliashberg/benchmark/eliashberg/particle_hole_transformation/PHT_Hubbard_Model.ipynb)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hubbard model on a square lattice\n", + "\n", + "The particle-hole symmetric Hamiltonian for the Hubbard model is given by\n", + "\n", + "$$\n", + "H=-t \\sum_{\\langle j, l\\rangle \\sigma}\\left(c_{j \\sigma}^{\\dagger} c_{l \\sigma}+c_{l \\sigma}^{\\dagger} c_{j \\sigma}\\right)+U \\sum_{j}\\left(n_{j \\uparrow}-\\frac{1}{2}\\right)\\left(n_{j \\downarrow}-\\frac{1}{2}\\right)-\\mu \\sum_{j}\\left(n_{j \\uparrow}+n_{j \\downarrow}\\right)\\,,\n", + "$$\n", + "\n", + "here $c_{j\\sigma}^{\\dagger}$ creates an electron on site $j$ with spin $\\sigma$ while $c_{j\\sigma}$ destroys such an electron, further the operator $n_{j\\sigma}$ count the number of electrons on site $j$ with spin $\\sigma$.\n", + "\n", + "The first term describes the kinetic energy of the electrons, which can be interpreted as an electron with spin $\\sigma$ *hopping* from site $l$ to site $j$ and vice versa.\n", + "Here the angular braket under the sum means that we only take *hopping* terms between neighboring lattice sites into account and the energy that is gained by such a *hopping* process is given by $t$.\n", + "\n", + "The second term describes the repulsive interaction between the electrons.\n", + "This repulsion is crudely approximated in the Hubbard model in the sense, that electrons only *see* each other if they occupy the same lattice site.\n", + "The energy that is needed to have a lattice site doubly occupied is given by $U$.\n", + "\n", + "The last term describes the filling of the lattice via an energy offset by the chemical potential $\\mu$.\n", + "\n", + "The Hubbard model is therefore defined by the parameters $t$, $U$ and $\\mu$, but we also need to know the temperature $T$ at which we shall observe the Hubbard model.\n", + "We will record these parameters using the `ParameterCollection` class of `triqs_tprf.ParameterCollection` module." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "T = 1000\n", + "U = 1.0\n", + "mu = 0.0\n", + "nk = 32\n", + "norb = 1\n", + "nw = 50\n", + "spin = False\n", + "t = 1.0" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from triqs_tprf.ParameterCollection import ParameterCollection\n", + "\n", + "hubbard = ParameterCollection( # -- Model Parameter\n", + " norb=1, # Number of orbitals.\n", + " t=1.0, # Hopping to nearest neighbor\n", + " U=1.0, # Strength of the on-site interaction\n", + " mu=0.0, # Chemical potential determining the filling.\n", + " T=1000, # Temperature.\n", + " spin=False, # Treat indices only for orbital character.\n", + " \n", + " # -- Technical parameter\n", + " nk=32, # Number of points in one dimension considered in the Brillouin zone.\n", + " nw=50, # Number of Matsubara points in positive dimension.\n", + " )\n", + "hubbard" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Semi particle-hole transformation\n", + "\n", + "The Hubbard model with only nearest neighbor hopping inhibts a useful semi particle-hole symmetry, which we will present without any rigorous derivations.\n", + "\n", + "First off, a bipartite lattice can be subdivided into two sublattices for which every lattice site on one of them only has neighboring sites from the other sublattice. This is the case for our square lattice.\n", + "With this knowledge we can define the particle-hole transformation (PHT) for the creation and annihilation operators as \n", + "\n", + "$$\n", + "c^\\dagger_{j \\sigma} \\xrightarrow{\\mathrm{PHT}} (-1)^{j} d_{j \\sigma} \\,,\\quad\n", + "\\mathrm{and}\\quad\n", + "c_{j \\sigma} \\xrightarrow{\\mathrm{PHT}}(-1)^{j}d_{j \\sigma}^{\\dagger}\\,,\\\\\n", + "$$\n", + "\n", + "where $j$ is either $0$ for one sublattice and $1$ for the other.\n", + "\n", + "If we use the PHT only on one spin specices it is called a semi particle-hole transformation (SPHT).\n", + "This means\n", + "\n", + "$$\n", + "c_{j \\uparrow}^{\\dagger} \\xrightarrow{\\mathrm{SPHT}} d_{j \\uparrow}^{\\dagger}\\quad\\mathrm{and}\\quad\n", + "c_{j \\uparrow} \\xrightarrow{\\mathrm{SPHT}} d_{j \\uparrow}\\\\\n", + "c_{j \\downarrow}^{\\dagger} \\xrightarrow{\\mathrm{SPHT}} (-1)^j d_{j \\downarrow}\\quad\\mathrm{and}\\quad\n", + "c_{j \\downarrow} \\xrightarrow{\\mathrm{SPHT}} (-1)^j d_{j \\downarrow}^{\\dagger}\\,,\n", + "$$\n", + "\n", + "and for the number operators\n", + "\n", + "$$\n", + "n_{j \\uparrow}\\xrightarrow{\\mathrm{SPHT}} \\tilde{n}_{j \\uparrow}\n", + "\\quad\\mathrm{and}\\quad\n", + "n_{j \\downarrow} \\xrightarrow{\\mathrm{SPHT}} 1-\\tilde{n}_{j \\downarrow}\\,.\n", + "$$\n", + "\n", + "One can convince themselves, that the kinetic part of the Hubbard model on a square lattice with only nearest neighbor hopping is invariant under a SPHT.\n", + "The interaction term on the other hand is not and changes sign\n", + "\n", + "$$\n", + "\\left(n_{j \\uparrow}-\\frac{1}{2}\\right)\\left(n_{j \\downarrow}-\\frac{1}{2}\\right) \\xrightarrow{\\mathrm{SPHT}}\n", + "-\\left(\\tilde{n}_{j \\uparrow} - \\frac{1}{2}\\right)\\left(\\tilde{n}_{j \\downarrow}-\\frac{1}{2}\\right)\\,.\n", + "$$\n", + "\n", + "Therefore the SPHT maps the repulsive Hubbard model with $U$ to the attractive one with $-U$.\n", + "Additionally to that, if our Hubbard model is not a half-filling, the chemical potential term is also not invariant under a SPHT\n", + "\n", + "$$\n", + "n_{j \\uparrow}+n_{j \\downarrow} \\xrightarrow{\\mathrm{SPHT}}\n", + "1 + \\left(\\tilde{n}_{j \\uparrow}-\\tilde{n}_{j \\downarrow}\\right)\\,,\n", + "$$\n", + "\n", + "and transforms into a Zeeman term.\n", + "\n", + "To summarize the SPHT maps the Hubbard Hamiltonian with interaction strength $U$ and chemical potential $\\mu$ to a Hubbard Hamiltonian with interaction strength $-U$, a chemical potential of $0$ and an additional Zeeman term of strength $\\mu$.\n", + "If we therefore calculate an observable $A$ in the attractive Hubbard model we know the observable $B\\xleftarrow{\\mathrm{SPHT}}A$ in the repulsive one.\n", + "\n", + "For example, the in-plane antiferromagnetic (AFM) phase of the repulsive model is connected to the superconducting (SC) phase in the attractive one, as can be seen by using the SPHT on the ladder operators of the spin\n", + "\n", + "$$\n", + "S^+_j = S^x_j + iS^y_j = c_{j \\uparrow}^{\\dagger}c_{j \\downarrow} \\xrightarrow{\\mathrm{SPHT}} (-1)^j d_{j \\uparrow}^{\\dagger}d_{j \\downarrow}^{\\dagger} = \\tilde{\\Delta}^{\\dagger}\\,,\\\\\n", + "S^-_j = S^x_j - iS^y_j = c_{j \\downarrow}^{\\dagger}c_{j \\uparrow} \\xrightarrow{\\mathrm{SPHT}} (-1)^j d_{j \\downarrow}d_{j \\uparrow} = \\tilde{\\Delta}\\,.\n", + "$$\n", + "\n", + "The $x$- and $y$-components of the spin operator are transformed to the complex superconducting oder parameter with a phase factor.\n", + "This means, that if we find a staggered in-plane spin phase in the repulsive model at some $U$, we will see a homogeneous superconducting phase at $-U$.\n", + "\n", + "The following plot shows this symmetry in a T-U phase diagram, which was previously calculated [here](https://github.com/TRIQS/tprf/blob/eliashberg/benchmark/eliashberg/particle_hole_transformation/PHT_Hubbard_Model.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.core.display import SVG\n", + "\n", + "SVG(filename='./plots/SPHT_hubbard_phase_diagram.svg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The right hand side of the phase diagram was calculated using an attractive Hubbard model at half-filling, i.e. $\\mu=0.0$, with an additional Zeeman term of strength $\\xi$.\n", + "The phase boundary was then calculated using the random phase approximation (RPA), i.e. using a frequency independent and local vertex $U$, to calculate $\\langle S^xS^x \\rangle$ and increasing $U$ until divergence.\n", + "For details on how to use TPRF for that see this [tutorial](Square lattice susceptibility.ipynb#Random-phase-approximation-(RPA)).\n", + "\n", + "The left hand side of the phase diagram was calculated using an repulsive Hubbard model with $\\mu=\\xi$, i.e. the SPHT mapping of the right hand side model.\n", + "Then the linearized Eliashberg equation was solved for this model for various interaction strengths until the superconducting phase transition was found." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solving the linearized Eliashberg equation\n", + "\n", + "The linearized Eliashberg equation is given in a very simplified form by\n", + "\n", + "$$\n", + "\\lambda\\Delta = \\Lambda \\Delta\\,,\n", + "$$\n", + "\n", + "where $\\Delta$ is a gap function and $\\lambda$ the largest eigenvalue of the matrix $\\Lambda$.\n", + "Here $\\Lambda$ is the product of the particle-particle vertex $\\Gamma$ and the Green's function $G$.\n", + "If $\\lambda=1$ a phase transition to a superconducting state is found.\n", + "For further information see the documentation [here](../theory/eliashberg.rst).\n", + "\n", + "To solve it in the same order as the RPA we need the non-interacting Green's function $G^{(0)}$ and the (singlet) particle-particle vertex $\\Gamma$ is approximated by a fequency independent and local vertex $2U$.\n", + "\n", + "First we setup our model by using previously established `ParameterCollection` `hubbard` as a template and alter it to the parameters of the repulsive Hubbard model.\n", + "To do this use its method `alter` and supply the parameters that shall be changed as keywords.\n", + "We set the chemical potential to $\\mu=\\xi$ and the interaction strength to $U=-1.41$, which is close to the superconducting phase boundary for $T=1000\\,\\mathrm{K}$." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "T = 1000\n", + "U = -1.41\n", + "mu = 0.1\n", + "nk = 32\n", + "norb = 1\n", + "nw = 50\n", + "spin = False\n", + "t = 1.0" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xi = 0.1\n", + "\n", + "repl_hubbard = hubbard.alter(mu=xi, U=-1.41)\n", + "repl_hubbard" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To construct a representation of the kinetic part of the Hubbard model use the `create_square_lattice` function of the `triqs_tprf.tight_binding` module.\n", + "Give it as keywords the number of orbitals `norb` and the hopping energy `t`, which can comfortably be accessed from `repl_hubbard`.\n", + "It returns a `TBLattice` object." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "triqs_tprf.tight_binding.TBLattice" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from triqs_tprf.tight_binding import create_square_lattice\n", + "\n", + "H = create_square_lattice(norb=repl_hubbard.norb, t=repl_hubbard.t)\n", + "type(H)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get the dispersion relation, use its member function `on_mesh_brillouin_zone` and enter a mesh on the Brillouin zone as a tuple.\n", + "It returns the dispersion relation stored as a `Gf` object." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "triqs.gf.gf.Gf" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "e_k = H.on_mesh_brillouin_zone(n_k=(repl_hubbard.nk, repl_hubbard.nk, 1))\n", + "type(e_k)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the dispersion relation we can construct the non-interacting Green's function.\n", + "To do this first create a `MeshImFreq` object with a fermionic statistic and the wished inverse temperature $\\beta$ and number of points.\n", + "Then use the `lattice_dyson_g0_wk` function of the `triqs_tprf.lattice` module and supply it with the dispersion relation, the `MeshImFreq` object and a chemical potential.\n", + "This yields the non-interacting Green's function as a `Gf` object.\n", + "(You can use the `temperature_to_beta` function of the `triqs_tprf.utilities` to calculate the inverse temperature in $\\mathrm{eV}$ from the temperature in $\\mathrm{Kelvin}$.)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "triqs.gf.gf.Gf" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from triqs_tprf.lattice import lattice_dyson_g0_wk\n", + "from triqs.gf import MeshImFreq\n", + "from triqs_tprf.utilities import temperature_to_beta\n", + "\n", + "beta = temperature_to_beta(repl_hubbard.T)\n", + "wmesh = MeshImFreq(beta=beta, S='Fermion', n_max=repl_hubbard.nw)\n", + "g0_wk = lattice_dyson_g0_wk(mu=repl_hubbard.mu, e_k=e_k, mesh=wmesh)\n", + "type(g0_wk)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The particle-particle vertex $\\Gamma$ in this case must be manually created.\n", + "To do this first create a `MeshImFreq` in the same manner as before, but this time with a bosonic statistic.\n", + "Then use this `MeshImFreq` and combine it with the momentum mesh of the non-interacting Green's function to create a `MeshProduct` object.\n", + "Use this `MeshProduct` object to create a `Gf` object with a `target_shape` that corresponds to a two-particle object, e.g. `(1, 1, 1, 1)`.\n", + "Then overwrite its data to be constant to $U$." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from triqs.gf import Gf, MeshProduct\n", + "\n", + "wmesh_boson = MeshImFreq(beta=temperature_to_beta(repl_hubbard.T), S='Boson', n_max=repl_hubbard.nw)\n", + "wmesh_boson_kmesh = MeshProduct(wmesh_boson, g0_wk.mesh[1])\n", + "gamma_pp = Gf(mesh=wmesh_boson_kmesh, target_shape=g0_wk.target_shape*2)\n", + "gamma_pp.data[:] = 2*repl_hubbard.U" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With this we have all ingredients for the linearized Eliashberg equation.\n", + "To solve it use the `solve_eliashberg` function of the `triqs_tprf.eliashberg` module and supply it with the particle-particle vertex and the non-interacting Green's function.\n", + "It returns the eigenvalues and eigenvectors, i.e. the gap functions.\n", + "\n", + "The returned maximum eigenvalue is $\\lambda \\approx 1$ as expected, because we are close to the phase boundary." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9999705817306739" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from triqs_tprf.eliashberg import solve_eliashberg\n", + "\n", + "Es, eigen_modes = solve_eliashberg(gamma_pp, g0_wk)\n", + "Es[0]" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/user_guide/Solving the linearized Eliashberg equation in the random phase approximation limit.ipynb b/doc/user_guide/Solving the linearized Eliashberg equation in the random phase approximation limit.ipynb new file mode 100644 index 00000000..d39a60a4 --- /dev/null +++ b/doc/user_guide/Solving the linearized Eliashberg equation in the random phase approximation limit.ipynb @@ -0,0 +1,491 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Starting run with 1 MPI rank(s) at : 2021-01-21 16:24:22.474799\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "from triqs.plot.mpl_interface import plt\n", + "from triqs.gf import Idx\n", + "from triqs_tprf.plotting_tools import bsplot\n", + "\n", + "def plot_delta(delta, lamb):\n", + " fig, axs = plt.subplots(figsize=(8, 5), ncols=2)\n", + "\n", + " nw = delta.data.shape[0]\n", + " axs[0].plot(range(-nw//2, nw//2), delta[:, :].data[:,500, 0, 0].real *1e3)\n", + "\n", + " axs[0].set_xlabel(r\"$i\\nu_n$\")\n", + " axs[0].set_ylabel(r\"$\\Delta$ (meV)\")\n", + "\n", + "\n", + " im = axs[1].imshow(delta[Idx(0), :].data.reshape(nk, nk).real, cmap=\"RdBu\")\n", + " axs[1].set_xticks([])\n", + " axs[1].set_yticks([])\n", + "\n", + " axs[1].spines['top'].set_visible(True)\n", + " axs[1].spines['right'].set_visible(True)\n", + "\n", + " axs[1].set_xlabel(\"$k_x$\")\n", + " axs[1].set_ylabel(\"$k_y$\")\n", + "\n", + " axs[1].text(16, 16, \"$\\Gamma$\", size=20)\n", + " axs[1].text(32, 0, \"$M$\", size=20)\n", + " axs[1].text(32, 16, \"$X$\", size=20)\n", + " \n", + " fig.suptitle(r\"$\\lambda = %.3f$\" % lamb, fontsize=20)\n", + " \n", + "\n", + "def plot_chi(chi_m_wk, chi_d_wk):\n", + " path = [(r'$\\Gamma$', 2*np.pi*np.array([0.0, 0.0, 0.0])), \n", + " ('X', 2*np.pi*np.array([0.5, 0.0, 0.0])),\n", + " ('M', 2*np.pi*np.array([0.5, 0.5, 0.0])), \n", + " (r'$\\Gamma$', 2*np.pi*np.array([0.0, 0.0, 0.0])), \n", + " ]\n", + "\n", + "\n", + " ax_bs = plt.subplot(111)\n", + "\n", + " ax_bs.bsplot(chi_m_wk[(Idx(0), slice(None))], path)\n", + " ax_bs.bsplot(chi_d_wk[(Idx(0), slice(None))], path)\n", + "\n", + " ax_bs.set_ylabel(r'$\\chi(i\\nu_n=0, \\mathbf{k})$', rotation=0, ha='right')\n", + " ax_bs.text(0.62, 0.6, \"$\\chi^{m}$\", transform = ax_bs.transAxes, size=22, color='C0')\n", + " ax_bs.text(0.55, 0.18, \"$\\chi^{d}$\", transform = ax_bs.transAxes, size=22, color='C1')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "plt.style.use('notebook.mplstyle')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Solving the linearized Eliashberg equation in the random phase approximation limit\n", + "\n", + "In this notebook we will walk you through the steps of solving the linearized Eliashberg equation in the random phase approximation (RPA) limit. Make sure, that you have read the [theory](https://triqs.github.io/tprf/latest/theory/eliashberg.html) before reading further.\n", + "\n", + "The steps are\n", + " 1. Construct the density- and magnetic-susceptibilties in RPA\n", + " 2. Construct the particle-particle vertex in RPA\n", + " 3. Construct the symmetrizing functions\n", + " 4. Solve the linearized Eliashberg equation\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Construct the density- and magnetic-susceptibilties in RPA\n", + "\n", + "First we need a model and in this example we use the 1-band square lattice." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from triqs_tprf.tight_binding import create_square_lattice\n", + "\n", + "square_lattice = create_square_lattice(norb=1, t=1.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we need the non-interacting one-particle Green's function. For this we first create the dispersion relation on a mesh on the Brillouin zone." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "nk = 32\n", + "\n", + "e_k = square_lattice.on_mesh_brillouin_zone((nk, nk, 1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And then we solve the lattice dyson equation `lattice_dyson_g0_wk` for a specific fermionic Matsubara frequency mesh `MeshImFreq` to obtain the non-interacting one-particle Green's function `g0_wk`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from triqs.gf import MeshImFreq\n", + "from triqs_tprf.lattice import lattice_dyson_g0_wk\n", + "\n", + "wmesh = MeshImFreq(beta=10, S='Fermion', n_max=100)\n", + "g0_wk = lattice_dyson_g0_wk(mu=0, e_k=e_k, mesh=wmesh)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we solve for the density- and magnetic-susceptibilties in RPA by first constructing the bare bubble $\\chi_0$ `imtime_bubble_chi0_wk`" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "╔╦╗╦═╗╦╔═╗ ╔═╗ ┌┬┐┌─┐┬─┐┌─┐\n", + " ║ ╠╦╝║║═╬╗╚═╗ │ ├─┘├┬┘├┤ \n", + " ╩ ╩╚═╩╚═╝╚╚═╝ ┴ ┴ ┴└─└ \n", + "Two-Particle Response Function tool-box \n", + "\n", + "beta = 10.0\n", + "nk = 1024\n", + "nw = 200\n", + "norb = 1\n", + "\n", + "Approx. Memory Utilization: 0.01 GB\n", + "\n", + "--> fourier_wk_to_wr\n", + "--> fourier_wr_to_tr\n", + "--> chi0_tr_from_grt_PH (bubble in tau & r)\n", + "--> chi_wr_from_chi_tr\n", + "--> chi_wk_from_chi_wr (r->k)\n" + ] + } + ], + "source": [ + "from triqs_tprf.lattice_utils import imtime_bubble_chi0_wk\n", + "\n", + "chi0_wk = imtime_bubble_chi0_wk(g0_wk, nw=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "and then solving the RPA equations `solve_rpa_PH` for a Hubbard $U$, a rank 4 numpy array." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from triqs_tprf.lattice import solve_rpa_PH\n", + "\n", + "U = 1.0 * np.ones(shape=(1, 1, 1, 1), dtype=np.complex)\n", + "\n", + "chi_d_wk = solve_rpa_PH(chi0_wk, -U) # Minus here for correct density RPA equation\n", + "chi_m_wk = solve_rpa_PH(chi0_wk, U)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting this over a path through the high-symmetry points looks as follows." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_chi(chi_m_wk, chi_d_wk)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Construct the particle-particle vertex in RPA\n", + "\n", + "Now we have all the ingredients to build the particle-particle vertex in the RPA limit. In this example we limit us to the singlet particle-particle vertex for a symmetry constraint calculation of the Eliashberg equation.\n", + "\n", + "\\begin{align}\n", + "\\Gamma^{\\mathrm{singlet}}(i\\omega_n, \\mathbf{q})\n", + "=\n", + "3\\Phi^{\\mathrm{m}}(i\\omega_n, \\mathbf{q}) - \n", + "3\\Phi^{\\mathrm{d}}(i\\omega_n, \\mathbf{q})\n", + "+\n", + "\\frac{1}{2}\n", + "U^{\\mathrm{d}}\n", + "+\n", + "\\frac{3}{2}\n", + "U^{\\mathrm{m}}\n", + "\\,\n", + "\\end{align}\n", + "\n", + "where\n", + "\n", + "\\begin{align}\n", + "\\Phi^{\\mathrm{d/m}}(i\\omega_n, \\mathbf{q})\n", + "=\n", + "U^{\\mathrm{d/m}}\n", + "\\chi^{\\mathrm{d/m}}(i\\omega_n, \\mathbf{q})\n", + "U^{\\mathrm{d/m}}\n", + "\\,.\n", + "\\end{align}\n", + "\n", + "\n", + "\n", + "For the 1-band case $U^{\\mathrm{d/m}}=U$ and we don't have to take correct orbital ording in the products into account, which simplifies everything. But for generality we will show the process which also works for multi-orbital systems, where we first construct the density/magentic reducible ladder vertex $\\Phi^{\\mathrm{d/m}}$ via `construct_phi_wk`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from triqs_tprf.lattice import construct_phi_wk\n", + "\n", + "phi_d_wk = construct_phi_wk(chi_d_wk, U)\n", + "phi_m_wk = construct_phi_wk(chi_m_wk, U)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And then construct the singlet particle-particle vertex via `construct_gamma_singlet_rpa`." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from triqs_tprf.eliashberg import construct_gamma_singlet_rpa\n", + "\n", + "gamma_singlet = construct_gamma_singlet_rpa(U, U, phi_d_wk, phi_m_wk)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Construct the symmetrizing functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By using the above $\\Gamma$ we must enforce the allowed $SPOT$ symmetries of the superconducting gap $\\Delta$.\n", + "Our 1-band model is by default even in orbital symmetry and by using the singlet $\\Gamma$ we are fixing the spin symmetry to odd. We are therefore left with two physical symmetry combinations.\n", + "\n", + "| Spin | Parity (Momentum) | Orbital | Time (Frequency) |\n", + "|:----:|:-----------------:|:-------:|:----------------:|\n", + "| odd | even | even | even |\n", + "| odd | odd | even | odd |\n", + "\n", + "We will solve for them individually, by constructing a symmetrizing function for each of them.\n", + "We do this by taking `enforce_symmetry` and using `functools.partial` to specifiy the symmetries that we want." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Frequency: Even, Momentum: Even" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import functools\n", + "from triqs_tprf.symmetries import enforce_symmetry\n", + "\n", + "variables = [\"frequency\", \"momentum\"]\n", + "symmetries = [\"even\", \"even\"]\n", + "\n", + "symmetrize_freq_even_mom_even = functools.partial(enforce_symmetry, variables=variables, symmetries=symmetries)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Frequency: Odd, Momentum: Odd" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "symmetries = [\"odd\", \"odd\"]\n", + "\n", + "symmetrize_freq_odd_mom_odd = functools.partial(enforce_symmetry, variables=variables, symmetries=symmetries)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Solve the linearized Eliashberg equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have everything that we need to solve the linearized Eliashberg equation. \n", + "We call the `solve_eliashberg` function with each of our `symmetrize_fct`s and solve for the first leading eigenvalue, gap pair (`k=1`)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from triqs_tprf.eliashberg import solve_eliashberg\n", + "\n", + "lambdas_freq_even_mom_even, deltas_freq_even_mom_even = solve_eliashberg(gamma_singlet, g0_wk, symmetrize_fct=symmetrize_freq_even_mom_even, k=1)\n", + "lambdas_freq_odd_mom_odd, deltas_freq_odd_mom_odd = solve_eliashberg(gamma_singlet, g0_wk, symmetrize_fct=symmetrize_freq_odd_mom_odd, k=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting them shows that all symmetries are correct and that the gap with even frequency and odd momentum has the higher $\\lambda$ and is therefore leading." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_delta(deltas_freq_even_mom_even[0], lambdas_freq_even_mom_even[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "dark" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_delta(deltas_freq_odd_mom_odd[0], lambdas_freq_odd_mom_odd[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/user_guide/notebook.mplstyle b/doc/user_guide/notebook.mplstyle new file mode 100644 index 00000000..9205141a --- /dev/null +++ b/doc/user_guide/notebook.mplstyle @@ -0,0 +1,39 @@ +# Style for jupyter-notebooks + +figure.figsize : 6,5 + +axes.titlesize : 26 +axes.labelsize : 24 +axes.linewidth : 2.5 + +axes.edgecolor : grey +axes.labelcolor : grey + +axes.spines.left : True +axes.spines.bottom : True +axes.spines.top : False +axes.spines.right : False + + +lines.linewidth : 3 +lines.markersize : 10 + + +xtick.color : grey +ytick.color : grey + +xtick.labelsize : 20 +ytick.labelsize : 20 + +xtick.major.size : 7 +xtick.major.width : 2.5 +ytick.major.size : 7 +ytick.major.width : 2.5 + + +axes.prop_cycle : cycler('color', ['e41a1c','377eb8','4daf4a','984ea3', 'ff7f00','ffff33','a65628','f781bf'] ) + +figure.subplot.wspace : 0.3 +figure.subplot.hspace : 0.3 + +legend.fontsize : 20 diff --git a/doc/user_guide/plots/SPHT_hubbard_phase_diagram.svg b/doc/user_guide/plots/SPHT_hubbard_phase_diagram.svg new file mode 100644 index 00000000..d9c5aeb1 --- /dev/null +++ b/doc/user_guide/plots/SPHT_hubbard_phase_diagram.svg @@ -0,0 +1,1082 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/python/triqs_tprf/Dummy.py b/python/triqs_tprf/Dummy.py deleted file mode 100644 index 12eee2e6..00000000 --- a/python/triqs_tprf/Dummy.py +++ /dev/null @@ -1,30 +0,0 @@ -################################################################################ -# -# TRIQS: a Toolbox for Research in Interacting Quantum Systems -# -# Copyright (C) 2017 by Hugo U.R. Strand -# -# TRIQS is free software: you can redistribute it and/or modify it under the -# terms of the GNU General Public License as published by the Free Software -# Foundation, either version 3 of the License, or (at your option) any later -# version. -# -# TRIQS is distributed in the hope that it will be useful, but WITHOUT ANY -# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more -# details. -# -# You should have received a copy of the GNU General Public License along with -# TRIQS. If not, see . -# -################################################################################ - -version = "@PROJECT_VERSION@" -triqs_hash = "@TRIQS_GIT_HASH@" -@PROJECT_NAME@_hash = "@PROJECT_GIT_HASH@" - -def show_version(): - print("\nYou are using @PROJECT_NAME@ version %s\n"%version) - -def show_git_hash(): - print("\nYou are using @PROJECT_NAME@ git hash %s based on triqs git hash %s\n"%("@PROJECT_GIT_HASH@", triqs_hash)) diff --git a/python/triqs_tprf/ParameterCollection.py b/python/triqs_tprf/ParameterCollection.py index 56c40d2c..e75085fe 100644 --- a/python/triqs_tprf/ParameterCollection.py +++ b/python/triqs_tprf/ParameterCollection.py @@ -1,9 +1,12 @@ +# -*- coding: utf-8 -*- ################################################################################ # # TPRF: Two-Particle Response Function (TPRF) Toolbox for TRIQS # # Copyright (C) 2017 by Hugo U.R. Strand +# Copyright (C) 2019 by S.Käser +# Author: H. U.R. Strand, S. Käser # # TPRF is free software: you can redistribute it and/or modify it under the # terms of the GNU General Public License as published by the Free Software @@ -21,6 +24,7 @@ ################################################################################ import inspect +import itertools import numpy as np # ---------------------------------------------------------------------- @@ -78,6 +82,23 @@ def keys(self): def dict(self): return self.__dict__ + def alter(self, **kwargs): + """Change or add attributes + + Returns + ------- + p : ``ParameterCollection`` + """ + p = self.copy() + p.__dict__.update(kwargs) + return p + + def copy(self): + """Shallow copy + """ + p = ParameterCollection(**self.dict()) + return p + def __getitem__(self, key): return self.__dict__[key] @@ -136,6 +157,8 @@ def __str__(self): out += ''.join([key, ' = ', str_value]) + '\n' return out + __repr__ = __str__ + def get_my_name(self): ans = [] frame = inspect.currentframe().f_back @@ -195,7 +218,7 @@ def set_sorted_order(self, sorted_idx): self.objects = list(np.array(self.objects)[sidx]) def getattr_from_objects(self, attr): - return np.array([getattr(o, attr) for o in self.objects ]) + return np.array([getattr(o, attr, None) for o in self.objects ]) def __getattr__(self, attr): return self.getattr_from_objects(attr) @@ -208,8 +231,75 @@ def __factory_from_dict__(cls, name, d): ret = cls(d['objects']) return ret + def __iter__(self): + return self.objects.__iter__() + + def __next__(self): + return self.objects.__next__() + + def __getitem__(self, idx): + return self.objects[idx] + + def __str__(self): + out = '' + for p in self: + out += p.__str__() + out += '\n' + return out + + __repr__ = __str__ + # ---------------------------------------------------------------------- # -- Register ParameterCollection in Triqs formats from h5.formats import register_class register_class(ParameterCollections) + +# ---------------------------------------------------------------------- + +def parameter_scan(p, **kwargs): + """Return ParameterCollections with copies of ParameterCollection for different parameters + + Uses a given ParameterCollection as a template to create copies of it with one or more + parameters changing. Stores all of these copies in a ParameterCollections for easy access. + + Parameters + ---------- + p : ParameterCollection, + The ParameterCollection that shall be used as a template for all the others + **kwargs : Sequence, + The keyword gives the parameter name and the Sequence the values that shall + be scanned through. + + Returns + ------- + ParameterCollections + + Examples + -------- + >>> p = ParameterCollection(beta=10., U=1.0, t=1.0) + >>> ps = parameter_scan(p, U=[1.0, 1.5, 2.0]) + >>> print ps[0] + U = 1.0 + beta = 10.0 + t = 1.0 + >>> print ps[1] + U = 1.5 + beta = 10.0 + t = 1.0 + >>> print ps[2] + U = 2.0 + beta = 10.0 + t = 1.0 + """ + parameter_values = [] + + for key, value in kwargs.items(): + parameter_values.append(zip([key]*len(value), value)) + + ps = [] + + for parameter_value in itertools.product(*parameter_values): + ps.append(p.alter(**dict(parameter_value))) + + return ParameterCollections(ps) diff --git a/python/triqs_tprf/bse.py b/python/triqs_tprf/bse.py index 6057ed92..8b574856 100644 --- a/python/triqs_tprf/bse.py +++ b/python/triqs_tprf/bse.py @@ -39,8 +39,9 @@ from triqs_tprf.lattice import chi0r_from_gr_PH from triqs_tprf.lattice import chi0r_from_gr_PH_nompi from triqs_tprf.lattice import chi0q_from_chi0r -from triqs_tprf.lattice import chi0q_sum_nu, chi0q_sum_nu_tail_corr_PH +from triqs_tprf.lattice import chi0q_sum_nu from triqs_tprf.lattice import chiq_sum_nu_from_chi0q_and_gamma_PH +from triqs_tprf.lattice_utils import imtime_bubble_chi0_wk # ---------------------------------------------------------------------- def solve_local_bse(chi0_wnn, chi_wnn): @@ -208,7 +209,7 @@ def get_chi0_wnk(g_wk, nw=1, nwf=None): return chi0_wnk # ---------------------------------------------------------------------- -def solve_lattice_bse(g_wk, gamma_wnn, tail_corr_nwf=None): +def solve_lattice_bse(g_wk, gamma_wnn): r""" Compute the generalized lattice susceptibility :math:`\chi_{abcd}(\omega, \mathbf{k})` using the Bethe-Salpeter @@ -220,8 +221,6 @@ def solve_lattice_bse(g_wk, gamma_wnn, tail_corr_nwf=None): g_wk : Single-particle Green's function :math:`G_{ab}(\omega, \mathbf{k})`. gamma_wnn : Local particle-hole vertex function :math:`\Gamma_{abcd}(\omega, \nu, \nu')` - tail_corr_nwf : Number of fermionic freqiencies to use in the - tail correction of the sum over fermionic frequencies. Returns ------- @@ -248,31 +247,16 @@ def solve_lattice_bse(g_wk, gamma_wnn, tail_corr_nwf=None): print('nw =', nw) print('nwf =', nwf) print('nwf_g =', nwf_g) - print('tail_corr_nwf =', tail_corr_nwf) print() - if tail_corr_nwf is None: - tail_corr_nwf = nwf - - mpi.report('--> chi0_wnk_tail_corr') - chi0_wnk_tail_corr = get_chi0_wnk(g_wk, nw=nw, nwf=tail_corr_nwf) - - mpi.report('--> trace chi0_wnk_tail_corr (WARNING! NO TAIL FIT. FIXME!)') - chi0_wk_tail_corr = chi0q_sum_nu_tail_corr_PH(chi0_wnk_tail_corr) - #chi0_wk_tail_corr = chi0q_sum_nu(chi0_wnk_tail_corr) + mpi.report('--> chi0_wk_tail_corr') + chi0_wk_tail_corr = imtime_bubble_chi0_wk(g_wk, nw=nw) mpi.barrier() mpi.report('B1 ' + str(chi0_wk_tail_corr[Idx(0), Idx(0,0,0)][0,0,0,0])) mpi.barrier() - mpi.report('--> chi0_wnk_tail_corr to chi0_wnk') - if tail_corr_nwf != nwf: - mpi.report('--> fixed_fermionic_window_python_wnk') - chi0_wnk = fixed_fermionic_window_python_wnk(chi0_wnk_tail_corr, nwf=nwf) - else: - chi0_wnk = chi0_wnk_tail_corr.copy() - - del chi0_wnk_tail_corr + chi0_wnk = get_chi0_wnk(g_wk, nw=nw, nwf=nwf) mpi.barrier() mpi.report('C ' + str(chi0_wnk[Idx(0), Idx(0), Idx(0,0,0)][0,0,0,0])) diff --git a/python/triqs_tprf/eliashberg.py b/python/triqs_tprf/eliashberg.py index 8778b64e..edc46d88 100644 --- a/python/triqs_tprf/eliashberg.py +++ b/python/triqs_tprf/eliashberg.py @@ -2,79 +2,60 @@ ################################################################################ # -# TRIQS: a Toolbox for Research in Interacting Quantum Systems +# TPRF: Two-Particle Response Function (TPRF) Toolbox for TRIQS # # Copyright (C) 2019, The Simons Foundation and S. Käser -# Authors: H. U.R. Strand, S. Käser +# Author: S. Käser, H. U.R. Strand # -# TRIQS is free software: you can redistribute it and/or modify it under the +# TPRF is free software: you can redistribute it and/or modify it under the # terms of the GNU General Public License as published by the Free Software # Foundation, either version 3 of the License, or (at your option) any later # version. # -# TRIQS is distributed in the hope that it will be useful, but WITHOUT ANY +# TPRF is distributed in the hope that it will be useful, but WITHOUT ANY # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License along with -# TRIQS. If not, see . +# TPRF. If not, see . # ################################################################################ +import functools import numpy as np from scipy.sparse.linalg import LinearOperator from scipy.sparse.linalg import eigs # ---------------------------------------------------------------------- +from triqs.gf import Gf from .lattice import eliashberg_product -from .lattice import eliashberg_product_fft +from .lattice import eliashberg_product_fft, eliashberg_product_fft_constant from .lattice import split_into_dynamic_wk_and_constant_k, dynamic_and_constant_to_tr +from .lattice import construct_phi_wk # ---------------------------------------------------------------------- -def solve_eliashberg(Gamma_pp, g_wk, tol=1e-10): - """ Solve the linearized Eliashberg equation using - iterative eigenvalue algorithms from scipy """ - - def from_x_to_wk(delta_x): - delta_wk = g_wk.copy() - delta_wk.data[:] = delta_x.reshape(delta_wk.data.shape) - return delta_wk - - def from_wk_to_x(delta_wk): - delta_x = delta_wk.data.copy().flatten() - return delta_x - - def matvec(delta_x): - delta_wk = from_x_to_wk(delta_x) - delta_out_wk = eliashberg_product(Gamma_pp, g_wk, delta_wk) - delta_out_x = from_wk_to_x(delta_out_wk) - return delta_out_x - - x = from_wk_to_x(g_wk) - N = x.shape[0] - linop = LinearOperator(matvec=matvec, dtype=np.complex, shape=(N, N)) - - np.random.seed(1337) - v0 = np.random.random(N) - E, U = eigs(linop, which='LR', tol=tol, v0=v0) - - eigen_modes = [] - for idx in range(U.shape[-1]): - delta_wk = from_x_to_wk(U[:, idx]) - eigen_modes.append(delta_wk) - - return E, eigen_modes - -def solve_eliashberg_fft(Gamma_pp_wk, g_wk, Gamma_pp_const_k=None, tol=1e-10): +def solve_eliashberg( + Gamma_pp_wk, + g_wk, + initial_delta=None, + Gamma_pp_const_k=None, + tol=1e-10, + product="FFT", + solver="IRAM", + symmetrize_fct=lambda x: x, + k=6, +): r""" Solve the linearized Eliashberg equation Returns the biggest eigenvalues and corresponding eigenvectors of the linearized Eliashberg - equation. The Eliashberg equation implementation is using fourier transformations for - computational efficiency. The eigenvalues are found using an iterative algorithm from scipy. + equation, for a particle-particle vertex in the random phase approximation, + as described here :ref:`eliashberg_rpa`. The Eliashberg equation implementation is + using fourier transformations for computational efficiency. The eigenvalues are found + using an iterative algorithm from scipy. Parameters ---------- @@ -84,12 +65,46 @@ def solve_eliashberg_fft(Gamma_pp_wk, g_wk, Gamma_pp_const_k=None, tol=1e-10): g_wk : Gf, Green's function :math:`G(i\nu_n, \mathbf{k})`. The mesh attribute of the Gf must be a MeshProduct with the components (MeshImFreq, MeshBrillouinZone). + initial_delta : Gf, optional + An initial anomalous self-energy :math:`\Delta(i\nu_n, \mathbf{k})` to start + an iterative solver, given as a Gf with MeshProduct with the components + (MeshImFreq, MeshBrillouinZone). + If not given :func:`semi_random_initial_delta` will be called. Gamma_pp_const_k : float or np.ndarray or Gf, optional Part of the pairing vertex that is constant in Matsubara frequency space :math:`\Gamma(\mathbf{k})`. If given as a Gf its mesh attribute needs to - be a MeshBrillouinZone. + be a MeshBrillouinZone. If not given, the constant part will be fitted. tol : float, optional Relative accuracy for eigenvalues (stopping criterion). + product : str, ['FFT', 'SUM'], optional + Which function of the Eliashberg product shall be used: + + 'FFT' : triqs_tprf.lattice.eliashberg_product_fft, + which uses Fourier transformation for optimal computational efficiency. + + 'SUM' : triqs_tprf.lattice.eliashberg_product, uses the explicit sum. + Restrictions : wmesh of Gamma_pp_wk must be atleast twice the size of the one of g_wk. + + solver : str, ['IRAM', 'PM'], optional + Which eigenvalue solver shall be used: + + 'IRAM' : Use the Implicitly Restarted Arnoldi Method implemented in :func:`implicitly_restarted_arnoldi_method`. + + 'PM' : Use the Power Method implemented in :func:`power_method_LR`. + + symmetrize_fct : function, optional + A function that takes one parameter: A Green's function + :math:`G(i\nu_n, \mathbf{k})`. The mesh attribute of the + Gf must be a MeshProduct with the components + (MeshImFreq, MeshBrillouinZone). + This function is applied after every iteration of the + eigenvalue solver and can be used to enforce a specific + symmetry. If no symmetries are enforced, caution is need, because + unphysical symmetries can occur. + + k : int, optional + The number of leading superconducting gaps that shall be calculated. Does + only have an effect, if 'IRAM' is used as a solver. Returns ------- @@ -102,27 +117,9 @@ def solve_eliashberg_fft(Gamma_pp_wk, g_wk, Gamma_pp_const_k=None, tol=1e-10): See Also -------- - :ref:`eliashberg` - + :ref:`eliashberg` : Theory of the linearized Eliashberg equation. """ - # -- Determine the dynamic and constant part via a tail fit - # -- (This is done even if the constant term is given to get the specific GF types) - Gamma_pp_dyn_wk_fit, Gamma_pp_const_k_fit = split_into_dynamic_wk_and_constant_k(Gamma_pp_wk) - - # -- Use a constant term if explicitly given - if Gamma_pp_const_k: - try: - Gamma_pp_const_k_fit.data[:] = Gamma_pp_const_k - Gamma_pp_dyn_wk_fit.data[:] = Gamma_pp_wk.data - Gamma_pp_const_k - except TypeError: - Gamma_pp_const_k_fit[:] = Gamma_pp_const_k.data - Gamma_pp_dyn_wk_fit.data[:] = Gamma_pp_wk.data - Gamma_pp_const_k.data - - # -- FFT dynamic and constant term to (tau, real) or (real) - Gamma_pp_dyn_tr, Gamma_pp_const_r = dynamic_and_constant_to_tr(Gamma_pp_dyn_wk_fit, - Gamma_pp_const_k_fit) - def from_x_to_wk(delta_x): delta_wk = g_wk.copy() delta_wk.data[:] = delta_x.reshape(delta_wk.data.shape) @@ -131,25 +128,397 @@ def from_x_to_wk(delta_x): def from_wk_to_x(delta_wk): delta_x = delta_wk.data.copy().flatten() return delta_x - + + if product == "FFT": + + Gamma_pp_dyn_tr, Gamma_pp_const_r = preprocess_gamma_for_fft( + Gamma_pp_wk, Gamma_pp_const_k + ) + + if np.allclose( + Gamma_pp_dyn_tr.data, 0 + ): # -- If dynamic part is zero reduced calculation + eli_prod = functools.partial( + eliashberg_product_fft_constant, Gamma_pp_const_r, g_wk + ) + + else: + eli_prod = functools.partial( + eliashberg_product_fft, Gamma_pp_dyn_tr, Gamma_pp_const_r, g_wk + ) + + elif product == "SUM": + eli_prod = functools.partial(eliashberg_product, Gamma_pp_wk, g_wk) + + else: + raise NotImplementedError( + "There is no implementation of the eliashberg product" + " called %s." % product + ) + def matvec(delta_x): delta_wk = from_x_to_wk(delta_x) - delta_out_wk = eliashberg_product_fft(Gamma_pp_dyn_tr, Gamma_pp_const_r, g_wk, delta_wk) + delta_out_wk = eli_prod(delta_wk) + delta_out_wk = symmetrize_fct(delta_out_wk) delta_out_x = from_wk_to_x(delta_out_wk) return delta_out_x - x = from_wk_to_x(g_wk) - N = x.shape[0] + if not initial_delta: + initial_delta = semi_random_initial_delta(g_wk) + initial_delta = from_wk_to_x(initial_delta) + + if solver == "PM": + es, evs = power_method_LR(matvec, initial_delta, tol=tol) + es, evs = [es], [evs] + + elif solver == "IRAM": + es, evs = implicitly_restarted_arnoldi_method( + matvec, initial_delta, k=k, tol=tol + ) + + else: + raise NotImplementedError("There is no solver called %s." % solver) + + eigen_modes = [from_x_to_wk(ele) for ele in evs] + + return es, eigen_modes + + +def preprocess_gamma_for_fft(Gamma_pp_wk, Gamma_pp_const_k=None): + r""" Prepare Gamma to be used with the FFT implementation + + Parameters + ---------- + Gamma_pp_wk : Gf, + Pairing vertex :math:`\Gamma(i\omega_n, \mathbf{k})`. The mesh attribute of + the Gf must be a MeshProduct with the components (MeshImFreq, MeshBrillouinZone). + Gamma_pp_const_k : float or np.ndarray or Gf + Part of the pairing vertex that is constant in Matsubara frequency space + :math:`\Gamma(\mathbf{k})`. If given as a Gf its mesh attribute needs to + be a MeshBrillouinZone. If not given, the constant part will be fitted. + + Returns + ------- + Gamma_pp_dyn_tr : Gf, + The dynamic part of Gamma, which converges to zero for + :math:`\omega_n \rightarrow \infty`, but now in :math:`\tau`-space. + Its mesh attribute is MeshProduct with the components + (MeshImTime, MeshCyclicLattice). + Gamma_pp_const_r : Gf, + The constant part of Gamma with mesh attribute MeshCyclicLattice. + """ + + # -- Determine the dynamic and constant part via a tail fit + # -- (This is done even if the constant term is given to get the specific Gf types) + Gamma_pp_dyn_wk_fit, Gamma_pp_const_k_fit = split_into_dynamic_wk_and_constant_k( + Gamma_pp_wk + ) + + # -- Use a constant term if explicitly given + const_type = type(Gamma_pp_const_k) + if (const_type == float) or (const_type == np.ndarray): + Gamma_pp_const_k_fit.data[:] = Gamma_pp_const_k + Gamma_pp_dyn_wk_fit.data[:] = Gamma_pp_wk.data - Gamma_pp_const_k + elif const_type == Gf: + Gamma_pp_const_k_fit[:] = Gamma_pp_const_k.data + Gamma_pp_dyn_wk_fit.data[:] = Gamma_pp_wk.data - Gamma_pp_const_k.data + # -- FFT dynamic and constant term to (tau, real) or (real) + Gamma_pp_dyn_tr, Gamma_pp_const_r = dynamic_and_constant_to_tr( + Gamma_pp_dyn_wk_fit, Gamma_pp_const_k_fit + ) + + return Gamma_pp_dyn_tr, Gamma_pp_const_r + + +def semi_random_initial_delta(g_wk, nr_factor=0.5, seed=None): + r"""Create a delta based on the GF with random elements + + Returns an anomalous self-energy that can be used as an inital input for the iterative + solvers. The momentum space is random, while the Matsubara space is only partialy + randomized to ensure working tail fits for the Fourier transformations. + + Parameters + ---------- + g_wk : Gf, + Green's function :math:`G(i\nu_n, \mathbf{k})`. The mesh attribute of the Gf must + be a MeshProduct with the components (MeshImFreq, MeshBrillouinZone). + nr_factor : float, optional + Percentage of :math:`\omega` points which shall not be randomized. This is needed + to assure a working tail fit for the Fourier transformations. The default is 0.5, + meaning that 50% of the :math:`\omega` points will not be randomized. + seed : int, optional + Set a np.random.seed to enforce predictable results. + + Returns + ------- + delta : Gf, + An initial anomalous self-energy :math:`\Delta(i\nu_n, \mathbf{k})` to start + an iterative solver, given as a Gf with MeshProduct with the components + (MeshImFreq, MeshBrillouinZone). + """ + + np.random.seed(seed) + + delta = g_wk.copy() + shape = delta.data.shape + delta.data[:] = delta.data.real # Pure real delta is sufficient w/o magnetic field + random_data = np.random.random(shape[1:]) + freq_data = np.mean(np.abs(delta.data), axis=tuple(range(len(shape))[1:])) + not_randomized = int(nr_factor * shape[0] / 2.0) + start, stop = not_randomized, shape[0] - not_randomized + freq_data[start:stop] *= np.random.random(stop - start) + + delta.data[:] = np.tensordot(freq_data, random_data, axes=0) + + return delta + + +def implicitly_restarted_arnoldi_method(matvec, init, tol=1e-10, k=6): + """Find the eigenvalue with the largest real value via the Implicitly Restarted + Arnoldi Method + + Parameters + ---------- + matvec : callable f(v), + Returns A*v. + init : np.ndarray, + The array representation of the anomalous self-energy to start the iterative + method with. Restriction: len(init.shape) == 1. + tol : float, optional + The tolerance at which the iterative scheme is considered to be converged. + k : int, optional + The number of eigenvalues and eigenvectors desired. + + Returns + ------- + Es : list of float, + The eigenvalues with the largest positive real part. + U : list of np.ndarray, + The corresponding eigenvectors. + + Notes + ----- + `scipy.sparse.linalg.eigs `_ + + `scipy.sparse.linalg.LinearOperator `_ + """ + N = init.shape[0] linop = LinearOperator(matvec=matvec, dtype=np.complex, shape=(N, N)) + Es, U = eigs(linop, k=k, which="LR", tol=tol, v0=init) + Es = Es.real - np.random.seed(1337) - v0 = np.random.random(N) - Es, U = eigs(linop, which='LR', tol=tol, v0=v0) + return list(Es), list(U.T) - eigen_modes = [] - for idx in range(U.shape[-1]): - delta_wk = from_x_to_wk(U[:, idx]) - eigen_modes.append(delta_wk) - return list(Es), eigen_modes - +def power_method_LR(matvec, init, tol=1e-10, max_it=1e5): + """Find the eigenvalue with the largest real value via the power method + + Parameters + ---------- + matvec : callable f(v), + Returns A*v. + init : np.ndarray, + The array representation of the anomalous self-energy to start the iterative + method with. Restriction: len(init.shape) == 1. + tol : float, optional + The tolerance at which the iterative scheme is considered to be converged. + max_it : float, optional + The maximum number of iterations that shall be done before a error is raised. + + Returns + ------- + norm : float, + The eigenvalue with the largest positive real part. + v_k : np.ndarray, + The corresponding eigenvector. + """ + + def iteration(v_k, offset=0.0): + v_k1 = matvec(v_k) - offset * v_k + v_k1_norm = np.linalg.norm(v_k1) + v_k1 = v_k1 / v_k1_norm + return v_k1_norm + offset, v_k1 + + def power_method(init, offset=0.0, tol=tol, max_it=max_it): + norm, v_k = iteration(init, offset) + it = 1 + while True: + norm, new_v_k = iteration(v_k, offset) + + # -- Convergence criterion + add = np.max(np.abs(v_k + new_v_k)) + diff = np.max(np.abs(v_k - new_v_k)) + + if (np.allclose(add, 0, atol=tol)) or (np.allclose(diff, 0, atol=tol)): + break + + v_k = new_v_k + it += 1 + if it > max_it: + raise AssertionError("Did not converge.") + return norm, v_k + + # Find eigenvalue with maximum magnitude + norm, v_k = power_method(init, tol=tol) + + # Check sign of found eigenvalue + _, v_k_test = iteration(v_k) + + add = np.sum(np.abs(v_k + v_k_test)) # small if sign of E is negative + diff = np.sum(np.abs(v_k - v_k_test)) # small if sign of E is positive + + # -- Return eigenvalue with largest real part + if diff > add: # The eigenvalue with the largest magnitude is negative + norm, v_k = power_method(init, offset=-norm, tol=tol) + return norm, v_k + + +def allclose_by_scalar_multiplication(delta_1, delta_2, atol=1e-10): + """Test if two eigenvectors are equal if multiplied by a scalar + + Eigenvectors are not unique and can be multiplied by any complex scalar. + Therfore two eigenvalue solver could output different eigenvectors for + the same non-degenerate eigenvalue. + This function checks if two eigenvectors are only different, because of a multiplication + by a scalar. + + Parameters + ---------- + delta_1 : Gf + delta_2 : Gf + tol : float, optional + The tolerance at which the eigenvector are considered to be equal up to a scalar + + Returns + ------- + have_common_scalar_factor : bool, + True if the two eigenvectors are equal up to a scalar. + False otherwise. + """ + delta_1_arr = delta_1.data.flatten() + delta_2_arr = delta_2.data.flatten() + + # Remove numerical zeroes + delta_1_arr = delta_1_arr[np.abs(delta_1_arr) > 1e-7] + delta_2_arr = delta_2_arr[np.abs(delta_2_arr) > 1e-7] + + try: + division_of_deltas = np.divide(delta_1_arr, delta_2_arr) + except ValueError: # Arrays do not contain the same # of zeroes and are therefore not equal + return False + + # Check if elements share common scalar factor + have_common_scalar_factor = np.allclose( + division_of_deltas, division_of_deltas[0], atol=atol + ) + + return have_common_scalar_factor + + +def construct_gamma_singlet_rpa(U_d, U_m, phi_d_wk, phi_m_wk): + r"""Construct the irreducible singlet vertex in the RPA limit + + The irreducible singlet vertex in the random phase approximation limit for a + symmetrized calculations of the Eliashberg equation is given by + + .. math:: + \Gamma^{\text{s}}_{a\overline{b}c\overline{d}}(Q=0, K, K') \equiv + \frac{1}{2}U_{a\overline{b}c\overline{d}}^{\mathrm{d}} + + + \frac{3}{2}U_{a\overline{b}c\overline{d}}^{\mathrm{m}} + + + \Re + \left[ + 3 + \Phi^{\text{m}}_{c\overline{b}a\overline{d}}(K-K') + - + \Phi^{\text{d}}_{c\overline{b}a\overline{d}}(K-K') + \right] + \,. + + For more details see :ref:`eliashberg`. + + Parameters + ---------- + U_d : np.ndarray, + The local static interaction in the density channel. + U_m : np.ndarray, + The local static interaction in the magnetic channel. + phi_d_wk : Gf, + The reducible ladder vertex in the density channel + :math:`\Phi^{\mathrm{d}}(i\omega_n, \mathbf{q})`. The mesh attribute of the Gf + must be a MeshProduct with the components (MeshImFreq, MeshBrillouinZone). + phi_m_wk : Gf, + The reducible ladder vertex in the magnetic channel + :math:`\Phi^{\mathrm{m}}(i\omega_n, \mathbf{q})`. The mesh attribute of the Gf + must be a MeshProduct with the components (MeshImFreq, MeshBrillouinZone). + + Returns + ------- + gamma_singlet : Gf, + The irreducible singlet vertex in the RPA limit for a symmetrized + calculation of the Eliashberg equation + :math:`\Gamma^{\mathrm{s}}(i\omega_n,\mathbf{q})`. + """ + gamma_singlet = 0.0 * phi_d_wk.copy() + + gamma_singlet.data[:] = 3 * phi_m_wk.data.real + phi_d_wk.data.real + gamma_singlet.data[:] = gamma_singlet.data.transpose([0, 1, 4, 3, 2, 5]) + + gamma_singlet.data[:] += 0.5 * U_d + 1.5 * U_m + return gamma_singlet + + +def construct_gamma_triplet_rpa(U_d, U_m, phi_d_wk, phi_m_wk): + r"""Construct the irreducible triplet vertex in the RPA limit + + The irreducible triplet vertex in the random phase approximation limit for a + symmetrized calculations of the Eliashberg equation is given by + + .. math:: + \Gamma^{\text{t}}_{a\overline{b}c\overline{d}}(Q=0, K, K') \equiv + - + \frac{1}{2}U_{a\overline{b}c\overline{d}}^{\mathrm{d}} + + + \frac{1}{2}U_{a\overline{b}c\overline{d}}^{\mathrm{m}} + + + \Re + \left[ + - + \Phi^{\text{m}}_{c\overline{b}a\overline{d}}(K-K') + - + \Phi^{\text{d}}_{c\overline{b}a\overline{d}}(K-K') + \right] + \,. + + For more details see :ref:`eliashberg`. + + Parameters + ---------- + U_d : np.ndarray, + The local static interaction in the density channel. + U_m : np.ndarray, + The local static interaction in the magnetic channel. + phi_d_wk : Gf, + The reducible ladder vertex in the density channel + :math:`\Phi^{\mathrm{d}}(i\omega_n, \mathbf{q})`. The mesh attribute of the Gf + must be a MeshProduct with the components (MeshImFreq, MeshBrillouinZone). + phi_m_wk : Gf, + The reducible ladder vertex in the magnetic channel + :math:`\Phi^{\mathrm{m}}(i\omega_n, \mathbf{q})`. The mesh attribute of the Gf + must be a MeshProduct with the components (MeshImFreq, MeshBrillouinZone). + + Returns + ------- + gamma_triplet : Gf, + The irreducible triplet vertex in the RPA limit for a symmetrized + calculation of the Eliashberg equation + :math:`\Gamma^{\mathrm{t}}(i\omega_n,\mathbf{q})`. + """ + gamma_triplet = 0.0 * phi_d_wk.copy() + + gamma_triplet.data[:] = -phi_m_wk.data.real - phi_d_wk.data.real + gamma_triplet.data[:] = gamma_triplet.data.transpose([0, 1, 4, 3, 2, 5]) + + gamma_triplet.data[:] += -0.5 * U_d + 0.5 * U_m + return gamma_triplet diff --git a/python/triqs_tprf/lattice_desc.py b/python/triqs_tprf/lattice_desc.py index 28efa266..702c97e4 100644 --- a/python/triqs_tprf/lattice_desc.py +++ b/python/triqs_tprf/lattice_desc.py @@ -1,3 +1,21 @@ +# Copyright (c) 2017-2018 Commissariat à l'énergie atomique et aux énergies alternatives (CEA) +# Copyright (c) 2017-2018 Centre national de la recherche scientifique (CNRS) +# Copyright (c) 2018-2020 Simons Foundation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http:#www.apache.org/licenses/LICENSE-2.0.txt +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Authors: Olivier Parcollet, Nils Wentzell + # Generated automatically using the command : # c++2py ../../c++/triqs_tprf/lattice.hpp --members_read_only -N triqs_tprf -a triqs_tprf -m lattice -o lattice -C triqs --moduledoc="Lattice functionality" --cxxflags="-std=c++17" from cpp2py.wrap_generator import * @@ -6,7 +24,7 @@ module = module_(full_name = "lattice", doc = r"Lattice functionality", app_name = "triqs_tprf") # Imports -module.add_imports(*['triqs.gf', 'triqs.lattice', 'triqs.utility.mpi']) +module.add_imports(*['triqs.gf', 'triqs.lattice']) # Add here all includes module.add_include("triqs_tprf/lattice.hpp") @@ -411,158 +429,208 @@ out GW self-energy :math:`\Sigma_{ab}(\tau, \mathbf{r})`""") -module.add_function ("triqs_tprf::gk_iw_t triqs_tprf::eliashberg_product (triqs_tprf::chi_wk_vt Gamma_pp, triqs_tprf::gk_iw_vt g_wk, triqs_tprf::gk_iw_vt delta_wk)", doc = r"""Linearized Eliashberg product +module.add_function ("triqs_tprf::g_wk_t triqs_tprf::eliashberg_product (triqs_tprf::chi_wk_vt Gamma_pp, triqs_tprf::g_wk_vt g_wk, triqs_tprf::g_wk_vt delta_wk)", doc = r"""Linearized Eliashberg product via summation - Computes the product + Computes the linearized Eliashberg product in the singlet/triplet channel given by .. math:: - \Delta^{(out)}_{\bar{a}\bar{b}}(\mathbf{k},i\nu) = -\frac{1}{N_k \beta}\sum_{\mathbf{k}'} \sum_{i\nu'} - \Gamma_{A\bar{a}B\bar{b}}(\mathbf{k}-\mathbf{k}', i\nu - i\nu') - \\ \times - G_{A\bar{c}}(\mathbf{k}', i\nu') - \Delta_{\bar{c}\bar{d}}(\mathbf{k}', i\nu') - G_{B\bar{d}}(-\mathbf{k}', -i\nu') + \Delta^{\mathrm{s/t}, \mathrm{out}}_{\bar{a}\bar{b}}(i\nu,\mathbf{k}) + = + -\frac{1}{2N_\mathbf{k} \beta}\sum_{i\nu'}\sum_{\mathbf{k}'} + \Gamma^{\mathrm{s/t}}_{c\bar{a}d\bar{b}}(i\nu - i\nu',\mathbf{k}-\mathbf{k}') + \\ + \times + G_{c\bar{e}}(i\nu',\mathbf{k}') + G_{d\bar{f}}(-i\nu',-\mathbf{k}') + \Delta^{\mathrm{s/t}, \mathrm{in}}_{\bar{e}\bar{f}}(i\nu',\mathbf{k}')\,, + + by summation. Parameters ---------- -chi_pp - particle-particle vertex :math:`\Gamma^{(pp)}_{a\bar{b}c\bar{d}}(\mathbf{k}, i\nu_n)` +Gamma_pp + particle-particle vertex :math:`\Gamma^{\mathrm{s/t}}_{a\bar{b}c\bar{d}}(i\nu_n,\mathbf{k})` -g_kw - single particle Green's function :math:`G_{a\bar{b}}(\mathbf{k}, i\nu_n)` +g_wk + single particle Green's function :math:`G_{a\bar{b}}(i\nu_n,\mathbf{k})` -delta_kw - pairing self-energy :math:`\Delta_{\bar{a}\bar{b}}(\mathbf{k}, i\nu_n)` +delta_wk + superconducting gap :math:`\Delta^{\mathrm{s/t}, \mathrm{in}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{k})` Returns ------- out - Gives the result of the product :math:`\Delta^{(out)} \sim \Gamma^{(pp)}GG \Delta`""") + Gives the result of the product :math:`\Delta^{\mathrm{s/t}, \mathrm{out}}`""") -module.add_function ("triqs_tprf::gk_iw_t triqs_tprf::eliashberg_product_fft (triqs_tprf::chi_tr_vt Gamma_pp_dyn_tr, triqs_tprf::chi_r_vt Gamma_pp_const_r, triqs_tprf::gk_iw_vt g_wk, triqs_tprf::gk_iw_vt delta_wk)", doc = r"""Linearized Eliashberg product via FFT +module.add_function ("triqs_tprf::g_wk_t triqs_tprf::eliashberg_product_fft (triqs_tprf::chi_tr_vt Gamma_pp_dyn_tr, triqs_tprf::chi_r_vt Gamma_pp_const_r, triqs_tprf::g_wk_vt g_wk, triqs_tprf::g_wk_vt delta_wk)", doc = r"""Linearized Eliashberg product via FFT - Computes the product + Computes the linearized Eliashberg product in the singlet/triplet channel given by .. math:: - \Delta^{(out)}_{\bar{a}\bar{b}}(\mathbf{k},i\nu) = -\frac{1}{N_k \beta}\sum_{\mathbf{k}'} \sum_{i\nu'} - \Gamma_{A\bar{a}B\bar{b}}(\mathbf{k}-\mathbf{k}', i\nu - i\nu') - \\ \times - G_{A\bar{c}}(\mathbf{k}', i\nu') - \Delta_{\bar{c}\bar{d}}(\mathbf{k}', i\nu') - G_{B\bar{d}}(-\mathbf{k}', -i\nu')\,, + \Delta^{\mathrm{s/t}, \mathrm{out}}_{\bar{a}\bar{b}}(i\nu,\mathbf{k}) + = + -\frac{1}{2N_\mathbf{k} \beta}\sum_{i\nu'}\sum_{\mathbf{k}'} + \Gamma^{\mathrm{s/t}}_{c\bar{a}d\bar{b}}(i\nu - i\nu',\mathbf{k}-\mathbf{k}') + \\ + \times + G_{c\bar{e}}(i\nu',\mathbf{k}') + G_{d\bar{f}}(-i\nu',-\mathbf{k}') + \Delta^{\mathrm{s/t}, \mathrm{in}}_{\bar{e}\bar{f}}(i\nu',\mathbf{k}')\,, by taking advantage of the convolution theorem. We therefore first calculate .. math:: - \Delta^{(out)}_{\bar{a}\bar{b}}(\mathbf{r}, \tau) = - -\Gamma_{A\bar{a}B\bar{b}}(\mathbf{r}, \tau) F_{AB}(\mathbf{r}, \tau) \,, + F^{\mathrm{s/t}}_{ab}(i\nu,\mathbf{k}) + = + G_{a\bar{c}}(i\nu,\mathbf{k}) + G_{b\bar{d}}(-i\nu,-\mathbf{k}) + \Delta^{\mathrm{s/t}, \mathrm{in}}_{\bar{c}\bar{d}}(i\nu,\mathbf{k})\,, - where + which we then Fourier transform to imaginary time and real-space .. math:: - F_{AB}(\mathbf{r}, \tau) = - \mathcal{F}\big(G_{A\bar{c}}(\mathbf{k}', i\nu') - \Delta_{\bar{c}\bar{d}}(\mathbf{k}', i\nu') - G_{B\bar{d}}(-\mathbf{k}', -i\nu')\big)\,. + F^{\mathrm{s/t}}_{ab}(\tau,\mathbf{r}) + = + \mathcal{F}^2 + \big( + F^{\mathrm{s/t}}_{ab}(i\nu,\mathbf{k}) + \big)\,. - Then we Fourier transform + We then calculate first the dynamic gap .. math:: - \Delta^{(out)}_{\bar{a}\bar{b}}(\mathbf{k},i\nu) = - \mathcal{F}\big(\Delta^{(out)}_{\bar{a}\bar{b}}(\mathbf{r}, \tau)\big)\,, + \Delta^{\mathrm{s/t}, \mathrm{dynamic}}_{\bar{a}\bar{b}}(\tau,\mathbf{r}) + = + -\frac{1}{2} + \Gamma^{\mathrm{s/t}, \mathrm{dynamic}}_{c\bar{a}d\bar{b}}(\tau, \mathbf{r}) + F^{\mathrm{s/t}}_{cd}(\tau, \mathbf{r})\,, + + and then the static gap + + .. math:: + \Delta^{\mathrm{s/t}, \mathrm{static}}_{\bar{a}\bar{b}}(\mathbf{r}) + = + -\frac{1}{2} + \Gamma^{\mathrm{s/t}, \mathrm{static}}_{c\bar{a}d\bar{b}}(\mathbf{r}) + F^{\mathrm{s/t}}_{cd}(\tau=0, \mathbf{r})\,. + + We then Fourier transform the dynamic gap to imaginary frequencies + + .. math:: + \Delta^{\mathrm{s/t}, \mathrm{dynamic}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{r}) + = + \mathcal{F} + \big( + \Delta^{\mathrm{s/t}, \mathrm{dynamic}}_{\bar{a}\bar{b}}(\tau,\mathbf{r}) + \big)\,, + + and then add both component together + + .. math:: + \Delta^{\mathrm{s/t}, \mathrm{out}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{r}) + = + \Delta^{\mathrm{s/t}, \mathrm{dynamic}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{r}) + + + \Delta^{\mathrm{s/t}, \mathrm{static}}_{\bar{a}\bar{b}}(\mathbf{r})\,, + + and then finally Fourier transform to :math:`\mathbf{k}`-space - to get the same result, but with far less computational effort. + .. math:: + \Delta^{\mathrm{s/t}, \mathrm{out}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{k}) + = + \mathcal{F} + \big( + \Delta^{\mathrm{s/t}, \mathrm{out}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{r}) + \big)\,. Parameters ---------- -chi_rt - dynamic part of the particle-particle vertex :math:`\Gamma^{(pp)}_{a\bar{b}c\bar{d}}(\mathbf{r}, \tau)` +Gamma_pp_dyn_tr + dynamic part of the particle-particle vertex :math:`\Gamma^{\mathrm{s/t}, \mathrm{dynamic}}_{c\bar{a}d\bar{b}}(\tau, \mathbf{r})` -chi_r - constant part of the particle-particle vertex :math:`\Gamma^{(pp)}_{a\bar{b}c\bar{d}}(\mathbf{r})` +Gamma_pp_const_r + static part of the particle-particle vertex :math:`\Gamma^{\mathrm{s/t}, \mathrm{static}}_{c\bar{a}d\bar{b}}(\mathbf{r})` -g_kw - single particle Green's function :math:`G_{a\bar{b}}(\mathbf{k}, i\nu_n)` +g_wk + one-particle Green's function :math:`G_{a\bar{b}}(i\nu_n,\mathbf{k})` -delta_kw - pairing self-energy :math:`\Delta_{\bar{a}\bar{b}}(\mathbf{k}, i\nu_n)` +delta_wk + superconducting gap :math:`\Delta^{\mathrm{s/t}, \mathrm{in}}_{\bar{a}\bar{b}}(i\nu_n,\mathbf{k})` Returns ------- out - Gives the result of the product :math:`\Delta^{(out)} \sim \Gamma^{(pp)}GG \Delta`""") + Gives the result of the product :math:`\Delta^{\mathrm{s/t}, \mathrm{out}}`""") -module.add_function ("triqs_tprf::gk_iw_t triqs_tprf::eliashberg_g_delta_g_product (triqs_tprf::gk_iw_vt g_wk, triqs_tprf::gk_iw_vt delta_wk)", doc = r"""""") +module.add_function ("triqs_tprf::g_wk_t triqs_tprf::eliashberg_product_fft_constant (triqs_tprf::chi_r_vt Gamma_pp_const_r, triqs_tprf::g_wk_vt g_wk, triqs_tprf::g_wk_vt delta_wk)", doc = r"""""") -module.add_function ("std::tuple triqs_tprf::split_into_dynamic_wk_and_constant_k (triqs_tprf::chi_wk_vt Gamma_pp)", doc = r"""""") +module.add_function ("triqs_tprf::g_wk_t triqs_tprf::eliashberg_g_delta_g_product (triqs_tprf::g_wk_vt g_wk, triqs_tprf::g_wk_vt delta_wk)", doc = r"""""") -module.add_function ("std::tuple triqs_tprf::dynamic_and_constant_to_tr (triqs_tprf::chi_wk_vt Gamma_pp_dyn_wk, triqs_tprf::chi_k_vt Gamma_pp_const_k)", doc = r"""""") +module.add_function ("std::tuple triqs_tprf::split_into_dynamic_wk_and_constant_k (triqs_tprf::chi_wk_vt Gamma_pp)", doc = r"""Split Gamma in dynamic and constant part by tail fitting -module.add_function ("triqs_tprf::chi_wk_t triqs_tprf::gamma_PP_singlet (triqs_tprf::chi_wk_vt chi_c, triqs_tprf::chi_wk_vt chi_s, array_view, 4> U_c, array_view, 4> U_s)", doc = r"""Gamma particle-particle singlet +Parameters +---------- +Gamma_pp + : particle-particle pairing vertex :math:`\Gamma(i\omega_n, \mathbf{k})`. - Computes the particle-particle vertex for singlet pairing in the RPA limit +Returns +------- +out + Tuple of Gamma_pp_dyn_wk, the dynamic part of Gamma, which converges to zero for :math:`\omega_n \rightarrow \infty`, and Gamma_pp_const_k, the part of Gamma that is constant in Matsubara frequency space :math:`\Gamma(\mathbf{k})`.""") - .. math:: - \Gamma^{(\mathrm{singlet})}(a\bar{b}c\bar{d}) = - \frac{3}{2} U^{(\mathrm{s})}(a\bar{b}A\bar{B}) \chi^{(\mathrm{s})}(\bar{B}A\bar{C}D) - U^{(\mathrm{s})}(D\bar{C}c\bar{d}) \\ - -\frac{1}{2} U^{(\mathrm{c})}(a\bar{b}A\bar{B}) \chi^{(\mathrm{c})}(\bar{B}A\bar{C}D) - U^{(\mathrm{c})}(D\bar{C}c\bar{d}) \\ - + \frac{1}{2}\big(U^{(\mathrm{s})}(a\bar{b}c\bar{d})+ - U^{(\mathrm{c})}(a\bar{b}c\bar{d})\big) +module.add_function ("std::tuple triqs_tprf::dynamic_and_constant_to_tr (triqs_tprf::chi_wk_vt Gamma_pp_dyn_wk, triqs_tprf::chi_k_vt Gamma_pp_const_k)", doc = r"""Fourier transform Gamma parts to imaginary time and real-space Parameters ---------- -chi_c - charge susceptibility :math:`\chi^{(\mathrm{c})}_{\bar{a}b\bar{c}d}(\mathbf{k}, i\omega_n)` +Gamma_pp_dyn_wk + : The dynamic part of Gamma, which converges to zero for :math:`\omega_n \rightarrow \infty`. -chi_s - spin susceptibility :math:`\chi^{(\mathrm{s})}_{\bar{a}b\bar{c}d}(\mathbf{k}, i\omega_n)` - -U_c - charge interaction :math:`U^{(\mathrm{c})}_{a\bar{b}c\bar{d}}` - -U_s - spin interaction :math:`U^{(\mathrm{s})}_{a\bar{b}c\bar{d}}` +Gamma_pp_const_k + : The part of Gamma that is constant in Matsubara frequency space :math:`\Gamma(\mathbf{k})`. Returns ------- out - :math:`\Gamma^{(\mathrm{singlet})}_{a\bar{b}c\bar{d}}(\mathbf{k}, i\omega_n)`""") + Tuple of Gamma_pp_dyn_tr, the dynamic part of Gamma, which converges to zero for :math:`\omega_n \rightarrow \infty`, but now in :math:`\tau`-space, Gamma_pp_const_r, the constant part of Gamma in real-space.""") -module.add_function ("triqs_tprf::chi_wk_t triqs_tprf::gamma_PP_triplet (triqs_tprf::chi_wk_vt chi_c, triqs_tprf::chi_wk_vt chi_s, array_view, 4> U_c, array_view, 4> U_s)", doc = r"""Gamma particle-particle triplet +module.add_function ("triqs_tprf::e_r_t triqs_tprf::eliashberg_constant_gamma_f_product (triqs_tprf::chi_r_vt Gamma_pp_const_r, triqs_tprf::g_tr_t F_tr)", doc = r"""""") - Computes the particle-particle vertex for triplet pairing in the RPA limit +module.add_function ("triqs_tprf::chi_wk_t triqs_tprf::construct_phi_wk (triqs_tprf::chi_wk_vt chi, array_view, 4> U)", doc = r"""Computes reducible ladder vertex for the approximation of a local and static vertex. + + In this approximation the reducible ladder vertex in density/magnetic channel are given by .. math:: - \Gamma^{(\mathrm{triplet})}(a\bar{b}c\bar{d}) = - -\frac{1}{2} U^{(\mathrm{s})}(a\bar{b}A\bar{B}) \chi^{(\mathrm{s})}(\bar{B}A\bar{C}D) - U^{(\mathrm{s})}(D\bar{C}c\bar{d}) \\ - -\frac{1}{2} U^{(\mathrm{c})}(a\bar{b}A\bar{B}) \chi^{(\mathrm{c})}(\bar{B}A\bar{C}D) - U^{(\mathrm{c})}(D\bar{C}c\bar{d}) \\ - + \frac{1}{2}\big(U^{(\mathrm{s})}(a\bar{b}c\bar{d})+ - U^{(\mathrm{c})}(a\bar{b}c\bar{d})\big) + \Phi^{\text{d/m}}_{a\overline{b}c\overline{d}}(Q) + &\approx + \frac{1}{(N_\mathbf{k}\beta)^2} + \sum_{K'', K'''} + \overline{U}^{\text{d/m}}\chi^{\text{d/m}}(Q, K'', K''') \overline{U}^{\text{d/m}} + \\ + &\approx + \overline{U}^{\mathrm{d/m}} + \chi^{\text{d/m}}(Q) \overline{U}^{\mathrm{d/m}}\,, -Parameters ----------- -chi_c - charge susceptibility :math:`\chi^{(\mathrm{c})}_{\bar{a}b\bar{c}d}(\mathbf{k}, i\omega_n)` -chi_s - spin susceptibility :math:`\chi^{(\mathrm{s})}_{\bar{a}b\bar{c}d}(\mathbf{k}, i\omega_n)` + where all products are particle-hole products. + The reducible ladder vertex in then only dependent on one bosonic frequency and momentum. + It can then be used in :meth:`triqs_tprf.eliashberg.construct_gamma_singlet_rpa` + or :meth:`triqs_tprf.eliashberg.construct_gamma__rpa` to construct the + irreducible singlet/triplet vertex. -U_c - charge interaction :math:`U^{(\mathrm{c})}_{a\bar{b}c\bar{d}}` +Parameters +---------- +chi + density/magnetic susceptibility :math:`\chi^{\mathrm{d/m}}_{\bar{a}b\bar{c}d}(i\omega_n,\mathbf{q})` -U_s - spin interaction :math:`U^{(\mathrm{s})}_{a\bar{b}c\bar{d}}` +U + density/magnetic local and static vertex :math:`U^{\mathrm{d/m}}_{a\bar{b}c\bar{d}}` Returns ------- out - :math:`\Gamma^{(\mathrm{triplet})}_{a\bar{b}c\bar{d}}(\mathbf{k}, i\omega_n)`""") + The reducible ladder vertex in the density/magnetic channel :math:`\Phi^{\mathrm{d/m}}(i\omega_n,\mathbf{q})`""") module.add_function ("array, 6> triqs_tprf::cluster_mesh_fourier_interpolation (array k_vecs, triqs_tprf::chi_wr_cvt chi)", doc = r"""""") @@ -934,4 +1002,4 @@ -module.generate_code() +module.generate_code() \ No newline at end of file diff --git a/python/triqs_tprf/lattice_utils.py b/python/triqs_tprf/lattice_utils.py index 5e9babad..a1506fc1 100644 --- a/python/triqs_tprf/lattice_utils.py +++ b/python/triqs_tprf/lattice_utils.py @@ -216,6 +216,33 @@ def imtime_bubble_chi0_wk(g_wk, nw=1): return chi0_wk +# ---------------------------------------------------------------------- +def chi_contraction(chi, op1, op2): + """Contract a susceptibility with two operators + + Parameters + ---------- + chi : Gf, + Susceptibility :math:`\chi(i\omega_n, \mathbf{k})`. The mesh attribute of + the Gf must be a MeshProduct with the components (MeshImFreq, MeshBrillouinZone) + and its target_rank 4. + op1, op2 : np.ndarray, + Operators in matrix representation. + + Returns + ------- + Gf, + Susceptibility :math:`\chi(i\omega_n, \mathbf{k})`. With a target_rank of 0. + """ + if chi.target_shape[:2] != op1.shape or chi.target_shape[2:] != op2.shape: + raise ValueError('The shape of the operators %s and %s'%(op1.shape, op2.shape) + + ' must fit the shape of chi %s.'%(chi.target_shape,)) + + chi_op1op2 = chi[0, 0, 0, 0].copy() + chi_op1op2.data[:] = np.einsum('...abcd,ab,cd->...', chi.data, op1, op2) + + return chi_op1op2 + # ---------------------------------------------------------------------- def chi0_w0k_tau_bubble(beta, mu, tb_lattice, nk, nw, sigma_w=None): diff --git a/test/python/matrix_rpa.py b/python/triqs_tprf/matrix_rpa.py similarity index 88% rename from test/python/matrix_rpa.py rename to python/triqs_tprf/matrix_rpa.py index 0e13238f..672c7ddb 100644 --- a/test/python/matrix_rpa.py +++ b/python/triqs_tprf/matrix_rpa.py @@ -1,3 +1,27 @@ +# -*- coding: utf-8 -*- + +################################################################################ +# +# TPRF: Two-Particle Response Function (TPRF) Toolbox for TRIQS +# +# Copyright (C) 2019, S. Käser +# Author: S. Käser +# +# TPRF is free software: you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the Free Software +# Foundation, either version 3 of the License, or (at your option) any later +# version. +# +# TPRF is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +# details. +# +# You should have received a copy of the GNU General Public License along with +# TPRF. If not, see . +# +################################################################################ + # ---------------------------------------------------------------------- """ This set of functions implements the matrix RPA as preseneted in mutliple papers. diff --git a/python/triqs_tprf/plotting_tools.py b/python/triqs_tprf/plotting_tools.py new file mode 100644 index 00000000..902f7f69 --- /dev/null +++ b/python/triqs_tprf/plotting_tools.py @@ -0,0 +1,115 @@ +# -*- coding: utf-8 -*- + +################################################################################ +# +# TPRF: Two-Particle Response Function (TPRF) Toolbox for TRIQS +# +# Copyright (C) 2019, S. Käser +# Author: S. Käser +# +# TPRF is free software: you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the Free Software +# Foundation, either version 3 of the License, or (at your option) any later +# version. +# +# TPRF is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +# details. +# +# You should have received a copy of the GNU General Public License along with +# TPRF. If not, see . +# +################################################################################ + +import itertools +import types + +import numpy as np + +import matplotlib as mpl +from triqs.plot.mpl_interface import plt + +from triqs_tprf.lattice_utils import k_space_path + +from scipy.stats import gaussian_kde + +# ========== Bandstructure ========== + +def bsplot(obj, path, *opt_list, **opt_dict): + """ + Plot Gf objects like bandstructure + """ + __bsplot_impl(plt, obj, path, *opt_list, **opt_dict) + +def __bsplot_impl(top, obj, path, *opt_list, **opt_dict): + + hs_labels, hs_k = list(zip(*path)) + + k_paths = list(zip(hs_k, hs_k[1:])) + k_vecs, k_plot, K_plot = k_space_path(k_paths, bz=obj.mesh.domain) + kx, ky, kz = k_vecs.T + + # -- If top is plt do now access the currently used Axes object + if isinstance(top, types.ModuleType): + top = top.gca() + + get_gf_on_path = np.vectorize(lambda kx, ky, kz : obj([kx, ky, kz]).real) + gf_on_path = get_gf_on_path(kx, ky, kz) + + top.plot(k_plot, gf_on_path, *opt_list, **opt_dict) + + top.set_xticks(K_plot) + top.set_xticklabels(hs_labels) + + # -- Make x-spine cut off at starting and ending high symmetry point + top.spines['bottom'].set_bounds(top.get_xticks()[0], top.get_xticks()[-1]) + + # -- Make y-spine cut off at highest and lowest value + lower_limit = np.min([line.get_ydata() for line in top.get_lines()]) + upper_limit = np.max([line.get_ydata() for line in top.get_lines()]) + + top.spines['left'].set_bounds(lower_limit, upper_limit) + top.set_yticks([lower_limit, upper_limit]) + +mpl.axes.Axes.bsplot = lambda self, obj, path, *opt_list, **opt_dict : \ + __bsplot_impl(self, obj, path, *opt_list, **opt_dict) + +# ========== DOS ========== + +def dosplot(obj, *opt_list, **opt_dict): + """Plot density of states for dispersion relation objects + """ + + __dosplot_impl(plt, obj, *opt_list, **opt_dict) + +def __dosplot_impl(top, obj, *opt_list, **opt_dict): + + lower_limit = np.min(obj.data.real) + upper_limit = np.max(obj.data.real) + + dos = gaussian_kde(obj.data.real) + xs = np.linspace(lower_limit, upper_limit, 500) + + dos.covariance_factor = lambda : .1 + dos._compute_covariance() + + # -- If top is plt do now access the currently used Axes object + if isinstance(top, types.ModuleType): + top = top.gca() + + top.plot(dos(xs).real, xs, *opt_list, **opt_dict) + top.fill_betweenx(xs, dos(xs).real, [0]*len(xs), alpha=0.25, *opt_list, **opt_dict) + + # -- Make y-spine cut off at highest and lowest value + lower_limit = np.min([line.get_ydata() for line in top.get_lines()]) + upper_limit = np.max([line.get_ydata() for line in top.get_lines()]) + + top.spines['left'].set_bounds(lower_limit, upper_limit) + top.set_yticks([lower_limit, upper_limit]) + + # -- No x-ticks + top.set_xticks([]) + +mpl.axes.Axes.dosplot = lambda self, obj, *opt_list, **opt_dict : \ + __dosplot_impl(self, obj, *opt_list, **opt_dict) diff --git a/python/triqs_tprf/rpa_tensor.py b/python/triqs_tprf/rpa_tensor.py index e7ca21f9..96242938 100644 --- a/python/triqs_tprf/rpa_tensor.py +++ b/python/triqs_tprf/rpa_tensor.py @@ -1,10 +1,11 @@ +# -*- coding: utf-8 -*- ################################################################################ # # TPRF: Two-Particle Response Function (TPRF) Toolbox for TRIQS # -# Copyright (C) 2018 by The Simons Foundation -# Author: H. U.R. Strand +# Copyright (C) 2019, The Simons Foundation and S. Käser +# Author: H. U.R. Strand, S. Käser # # TPRF is free software: you can redistribute it and/or modify it under the # terms of the GNU General Public License as published by the Free Software @@ -190,6 +191,44 @@ def quartic_tensor_from_charge_and_spin(U_c, U_s): return U_4 +# ---------------------------------------------------------------------- +def kanamori_quartic_tensor(norb, U, Up, J, Jp): + r"""Return Kanamori interaction as a quartic tensor + + .. math:: + + \hat{U}_{\text { Kanamori }} = U \sum_{i} \hat{n}_{i, \uparrow} \hat{n}_{i, \downarrow}+ + \sum_{i>j, s, s^{\prime}}\left(U^{\prime}-J \delta_{\sigma, \sigma^{\prime}}\right) + \hat{n}_{i, \sigma} \hat{n}_{j, \sigma^{\prime}} - + \\ J \sum_{i \neq j}\left(\hat{c}_{i, \downarrow}^{\dagger} \hat{c}_{j, \uparrow}^{\dagger} + \hat{c}_{j, \downarrow} \hat{c}_{i, \uparrow}+\hat{c}_{j, \uparrow}^{\dagger} + \hat{c}_{j, \downarrow}^{\dagger} \hat{c}_{i, \uparrow} \hat{c}_{i, \downarrow}+ + \mathrm{h.c.}\right) + + Parameters + ---------- + norb : int, + Number of orbitals excluding spin. + U : complex, + Strength of intra-orbital interaction. + Up : complex, + Strength of inter-orbital interaction. + J : complex, + Strength of Hound's coupling. + Jp : complex, + Strength pair hopping and spin-flip. + + Returns + ------- + U : np.ndarray, + shape = (2*norb, 2*norb, 2*norb, 2*norb) + """ + + U_c, U_s = kanamori_charge_and_spin_quartic_interaction_tensors(norb, U, Up, J, Jp) + U = quartic_tensor_from_charge_and_spin(U_c, U_s) + + return U + # ---------------------------------------------------------------------- def lose_spin_degree_of_freedom(gf, spin_fast=True): """Only keep the up spin elements of a Greens function @@ -257,16 +296,24 @@ def general_susceptibility_from_charge_and_spin(chi_c, chi_s, spin_fast=True): return chi_general # ---------------------------------------------------------------------- -def charge_and_spin_susceptibility_from_general(chi, spin_fast=True): - """Construct a chi spin and charge from a general susceptibility - - Parameters: - - chi: Greens function, the general susceptibility - spin_fast: bool, True if spin is the fast index, e.g. - xz up, xz down, xy up, xy down, yz up, yz down, - or False if spin is the slow index, e.g. - xz up, xy up, yz up, xz down, xy down, yz down. +def charge_and_spin_susceptibility_from_general(chi, spin_fast=True, check_spin_conservation=True): + r"""Construct a chi spin and charge from a generalized susceptibility + + Should only be used for a :math:`SU(2)` susceptibility. + + Parameters + ---------- + chi : Gf, + Generalized susceptibility :math:`\chi_{a,b,c,d}` where :math:`a,b,c,d` are + combined indices of spin and orbital. + spin_fast : bool, optional + True if spin is the fast index, e.g. + xz up, xz down, xy up, xy down, yz up, yz down. + False if spin is the slow index, e.g. + xz up, xy up, yz up, xz down, xy down, yz down. + check_spin_conservation : bool, optional + True if the susceptibility should be checked for spin + conservation, False otherwise. """ norb = chi.target_shape[-1] // 2 @@ -283,20 +330,19 @@ def charge_and_spin_susceptibility_from_general(chi, spin_fast=True): up = slice(norb) down = slice(norb, None) - # -- Check spin-conservation - - np.testing.assert_allclose(chi[(up, up, up, down)].data, 0) - np.testing.assert_allclose(chi[(up, up, down, up)].data, 0) - np.testing.assert_allclose(chi[(up, down, up, up)].data, 0) - np.testing.assert_allclose(chi[(down, up, up, up)].data, 0) + if check_spin_conservation: + np.testing.assert_allclose(chi[(up, up, up, down)].data, 0) + np.testing.assert_allclose(chi[(up, up, down, up)].data, 0) + np.testing.assert_allclose(chi[(up, down, up, up)].data, 0) + np.testing.assert_allclose(chi[(down, up, up, up)].data, 0) - np.testing.assert_allclose(chi[(down, down, down, up)].data, 0) - np.testing.assert_allclose(chi[(down, down, up, down)].data, 0) - np.testing.assert_allclose(chi[(down, up, down, down)].data, 0) - np.testing.assert_allclose(chi[(up, down, down, down)].data, 0) + np.testing.assert_allclose(chi[(down, down, down, up)].data, 0) + np.testing.assert_allclose(chi[(down, down, up, down)].data, 0) + np.testing.assert_allclose(chi[(down, up, down, down)].data, 0) + np.testing.assert_allclose(chi[(up, down, down, down)].data, 0) - np.testing.assert_allclose(chi[(up, down, up, down)].data, 0) - np.testing.assert_allclose(chi[(down, up, down, up)].data, 0) + np.testing.assert_allclose(chi[(up, down, up, down)].data, 0) + np.testing.assert_allclose(chi[(down, up, down, up)].data, 0) chi_uu = chi[(up, up, up, up)] chi_ud = chi[(up, up, down, down)] diff --git a/python/triqs_tprf/symmetries.py b/python/triqs_tprf/symmetries.py new file mode 100644 index 00000000..939faf38 --- /dev/null +++ b/python/triqs_tprf/symmetries.py @@ -0,0 +1,427 @@ +# -*- coding: utf-8 -*- + +################################################################################ +# +# TPRF: Two-Particle Response Function (TPRF) Toolbox for TRIQS +# +# Copyright (C) 2019, S. Käser +# Author: S. Käser +# +# TPRF is free software: you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the Free Software +# Foundation, either version 3 of the License, or (at your option) any later +# version. +# +# TPRF is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +# details. +# +# You should have received a copy of the GNU General Public License along with +# TPRF. If not, see . +# +################################################################################ + +import numpy as np + +def enforce_symmetry(gf, variables, symmetries): + """Symmetrize Green's function in the given variables + + Parameters + ---------- + gf : Gf, + One-particle fermionic Green's function with a MeshProduct containing + a MeshImFreq on first and a MeshBrillouinZone in second position. + variables : str or iterator of str, + Tells what variable(s) shall be symmetrized, e.g. "momentum" + or ["frequency", "momentum"] + symmetries : str or iterator of str, + Gives the symmetry for the respective variable, e.g. "even" + or ["odd", "even"] + + Returns + ------- + gf : Gf + """ + if type(variables) == str: + variables = [variables] + if type(symmetries) == str: + symmetries = [symmetries] + if len(variables) != len(symmetries): + raise ValueError("Variables and symmetries must be of equal length.") + + variable_symmetrize_fct = {"frequency" : _symmetrize_frequency, + "momentum" : _symmetrize_momentum, + "orbital" : _symmetrize_orbital,} + + for variable in variables: + if variable not in list(variable_symmetrize_fct.keys()): + raise ValueError("No symmetrize function for this variable exists.") + + for symmetry in symmetries: + if symmetry not in ['even', 'odd']: + raise ValueError("Symmetry can only be 'even' or 'odd'.") + + gf_symmetrized = gf.copy() + + for variable, symmetry in zip(variables, symmetries): + symmetrize_fct = variable_symmetrize_fct[variable] + symmetrize_fct(gf_symmetrized, symmetry) + + return gf_symmetrized + +def check_symmetry(gf, atol=1e-08): + """Check the symmetry of a Green's function for various variables + + Parameters + ---------- + gf : Gf, + One-particle fermionic Green's function with a MeshProduct containing + a MeshImFreq on first and a MeshBrillouinZone in second position. + atol : float, + Absolute tolerance used as parameter `atol` in `np.allclose`. + + Returns + ------- + variable_symmetry : dict, + Keys give the variable and values the symmetry. + If even, +1, if odd, -1, else None. + """ + variable_check_symmetry = {"frequency" : _check_frequency_symmetry, + "momentum" : _check_momentum_symmetry, + "orbital" : _check_orbital_symmetry,} + + variable_symmetry = {} + for variable, check_symmetry_fct in list(variable_check_symmetry.items()): + variable_symmetry[variable] = check_symmetry_fct(gf, atol) + + return variable_symmetry + +def _average_halfs(half_1, half_2): + """Stub that can be used as an averager + """ + return half_2 + +def _overall_sign(signs): + """Return +/- 1 if all elements of signs are +/- 1, None else + + Parameters + ---------- + signs : list of +/- 1 + """ + signs = set(signs) + if len(signs) == 1: + return signs.pop() + return None + +# -- Frequency +# ============================================================================ +def _split_frequency(gf): + """Split Green's function data in positive and negative frequencies + + Parameters + --------- + gf : Gf, + Fermionic Green's function with a MeshProduct containing + a MeshImFreq on first position. + + Returns + ------- + negative_half : np.array, + positive_half : np.array, + """ + if not gf.mesh[0].statistic == 'Fermion': + raise ValueError("The Green's function must be a fermionic one") + + nw_half = gf.data.shape[0]//2 + + negative_half = gf.data[:nw_half] + positive_half = gf.data[nw_half:] + + return negative_half, positive_half + +def _check_frequency_symmetry(gf, atol=1e-08): + """Check if frequency symmetry of Green's function is even or odd + + Parameters + ---------- + gf : Gf, + Fermionic Green's function with a MeshProduct containing + a MeshImFreq on first position. + atol : float, + Absolute tolerance used as parameter `atol` in `np.allclose`. + + Returns + ------- + +1 if the Green's function is even in frequency space, -1 if odd, + and None if undefined. + """ + negative_half, positive_half = _split_frequency(gf) + + if np.allclose(negative_half[::-1], positive_half, atol=atol): + return +1 + elif np.allclose(negative_half[::-1], -1*positive_half, atol=atol): + return -1 + return None + +def _symmetrize_frequency(gf, symmetry='even'): + r"""Symmetrize the data of a Green's function in frequency space + + Parameters + --------- + gf : Gf, + Fermionic Green's function with a MeshProduct containing + a MeshImFreq on first position. + symmetry : str, ['even', 'odd'], optional + What frequency symmetry shall be enforced: + + 'even' : no sign change :math:`\nu_n\rightarrow\nu_{-n}` + 'odd' : sign change :math:`\nu_n\rightarrow\nu_{-n}` + """ + negative_half, positive_half = _split_frequency(gf) + avg = _average_halfs(negative_half[::-1], positive_half) + + # Use slice access so that the data in the Green's function get changed + positive_half[:] = avg + if symmetry == "even": + negative_half[:] = avg[::-1] + else: + negative_half[:] = -1* avg[::-1] + +# -- Momentum +# ============================================================================ +def _invert_momentum(momentum, momentum_mesh): + """Returns the indices corresponding to the inverted momentum + + Parameters + ---------- + momentum : array_like, + The indices that correspond to a momentum, e.g. (0, 3). + momentum_mesh : array_like, + The number of points used in the corresponding dimension, + e.g. [4, 4]. + + Returns + ------- + inv_k : tuple, + The indices that correspond to the inverted momentum, + e.g. (0, 1). + """ + momentum = np.array(momentum) + momentum_mesh = np.array(momentum_mesh) + inv_k = momentum_mesh - momentum + inv_k = inv_k % momentum_mesh + inv_k = tuple(inv_k) + return inv_k + +def _split_momentum(gf): + """Split Green's function data in momentum and inversed momentum + + Parameters + ---------- + gf : Gf, + Green's function with a MeshProduct containing and a + MeshBrillouinZone in second position. + + Yields + ------ + positive_half : np.array + negative_half : np.array + """ + nk = gf.data.shape[1] + momentum_mesh = gf.mesh[1].linear_dims + # Drop dimensions which are not meshed over, i.e. value of 1 + momentum_mesh = [mesh for mesh in momentum_mesh if mesh != 1] + + for idx in range(nk): + unraveled_idx = np.unravel_index(idx, momentum_mesh) + unraveled_inv_idx = _invert_momentum(unraveled_idx, momentum_mesh) + inv_idx = np.ravel_multi_index(unraveled_inv_idx, momentum_mesh) + + positive_half = gf.data[slice(None), idx] + negative_half = gf.data[slice(None), inv_idx] + + if idx == inv_idx: + # Give same id to both halfs for identification of k = -k + yield positive_half, positive_half + else: + yield positive_half, negative_half + +def _check_momentum_symmetry(gf, atol=1e-08): + """Check if momentum symmetry of Green's function is even or odd + + Parameters + ---------- + gf : Gf, + Green's function with a MeshProduct containing and a + MeshBrillouinZone in second position. + atol : float, + Absolute tolerance used as parameter `atol` in `np.allclose`. + + Returns + ------- + +1 if the Green's function is even in momentum space, -1 if odd, + and None if undefined. + """ + signs= [] + for positive_half, negative_half in _split_momentum(gf): + + # If the k-point and its inverse are numercial zero the symmetry does + # not matter + if np.allclose(positive_half, 0.0, atol=atol) and \ + np.allclose(negative_half, 0.0, atol=atol): + continue + + # Check if k = -k, if not equal to 0.0 the gf must be even + if id(positive_half) == id(negative_half): + if not np.allclose(0.0, positive_half): + signs.append(+1) + continue + + if np.allclose(positive_half, negative_half, atol=atol): + signs.append(+1) + elif np.allclose(-1*positive_half, negative_half, atol=atol): + signs.append(-1) + else: + return None + + return _overall_sign(signs) + +def _symmetrize_momentum(gf, symmetry='even'): + r"""Symmetrize the data of a Green's function in momentum space + + Parameters + ---------- + gf : Gf, + Green's function with a MeshProduct containing and a + MeshBrillouinZone in second position. + symmetry : str, ['even', 'odd'], optional + What momentum symmetry shall be enforced: + + 'even' : no sign change :math:`\mathbf{k}\rightarrow\mathbf{k}` + 'odd' : sign change :math:`\mathbf{k}\rightarrow\mathbf{k}` + """ + for positive_half, negative_half in _split_momentum(gf): + # Check if k = -k, i.e. needs different symmetry treatment + if id(positive_half) == id(negative_half): + if symmetry == "odd": + positive_half *= 0.0 + continue + + avg = _average_halfs(positive_half, negative_half) + + # Use slice access so that the data in the Green's function get changed + positive_half[:] = avg + if symmetry == "even": + negative_half[:] = avg + else: + negative_half[:] = -1 * avg + +# -- Orbitals +# ============================================================================ +def _split_orbital_triangle(gf): + """Split Green's function data in upper and lower triangle without diagonal + + Parameters + ---------- + gf : Gf, + One-particle Green's function with a MeshProduct with two meshes. + + Yields + ------ + upper_triangle : np.array + lower_triangle : np.array + """ + target_shape = gf.target_shape + nparticle = len(target_shape) + if nparticle != 2: + raise ValueError("The Green's function must be a one-particle one.") + + norb = target_shape[0] + mesh_slice = (slice(None),) * gf.mesh.rank + + upper_triangle_slice = np.triu_indices(norb, k=1) + lower_triangle_slice = np.tril_indices(norb, k=-1) + combined_slice = upper_triangle_slice + lower_triangle_slice + + for upper_1, upper_2, lower_1, lower_2 in zip(*combined_slice): + upper_triangle = gf.data[mesh_slice + (upper_1, upper_2)] + lower_triangle = gf.data[mesh_slice + (lower_1, lower_2)] + + yield upper_triangle, lower_triangle + +def _split_orbital_diagonal(gf): + """Extract the diagonal part of the Green's function data + + Parameters + ---------- + gf : Gf, + One-particle Green's function with a MeshProduct with two meshes. + + Yields + ------ + diagonal : np.array + """ + target_shape = gf.target_shape + nparticle = len(target_shape) + if nparticle != 2: + raise ValueError("The Green's function must be a one-particle one.") + + norb = target_shape[0] + mesh_slice = (slice(None),) * gf.mesh.rank + + for orb in range(norb): + yield gf.data[mesh_slice + (orb,)*nparticle] + +def _check_orbital_symmetry(gf, atol=1e-08): + """Check if orbital symmetry of Green's function is even or odd + + Parameters + ---------- + gf : Gf, + One-particle Green's function with a MeshProduct with two meshes. + atol : float, + Absolute tolerance used as parameter `atol` in `np.allclose`. + + Returns + ------- + +1 if the Green's function is even in orbital space, -1 if odd, + and None if undefined. + """ + signs = [] + for upper_triangle, lower_triangle in _split_orbital_triangle(gf): + if np.allclose(upper_triangle, lower_triangle, atol=atol): + signs.append(+1) + elif np.allclose(upper_triangle, -1*lower_triangle, atol=atol): + signs.append(-1) + else: + return None + + for diagonal in _split_orbital_diagonal(gf): + if not np.allclose(diagonal, 0.0, atol=atol): + signs.append(+1) + + return _overall_sign(signs) + +def _symmetrize_orbital(gf, symmetry="even"): + r"""Symmetrize the data of a Green's function in orbital space + + Parameters + --------- + gf : Gf, + One-particle Green's function with a MeshProduct with two meshes. + """ + for upper_triangle, lower_triangle in _split_orbital_triangle(gf): + avg = _average_halfs(upper_triangle, lower_triangle) + + # Use slice access so that the data in the Green's function get changed + upper_triangle[:] = avg + if symmetry == "even": + lower_triangle[:] = avg + else: + lower_triangle[:] = -1 * avg + + if symmetry == "odd": + for diagonal in _split_orbital_diagonal(gf): + diagonal *= 0.0 + diff --git a/python/triqs_tprf/tight_binding.py b/python/triqs_tprf/tight_binding.py index 0205a8e7..4f38d88c 100644 --- a/python/triqs_tprf/tight_binding.py +++ b/python/triqs_tprf/tight_binding.py @@ -4,7 +4,8 @@ # # Copyright (C) 2011 by M. Ferrero, O. Parcollet # Copyright (C) 2018 The Simons Foundation -# Author: Hugo U. R. Strand +# Copyright (C) 2019, S. Käser +# Author: Hugo U. R. Strand, S. Käser # # TRIQS is free software: you can redistribute it and/or modify it under the # terms of the GNU General Public License as published by the Free Software @@ -21,6 +22,8 @@ # ################################################################################ +import itertools + import numpy as np from triqs.lattice.lattice_tools import BrillouinZone as BrillouinZone @@ -129,3 +132,97 @@ def on_mesh_brillouin_zone(self, n_k): e_k.data[:] = self.hopping(k_vec_rel.T).transpose(2, 0, 1) return e_k + +# ---------------------------------------------------------------------- +def create_square_lattice(norb, t, tp=0.0, zeeman=0.0, spin=False, **kwargs): + r"""Retuns TBLattice that represents a model on a square lattice + + The model is described by the Hamiltonian + + .. math:: + H=-t \sum_{\langle j, l\rangle \sigma}\left(c_{j \sigma}^{\dagger} + c_{l \sigma}+c_{l \sigma}^{\dagger} c_{j \sigma}\right) - + t' \sum_{\langle\langle j, l\rangle\rangle \sigma}\left(c_{j \sigma}^{\dagger} + c_{l \sigma}+c_{l \sigma}^{\dagger} c_{j \sigma}\right) + + \xi \sum_j \left(n_{j \uparrow} - n_{j \downarrow} \right)\,, + + where the angular bracket describes a sum over nearest neighbors and the double + angular bracket over next-nearest neighbors. + + + Parameters + ---------- + norb : int, + Number of orbitals excluding spin + t : complex, + Kinetic energy of nearest neighbor hopping. + Corresponds to :math:`t`. + tp : complex, optional + Kinetic energy of next-nearest neighbor hopping. + Corresponds to :math:`t'`. + zeeman : complex, optional + Strength of Zeeman term. + Corresponds to :math:`\xi`. + spin : bool, + True if spin index should be used explicitly, False otherwise. + The Zeeman term can only be applied if spin=True. + + Returns + ------- + square_lattice : TBLattice + """ + + if zeeman != 0.0 and not spin: + raise AttributeError('There can not be a Zeeman term in a spinless model.') + if spin: + norb *= 2 + + t_matrix = -t * np.eye(norb) + tp_matrix = -tp * np.eye(norb) + zeeman_matrix = zeeman * np.diag([(-1)**orb for orb in range(norb)]) + + hopping = { + # Zeeman term + ( 0, 0): zeeman_matrix, + + # nearest neighbour hopping + ( 0,+1): t_matrix, + ( 0,-1): t_matrix, + (+1, 0): t_matrix, + (-1, 0): t_matrix, + + # next-nearest neighbour hopping + ( +1,+1): tp_matrix, + ( -1,-1): tp_matrix, + (+1, -1): tp_matrix, + (-1, +1): tp_matrix, + } + + units = [(1, 0, 0), (0, 1, 0)] + orbital_positions = [(0, 0, 0)] * norb + + square_lattice = TBLattice(units, hopping, orbital_positions) + + return square_lattice + +# ---------------------------------------------------------------------- +def create_model_for_tests(norb, dim, t=0, t1=0, t2=0, t12=0, t21=0, **kwargs): + full_units = [(1, 0, 0), (0, 1, 0), (0, 0, 1)] + units = full_units[:dim] + + if norb == 1: + t_matrix = -t * np.eye(norb) + elif norb == 2: + t_matrix = -np.array([[t1, t12], [t21, t2]]) + else: + raise NotImplementedError + + all_nn_hoppings = list(itertools.product([-1, 0, 1], repeat=dim)) + non_diagonal_hoppings = [hopping for hopping in all_nn_hoppings if sum(np.abs(hopping)) == 1] + hoppings = {hopping : t_matrix for hopping in non_diagonal_hoppings} + + orbital_positions = [(0, 0, 0)] * norb + + model_for_tests = TBLattice(units, hoppings, orbital_positions) + + return model_for_tests diff --git a/python/triqs_tprf/utilities.py b/python/triqs_tprf/utilities.py index 85fc8c3b..adde4f97 100644 --- a/python/triqs_tprf/utilities.py +++ b/python/triqs_tprf/utilities.py @@ -4,9 +4,8 @@ # # TPRF: Two-Particle Response Function (TPRF) Toolbox for TRIQS # -# Copyright (C) 2019 S. Käser -# Copyright (C) 2019 by The Simons Foundation -# Author: H. U.R. Strand +# Copyright (C) 2019, The Simons Foundation and S. Käser +# Author: H. U.R. Strand, S. Käser # # TPRF is free software: you can redistribute it and/or modify it under the # terms of the GNU General Public License as published by the Free Software @@ -23,6 +22,25 @@ # ################################################################################ +import os +import tarfile +from tempfile import NamedTemporaryFile + +import numpy as np + +from h5 import HDFArchive + +from triqs.gf import Gf, MeshImFreq, MeshProduct, BlockGf +from triqs.gf.tools import fit_legendre +from triqs.gf.gf_fnt import enforce_discontinuity + +from triqs_tprf.lattice import lattice_dyson_g0_wk, solve_rpa_PH, construct_phi_wk +from triqs_tprf.tight_binding import create_model_for_tests +from triqs_tprf.ParameterCollection import ParameterCollection +from triqs_tprf.lattice_utils import imtime_bubble_chi0_wk +from triqs_tprf.rpa_tensor import kanamori_charge_and_spin_quartic_interaction_tensors +from triqs_tprf.eliashberg import construct_gamma_singlet_rpa + # ---------------------------------------------------------------------- def show_version_info(info): """ Return a string that formats the version information @@ -35,11 +53,6 @@ def show_version_info(info): # ---------------------------------------------------------------------- def write_TarGZ_HDFArchive(filename, **kwargs): - - import os - import tarfile - from h5 import HDFArchive - filename = filename.split('.')[0] filename_h5 = filename + '.h5' filename_tar = filename + '.tar.gz' @@ -55,12 +68,6 @@ def write_TarGZ_HDFArchive(filename, **kwargs): # ---------------------------------------------------------------------- def read_TarGZ_HDFArchive(filename): - - import os - import tarfile - from tempfile import NamedTemporaryFile - from h5 import HDFArchive - tar = tarfile.open(filename, "r:gz") f = tar.extractfile(tar.getmembers()[0]) @@ -77,9 +84,6 @@ def read_TarGZ_HDFArchive(filename): # ---------------------------------------------------------------------- def BlockGf_data(G): """ Returns a ndarray copy of all data in a BlockGf """ - - import numpy as np - shape = [G.n_blocks] + list(G[next(G.indices)].data.shape) data = np.zeros(shape, dtype=np.complex) for bidx, (b, g) in enumerate(G): @@ -110,12 +114,6 @@ def legendre_filter(G_tau, order=100, G_l_cut=1e-19): Fitted Green's function on a Legendre mesh """ - - import numpy as np - from triqs.gf import BlockGf - from triqs.gf.tools import fit_legendre - from triqs.gf.gf_fnt import enforce_discontinuity - l_g_l = [] for b, g in G_tau: @@ -141,7 +139,6 @@ def G2_loc_fixed_fermionic_window_python(g2, nwf): assert(n//2 >= nwf) - from triqs.gf import Gf, MeshImFreq, MeshProduct mesh_iw = MeshImFreq(beta=beta, S='Boson', n_max=nw) mesh_inu = MeshImFreq(beta=beta, S='Fermion', n_max=nwf) @@ -154,3 +151,65 @@ def G2_loc_fixed_fermionic_window_python(g2, nwf): g2_out.data[:] = g2.data[:, s:e, s:e] return g2_out + +# ---------------------------------------------------------------------- +def beta_to_temperature(beta): + """Convert beta in 1/eV to Temperature in Kelvin + """ + def eV_to_Kelvin(ev): + return 11604.5250061657 * ev + + T = 1. / beta + return eV_to_Kelvin(T) + +# ---------------------------------------------------------------------- +def temperature_to_beta(T): + """Convert Temperature in Kelvin to beta in 1/eV + """ + def Kelvin_to_eV(K): + return K / 11604.5250061657 + + T = Kelvin_to_eV(T) + beta = 1./ T + return beta + +# ---------------------------------------------------------------------- +def create_eliashberg_ingredients(p): + H = create_model_for_tests(**p) + e_k = H.on_mesh_brillouin_zone(n_k=[p.nk] * p.dim + [1] * (3 - p.dim)) + + wmesh = MeshImFreq(beta=p.beta, S="Fermion", n_max=p.nw) + g0_wk = lattice_dyson_g0_wk(mu=p.mu, e_k=e_k, mesh=wmesh) + + chi0_wk = imtime_bubble_chi0_wk(g0_wk, nw=p.nw) + + U_d, U_m = kanamori_charge_and_spin_quartic_interaction_tensors( + p.norb, p.U, p.Up, p.J, p.Jp + ) + + chi_d = solve_rpa_PH(chi0_wk, U_d) + chi_m = solve_rpa_PH(chi0_wk, -U_m) # Minus for correct charge rpa equation + + phi_d_wk = construct_phi_wk(chi_d, U_d) + phi_m_wk = construct_phi_wk(chi_m, U_m) + + gamma = construct_gamma_singlet_rpa(U_d, U_m, phi_d_wk, phi_m_wk) + + eliashberg_ingredients = ParameterCollection( + g0_wk = g0_wk, + gamma = gamma, + U_m = U_m, + U_d = U_d, + chi_m = chi_m, + chi_d = chi_d, + ) + return eliashberg_ingredients + +# ---------------------------------------------------------------------- +def assert_parameter_collection_not_equal_model_parameters(p1, p2, model_parameters): + for model_parameter in model_parameters: + value1, value2 = p1[model_parameter], p2[model_parameter] + if value1 != value2: + error = 'The model of the benchmark and the one used now are not the same.\n' + error += '\t\tNow: {0} = {1}, benchmark: {0} = {2}.'.format(model_parameter, value1, value2) + raise AssertionError(error) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index e79313ff..733c3700 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -1,3 +1,12 @@ +# runs a python test +# Example: add_python_test(my_script) +# where my_script.py is the script +macro(add_python_test test) + get_filename_component(test_name ${test} NAME_WE) + add_test(NAME Py_${ARGN}${test_name} COMMAND ${TRIQS_PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${test_name}.py WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + set_property(TEST Py_${ARGN}${test_name} APPEND PROPERTY ENVIRONMENT PYTHONPATH=${CMAKE_BINARY_DIR}/python:$ENV{PYTHONPATH} ${SANITIZER_RT_PRELOAD}) +endmacro(add_python_test) + add_subdirectory(c++) if(PythonSupport) diff --git a/test/c++/bubble.cpp b/test/c++/bubble.cpp index 477398d4..69e3b6cb 100644 --- a/test/c++/bubble.cpp +++ b/test/c++/bubble.cpp @@ -62,8 +62,8 @@ TEST(Gf, Bubble) { EXPECT_ARRAY_NEAR(chi0q_from_r.data(), chi0q.data()); // hdf5 - rw_h5(chi0q); - rw_h5(chi0r); + //rw_h5(chi0q); + //rw_h5(chi0r); } // ------------------------------------------------------------ @@ -97,8 +97,8 @@ TEST(Gf, BubbleScalar) { } EXPECT_ARRAY_NEAR(chi0q_from_r.data(), chi0q.data()); - rw_h5(chi0q); - rw_h5(chi0r); + //rw_h5(chi0q); + //rw_h5(chi0r); } // ------------------------------------------------------------ @@ -134,8 +134,8 @@ TEST(Gf, BubbleTensor) { } EXPECT_ARRAY_NEAR(chi0q_from_r.data(), chi0q.data()); - rw_h5(chi0q); - rw_h5(chi0r); + //rw_h5(chi0q); + //rw_h5(chi0r); } // ------------------------------------------------------------ diff --git a/test/c++/mpi_and_openmp.cpp b/test/c++/mpi_and_openmp.cpp index 89d32639..63905955 100644 --- a/test/c++/mpi_and_openmp.cpp +++ b/test/c++/mpi_and_openmp.cpp @@ -79,7 +79,7 @@ TEST(mpi, mpi_view_openmp) { { auto arr = mpi_view(g_wk.mesh()); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { auto &[w, k] = arr(idx); int tid = omp_get_thread_num(); @@ -96,7 +96,7 @@ TEST(mpi, mpi_view_openmp) { { auto arr = mpi_view(wmesh); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { auto &w = arr(idx); int tid = omp_get_thread_num(); @@ -112,7 +112,7 @@ TEST(mpi, mpi_view_openmp) { { auto arr = mpi_view(kmesh); #pragma omp parallel for - for (int idx = 0; idx < arr.size(); idx++) { + for (unsigned int idx = 0; idx < arr.size(); idx++) { auto &k = arr(idx); int tid = omp_get_thread_num(); diff --git a/test/python/CMakeLists.txt b/test/python/CMakeLists.txt index 1d92b99d..b574f0cb 100644 --- a/test/python/CMakeLists.txt +++ b/test/python/CMakeLists.txt @@ -4,12 +4,18 @@ foreach(file ${all_h5_tgz_files}) configure_file(${file} ${file} COPYONLY) endforeach() -# List of all tests -set(all_tests chi4_iw_from_tau g_wk_to_from_g_wr_py chi00_square_lattice bse_and_rpa_loc_vs_latt mean_field mean_field_kanamori hartree_response 1d_hubbard_hf_rpa 1d_hubbard_hf_spin_rot_inv 1d_hubbard_hf_rpa_2site_AFM eliashberg compare_general_rpa_to_matrix_rpa interaction_tensor_charge_spin_factorization) +add_python_test(chi4_iw_from_tau) +add_python_test(g_wk_to_from_g_wr_py) +add_python_test(chi00_square_lattice) +add_python_test(bse_and_rpa_loc_vs_latt) +add_python_test(mean_field) +add_python_test(mean_field_kanamori) +add_python_test(hartree_response) +add_python_test(1d_hubbard_hf_rpa) +add_python_test(1d_hubbard_hf_spin_rot_inv) +add_python_test(1d_hubbard_hf_rpa_2site_AFM) +add_python_test(compare_general_rpa_to_matrix_rpa) +add_python_test(interaction_tensor_charge_spin_factorization) +add_python_test(symmetrize_gf) -foreach(test ${all_tests}) - get_filename_component(test_name ${test} NAME_WE) - get_filename_component(test_dir ${test} DIRECTORY) - add_test(NAME Py_${test_name} COMMAND ${TRIQS_PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${test_dir}/${test_name}.py WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${test_dir}) - set_property(TEST Py_${test_name} APPEND PROPERTY ENVIRONMENT PYTHONPATH=${PROJECT_BINARY_DIR}/python:$ENV{PYTHONPATH} ${SANITIZER_RT_PRELOAD}) -endforeach() +add_subdirectory(eliashberg) diff --git a/test/python/Dummy.out.h5 b/test/python/Dummy.out.h5 deleted file mode 100644 index 92664816..00000000 Binary files a/test/python/Dummy.out.h5 and /dev/null differ diff --git a/test/python/Dummy.py b/test/python/Dummy.py deleted file mode 100644 index 8299f33e..00000000 --- a/test/python/Dummy.py +++ /dev/null @@ -1,19 +0,0 @@ - -import numpy as np - -from h5 import HDFArchive - -from triqs.applications.susceptibility.Dummy import Dummy - -d = Dummy() -d.test_data = np.random.random(100) - -filename = 'Dummy.out.h5' - -with HDFArchive(filename,'w') as ar: - ar['d'] = d - -with HDFArchive(filename,'r') as ar: - d_ref = ar['d'] - -np.testing.assert_array_almost_equal(d.test_data, d_ref.test_data) diff --git a/test/python/compare_general_rpa_to_matrix_rpa.py b/test/python/compare_general_rpa_to_matrix_rpa.py index 170ec402..d58ad8b2 100644 --- a/test/python/compare_general_rpa_to_matrix_rpa.py +++ b/test/python/compare_general_rpa_to_matrix_rpa.py @@ -1,7 +1,9 @@ # ---------------------------------------------------------------------- """ Comparison of the general RPA formalism and the matrix RPA formalism -for the spin- and charge-susceptibility. """ +for the spin- and charge-susceptibility. + +Author: Stefan Käser (2020) stefan.kaeser7@gmail.com """ # ---------------------------------------------------------------------- @@ -94,7 +96,7 @@ # -- Showcase reshaping from 4-rank tensors to matrix as done in papers # -- and test if the process is reversable -from matrix_rpa import tensor_to_matrix, matrix_to_tensor +from triqs_tprf.matrix_rpa import tensor_to_matrix, matrix_to_tensor test_chi = np.chararray([norb]*4, itemsize=4) @@ -156,13 +158,13 @@ # ---------------------------------------------------------------------- # -- Calculate chi spin/charge with spin independent chi0 -from matrix_rpa import lose_spin_degree_of_freedom, tprf_order_to_matrix_rpa_order +from triqs_tprf.matrix_rpa import lose_spin_degree_of_freedom, tprf_order_to_matrix_rpa_order chi00_wk_wo_spin_array = lose_spin_degree_of_freedom(chi00_wk.data, rank=4, spin_fast=False) # c^+cc^+c chi00_wk_matrix_rpa = tprf_order_to_matrix_rpa_order(chi00_wk_wo_spin_array) # now in c^+ccc^+ order -from matrix_rpa import get_rpa_us_tensor, get_rpa_uc_tensor +from triqs_tprf.matrix_rpa import get_rpa_us_tensor, get_rpa_uc_tensor U = 1.0 Up = 0.8 @@ -172,7 +174,7 @@ us_matrix_rpa = get_rpa_us_tensor(norb, U, Up, J ,Jp) # given in cc^+c^+c uc_matrix_rpa = get_rpa_uc_tensor(norb, U, Up, J ,Jp) # given in cc^+c^+c -from matrix_rpa import chi_rpa_spin, chi_rpa_charge +from triqs_tprf.matrix_rpa import chi_rpa_spin, chi_rpa_charge chi_spin_matrix_rpa = chi_rpa_spin(chi00_wk_matrix_rpa, us_matrix_rpa) # given in c^+ccc^+ chi_charge_matrix_rpa = chi_rpa_charge(chi00_wk_matrix_rpa, uc_matrix_rpa) # given in c^+ccc^+ diff --git a/test/python/eliashberg.py b/test/python/eliashberg.py deleted file mode 100644 index 701edff4..00000000 --- a/test/python/eliashberg.py +++ /dev/null @@ -1,130 +0,0 @@ - -# ---------------------------------------------------------------------- - -""" Goes through the steps of solving the linearized Eliashberg equation for singlet pairing in -RPA limit, saves the results and compares to previously established benchmark data. """ - -# ---------------------------------------------------------------------- - -import itertools - -# ---------------------------------------------------------------------- - -import numpy as np - -# ---------------------------------------------------------------------- - -from triqs.gf import MeshImFreq - -from triqs_tprf.ParameterCollection import ParameterCollection -from triqs_tprf.tight_binding import TBLattice -from triqs_tprf.lattice import lattice_dyson_g0_wk -from triqs_tprf.lattice_utils import imtime_bubble_chi0_wk -from triqs_tprf.rpa_tensor import kanamori_charge_and_spin_quartic_interaction_tensors -from triqs_tprf.lattice import solve_rpa_PH -from triqs_tprf.lattice import gamma_PP_singlet -from triqs_tprf.lattice import eliashberg_product -from triqs_tprf.eliashberg import solve_eliashberg - -# ---------------------------------------------------------------------- - -from triqs_tprf.utilities import write_TarGZ_HDFArchive, read_TarGZ_HDFArchive, show_version_info -import triqs_tprf.version as version - -# ---------------------------------------------------------------------- - -p = ParameterCollection( - filename = 'eliashberg_benchmark_new.tar.gz', - dim = 2, - norbs = 1, - t = 1.0, - mu = 0.0, - beta = 1, - U = 1.0, - nk = 2, - nw = 100, - version_info = version.info, - ) - -# -- Setup model, RPA susceptibilities and spin/charge interaction - -full_units = [(1, 0, 0), (0, 1, 0), (0, 0, 1)] -all_nn_hoppings = list(itertools.product([-1, 0, 1], repeat=p.dim)) -non_diagonal_hoppings = [ele for ele in all_nn_hoppings if sum(np.abs(ele)) == 1] - -t = -p.t * np.eye(p.norbs) - -H = TBLattice( - units = full_units[:p.dim], - hopping = {hop : t for hop in non_diagonal_hoppings}, - orbital_positions = [(0,0,0)]*p.norbs, - ) - -e_k = H.on_mesh_brillouin_zone(n_k=[p.nk]*p.dim + [1]*(3-p.dim)) - -# A bigger w-mesh is needed to construct a Gamma with a twice as big w-mesh than GF -big_factor = 2.0 - -wmesh = MeshImFreq(beta=p.beta, S='Fermion', n_max=p.nw) -wmesh_big = MeshImFreq(beta=p.beta, S='Fermion', n_max=int(big_factor*p.nw)) - -g0_wk = lattice_dyson_g0_wk(mu=p.mu, e_k=e_k, mesh=wmesh) -g0_wk_big = lattice_dyson_g0_wk(mu=p.mu, e_k=e_k, mesh=wmesh_big) - -chi0_wk = imtime_bubble_chi0_wk(g0_wk_big, nw=p.nw) -chi0_wk_big = imtime_bubble_chi0_wk(g0_wk_big, nw=int(big_factor*p.nw)+1) - -U_c, U_s = kanamori_charge_and_spin_quartic_interaction_tensors(p.norbs, p.U, 0, 0, 0) - -chi_s = solve_rpa_PH(chi0_wk, U_s) -chi_c = solve_rpa_PH(chi0_wk, -U_c) # Minus for correct charge rpa equation -chi_s_big = solve_rpa_PH(chi0_wk_big, U_s) -chi_c_big = solve_rpa_PH(chi0_wk_big, -U_c) # Minus for correct charge rpa equation - -# -- The output of the following three functions shall be tested - -gamma = gamma_PP_singlet(chi_c, chi_s, U_c, U_s) -gamma_big = gamma_PP_singlet(chi_c_big, chi_s_big, U_c, U_s) -next_delta = eliashberg_product(gamma_big, g0_wk, g0_wk) -E, eigen_modes = solve_eliashberg(gamma_big, g0_wk) - -# -- Save results - -p.gamma = gamma -p.next_delta = next_delta -p.E = E[0] -p.eigen_mode = eigen_modes[0] - -write_TarGZ_HDFArchive(p.filename, p=p) - -# -- Load benchmark data - -filename = './eliashberg_benchmark.tar.gz' -p_benchmark = read_TarGZ_HDFArchive(filename)['p'] - -# -- Check if the benchmark data was calculated for the same model, -# -- otherwise a comparison does not make sense. - -model_parameters = ['dim', 'norbs', 't', 'mu', 'beta', 'U'] - -for model_parameter in model_parameters: - run_time, benchmark = p[model_parameter], p_benchmark[model_parameter] - if run_time != benchmark: - error = 'The model of the benchmark and the one used now are not the same.\n' - error += '\t\tNow: {0} = {1}, benchmark: {0} = {2}.'.format(model_parameter, run_time, - benchmark) - raise AssertionError(error) - -# -- Compare the results. Raise an error if the are not the same within a tolerance. - -print('\nThe benchmark data was obtained with %s.'%show_version_info(p_benchmark.version_info)) - -np.testing.assert_allclose(p_benchmark.gamma.data, p.gamma.data) -np.testing.assert_allclose(p_benchmark.next_delta.data, p.next_delta.data, atol=1e-7) -np.testing.assert_allclose(p_benchmark.E, p.E) -try: - np.testing.assert_allclose(p_benchmark.eigen_mode.data, p.eigen_mode.data, atol=1e-6) -except AssertionError: - np.testing.assert_allclose(-p_benchmark.eigen_mode.data, p.eigen_mode.data, atol=1e-6) - -print('\nThis (new) version with %s yields the same results!'%show_version_info(p.version_info)) diff --git a/test/python/eliashberg/CMakeLists.txt b/test/python/eliashberg/CMakeLists.txt new file mode 100644 index 00000000..0d5a31cd --- /dev/null +++ b/test/python/eliashberg/CMakeLists.txt @@ -0,0 +1,15 @@ +FILE(GLOB all_tgz_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.tar.gz) +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/${all_tgz_files} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) + +set(PREFIX eliashberg-) + +add_python_test(preprocessing_gamma ${PREFIX}) +add_python_test(gamma_creation ${PREFIX}) +add_python_test(solve_eliashberg_functionality ${PREFIX}) +add_python_test(semi_random_initial_delta ${PREFIX}) +add_python_test(product_summation_vs_fft ${PREFIX}) +add_python_test(eigenvalue_solver ${PREFIX}) +add_python_test(regression_test_one_band ${PREFIX}) +add_python_test(regression_test_two_band ${PREFIX}) +add_python_test(fft_product_constant_vs_full ${PREFIX}) +add_python_test(symmetrize_delta ${PREFIX}) diff --git a/test/python/eliashberg/eigenvalue_solver.py b/test/python/eliashberg/eigenvalue_solver.py new file mode 100644 index 00000000..6861cef7 --- /dev/null +++ b/test/python/eliashberg/eigenvalue_solver.py @@ -0,0 +1,66 @@ +# ---------------------------------------------------------------------- + +""" Compare the output of the implemented eigenvalue solver: +The Power Method and the Implicitly Restarted Arnoldi Method. + +Author: Stefan Käser (2020) stefan.kaeser7@gmail.com """ + +# ---------------------------------------------------------------------- + +import itertools + +# ---------------------------------------------------------------------- + +import numpy as np + +# ---------------------------------------------------------------------- + +from triqs_tprf.ParameterCollection import ParameterCollection +from triqs.gf import Gf, MeshImFreq, Idx +from triqs_tprf.utilities import create_eliashberg_ingredients +from triqs_tprf.eliashberg import solve_eliashberg, semi_random_initial_delta +from triqs_tprf.eliashberg import allclose_by_scalar_multiplication + +# ---------------------------------------------------------------------- + + +def test_equality_of_eigenvalue_solvers(g0_wk, gamma): + initial_delta = semi_random_initial_delta(g0_wk, seed=1337) + + Es_PM, eigen_modes_PM = solve_eliashberg( + gamma, g0_wk, product="FFT", solver="PM", initial_delta=initial_delta + ) + Es_IRAM, eigen_modes_IRAM = solve_eliashberg( + gamma, g0_wk, product="FFT", solver="IRAM", initial_delta=initial_delta, k=1 + ) + + np.testing.assert_allclose(Es_PM[0], Es_IRAM[0]) + assert allclose_by_scalar_multiplication( + eigen_modes_PM[0], eigen_modes_IRAM[0] + ), "Eigenvectors are not the same." + + print("Both solvers yield the same results.") + + +# ================================================================================ + +if __name__ == "__main__": + + p = ParameterCollection( + dim=1, + norb=1, + t=1.0, + mu=0.0, + beta=5, + U=1.0, + Up=0.0, + J=0.0, + Jp=0.0, + nk=2, + nw=200, + ) + eliashberg_ingredients = create_eliashberg_ingredients(p) + g0_wk = eliashberg_ingredients.g0_wk + gamma = eliashberg_ingredients.gamma + + test_equality_of_eigenvalue_solvers(g0_wk, gamma) diff --git a/test/python/eliashberg/eliashberg_benchmark_one_band.tar.gz b/test/python/eliashberg/eliashberg_benchmark_one_band.tar.gz new file mode 100644 index 00000000..22d940a6 Binary files /dev/null and b/test/python/eliashberg/eliashberg_benchmark_one_band.tar.gz differ diff --git a/test/python/eliashberg/eliashberg_benchmark_two_band.tar.gz b/test/python/eliashberg/eliashberg_benchmark_two_band.tar.gz new file mode 100644 index 00000000..abc66c3e Binary files /dev/null and b/test/python/eliashberg/eliashberg_benchmark_two_band.tar.gz differ diff --git a/test/python/eliashberg/fft_product_constant_vs_full.py b/test/python/eliashberg/fft_product_constant_vs_full.py new file mode 100644 index 00000000..29d51d08 --- /dev/null +++ b/test/python/eliashberg/fft_product_constant_vs_full.py @@ -0,0 +1,62 @@ +# ---------------------------------------------------------------------- + +""" Compare the implementations of the eliashberg products that use FFT. + +The function `eliashberg_product_fft_constant` can only handle Gammas that are +constant in frequecny space, while `eliashberg_product_fft` can treat dynamic Gammas. +Here we test if both implementations give the same result for a Gamma that +is constant in momentum space. +This also tests the function 'split_into_dynamic_wk_and_constant_k', to +see if the split is done correctly. + +Author: Stefan Käser (2020) stefan.kaeser7@gmail.com """ + +# ---------------------------------------------------------------------- + +import numpy as np + +# ---------------------------------------------------------------------- + +from triqs.gf import Gf, MeshImFreq, MeshProduct +from triqs_tprf.lattice import eliashberg_product_fft, eliashberg_product_fft_constant +from triqs_tprf.eliashberg import semi_random_initial_delta, preprocess_gamma_for_fft +from triqs_tprf.utilities import create_eliashberg_ingredients +from triqs_tprf.ParameterCollection import ParameterCollection + +# ---------------------------------------------------------------------- + +def test_eliashberg_product_fft_constant(g0_wk, gamma): + gamma.data[:] = np.random.rand(*gamma.data.shape[1:]) + gamma_dyn_tr, gamma_const_r = preprocess_gamma_for_fft(gamma) + + initial_delta = semi_random_initial_delta(g0_wk) + + delta_1 = eliashberg_product_fft_constant(gamma_const_r, g0_wk, initial_delta) + delta_2 = eliashberg_product_fft(gamma_dyn_tr, gamma_const_r, g0_wk, initial_delta) + + np.testing.assert_allclose(delta_1.data, delta_2.data) + + print('The functions eliashberg_product_fft and eliashberg_product_fft_constant' + ' yield the same result for a Gamma that is only constant in momentum space.' + '\nThe function split_into_dynamic_wk_and_constant_k therefore also worked correcty.') + +if __name__ == '__main__': + + p = ParameterCollection( + dim = 2, + norb = 1, + t = 2.0, + mu = 0.0, + beta = 5, + U = 1.0, + Up = 0.0, + J = 0.0, + Jp = 0.0, + nk = 4, + nw = 200, + ) + eliashberg_ingredients = create_eliashberg_ingredients(p) + g0_wk = eliashberg_ingredients.g0_wk + gamma = eliashberg_ingredients.gamma + + test_eliashberg_product_fft_constant(g0_wk, gamma) diff --git a/test/python/eliashberg/gamma_creation.py b/test/python/eliashberg/gamma_creation.py new file mode 100644 index 00000000..8e2377c0 --- /dev/null +++ b/test/python/eliashberg/gamma_creation.py @@ -0,0 +1,97 @@ +""" Author: Stefan Käser (2020) stefan.kaeser7@gmail.com """ +import numpy as np + +from triqs_tprf.ParameterCollection import ParameterCollection +from triqs_tprf.utilities import create_eliashberg_ingredients +from triqs.gf import MeshProduct, MeshImFreq, MeshBrillouinZone + +# from triqs_tprf.lattice import gamma_PP_spin_charge, gamma_PP_singlet, gamma_PP_triplet +from triqs_tprf.lattice import construct_phi_wk +from triqs_tprf.eliashberg import ( + construct_gamma_singlet_rpa, + construct_gamma_triplet_rpa, +) + + +def test_phi_wk_mesh_type(chi_d, U_d): + phi_d_wk = construct_phi_wk(chi_d, U_d) + assert type(phi_d_wk.mesh) == MeshProduct + assert type(phi_d_wk.mesh[0]) == MeshImFreq + assert type(phi_d_wk.mesh[1]) == MeshBrillouinZone + + +def test_phi_wk_one_zero(chi_d, U_d): + phi_d_wk = construct_phi_wk(chi_d, 0 * U_d) + np.testing.assert_equal(phi_d_wk.data, 0.0) + + phi_d_wk = construct_phi_wk(0 * chi_d, U_d) + np.testing.assert_equal(phi_d_wk.data, 0.0) + + +def test_gamma_singlet_mesh_type(chi_d, chi_m, U_d, U_m): + phi_d_wk = construct_phi_wk(chi_d, U_d) + phi_m_wk = construct_phi_wk(chi_m, U_m) + + gamma_singlet = construct_gamma_singlet_rpa(U_d, U_m, phi_d_wk, phi_m_wk) + + assert type(gamma_singlet.mesh) == MeshProduct + assert type(gamma_singlet.mesh[0]) == MeshImFreq + assert type(gamma_singlet.mesh[1]) == MeshBrillouinZone + +def test_gamma_singlet_constant_only(chi_d, chi_m, U_d, U_m): + phi_d_wk = construct_phi_wk(chi_d, U_d) + phi_m_wk = construct_phi_wk(chi_m, U_m) + + gamma_singlet = construct_gamma_singlet_rpa(U_d, U_m, 0*phi_d_wk, 0*phi_m_wk) + benchmark_value = 0.5 * U_d + 1.5 * U_m + np.testing.assert_equal(gamma_singlet.data[0, 0], benchmark_value) + + +def test_gamma_triplet_mesh_type(chi_d, chi_m, U_d, U_m): + phi_d_wk = construct_phi_wk(chi_d, U_d) + phi_m_wk = construct_phi_wk(chi_m, U_m) + + gamma_triplet = construct_gamma_triplet_rpa(U_d, U_m, phi_d_wk, phi_m_wk) + + assert type(gamma_triplet.mesh) == MeshProduct + assert type(gamma_triplet.mesh[0]) == MeshImFreq + assert type(gamma_triplet.mesh[1]) == MeshBrillouinZone + +def test_gamma_triplet_constant_only(chi_d, chi_m, U_d, U_m): + phi_d_wk = construct_phi_wk(chi_d, U_d) + phi_m_wk = construct_phi_wk(chi_m, U_m) + + gamma_triplet = construct_gamma_triplet_rpa(U_d, U_m, 0*phi_d_wk, 0*phi_m_wk) + benchmark_value = -0.5 * U_d + 0.5 * U_m + np.testing.assert_equal(gamma_triplet.data[0, 0], benchmark_value) + +if __name__ == "__main__": + p = ParameterCollection( + dim=2, + norb=2, + t1=1.0, + t2=0.5, + t12=0.1, + t21=0.1, + mu=0.1, + beta=1, + U=1.0, + Up=0.8, + J=0.1, + Jp=0.1, + nk=3, + nw=50, + ) + + eliashberg_ingredients = create_eliashberg_ingredients(p) + chi_d = eliashberg_ingredients.chi_d + chi_m = eliashberg_ingredients.chi_m + U_d = eliashberg_ingredients.U_d + U_m = eliashberg_ingredients.U_m + + test_phi_wk_mesh_type(chi_d, U_d) + test_phi_wk_one_zero(chi_d, U_d) + test_gamma_singlet_mesh_type(chi_d, chi_m, U_d, U_m) + test_gamma_singlet_constant_only(chi_d, chi_m, U_d, U_m) + test_gamma_triplet_mesh_type(chi_d, chi_m, U_d, U_m) + test_gamma_triplet_constant_only(chi_d, chi_m, U_d, U_m) diff --git a/test/python/eliashberg/preprocess_gamma_for_fft_benchmark.tar.gz b/test/python/eliashberg/preprocess_gamma_for_fft_benchmark.tar.gz new file mode 100644 index 00000000..d6f1757c Binary files /dev/null and b/test/python/eliashberg/preprocess_gamma_for_fft_benchmark.tar.gz differ diff --git a/test/python/eliashberg/preprocessing_gamma.py b/test/python/eliashberg/preprocessing_gamma.py new file mode 100644 index 00000000..a498a82a --- /dev/null +++ b/test/python/eliashberg/preprocessing_gamma.py @@ -0,0 +1,103 @@ +""" Author: Stefan Käser (2020) stefan.kaeser7@gmail.com """ +import numpy as np + +from triqs.gf import MeshProduct, MeshImFreq, MeshBrillouinZone, MeshImTime, MeshCyclicLattice + +from triqs_tprf.ParameterCollection import ParameterCollection +from triqs_tprf.utilities import create_eliashberg_ingredients +from triqs_tprf.lattice import split_into_dynamic_wk_and_constant_k, dynamic_and_constant_to_tr +from triqs_tprf.eliashberg import preprocess_gamma_for_fft + +from triqs_tprf.utilities import assert_parameter_collection_not_equal_model_parameters, write_TarGZ_HDFArchive, read_TarGZ_HDFArchive +import triqs_tprf.version as version + +def test_split_into_dynamic_wk_and_constant_k_mesh_types(gamma): + gamma_dyn, gamma_const = split_into_dynamic_wk_and_constant_k(gamma) + + assert type(gamma_dyn.mesh) == MeshProduct + assert type(gamma_dyn.mesh[0]) == MeshImFreq + assert type(gamma_dyn.mesh[1]) == MeshBrillouinZone + + assert type(gamma_const.mesh) == MeshBrillouinZone + +def test_split_into_dynamic_wk_and_constant_k_mesh_values(gamma, U_d, U_m): + gamma_dyn, gamma_const = split_into_dynamic_wk_and_constant_k(gamma) + + analytical_constant_expression = 0.5*U_d + 1.5*U_m + np.testing.assert_allclose(gamma_const.data[0], analytical_constant_expression) + + gamma_without_constant_part = gamma.data - analytical_constant_expression + np.testing.assert_allclose(gamma_without_constant_part, gamma_dyn.data, atol=1e-12) + +def test_dynamic_and_constant_to_tr_mesh_types(gamma): + gamma_dyn, gamma_const = split_into_dynamic_wk_and_constant_k(gamma) + gamma_dyn_tr, gamma_const_r = dynamic_and_constant_to_tr(gamma_dyn, gamma_const) + + assert type(gamma_dyn_tr.mesh) == MeshProduct + assert type(gamma_dyn_tr.mesh[0]) == MeshImTime + assert type(gamma_dyn_tr.mesh[1]) == MeshCyclicLattice + + assert type(gamma_const_r.mesh) == MeshCyclicLattice + +def test_preprocess_gamma_for_fft_types(gamma): + gamma_dyn_tr, gamma_const_r = preprocess_gamma_for_fft(gamma) + + assert type(gamma_dyn_tr.mesh) == MeshProduct + assert type(gamma_dyn_tr.mesh[0]) == MeshImTime + assert type(gamma_dyn_tr.mesh[1]) == MeshCyclicLattice + + assert type(gamma_const_r.mesh) == MeshCyclicLattice + +def save_new_preprocess_gamma_for_fft_benchmark(filename, p): + eliashberg_ingredients = create_eliashberg_ingredients(p) + gamma = eliashberg_ingredients.gamma + + gamma_dyn_tr, gamma_const_r = preprocess_gamma_for_fft(gamma) + + p.gamma = gamma + p.gamma_dyn_tr = gamma_dyn_tr + p.gamma_const_r = gamma_const_r + + write_TarGZ_HDFArchive(filename, p=p) + +def test_preprocess_gamma_for_fft_benchmark(gamma, p): + p_benchmark = read_TarGZ_HDFArchive(p.benchmark_filename)['p'] + model_parameters_to_test = ['dim', 'norb', 't', 'mu', 'beta', 'U'] + assert_parameter_collection_not_equal_model_parameters(p, p_benchmark, model_parameters_to_test) + + np.testing.assert_allclose(gamma.data, p_benchmark.gamma.data, atol=1e-10) + + gamma_dyn_tr, gamma_const_r = preprocess_gamma_for_fft(gamma) + np.testing.assert_allclose(gamma_dyn_tr.data, p_benchmark.gamma_dyn_tr.data, atol=1e-10) + np.testing.assert_allclose(gamma_const_r.data, p_benchmark.gamma_const_r.data, atol=1e-10) + + +if __name__ == '__main__': + p = ParameterCollection( + filename = "preprocess_gamma_for_fft_benchmark_new.tar.gz", + benchmark_filename = "preprocess_gamma_for_fft_benchmark.tar.gz", + dim = 1, + norb = 2, + t = 2.0, + mu = 0.0, + beta = 5, + U = 1.0, + Up = 0.8, + J = 0.1, + Jp = 0.1, + nk = 3, + nw = 500, + version_info = version.info, + ) + eliashberg_ingredients = create_eliashberg_ingredients(p) + gamma = eliashberg_ingredients.gamma + U_d = eliashberg_ingredients.U_d + U_m = eliashberg_ingredients.U_m + + test_split_into_dynamic_wk_and_constant_k_mesh_types(gamma) + test_split_into_dynamic_wk_and_constant_k_mesh_values(gamma, U_d, U_m) + test_dynamic_and_constant_to_tr_mesh_types(gamma) + test_preprocess_gamma_for_fft_types(gamma) + + #save_new_preprocess_gamma_for_fft_benchmark(p.filename, p) + test_preprocess_gamma_for_fft_benchmark(gamma, p) diff --git a/test/python/eliashberg/product_summation_vs_fft.py b/test/python/eliashberg/product_summation_vs_fft.py new file mode 100644 index 00000000..32c872c1 --- /dev/null +++ b/test/python/eliashberg/product_summation_vs_fft.py @@ -0,0 +1,169 @@ +# ---------------------------------------------------------------------- + +""" Compare the summation implementation of the linearized Eliashberg product +and the one using Fourier transformations. + +Author: Stefan Käser (2020) stefan.kaeser7@gmail.com """ + +# ---------------------------------------------------------------------- + +import numpy as np +import warnings + +# ---------------------------------------------------------------------- + +from triqs_tprf.ParameterCollection import ParameterCollection +from triqs.gf import Idx +from triqs_tprf.utilities import create_eliashberg_ingredients +from triqs_tprf.lattice import eliashberg_product, eliashberg_product_fft +from triqs_tprf.eliashberg import semi_random_initial_delta, preprocess_gamma_for_fft + +# ---------------------------------------------------------------------- + +def compare_deltas(deltas_1, deltas_2=None, static=False): + """ Build comparison matrix of list of Gf + """ + if not deltas_2: + deltas_2 = deltas_1 + + if static: + deltas_1 = [ele[Idx(0), :] for ele in deltas_1] + deltas_2 = [ele[Idx(0), :] for ele in deltas_2] + + diff = np.zeros(shape=(len(deltas_1), len(deltas_2))) + + for i, delta_1 in enumerate(deltas_1): + for j, delta_2 in enumerate(deltas_2): + + diff[i,j] = np.max(np.abs(delta_1.data - delta_2.data)) + + return diff + +def print_diff(diff): + """ Print output of 'compare_deltas' more readable + """ + i_max, j_max = diff.shape + + s = "" + s += "\n Differences matrix\n" + dashes = "-"*14*diff.shape[0] + "\n" + s += dashes + + for i in range(i_max): + for j in range(j_max): + try: + s += np.format_float_scientific(diff[i,j], precision=2, pad_left=3) + except AttributeError: + s += str(diff[i,j]) + s += "\t" + s += "\n" + s += dashes + print(s) + +def test_eliashberg_product_for_same_initital_delta(g0_wk, gamma, gamma_big): + initial_delta = semi_random_initial_delta(g0_wk, seed=1337) + + next_delta_summation = eliashberg_product(gamma_big, g0_wk, initial_delta) + + gamma_dyn_tr, gamma_const_r = preprocess_gamma_for_fft(gamma) + next_delta_fft = eliashberg_product_fft(gamma_dyn_tr, gamma_const_r, g0_wk, initial_delta) + + diff = compare_deltas([next_delta_summation, next_delta_fft]) + + print_diff(diff) + np.testing.assert_allclose(diff, 0, atol=p.atol) + print('The summation and FFT implementation of the eliashberg product' + ' both yield the same result.') +def test_eliashberg_product_for_different_initital_delta(g0_wk, gamma, gamma_big): + initial_delta = semi_random_initial_delta(g0_wk, seed=1337) + + next_delta_summation = eliashberg_product(gamma_big, g0_wk, initial_delta) + + gamma_dyn_tr, gamma_const_r = preprocess_gamma_for_fft(gamma) + initial_delta = semi_random_initial_delta(g0_wk, seed=1338) + next_delta_fft = eliashberg_product_fft(gamma_dyn_tr, gamma_const_r, g0_wk, initial_delta) + + diff = compare_deltas([next_delta_summation, next_delta_fft]) + + print_diff(diff) + try: + np.testing.assert_allclose(diff, 0, atol=p.atol) + raise ValueError + except AssertionError: + print('The summation and FFT implementation of the eliashberg product' + ' both yield DIFFERENT results, as expected when using a different inital delta.') + +def plot_output(g0_wk, gamma): + from triqs.plot.mpl_interface import oplot, plt + + initial_delta = semi_random_initial_delta(g0_wk) + + next_delta_summation = eliashberg_product(gamma_big, g0_wk, initial_delta) + + gamma_dyn_tr, gamma_const_r = preprocess_gamma_for_fft(gamma) + next_delta_fft = eliashberg_product_fft(gamma_dyn_tr, gamma_const_r, g0_wk, initial_delta) + + deltas = [initial_delta, next_delta_summation, next_delta_fft] + + warnings.filterwarnings("ignore") #ignore some matplotlib warnings + subp = [4, 3, 1] + fig = plt.figure(figsize=(18, 15)) + + titles = ['Input', 'Summation', 'FFT'] + + for k_point in [Idx(0,0,0), Idx(1,0,0)]: + + ax = plt.subplot(*subp); subp[-1] += 1 + oplot(g0_wk[:, k_point]) + plt.title('GF') + + ax = plt.subplot(*subp); subp[-1] += 1 + oplot(gamma[:, k_point]) + plt.title('Gamma') + + ax = plt.subplot(*subp); subp[-1] += 1 + oplot(gamma_dyn_tr[:, k_point]) + plt.title('Gamma dyn tr') + + for delta, title in zip(deltas, titles): + + ax = plt.subplot(*subp); subp[-1] += 1 + oplot(delta[:, k_point]) + plt.title(title) + + ax.legend_ = None + + plt.show() + +#================================================================================ + +if __name__ == '__main__': + p = ParameterCollection( + dim = 1, + norb = 2, + t1 = 1.0, + t2 = 0.5, + t12 = 0.1, + t21 = 0.1, + mu = 0.0, + beta = 1, + U = 1.0, + Up = 0.8, + J = 0.1, + Jp = 0.1, + nk = 3, + nw = 30, + atol = 1e-8, + ) + + eliashberg_ingredients = create_eliashberg_ingredients(p) + g0_wk = eliashberg_ingredients.g0_wk + gamma = eliashberg_ingredients.gamma + # For the eliashberg SUM procedure a Gamma with a twice as big w-mesh then the GF is needed. + big_nw = 2*p.nw + 1 + eliashberg_ingredients_big = create_eliashberg_ingredients(p.alter(nw=big_nw)) + gamma_big = eliashberg_ingredients_big.gamma + + test_eliashberg_product_for_same_initital_delta(g0_wk, gamma, gamma_big) + test_eliashberg_product_for_different_initital_delta(g0_wk, gamma, gamma_big) + #plot_output(g0_wk, gamma) diff --git a/test/python/eliashberg/regression_test_one_band.py b/test/python/eliashberg/regression_test_one_band.py new file mode 100644 index 00000000..52cfcc7b --- /dev/null +++ b/test/python/eliashberg/regression_test_one_band.py @@ -0,0 +1,96 @@ + +# ---------------------------------------------------------------------- + +""" Goes through the steps of solving the linearized Eliashberg equation for singlet pairing in +RPA limit in model with two orbitals, saves the results and compares to previously established +benchmark data. + +Author: Stefan Käser (2020) stefan.kaeser7@gmail.com """ + +# ---------------------------------------------------------------------- + +import itertools + +# ---------------------------------------------------------------------- + +import numpy as np + +# ---------------------------------------------------------------------- + +from triqs.gf import MeshImFreq + +from triqs_tprf.ParameterCollection import ParameterCollection + +from triqs_tprf.tight_binding import create_model_for_tests + +from triqs_tprf.lattice import eliashberg_product_fft +from triqs_tprf.utilities import create_eliashberg_ingredients +from triqs_tprf.eliashberg import preprocess_gamma_for_fft, solve_eliashberg +from triqs_tprf.eliashberg import allclose_by_scalar_multiplication + +# ---------------------------------------------------------------------- + +from triqs_tprf.utilities import assert_parameter_collection_not_equal_model_parameters, write_TarGZ_HDFArchive, read_TarGZ_HDFArchive, show_version_info +import triqs_tprf.version as version + +# ---------------------------------------------------------------------- + +def save_new_benchmarks(filename, p): + eliashberg_ingredients = create_eliashberg_ingredients(p) + g0_wk = eliashberg_ingredients.g0_wk + gamma = eliashberg_ingredients.gamma + + Gamma_pp_dyn_tr, Gamma_pp_const_r = preprocess_gamma_for_fft(gamma) + next_delta = eliashberg_product_fft(Gamma_pp_dyn_tr, Gamma_pp_const_r, g0_wk, g0_wk) + Es, eigen_modes = solve_eliashberg(gamma, g0_wk, product='FFT', solver='IRAM') + + p.next_delta = next_delta + p.E = Es[0] + p.eigen_mode = eigen_modes[0] + + write_TarGZ_HDFArchive(filename, p=p) + +def test_next_delta(g0_wk, gamma, expected_next_delta): + Gamma_pp_dyn_tr, Gamma_pp_const_r = preprocess_gamma_for_fft(gamma) + next_delta = eliashberg_product_fft(Gamma_pp_dyn_tr, Gamma_pp_const_r, g0_wk, g0_wk) + np.testing.assert_allclose(next_delta.data, expected_next_delta.data, atol=10e-12) + +def test_solve_eliashberg(g0_wk, gamma, expected_E, expected_eigen_mode): + Es, eigen_modes = solve_eliashberg(gamma, g0_wk, product='FFT', solver='IRAM') + np.testing.assert_allclose(Es[0], expected_E) + assert allclose_by_scalar_multiplication(eigen_modes[0], expected_eigen_mode),\ + "Eigenvectors are not the same." + +if __name__ == "__main__": + p = ParameterCollection( + benchmark_filename = "./eliashberg_benchmark_one_band.tar.gz", + filename = 'eliashberg_benchmark_one_band_new.tar.gz', + dim = 2, + norb = 1, + t = 1.0, + mu = 0.0, + beta = 1, + U = 1.0, + Up = 0.0, + J = 0.0, + Jp = 0.0, + nk = 2, + nw = 100, + version_info = version.info, + ) + + #save_new_benchmarks(p.filename, p) + + p_benchmark = read_TarGZ_HDFArchive(p.benchmark_filename)['p'] + model_parameters_to_test = ['dim', 'norb', 't', 'mu', 'beta', 'U'] + assert_parameter_collection_not_equal_model_parameters(p, p_benchmark, model_parameters_to_test) + + eliashberg_ingredients = create_eliashberg_ingredients(p) + g0_wk = eliashberg_ingredients.g0_wk + gamma = eliashberg_ingredients.gamma + + test_next_delta(g0_wk, gamma, p_benchmark.next_delta) + test_solve_eliashberg(g0_wk, gamma, p_benchmark.E, p_benchmark.eigen_mode) + + print(('\nThe benchmark data was obtained with %s.'%show_version_info(p_benchmark.version_info))) + print(('\nThis (new) version with %s yields the same results!'%show_version_info(p.version_info))) diff --git a/test/python/eliashberg/regression_test_two_band.py b/test/python/eliashberg/regression_test_two_band.py new file mode 100644 index 00000000..67aded9f --- /dev/null +++ b/test/python/eliashberg/regression_test_two_band.py @@ -0,0 +1,99 @@ + +# ---------------------------------------------------------------------- + +""" Goes through the steps of solving the linearized Eliashberg equation for singlet pairing in +RPA limit in model with two orbitals, saves the results and compares to previously established +benchmark data. + +Author: Stefan Käser (2020) stefan.kaeser7@gmail.com """ + +# ---------------------------------------------------------------------- + +import itertools + +# ---------------------------------------------------------------------- + +import numpy as np + +# ---------------------------------------------------------------------- + +from triqs.gf import MeshImFreq + +from triqs_tprf.ParameterCollection import ParameterCollection + +from triqs_tprf.tight_binding import create_model_for_tests + +from triqs_tprf.lattice import eliashberg_product_fft +from triqs_tprf.utilities import create_eliashberg_ingredients +from triqs_tprf.eliashberg import preprocess_gamma_for_fft, solve_eliashberg +from triqs_tprf.eliashberg import allclose_by_scalar_multiplication + +# ---------------------------------------------------------------------- + +from triqs_tprf.utilities import assert_parameter_collection_not_equal_model_parameters, write_TarGZ_HDFArchive, read_TarGZ_HDFArchive, show_version_info +import triqs_tprf.version as version + +# ---------------------------------------------------------------------- + +def save_new_benchmarks(filename, p): + eliashberg_ingredients = create_eliashberg_ingredients(p) + g0_wk = eliashberg_ingredients.g0_wk + gamma = eliashberg_ingredients.gamma + + Gamma_pp_dyn_tr, Gamma_pp_const_r = preprocess_gamma_for_fft(gamma) + next_delta = eliashberg_product_fft(Gamma_pp_dyn_tr, Gamma_pp_const_r, g0_wk, g0_wk) + Es, eigen_modes = solve_eliashberg(gamma, g0_wk, product='FFT', solver='IRAM') + + p.next_delta = next_delta + p.E = Es[0] + p.eigen_mode = eigen_modes[0] + + write_TarGZ_HDFArchive(filename, p=p) + +def test_next_delta(g0_wk, gamma, expected_next_delta): + Gamma_pp_dyn_tr, Gamma_pp_const_r = preprocess_gamma_for_fft(gamma) + next_delta = eliashberg_product_fft(Gamma_pp_dyn_tr, Gamma_pp_const_r, g0_wk, g0_wk) + np.testing.assert_allclose(next_delta.data, expected_next_delta.data, atol=10e-12) + +def test_solve_eliashberg(g0_wk, gamma, expected_E, expected_eigen_mode): + Es, eigen_modes = solve_eliashberg(gamma, g0_wk, product='FFT', solver='IRAM') + np.testing.assert_allclose(Es[0], expected_E) + assert allclose_by_scalar_multiplication(eigen_modes[0], expected_eigen_mode),\ + "Eigenvectors are not the same." + +if __name__ == "__main__": + p = ParameterCollection( + filename = 'eliashberg_benchmark_two_band_new.tar.gz', + benchmark_filename = './eliashberg_benchmark_two_band.tar.gz', + dim = 2, + norb = 2, + t1 = 1.0, + t2 = 0.5, + t12 = 0.1, + t21 = 0.1, + mu = 0.0, + beta = 1, + U = 1.0, + Up = 0.8, + J = 0.1, + Jp = 0.1, + nk = 2, + nw = 100, + version_info = version.info, + ) + + #save_new_benchmarks(p.filename, p) + + p_benchmark = read_TarGZ_HDFArchive(p.benchmark_filename)['p'] + model_parameters_to_test = ['dim', 'norb', 't1', 't2', 't12', 't21', 'mu', 'beta', 'U'] + assert_parameter_collection_not_equal_model_parameters(p, p_benchmark, model_parameters_to_test) + + eliashberg_ingredients = create_eliashberg_ingredients(p) + g0_wk = eliashberg_ingredients.g0_wk + gamma = eliashberg_ingredients.gamma + + test_next_delta(g0_wk, gamma, p_benchmark.next_delta) + test_solve_eliashberg(g0_wk, gamma, p_benchmark.E, p_benchmark.eigen_mode) + + print(('\nThe benchmark data was obtained with %s.'%show_version_info(p_benchmark.version_info))) + print(('\nThis (new) version with %s yields the same results!'%show_version_info(p.version_info))) diff --git a/test/python/eliashberg/semi_random_initial_delta.py b/test/python/eliashberg/semi_random_initial_delta.py new file mode 100644 index 00000000..205ebdd2 --- /dev/null +++ b/test/python/eliashberg/semi_random_initial_delta.py @@ -0,0 +1,48 @@ +""" Author: Stefan Käser (2020) stefan.kaeser7@gmail.com """ +import numpy as np + +from triqs_tprf.ParameterCollection import ParameterCollection +from triqs_tprf.utilities import create_eliashberg_ingredients + +from triqs_tprf.eliashberg import semi_random_initial_delta + +def test_same_output_for_same_seed(g0_wk): + random_delta1 = semi_random_initial_delta(g0_wk, seed=1) + random_delta2 = semi_random_initial_delta(g0_wk, seed=1) + + np.testing.assert_equal(random_delta1.data, random_delta2.data) + +def test_different_output_for_different_seed(g0_wk): + random_delta1 = semi_random_initial_delta(g0_wk, seed=1) + random_delta2 = semi_random_initial_delta(g0_wk, seed=42) + + try: + np.testing.assert_equal(random_delta1.data, random_delta2.data) + raise ValueError + except AssertionError: + pass + +if __name__ == "__main__": + + p = ParameterCollection( + dim = 2, + norb = 2, + t1 = 1.0, + t2 = 0.5, + t12 = 0.1, + t21 = 0.1, + mu = 0.0, + beta = 1, + U = 0.0, + Up = 0.0, + J = 0.0, + Jp = 0.0, + nk = 2, + nw = 100, + ) + + eliashberg_ingredients = create_eliashberg_ingredients(p) + g0_wk = eliashberg_ingredients.g0_wk + + test_same_output_for_same_seed(g0_wk) + test_different_output_for_different_seed(g0_wk) diff --git a/test/python/eliashberg/solve_eliashberg_functionality.py b/test/python/eliashberg/solve_eliashberg_functionality.py new file mode 100644 index 00000000..a2a833b7 --- /dev/null +++ b/test/python/eliashberg/solve_eliashberg_functionality.py @@ -0,0 +1,195 @@ +""" Author: Stefan Käser (2020) stefan.kaeser7@gmail.com """ +from unittest.mock import patch, MagicMock + +import numpy as np + +from triqs_tprf.ParameterCollection import ParameterCollection +from triqs_tprf.utilities import create_eliashberg_ingredients + +from triqs_tprf.eliashberg import solve_eliashberg + + +@patch("triqs_tprf.eliashberg.implicitly_restarted_arnoldi_method") +def test_no_initial_delta_input(patched_solver, g0_wk, gamma): + patched_solver.return_value = [0.0], [g0_wk.data.flatten()] + with patch("triqs_tprf.eliashberg.semi_random_initial_delta") as patched: + patched.return_value = g0_wk + + solve_eliashberg(gamma, g0_wk) + + patched.assert_called() + + +@patch("triqs_tprf.eliashberg.implicitly_restarted_arnoldi_method") +def test_initial_delta_input(patched_solver, g0_wk, gamma): + patched_solver.return_value = [0.0], [g0_wk.data.flatten()] + with patch("triqs_tprf.eliashberg.semi_random_initial_delta") as patched: + patched.return_value = g0_wk + + solve_eliashberg(gamma, g0_wk, initial_delta=g0_wk) + + patched.assert_not_called() + + +def test_tol_used_in_IRAM(g0_wk, gamma): + expected_tol = 1e-4 + + with patch("triqs_tprf.eliashberg.implicitly_restarted_arnoldi_method") as patched: + patched.return_value = [0.0], [g0_wk.data.flatten()] + + solve_eliashberg(gamma, g0_wk, solver="IRAM", tol=expected_tol) + + kwargs = patched.call_args[-1] + called_tol = kwargs["tol"] + assert called_tol == expected_tol + + +def test_tol_used_in_PM(g0_wk, gamma): + expected_tol = 1e-10 + + with patch("triqs_tprf.eliashberg.power_method_LR") as patched: + patched.return_value = 0.0, g0_wk.data.flatten() + + solve_eliashberg(gamma, g0_wk, solver="PM", tol=expected_tol) + + kwargs = patched.call_args[-1] + called_tol = kwargs["tol"] + assert called_tol == expected_tol + + +def test_call_eliashberg_product_fft(g0_wk, gamma): + with patch("triqs_tprf.eliashberg.eliashberg_product_fft") as patched: + patched.return_value = g0_wk + + solve_eliashberg(gamma, g0_wk, product="FFT") + + patched.assert_called() + + +def test_call_eliashberg_product_fft_constant(g0_wk, gamma): + with patch("triqs_tprf.eliashberg.eliashberg_product_fft_constant") as patched: + patched.return_value = g0_wk + + non_dynamic_gamma = 0 * gamma + + solve_eliashberg(non_dynamic_gamma, g0_wk, product="FFT") + + patched.assert_called() + + +def test_call_eliashberg_product(g0_wk, gamma): + with patch("triqs_tprf.eliashberg.eliashberg_product") as patched: + patched.return_value = g0_wk + + solve_eliashberg(gamma, g0_wk, product="SUM") + + patched.assert_called() + + +def test_wrong_input_for_product(g0_wk, gamma): + wrong_input = "false" + + try: + solve_eliashberg(gamma, g0_wk, product=wrong_input) + except NotImplementedError as e: + expected_message = ( + "There is no implementation of the eliashberg product called %s." + % wrong_input + ) + assert str(e) == expected_message + + +def test_call_IRAM_solver(g0_wk, gamma): + with patch("triqs_tprf.eliashberg.implicitly_restarted_arnoldi_method") as patched: + patched.return_value = [0.0], [g0_wk.data.flatten()] + + solve_eliashberg(gamma, g0_wk, solver="IRAM") + + patched.assert_called() + + +def test_call_PM_solver(g0_wk, gamma): + with patch("triqs_tprf.eliashberg.power_method_LR") as patched: + patched.return_value = 0.0, g0_wk.data.flatten() + + solve_eliashberg(gamma, g0_wk, solver="PM") + + patched.assert_called() + + +def test_wrong_input_for_solver(g0_wk, gamma): + wrong_input = "false" + + try: + solve_eliashberg(gamma, g0_wk, solver=wrong_input) + except NotImplementedError as e: + expected_message = "There is no solver called %s." % wrong_input + assert str(e) == expected_message + + +@patch("triqs_tprf.eliashberg.eliashberg_product_fft") +def test_call_symmetrize_function(patched_product, g0_wk, gamma): + patched_product.return_value = g0_wk + + symmetrize_fct = MagicMock() + symmetrize_fct.return_value = g0_wk + + solve_eliashberg(gamma, g0_wk, symmetrize_fct=symmetrize_fct) + + symmetrize_fct.assert_called() + + +def test_invalid_symmetrize_function(g0_wk, gamma): + invalid_symmetrize_fct = lambda x: 1 + + try: + solve_eliashberg(gamma, g0_wk, symmetrize_fct=invalid_symmetrize_fct) + except AttributeError as e: + assert str(e) == "'int' object has no attribute 'data'" + + +@patch("triqs_tprf.eliashberg.eliashberg_product_fft") +def test_k_input(patched_product, g0_wk, gamma): + patched_product.return_value = g0_wk + + for k_input in [1, 3]: + Es, evs = solve_eliashberg(gamma, g0_wk, k=k_input) + assert len(Es) == k_input + assert len(evs) == k_input + + +if __name__ == "__main__": + p = ParameterCollection( + dim=2, + norb=1, + t=1.0, + mu=0.0, + beta=1, + U=1.0, + Up=0.0, + J=0.0, + Jp=0.0, + nk=2, + nw=100, + ) + + eliashberg_ingredients = create_eliashberg_ingredients(p) + g0_wk = eliashberg_ingredients.g0_wk + gamma = eliashberg_ingredients.gamma + + test_no_initial_delta_input(g0_wk=g0_wk, gamma=gamma) + test_initial_delta_input(g0_wk=g0_wk, gamma=gamma) + test_tol_used_in_IRAM(g0_wk, gamma) + test_tol_used_in_PM(g0_wk, gamma) + test_call_eliashberg_product_fft(g0_wk, gamma) + test_call_eliashberg_product_fft_constant(g0_wk, gamma) + test_call_eliashberg_product(g0_wk, gamma) + + test_call_IRAM_solver(g0_wk, gamma) + test_call_PM_solver(g0_wk, gamma) + + test_wrong_input_for_product(g0_wk, gamma) + test_wrong_input_for_solver(g0_wk, gamma) + test_call_symmetrize_function(g0_wk=g0_wk, gamma=gamma) + test_invalid_symmetrize_function(g0_wk, gamma) + test_k_input(g0_wk=g0_wk, gamma=gamma) diff --git a/test/python/eliashberg/symmetrize_delta.py b/test/python/eliashberg/symmetrize_delta.py new file mode 100644 index 00000000..dae03f44 --- /dev/null +++ b/test/python/eliashberg/symmetrize_delta.py @@ -0,0 +1,99 @@ +# ---------------------------------------------------------------------- + +""" Test the symmetrizing feature of the solve_eliashberg function + +Author: Stefan Käser (2020) stefan.kaeser7@gmail.com """ + +# ---------------------------------------------------------------------- + +import itertools +import functools + +# ---------------------------------------------------------------------- + +import numpy as np + +# ---------------------------------------------------------------------- + +from triqs.gf import Idx + +from triqs_tprf.ParameterCollection import ParameterCollection +from triqs_tprf.utilities import create_eliashberg_ingredients +from triqs_tprf.eliashberg import solve_eliashberg + +# ---------------------------------------------------------------------- + +from triqs_tprf.symmetries import enforce_symmetry, check_symmetry + +# ---------------------------------------------------------------------- + +def test_symmetry_constraint_of_solve_eliashberg(g0_wk, gamma, do_plot=False): + variables = ["frequency", "momentum", "orbital"] + all_symmetries = [('even', 'odd', 'even'), ('odd', 'even', 'even')] + + for symmetries in all_symmetries: + symmetrize_fct = functools.partial(enforce_symmetry, + variables=variables, + symmetries=symmetries) + + E, eigen_modes = solve_eliashberg(gamma, g0_wk, product='FFT', solver='IRAM', + symmetrize_fct=symmetrize_fct) + + translate_symmetries = {"even" : +1, "odd" : -1, None : None} + expected_symmetries = {variable : translate_symmetries[symmetry] \ + for (variable, symmetry) in zip(variables, symmetries)} + + for delta in eigen_modes: + produced_symmetries = check_symmetry(delta) + if not expected_symmetries == produced_symmetries: + raise AssertionError("Incorrect symmetries were produced.") + + if do_plot: + plot_delta(delta) + +def plot_delta(delta): + import matplotlib.pyplot as plt + + fig, axes = plt.subplots(3, 3) + + vmax = np.max(np.abs(delta[Idx(0),:].data)) + + for orb1, orb2 in itertools.product(list(range(p.norb)), repeat=2): + shape = (p.nk, p.nk, p.norb, p.norb) + data = delta[Idx(0), :].data.reshape(shape) + plt.sca(axes[orb1,orb2]) + plt.imshow(data[:,:,orb1,orb2].real, cmap="RdBu_r", + vmax=vmax, vmin=-vmax) + plt.colorbar() + + plt.sca(axes[-1,-1]) + for orb1, orb2 in itertools.product(list(range(p.norb)), repeat=2): + plt.plot(delta.data[:, 1, orb1, orb2].real) + plt.plot(delta.data[:, 1, orb1, orb2].imag) + + plt.show() + +if __name__ == "__main__": + p = ParameterCollection( + dim = 2, + norb = 2, + t1 = 1.0, + t2 = 0.5, + t12 = 0.1, + t21 = 0.1, + mu = 0.1, + beta = 1, + U = 1.0, + Up = 0.8, + J = 0.1, + Jp = 0.1, + nk = 3, + nw = 50, + plot=False + ) + + eliashberg_ingredients = create_eliashberg_ingredients(p) + g0_wk = eliashberg_ingredients.g0_wk + gamma = eliashberg_ingredients.gamma + + test_symmetry_constraint_of_solve_eliashberg(g0_wk, gamma) diff --git a/test/python/eliashberg_benchmark.tar.gz b/test/python/eliashberg_benchmark.tar.gz deleted file mode 100644 index 6ebe387f..00000000 Binary files a/test/python/eliashberg_benchmark.tar.gz and /dev/null differ diff --git a/test/python/eliashberg_fft.py b/test/python/eliashberg_fft.py deleted file mode 100644 index db43bf43..00000000 --- a/test/python/eliashberg_fft.py +++ /dev/null @@ -1,107 +0,0 @@ -# ---------------------------------------------------------------------- - -""" Compare the naive implementation of the linearized Eliashberg product -and the one using Fourier transformations. -This test is quite computational intensive, because of the inefficiency of -the naive implementations. In the future the Fourier transformation -implementation will subsitute the naive one. -""" - -# ---------------------------------------------------------------------- - -import itertools - -# ---------------------------------------------------------------------- - -import numpy as np - -# ---------------------------------------------------------------------- - -from triqs_tprf.ParameterCollection import ParameterCollection -from triqs.gf import Gf, MeshImFreq - -from triqs_tprf.tight_binding import TBLattice - -from triqs_tprf.lattice import lattice_dyson_g0_wk, solve_rpa_PH -from triqs_tprf.lattice_utils import imtime_bubble_chi0_wk -from triqs_tprf.lattice import gamma_PP_singlet -from triqs_tprf.lattice import eliashberg_product, eliashberg_product_fft -from triqs_tprf.lattice import split_into_dynamic_wk_and_constant_k, dynamic_and_constant_to_tr -from triqs_tprf.eliashberg import solve_eliashberg, solve_eliashberg_fft -from triqs_tprf.rpa_tensor import kanamori_charge_and_spin_quartic_interaction_tensors - -# ---------------------------------------------------------------------- - -p = ParameterCollection( - dim = 1, - norbs = 1, - t = 1.0, - mu = 0.0, - beta = 5, - U = 1.0, - nk = 4, - nw = 500, - ) - -# -- Setup model, RPA susceptibilities and spin/charge interaction - -full_units = [(1, 0, 0), (0, 1, 0), (0, 0, 1)] -all_nn_hoppings = list(itertools.product([-1, 0, 1], repeat=p.dim)) -non_diagonal_hoppings = [ele for ele in all_nn_hoppings if sum(np.abs(ele)) == 1] - -t = -p.t * np.eye(p.norbs) - -H = TBLattice( - units = full_units[:p.dim], - hopping = {hop : t for hop in non_diagonal_hoppings}, - orbital_positions = [(0,0,0)]*p.norbs, - ) - -e_k = H.on_mesh_brillouin_zone(n_k=[p.nk]*p.dim + [1]*(3-p.dim)) - -# A bigger w-mesh is needed to construct a Gamma with a twice as big w-mesh than GF -big_factor = 2.0 - -wmesh = MeshImFreq(beta=p.beta, S='Fermion', n_max=p.nw) -wmesh_big = MeshImFreq(beta=p.beta, S='Fermion', n_max=int(big_factor*p.nw)) - -g0_wk = lattice_dyson_g0_wk(mu=p.mu, e_k=e_k, mesh=wmesh) -g0_wk_big = lattice_dyson_g0_wk(mu=p.mu, e_k=e_k, mesh=wmesh_big) - -chi0_wk_big = imtime_bubble_chi0_wk(g0_wk_big, nw=int(big_factor*p.nw)+1) - -U_c, U_s = kanamori_charge_and_spin_quartic_interaction_tensors(p.norbs, p.U, 0, 0, 0) - -chi_s_big = solve_rpa_PH(chi0_wk_big, U_s) -chi_c_big = solve_rpa_PH(chi0_wk_big, -U_c) # Minus for correct charge rpa equation - -gamma_big = gamma_PP_singlet(chi_c_big, chi_s_big, U_c, U_s) - -# -- Preprocess gamma for the FFT implementation - -gamma_dyn_wk, gamma_const_k = split_into_dynamic_wk_and_constant_k(gamma_big) -gamma_dyn_tr, gamma_const_r = dynamic_and_constant_to_tr(gamma_dyn_wk, gamma_const_k) - -# -- Test the Eliashberg equation - -next_delta = eliashberg_product(gamma_big, g0_wk, g0_wk) -next_delta_fft = eliashberg_product_fft(gamma_dyn_tr, gamma_const_r, g0_wk, g0_wk) - -np.testing.assert_allclose(next_delta.data, next_delta_fft.data, atol=1e-7) - -Es, eigen_modes = solve_eliashberg(gamma_big, g0_wk) -Es_fft, eigen_modes_fft = solve_eliashberg_fft(gamma_big, g0_wk) - -E = Es[0] -eigen_mode = eigen_modes[0] -E_fft = Es_fft[0] -eigen_mode_fft = eigen_modes_fft[0] - -np.testing.assert_allclose(E, E_fft, atol=1e-7) - -try: - np.testing.assert_allclose(eigen_mode.data, eigen_mode_fft.data, atol=1e-7) -except AssertionError: - np.testing.assert_allclose(-eigen_mode.data, eigen_mode_fft.data, atol=1e-7) - -print('\nSame results for both implementations of the linearized Eliashberg equation.') diff --git a/test/python/interaction_tensor_charge_spin_factorization.py b/test/python/interaction_tensor_charge_spin_factorization.py index 35fb1a5b..0c41d42d 100644 --- a/test/python/interaction_tensor_charge_spin_factorization.py +++ b/test/python/interaction_tensor_charge_spin_factorization.py @@ -23,6 +23,7 @@ from triqs_tprf.rpa_tensor import kanamori_charge_and_spin_quartic_interaction_tensors from triqs_tprf.rpa_tensor import split_quartic_tensor_in_charge_and_spin from triqs_tprf.rpa_tensor import quartic_tensor_from_charge_and_spin +from triqs_tprf.rpa_tensor import kanamori_quartic_tensor # ---------------------------------------------------------------------- def print_tensors(T1, T2): @@ -60,7 +61,9 @@ def print_tensors(T1, T2): U_c_ref, U_s_ref = kanamori_charge_and_spin_quartic_interaction_tensors( norb, U, U - 2*J, J, J) + U_abcd_ref_2 = kanamori_quartic_tensor(norb, U, U - 2*J, J, J) + np.testing.assert_array_almost_equal(U_abcd, U_abcd_ref) np.testing.assert_array_almost_equal(U_c, U_c_ref) np.testing.assert_array_almost_equal(U_s, U_s_ref) - + np.testing.assert_array_almost_equal(U_abcd, U_abcd_ref_2) diff --git a/test/python/symmetrize_gf.py b/test/python/symmetrize_gf.py new file mode 100644 index 00000000..31f61e3a --- /dev/null +++ b/test/python/symmetrize_gf.py @@ -0,0 +1,121 @@ +# ---------------------------------------------------------------------- + +""" Symmetrize a randomly filled Green's function in frequency, momentum, + and orbital and test if it was done proberly. + +Author: Stefan Käser (2020) stefan.kaeser7@gmail.com """ + +# ---------------------------------------------------------------------- + +import itertools + +# ---------------------------------------------------------------------- + +import numpy as np + +# ---------------------------------------------------------------------- + +from triqs.gf import Gf, MeshImFreq, MeshBrillouinZone, MeshProduct +from triqs.lattice import BrillouinZone, BravaisLattice +from triqs_tprf.ParameterCollection import * + +# ---------------------------------------------------------------------- + +from triqs_tprf.symmetries import enforce_symmetry, check_symmetry, _invert_momentum + +# ---------------------------------------------------------------------- + +p = ParameterCollection(beta = 10, + nw = 10, + nk = 4, + norb = 2,) + +wmesh = MeshImFreq(beta=p.beta, S='Fermion', n_max=p.nw) + +cell = np.eye(3) +bl = BravaisLattice(cell) +bz = BrillouinZone(bl) +kmesh = MeshBrillouinZone(bz, p.nk * np.eye(3, dtype=np.int32)) + +gf = Gf(mesh=MeshProduct(wmesh, kmesh), target_shape=2*(p.norb,)) +gf.data[:] = np.random.rand(*gf.data.shape) + +# -- Eexception handling +try: + enforce_symmetry(gf, "something", "odd") +except ValueError as error: + if not str(error) == "No symmetrize function for this variable exists.": + raise Exception("Wrong exception was raised: \n %s"%error) +else: + raise Exception("Function call should have failed.") + +try: + enforce_symmetry(gf, "frequency", "weird") +except ValueError as error: + if not str(error) == "Symmetry can only be 'even' or 'odd'.": + raise Exception("Wrong exception was raised: \n %s"%error) +else: + raise Exception("Function call should have failed.") + +# -- Frequency +even_freq_gf = enforce_symmetry(gf, "frequency", "even") +np.testing.assert_equal(+1, check_symmetry(even_freq_gf)['frequency']) + +odd_freq_gf = enforce_symmetry(gf, "frequency", "odd") +np.testing.assert_equal(-1, check_symmetry(odd_freq_gf)['frequency']) + +# -- Momentum +momentum_mesh = [16, 32, 5] +momenta = [ [0, 0, 0], + [1, 4, 0], + [8, 16, 3], + ] +inv_momenta = [ [0, 0, 0], + [15, 28, 0], + [8, 16, 2], + ] +for momentum, inv_momentum in zip(momenta, inv_momenta): + inv_momentum_test = _invert_momentum(momentum, momentum_mesh) + if not np.equal(inv_momentum, inv_momentum_test).all: + raise Exception("The function '_invert_momentum' does not behave as" + " expected.") + +even_momentum_gf = enforce_symmetry(gf, "momentum", "even") +np.testing.assert_equal(+1, check_symmetry(even_momentum_gf)["momentum"]) + +odd_momentum_gf = enforce_symmetry(gf, "momentum", "odd") +np.testing.assert_equal(-1, check_symmetry(odd_momentum_gf)["momentum"]) + +# -- Orbital + +even_orbital_gf = enforce_symmetry(gf, "orbital", "even") +np.testing.assert_equal(+1, check_symmetry(even_orbital_gf)["orbital"]) + +odd_orbital_gf = enforce_symmetry(gf, "orbital", "odd") +np.testing.assert_equal(-1, check_symmetry(odd_orbital_gf)["orbital"]) + +# -- Combination +variables = ["frequency", "momentum", "orbital"] +avail_symmetries = ["even", "odd", None] +for symmetries in itertools.product(avail_symmetries, repeat=len(variables)): + + # Remove the corresponding variable to None that it does not get symmetrized + variables_copy = list(variables) + symmetries_copy = list(symmetries) + while None in symmetries_copy: + idx = symmetries_copy.index(None) + del symmetries_copy[idx] + del variables_copy[idx] + + symmetrized_gf = enforce_symmetry(gf, variables_copy, symmetries_copy) + + translate_symmetries = {"even" : +1, "odd" : -1, None : None} + expected_symmetries = {variable : translate_symmetries[symmetry] \ + for (variable, symmetry) in zip(variables, symmetries)} + + produced_symmetries = check_symmetry(symmetrized_gf) + + if not expected_symmetries == produced_symmetries: + raise AssertionError("Incorrect symmetries were produced") + +print("It's all good honey")