quant-met 0.0.26__py3-none-any.whl → 0.1.0__py3-none-any.whl

quant_met/cli/dmft.py

@@ -1,96 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""Functions to run self-consistent calculation for the order parameter."""
-
-import logging
-from pathlib import Path
-
-from h5 import HDFArchive
-from mpi4py import MPI
-from triqs.gf import Gf
-
-from quant_met.cli._utils import _hamiltonian_factory, _tbl_factory
-from quant_met.dmft.dmft_loop import dmft_loop
-from quant_met.dmft.utils import get_gloc
-from quant_met.parameters import Parameters
-
-logger = logging.getLogger(__name__)
-
-
-def dmft_scf(parameters: Parameters) -> None:
-    """Self-consistent calculation for the order parameter.
-
-    Parameters
-    ----------
-    parameters: Parameters
-        An instance of Parameters containing control settings, the model,
-        and k-point specifications for the self-consistency calculation.
-    """
-    result_path = Path(parameters.control.outdir)
-    result_path.mkdir(exist_ok=True, parents=True)
-
-    h = _hamiltonian_factory(parameters=parameters.model, classname=parameters.model.name)
-    tbl = _tbl_factory(h=h)
-
-    kmesh = tbl.get_kmesh(n_k=(parameters.k_points.nk1, parameters.k_points.nk2, 1))
-
-    enk = tbl.fourier(kmesh)
-    n_orbitals = tbl.n_orbitals
-    nambu_shape = (2 * n_orbitals, 2 * n_orbitals)
-    h0_nambu_k = Gf(mesh=kmesh, target_shape=nambu_shape)
-    for k in kmesh:
-        h0_nambu_k[k][:n_orbitals, :n_orbitals] = enk(k)
-        h0_nambu_k[k][n_orbitals:, n_orbitals:] = -enk(-k)
-
-    ust = 0
-    jh = 0
-    xmu = (
-        h.hubbard_int_orbital_basis[0] / 2
-        + (tbl.n_orbitals - 1) * ust / 2
-        + (tbl.n_orbitals - 1) * (ust - jh) / 2
-    )
-
-    solver = dmft_loop(
-        tbl=tbl,
-        h=h,
-        h0_nambu_k=h0_nambu_k,
-        n_bath=parameters.control.n_bath,
-        n_iw=parameters.control.n_iw,
-        broadening=parameters.control.broadening,
-        n_w=parameters.control.n_w,
-        w_mixing=parameters.control.wmixing,
-        n_success=parameters.control.n_success,
-        xmu=xmu,
-        kmesh=kmesh,
-        epsilon=parameters.control.conv_treshold,
-        max_iter=parameters.control.max_iter,
-    )
-
-    # Calculate local Green's function on the real axis
-    s_w = solver.Sigma_w["up"]
-    s_an_w = solver.Sigma_an_w["up_dn"]
-    s_iw = solver.Sigma_iw["up"]
-    s_an_iw = solver.Sigma_an_iw["up_dn"]
-    g_iw, g_an_iw = get_gloc(s_iw, s_an_iw, h0_nambu_k, xmu, parameters.control.broadening, kmesh)
-    g_w, g_an_w = get_gloc(s_w, s_an_w, h0_nambu_k, xmu, parameters.control.broadening, kmesh)
-
-    comm = MPI.COMM_WORLD
-    rank = comm.Get_rank()
-
-    if rank == 0:
-        data_dir = Path("data/DressedGraphene/dmft/sweep_V/")
-        data_dir.mkdir(parents=True, exist_ok=True)
-
-        # Save calculation results
-        result_file = result_path / f"{parameters.control.prefix}.hdf5"
-        with HDFArchive(f"{result_file}", "w") as ar:
-            ar["s_iw"] = s_iw
-            ar["s_an_iw"] = s_an_iw
-            ar["g_iw"] = g_iw
-            ar["g_an_iw"] = g_an_iw
-            ar["g_w"] = g_w
-            ar["g_an_w"] = g_an_w
-
-        logger.info("Results saved to %s", result_file)

quant_met/dmft/__init__.py

@@ -1,5 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""DMFT package."""

quant_met/dmft/dmft_loop.py

