downfolding.hpp

Go to the documentation of this file.

// Copyright (c) 2025--present, The Simons Foundation
// This file is part of TRIQS/modest and is licensed under the terms of GPLv3 or later.
// SPDX-License-Identifier: GPL-3.0-or-later
// See LICENSE in the root of this distribution for details.
 
#pragma once
#include <triqs/gfs.hpp>
#include <type_traits>
#include "./local_space.hpp"
#include "./ibz_symmetry_ops.hpp"
#include "utils/nda_supp.hpp"
 
namespace triqs::modest {
 
  [[nodiscard]] inline long sigma_to_data_idx(spin_kind_e spin_kind, long sigma) { return (spin_kind == spin_kind_e::Polarized) ? sigma : 0; };
 
  struct band_dispersion {
    spin_kind_e spin_kind;             
    nda::array<dcomplex, 4> H_k;       
    nda::array<long, 2> n_bands_per_k; 
    nda::array<double, 1> k_weights;   
    bool matrix_valued;                
 
    bool operator==(band_dispersion const &) const = default;
 
    friend void mpi_broadcast(band_dispersion &x, mpi::communicator c = {}, int root = 0) {
      mpi::broadcast(x.spin_kind, c, root);
      mpi::broadcast(x.H_k, c, root);
      mpi::broadcast(x.n_bands_per_k, c, root);
      mpi::broadcast(x.k_weights, c, root);
      mpi::broadcast(x.matrix_valued, c, root);
    }
 
    // public:
    // /// Constructor
    // band_dispersion(spin_kind_e spin_kind, nda::array<dcomplex, 4> H_k, nda::array<long, 2> n_bands_per_k,
    //                 nda::array<double, 1> k_weights)
    //    : spin_kind(spin_kind),
    //      H_k(std::move(H_k)),
    //      n_bands_per_k(std::move(n_bands_per_k)),
    //      _k_weights(std::move(k_weights)) {
    //   // TODO add some checks on the data ?
    // }
 
    [[nodiscard]] nda::matrix_const_view<dcomplex> H(long sigma, long k_idx) const {
      auto sigma_p = sigma_to_data_idx(spin_kind, sigma);
      auto R_nu    = nda::range(n_bands_per_k(k_idx, sigma_p));
      return H_k(k_idx, sigma_p, R_nu, R_nu);
    }
 
    [[nodiscard]] long N_nu(long sigma, long k_idx) const { return n_bands_per_k(k_idx, sigma_to_data_idx(spin_kind, sigma)); }
 
    [[nodiscard]] long n_k() const { return H_k.extent(0); }
 
    // /// Weight of k point (typically from DFT code).
    // [[nodiscard]] double k_weights(long k_idx) const { return _k_weights(k_idx); }
 
    friend std::ostream &operator<<(std::ostream &out, band_dispersion const &bd);
  };
 
  struct downfolding_projector {
    spin_kind_e spin_kind;             
    nda::array<dcomplex, 4> P_k;       
    nda::array<long, 2> n_bands_per_k; 
 
    bool operator==(downfolding_projector const &) const = default;
 
    friend void mpi_broadcast(downfolding_projector &x, mpi::communicator c = {}, int root = 0) {
      mpi::broadcast(x.spin_kind, c, root);
      mpi::broadcast(x.P_k, c, root);
      mpi::broadcast(x.n_bands_per_k, c, root);
    }
 
    // public:
    // /// Constructor
    // downfolding_projector(spin_kind_e spin_kind, nda::array<dcomplex, 4> P_k, nda::array<long, 2> n_bands_per_k)
    //    : spin_kind(spin_kind), P_k(std::move(P_k)), n_bands_per_k(std::move(n_bands_per_k)) {}
 
    // ----------------- accessors --------------------
    // FIXME : SWAP k and sigma in data
 
    [[nodiscard]] nda::matrix_const_view<dcomplex> P(long sigma, long k_idx) const {
      auto sigma_p = sigma_to_data_idx(spin_kind, sigma);
      auto R_nu    = nda::range(n_bands_per_k(k_idx, sigma_p));
      return P_k(k_idx, sigma_p, r_all, R_nu);
    }
 
    downfolding_projector rotate_local_basis(nda::array<nda::matrix<dcomplex>, 2> const &U) const;
 
    friend std::ostream &operator<<(std::ostream &out, downfolding_projector const &proj);
  };
 
  // ------------------------------------------------------------
  struct one_body_elements_on_grid {
    band_dispersion H;                                 
    local_space C_space;                               
    downfolding_projector P;                           
    std::optional<ibz_symmetry_ops> ibz_symm_ops = {}; 
 
    bool operator==(one_body_elements_on_grid const &) const = default;
 
    friend void mpi_broadcast(one_body_elements_on_grid &x, mpi::communicator c = {}, int root = 0) {
      mpi::broadcast(x.H, c, root);
      mpi::broadcast(x.C_space, c, root);
      mpi::broadcast(x.P, c, root);
      mpi::broadcast(x.ibz_symm_ops, c, root);
    }
  };
 
  std::ostream &operator<<(std::ostream &out, one_body_elements_on_grid const &);
  void h5_read(h5::group g, std::string const &name, one_body_elements_on_grid &x);
  void h5_write(h5::group g, std::string const &name, one_body_elements_on_grid const &x);
 
  //-------------------------------------------------------------
  one_body_elements_on_grid permute_local_space(std::vector<std::vector<long>> const &atom_partition, one_body_elements_on_grid const &x);
 
  // -------------------------------------------------------------
  one_body_elements_on_grid rotate_local_basis(nda::array<nda::matrix<dcomplex>, 2> const &U, one_body_elements_on_grid const &x);
  // -------------------------------------------------------------
 
 
  nda::array<nda::matrix<dcomplex>, 2> impurity_levels(one_body_elements_on_grid const &obe);
  // -------------------------------------------------------------
 
  // These functions are not part of the public API: not documented, not wrapped.
  namespace detail {
    nda::array<dcomplex, 3> G0_C_k_sigma(one_body_elements_on_grid const &obe, double mu, long k_idx, long sigma, std::vector<dcomplex> const &omegas,
                                         bool mu_derivative = false);
  } // namespace detail
 
} // namespace triqs::modest