brillouin_zone.hpp

Go to the documentation of this file.

// Copyright (c) 2014-2018 Commissariat à l'énergie atomique et aux énergies alternatives (CEA)
// Copyright (c) 2014-2018 Centre national de la recherche scientifique (CNRS)
// Copyright (c) 2018-2023 Simons Foundation
//
// This program 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.
//
// This program 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 may obtain a copy of the License at
//     https://www.gnu.org/licenses/gpl-3.0.txt
//
// Authors: Thomas Ayral, Michel Ferrero, Olivier Parcollet, Nils Wentzell

 
#pragma once
 
#include "./bravais_lattice.hpp"
#include "../utility/macros.hpp"
 
#include <fmt/ranges.h>
#include <h5/h5.hpp>
#include <nda/nda.hpp>
 
#include <iostream>
#include <ranges>
#include <string>
 
namespace triqs::lattice {


  using k_t = nda::vector<double>;

  class brillouin_zone {
    public:
    using value_t = k_t;

    brillouin_zone() : brillouin_zone{bravais_lattice{}} {}

    explicit brillouin_zone(bravais_lattice bl);

    [[nodiscard]] C2PY_IGNORE bool contains(k_t const &) const { return true; }

    [[nodiscard]] auto const &lattice() const { return lattice_; }

    explicit operator bravais_lattice() const { return lattice_; }

    [[nodiscard]] auto ndim() const { return lattice_.ndim(); }

    [[nodiscard]] matrix_t const &units() const { return k_units_; }

    [[nodiscard]] matrix_t const &reciprocal_matrix() const { return k_units_; }

    [[nodiscard]] matrix_t const &reciprocal_matrix_inv() const { return k_units_inv_; }

    template <typename K> [[nodiscard]] k_t lattice_to_real_coordinates(K const &v) const {
      return nda::transpose(k_units_)(nda::range::all, nda::range(ndim())) * nda::basic_array_view{v}(nda::range(ndim()));
    }

    template <typename K> [[nodiscard]] k_t real_to_lattice_coordinates(K const &v_tilde) const {
      return nda::transpose(k_units_inv_)(nda::range::all, nda::range(ndim())) * nda::basic_array_view{v_tilde}(nda::range(ndim()));
    }

    bool operator==(brillouin_zone const &bz) const { return reciprocal_matrix() == bz.reciprocal_matrix() && lattice() == bz.lattice(); }

    friend std::ostream &operator<<(std::ostream &sout, brillouin_zone const &bz) {
      auto str = fmt::format("Brillouin zone in {} dimensions:\n", bz.ndim());
      str += fmt::format("  Basis vectors: {}\n",
                         std::views::transform(nda::range(bz.ndim()), [&bz](int i) { return bz.units()(i, nda::range(bz.ndim())); }));
      return sout << str;
    }

    void serialize(auto &ar) const { ar & lattice_ & k_units_ & k_units_inv_; }

    void deserialize(auto &ar) { ar & lattice_ & k_units_ & k_units_inv_; }

    [[nodiscard]] static std::string hdf5_format() { return "brillouin_zone"; }

    friend void h5_write(h5::group g, std::string const &name, brillouin_zone const &bz);

    friend void h5_read(h5::group g, std::string const &name, brillouin_zone &bz);
 
    private:
    bravais_lattice lattice_;
    matrix_t k_units_     = matrix_t::zeros(3, 3);
    matrix_t k_units_inv_ = matrix_t::zeros(3, 3);
  };

 
} // namespace triqs::lattice