adjoint.hpp

Go to the documentation of this file.

// Copyright (c) 2022-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: Olivier Parcollet, Nils Wentzell

 
#pragma once
 
#include "./imtime.hpp"
#include "./imfreq.hpp"
#include "./dlr_imtime.hpp"
#include "./dlr_imfreq.hpp"
#include "./retime.hpp"
#include "./refreq.hpp"
#include "./cyclat.hpp"
#include "./brzone.hpp"
 
#include <numbers>
 
namespace triqs::mesh {

  [[nodiscard]] inline imfreq make_adjoint_mesh(imtime const &m, long n_iw = -1) {
    if (n_iw == -1) n_iw = (m.size() - 1) / 6;
    return {m.beta(), m.statistic(), n_iw};
  }

  [[nodiscard]] inline imtime make_adjoint_mesh(imfreq const &m, long n_tau = -1) {
    if (n_tau == -1) n_tau = 6 * (m.last_index() + 1) + 1;
    return {m.beta(), m.statistic(), n_tau};
  }

  [[nodiscard]] inline dlr_imfreq make_adjoint_mesh(dlr_imtime const &m) { return dlr_imfreq{m}; }

  [[nodiscard]] inline dlr_imtime make_adjoint_mesh(dlr_imfreq const &m) { return dlr_imtime{m}; }

  [[nodiscard]] inline refreq make_adjoint_mesh(retime const &m, bool shift_half_bin = false) {
    using std::numbers::pi;
    auto const N    = static_cast<double>(m.size());
    auto const wmax = pi * (N - 1) / (N * m.delta());
    if (shift_half_bin) return {-wmax + pi / N / m.delta(), wmax + pi / N / m.delta(), m.size()};
    return {-wmax, wmax, m.size()};
  }

  [[nodiscard]] inline retime make_adjoint_mesh(refreq const &m, bool shift_half_bin = false) {
    using std::numbers::pi;
    auto const N    = static_cast<double>(m.size());
    auto const tmax = pi * (N - 1) / (N * m.delta());
    if (shift_half_bin) return {-tmax + pi / N / m.delta(), tmax + pi / N / m.delta(), m.size()};
    return {-tmax, tmax, m.size()};
  }

  [[nodiscard]] inline brzone make_adjoint_mesh(cyclat const &m) { return {brillouin_zone{m.lattice()}, m.dims()}; }

  [[nodiscard]] inline cyclat make_adjoint_mesh(brzone const &m) { return {m.bz().lattice(), m.dims()}; }
 
} // namespace triqs::mesh