@@ -1,178 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""Functions to run self-consistent calculation for the order parameter."""
-
-import logging
-from itertools import product
-
-import numpy as np
-import numpy.typing as npt
-from edipack2triqs.fit import BathFittingParams
-from edipack2triqs.solver import EDIpackSolver
-from triqs.gf import BlockGf, Gf, MeshBrZone
-from triqs.lattice.tight_binding import TBLattice
-from triqs.operators import c, c_dag, dagger, n
-
-from quant_met.mean_field.hamiltonians import BaseHamiltonian
-from quant_met.parameters import GenericParameters
-
-from .utils import _check_convergence, _dmft_weiss_field, get_gloc
-
-logger = logging.getLogger(__name__)
-
-
-def dmft_loop(
-    tbl: TBLattice,
-    h: BaseHamiltonian[GenericParameters],
-    h0_nambu_k: Gf,
-    n_bath: float,
-    n_iw: int,
-    broadening: float,
-    n_w: int,
-    w_mixing: float,
-    n_success: int,
-    xmu: npt.NDArray[np.float64],
-    kmesh: MeshBrZone,
-    epsilon: float,
-    max_iter: int,
-) -> EDIpackSolver:
-    """DMFT loop.
-
-    Parameters
-    ----------
-    tbl
-    h
-    h0_nambu_k
-    n_bath
-    n_iw
-    broadening
-    n_w
-    w_mixing
-    n_success
-    xmu
-    kmesh
-    epsilon
-    max_iter
-
-    Returns
-    -------
-    EDIpackSolver
-
-    """
-    energy_window = (-2.0 * h.hopping_gr, 2.0 * h.hopping_gr)
-
-    spins = ("up", "dn")
-    orbs = range(tbl.n_orbitals)
-
-    # Fundamental sets for impurity degrees of freedom
-    fops_imp_up = [("up", o) for o in orbs]
-    fops_imp_dn = [("dn", o) for o in orbs]
-
-    # Fundamental sets for bath degrees of freedom
-    fops_bath_up = [("B_up", i) for i in range(tbl.n_orbitals * n_bath)]
-    fops_bath_dn = [("B_dn", i) for i in range(tbl.n_orbitals * n_bath)]
-
-    # Non-interacting part of the impurity Hamiltonian
-    h_loc = -xmu * np.eye(tbl.n_orbitals)
-    hamiltonian = sum(
-        h_loc[o1, o2] * c_dag(spin, o1) * c(spin, o2) for spin, o1, o2 in product(spins, orbs, orbs)
-    )
-
-    ust = 0
-    jh = 0
-    jx = 0
-    jp = 0
-
-    # Interaction part
-    hamiltonian += h.hubbard_int_orbital_basis[0] * sum(n("up", o) * n("dn", o) for o in orbs)
-    hamiltonian += ust * sum(
-        int(o1 != o2) * n("up", o1) * n("dn", o2) for o1, o2 in product(orbs, orbs)
-    )
-    hamiltonian += (ust - jh) * sum(
-        int(o1 < o2) * n(s, o1) * n(s, o2) for s, o1, o2 in product(spins, orbs, orbs)
-    )
-    hamiltonian -= jx * sum(
-        int(o1 != o2) * c_dag("up", o1) * c("dn", o1) * c_dag("dn", o2) * c("up", o2)
-        for o1, o2 in product(orbs, orbs)
-    )
-    hamiltonian += jp * sum(
-        int(o1 != o2) * c_dag("up", o1) * c_dag("dn", o1) * c("dn", o2) * c("up", o2)
-        for o1, o2 in product(orbs, orbs)
-    )
-
-    # Matrix dimensions of eps and V: 3 orbitals x 2 bath states
-    eps = np.array([[-1.0, -0.5, 0.5, 1.0] for _ in range(tbl.n_orbitals)])
-    v = 0.5 * np.ones((tbl.n_orbitals, n_bath))
-    d = -0.2 * np.eye(tbl.n_orbitals * n_bath)
-
-    # Bath
-    hamiltonian += sum(
-        eps[o, nu] * c_dag("B_" + s, o * n_bath + nu) * c("B_" + s, o * n_bath + nu)
-        for s, o, nu in product(spins, orbs, range(n_bath))
-    )
-
-    hamiltonian += sum(
-        v[o, nu]
-        * (c_dag(s, o) * c("B_" + s, o * n_bath + nu) + c_dag("B_" + s, o * n_bath + nu) * c(s, o))
-        for s, o, nu in product(spins, orbs, range(n_bath))
-    )
-
-    # Anomalous bath
-    hamiltonian += sum(
-        d[o, q] * (c("B_up", o) * c("B_dn", q)) + dagger(d[o, q] * (c("B_up", o) * c("B_dn", q)))
-        for o, q in product(range(tbl.n_orbitals * n_bath), range(tbl.n_orbitals * n_bath))
-    )
-
-    # Create solver object
-    fit_params = BathFittingParams(method="minimize", grad="numeric")
-    solver = EDIpackSolver(
-        hamiltonian,
-        fops_imp_up,
-        fops_imp_dn,
-        fops_bath_up,
-        fops_bath_dn,
-        lanc_dim_threshold=1024,
-        verbose=1,
-        bath_fitting_params=fit_params,
-    )
-
-    for iloop in range(max_iter):
-        print(f"\nLoop {iloop + 1} of {max_iter}")
-
-        # Solve the effective impurity problem
-        solver.solve(
-            beta=h.beta,
-            n_iw=n_iw,
-            energy_window=energy_window,
-            n_w=n_w,
-            broadening=broadening,
-        )
-
-        # Normal and anomalous components of computed self-energy
-        s_iw = solver.Sigma_iw["up"]
-        s_an_iw = solver.Sigma_an_iw["up_dn"]
-
-        # Compute local Green's function
-        g_iw, g_an_iw = get_gloc(s_iw, s_an_iw, h0_nambu_k, xmu, broadening, kmesh)
-        # Compute Weiss field
-        g0_iw, g0_an_iw = _dmft_weiss_field(g_iw, g_an_iw, s_iw, s_an_iw)
-
-        # Bath fitting and mixing
-        g0_iw_full = BlockGf(name_list=spins, block_list=[g0_iw, g0_iw])
-        g0_an_iw_full = BlockGf(name_list=["up_dn"], block_list=[g0_an_iw])
-
-        bath_new = solver.chi2_fit_bath(g0_iw_full, g0_an_iw_full)[0]
-        solver.bath = w_mixing * bath_new + (1 - w_mixing) * solver.bath
-
-        # Check convergence of the Weiss field
-        g0 = np.asarray([g0_iw.data, g0_an_iw.data])
-        # Check convergence of the Weiss field
-        g0 = np.asarray([g0_iw.data, g0_an_iw.data])
-        err, converged = _check_convergence(g0, epsilon, n_success, max_iter)
-
-        if converged:
-            break
-
-    return solver

quant_met/dmft/utils.py

@@ -1,207 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""Utility functions used in DMFT."""
-
-import sys
-from pathlib import Path
-
-import numpy as np
-import numpy.typing as npt
-from mpi4py import MPI
-from triqs.gf import Gf, MeshBrZone, MeshImFreq, MeshProduct, conjugate, dyson, inverse, iOmega_n
-
-
-def _check_convergence(
-    func: npt.NDArray[np.complex128], threshold: float = 1e-6, nsuccess: int = 1, nloop: int = 100
-) -> tuple[float, bool]:
-    comm = MPI.COMM_WORLD
-    rank = comm.Get_rank()
-
-    func = np.asarray(func)
-    err = 1.0
-    conv_bool = False
-    outfile = "error.err"
-
-    if globals().get("_whichiter") is None:
-        global _whichiter
-        global _gooditer
-        global _oldfunc
-
-        _whichiter = 0
-        _gooditer = 0
-        _oldfunc = np.zeros_like(func)
-
-    green = "\033[92m"
-    yellow = "\033[93m"
-    red = "\033[91m"
-    bold = "\033[1m"
-    colorend = "\033[0m"
-
-    # only the master does the calculation
-    if rank == 0:
-        errvec = np.real(np.sum(abs(func - _oldfunc), axis=-1) / np.sum(abs(func), axis=-1))
-        # first iteration
-        if _whichiter == 0:
-            errvec = np.ones_like(errvec)
-            # remove nan compoments, if some component is divided by zero
-        if np.prod(np.shape(errvec)) > 1:
-            errvec = errvec[~np.isnan(errvec)]
-        errmax = np.max(errvec)
-        errmin = np.min(errvec)
-        err = np.average(errvec)
-        _oldfunc = np.copy(func)
-        if err < threshold:
-            _gooditer += 1  # increase good iterations count
-        else:
-            _gooditer = 0  # reset good iterations count
-        _whichiter += 1
-        conv_bool = ((err < threshold) and (_gooditer > nsuccess) and (_whichiter < nloop)) or (
-            _whichiter >= nloop
-        )
-
-        # write out
-        with Path(outfile).open("a") as file:
-            file.write(f"{_whichiter} {err:.6e}\n")
-        if np.prod(np.shape(errvec)) > 1:
-            with Path(outfile + ".max").open("a") as file:
-                file.write(f"{_whichiter} {errmax:.6e}\n")
-            with Path(outfile + ".min").open("a") as file:
-                file.write(f"{_whichiter} {errmin:.6e}\n")
-            with Path(outfile + ".distribution").open("a") as file:
-                file.write(
-                    f"{_whichiter}" + " ".join([f"{x:.6e}" for x in errvec.flatten()]) + "\n"
-                )
-
-        # print convergence message:
-        if conv_bool:
-            colorprefix = bold + green
-        elif (err < threshold) and (_gooditer <= nsuccess):
-            colorprefix = bold + yellow
-        else:
-            colorprefix = bold + red
-
-        if _whichiter < nloop:
-            if np.prod(np.shape(errvec)) > 1:
-                print(colorprefix + "max error=" + colorend + f"{errmax:.6e}")
-            print(
-                colorprefix
-                + "    " * (np.prod(np.shape(errvec)) > 1)
-                + "error="
-                + colorend
-                + f"{err:.6e}"
-            )
-            if np.prod(np.shape(errvec)) > 1:
-                print(colorprefix + "min error=" + colorend + f"{errmin:.6e}")
-        else:
-            if np.prod(np.shape(errvec)) > 1:
-                print(colorprefix + "max error=" + colorend + f"{errmax:.6e}")
-            print(
-                colorprefix
-                + "    " * (np.prod(np.shape(errvec)) > 1)
-                + "error="
-                + colorend
-                + f"{err:.6e}"
-            )
-            if np.prod(np.shape(errvec)) > 1:
-                print(colorprefix + "min error=" + colorend + f"{errmin:.6e}")
-            print("Not converged after " + str(nloop) + " iterations.")
-            with Path("ERROR.README").open("a") as file:
-                file.write("Not converged after " + str(nloop) + " iterations.")
-        print("\n")
-
-    # pass to other cores:
-    conv_bool = comm.bcast(conv_bool, root=0)
-    err = comm.bcast(err, root=0)
-    sys.stdout.flush()
-    return err, conv_bool
-
-
-def get_gloc(
-    s: Gf,
-    s_an: Gf,
-    h0_nambu_k: Gf,
-    xmu: npt.NDArray[np.complex128],
-    broadening: float,
-    kmesh: MeshBrZone,
-) -> tuple[Gf, Gf]:
-    """Compute local GF from bare lattice Hamiltonian and self-energy.
-
-    Parameters
-    ----------
-    s
-    s_an
-    h0_nambu_k
-
-    Returns
-    -------
-    tuple[Gf, Gf]
-
-    """
-    z = Gf(mesh=s.mesh, target_shape=h0_nambu_k.target_shape)
-    n_orbitals = z.target_shape[0] // 2
-    if isinstance(s.mesh, MeshImFreq):
-        z[:n_orbitals, :n_orbitals] << iOmega_n + xmu - s
-        z[:n_orbitals, n_orbitals:] << -s_an
-        z[n_orbitals:, :n_orbitals] << -s_an
-        z[n_orbitals:, n_orbitals:] << iOmega_n - xmu + conjugate(s)
-    else:
-        z[:n_orbitals, n_orbitals:] << -s_an
-        z[n_orbitals:, :n_orbitals] << -s_an
-        for w in z.mesh:
-            z[w][:n_orbitals, :n_orbitals] = (w + 1j * broadening + xmu) * np.eye(n_orbitals) - s[w]
-            z[w][n_orbitals:, n_orbitals:] = (w + 1j * broadening - xmu) * np.eye(
-                n_orbitals
-            ) + conjugate(s(-w))
-
-    g_k = Gf(mesh=MeshProduct(kmesh, z.mesh), target_shape=h0_nambu_k.target_shape)
-    for k in kmesh:
-        g_k[k, :] << inverse(z - h0_nambu_k[k])
-
-    g_loc_nambu = sum(g_k[k, :] for k in kmesh) / len(kmesh)
-
-    g_loc = s.copy()
-    g_loc_an = s_an.copy()
-    g_loc[:] = g_loc_nambu[:n_orbitals, :n_orbitals]
-    g_loc_an[:] = g_loc_nambu[:n_orbitals, n_orbitals:]
-    return g_loc, g_loc_an
-
-
-def _dmft_weiss_field(g_iw: Gf, g_an_iw: Gf, s_iw: Gf, s_an_iw: Gf) -> tuple[Gf, Gf]:
-    """Compute Weiss field from local GF and self-energy.
-
-    Parameters
-    ----------
-    g_iw
-    g_an_iw
-    s_iw
-    s_an_iw
-
-    Returns
-    -------
-    tuple[Gf, Gf]
-
-    """
-    n_orbitals = g_iw.target_shape[0]
-    nambu_shape = (2 * n_orbitals, 2 * n_orbitals)
-    g_nambu_iw = Gf(mesh=g_iw.mesh, target_shape=nambu_shape)
-    s_nambu_iw = Gf(mesh=s_iw.mesh, target_shape=nambu_shape)
-
-    g_nambu_iw[:n_orbitals, :n_orbitals] = g_iw
-    g_nambu_iw[:n_orbitals, n_orbitals:] = g_an_iw
-    g_nambu_iw[n_orbitals:, :n_orbitals] = g_an_iw
-    g_nambu_iw[n_orbitals:, n_orbitals:] = -conjugate(g_iw)
-
-    s_nambu_iw[:n_orbitals, :n_orbitals] = s_iw
-    s_nambu_iw[:n_orbitals, n_orbitals:] = s_an_iw
-    s_nambu_iw[n_orbitals:, :n_orbitals] = s_an_iw
-    s_nambu_iw[n_orbitals:, n_orbitals:] = -conjugate(s_iw)
-
-    g0_nambu_iw = dyson(G_iw=g_nambu_iw, Sigma_iw=s_nambu_iw)
-
-    g0_iw = g_iw.copy()
-    g0_an_iw = g_an_iw.copy()
-    g0_iw[:] = g0_nambu_iw[:n_orbitals, :n_orbitals]
-    g0_an_iw[:] = g0_nambu_iw[:n_orbitals, n_orbitals:]
-    return g0_iw, g0_an_iw

