matsubara_freq.hpp

Go to the documentation of this file.

// Copyright (c) 2013-2018 Commissariat à l'énergie atomique et aux énergies alternatives (CEA)
// Copyright (c) 2013-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, Philipp Dumitrescu, Laura Messio, Olivier Parcollet, Nils Wentzell

 
#pragma once
 
#include "./utils.hpp"
#include "../utility/kronecker.hpp"
#include "../utility/macros.hpp"
 
#include <compare>
#include <complex>
#include <iostream>
#include <numbers>
#include <type_traits>
#include <utility>
 
namespace triqs::mesh {


  struct C2PY_IGNORE matsubara_freq {
    using cast_t = std::complex<double>;

    long n = 0;

    double beta = 0.0;

    statistic_enum statistic = Fermion;

    matsubara_freq() = default;

    matsubara_freq(long n_idx, double b, statistic_enum stat) : n(n_idx), beta(b), statistic(stat) {}

    [[nodiscard]] long index() const { return n; }

    operator cast_t() const { return std::complex<double>{0, std::numbers::pi * static_cast<double>(2 * n + statistic) / beta}; }

    bool operator==(matsubara_freq const &) const = default;

    std::partial_ordering operator<=>(matsubara_freq const &other) const {
      if (beta != other.beta || statistic != other.statistic) return std::partial_ordering::unordered;
      return n <=> other.n;
    }
  };

  C2PY_IGNORE inline std::ostream &operator<<(std::ostream &sout, matsubara_freq const &iw) { return sout << std::complex<double>(iw); }

  [[nodiscard]] C2PY_IGNORE inline matsubara_freq operator+(matsubara_freq const &iw1, matsubara_freq const &iw2) {
    return {iw1.n + iw2.n + (iw1.statistic & iw2.statistic), iw1.beta, ((iw1.statistic ^ iw2.statistic) == 1 ? Fermion : Boson)};
  }

  [[nodiscard]] C2PY_IGNORE inline matsubara_freq operator-(matsubara_freq const &iw1, matsubara_freq const &iw2) {
    return {iw1.n - iw2.n - (~iw1.statistic & iw2.statistic), iw1.beta, ((iw1.statistic ^ iw2.statistic) == 1 ? Fermion : Boson)};
  }

  [[nodiscard]] C2PY_IGNORE inline matsubara_freq operator-(matsubara_freq const &iw) {
    return {-(iw.n + (iw.statistic == Fermion ? 1 : 0)), iw.beta, iw.statistic};
  }

  [[nodiscard]] C2PY_IGNORE inline auto operator/(matsubara_freq const &iw1, matsubara_freq const &iw2) {
    return std::complex<double>{iw1} / std::complex<double>{iw2};
  }

  [[nodiscard]] C2PY_IGNORE inline auto operator*(matsubara_freq const &iw1, matsubara_freq const &iw2) {
    return std::complex<double>{iw1} * std::complex<double>{iw2};
  }
 
#define IMPL_OP(OP)                                                                                                                                  \
                                                       \
  template <typename T>                                                                                                                              \
    requires(not std::is_base_of_v<matsubara_freq, std::decay_t<T>>)                                                                                 \
  [[nodiscard]] inline auto operator OP(matsubara_freq const &iw, T &&y) {                                                                           \
    return std::complex<double>(iw) OP std::forward<T>(y);                                                                                           \
  }                                                                                                                                                  \
                                                       \
  template <typename T>                                                                                                                              \
    requires(not std::is_base_of_v<matsubara_freq, std::decay_t<T>>)                                                                                 \
  [[nodiscard]] inline auto operator OP(T &&x, matsubara_freq const &iw) {                                                                           \
    return std::forward<T>(x) OP std::complex<double>(iw);                                                                                           \
  }
  IMPL_OP(+);
  IMPL_OP(-);
  IMPL_OP(*);
  IMPL_OP(/);
#undef IMPL_OP

  [[nodiscard]] C2PY_IGNORE inline bool kronecker(matsubara_freq const &iw) { return iw.n == 0; }

  [[nodiscard]] C2PY_IGNORE inline bool kronecker(matsubara_freq const &iw1, matsubara_freq const &iw2) { return iw1.n == iw2.n; }

 
} // namespace triqs::mesh