quant_met/geometry/__init__.py

@@ -1,35 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""
-Geometry
-========
-
-.. currentmodule:: quant_met.geometry
-
-Functions
----------
-
-.. autosummary::
-   :toctree: generated/
-
-    generate_bz_path
-
-Classes
--------
-
-.. autosummary::
-   :toctree: generated/
-
-   BaseLattice
-   GrapheneLattice
-   SquareLattice
-"""  # noqa: D205, D400
-
-from .base_lattice import BaseLattice
-from .bz_path import generate_bz_path
-from .graphene import GrapheneLattice
-from .square import SquareLattice
-
-__all__ = ["BaseLattice", "GrapheneLattice", "SquareLattice", "generate_bz_path"]

quant_met/geometry/base_lattice.py

@@ -1,99 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""Base class for lattice geometries."""
-
-from abc import ABC, abstractmethod
-
-import numpy as np
-import numpy.typing as npt
-
-from quant_met.utils import generate_uniform_grid
-
-from .bz_path import generate_bz_path
-
-
-class BaseLattice(ABC):
-    """Base class for lattice geometries."""
-
-    @property
-    @abstractmethod
-    def lattice_constant(self) -> float:  # pragma: no cover
-        """Lattice constant."""
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def bz_corners(self) -> npt.NDArray[np.floating]:  # pragma: no cover
-        """Corners of the BZ."""
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def reciprocal_basis(
-        self,
-    ) -> tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]:  # pragma: no cover
-        """Reciprocal basis vectors."""
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def high_symmetry_points(
-        self,
-    ) -> tuple[tuple[npt.NDArray[np.floating], str], ...]:  # pragma: no cover
-        """Tuple of high symmetry points and names."""
-        raise NotImplementedError
-
-    def generate_bz_grid(self, ncols: int, nrows: int) -> npt.NDArray[np.floating]:
-        """Generate a grid in the BZ.
-
-        Parameters
-        ----------
-        ncols : int
-            Number of points in column.
-        nrows : int
-            Number of points in row.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            Array of grid points in the BZ.
-
-        """
-        return generate_uniform_grid(
-            ncols,
-            nrows,
-            self.reciprocal_basis[0],
-            self.reciprocal_basis[1],
-            origin=np.array([0, 0]),
-        )
-
-    def generate_high_symmetry_path(
-        self, number_of_points: int
-    ) -> tuple[
-        npt.NDArray[np.floating],
-        npt.NDArray[np.floating],
-        list[float],
-        list[str],
-    ]:
-        """Generate a path through high symmetry points.
-
-        Parameters
-        ----------
-        number_of_points: int
-            Number of point in the whole path.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            List of two-dimensional k points.
-        :class:`numpy.ndarray`
-            Path for plotting purposes: points between 0 and 1, with appropriate spacing.
-        list[float]
-            A list of ticks for the plotting path.
-        list[str]
-            A list of labels for the plotting path.
-
-        """
-        return generate_bz_path(list(self.high_symmetry_points), number_of_points=number_of_points)