imtime.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, Olivier Parcollet, Nils Wentzell

 
#pragma once
 
#include "./bases/linear.hpp"
#include "./utils.hpp"
#include "../utility/macros.hpp"
 
#include <fmt/format.h>
#include <h5/h5.hpp>
 
#include <iostream>
#include <string>
 
namespace triqs::mesh {


  class C2PY_RENAME(MeshImTime) imtime : public detail::linear<imtime, double> {
    public:
    using mesh_point_t = detail::linear<imtime, double>::mesh_point_t;

    C2PY_DEPRECATED_PARAMETER_NAME(S : statistic, n_max : n_tau)
    imtime(double beta = 1.0, statistic_enum statistic = Fermion, long n_tau = 0) : linear(0, beta, n_tau), beta_(beta), stat_(statistic) {}

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

    [[nodiscard]] C2PY_PROPERTY_GET(beta) double beta() const noexcept { return beta_; }

    [[nodiscard]] C2PY_PROPERTY_GET(statistic) statistic_enum statistic() const noexcept { return stat_; }

    void serialize(auto &ar) const {
      static_cast<detail::linear<imtime, double> const &>(*this).serialize(ar);
      ar & beta_ & stat_;
    }

    void deserialize(auto &ar) {
      static_cast<detail::linear<imtime, double> &>(*this).deserialize(ar);
      ar & beta_ & stat_;
    }

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

    friend void h5_write(h5::group g, std::string const &name, imtime const &m) {
      h5::group gr = g.create_group(name);
      h5::write_hdf5_format(gr, m); // NOLINT (downcasting to base class)
      h5::write(gr, "beta", m.beta_);
      h5::write(gr, "statistic", (m.stat_ == Fermion ? "F" : "B"));
      h5::write(gr, "n_tau", m.N_);
    }

    friend void h5_read(h5::group g, std::string const &name, imtime &m) {
      h5::group gr = g.open_group(name);
      h5::assert_hdf5_format(gr, m, true); // NOLINT (downcasting to base class)
 
      // for backward compatibility
      long N = 0;
      if (not h5::try_read(gr, "n_tau", N)) h5::read(gr, "size", N);
      if (gr.has_key("domain")) gr = gr.open_group("domain");
 
      auto beta      = h5::read<double>(gr, "beta");
      auto statistic = (h5::read<std::string>(gr, "statistic") == "F" ? Fermion : Boson);
      m              = imtime(beta, statistic, N);
    }

    friend std::ostream &operator<<(std::ostream &sout, imtime const &m) {
      auto stat_cstr = (m.stat_ == Boson ? "Boson" : "Fermion");
      return sout << fmt::format("Imaginary time mesh with beta = {}, statistics = {}, N = {}", m.beta_, stat_cstr, m.N_);
    }
 
    private:
    double beta_;
    statistic_enum stat_;
  };

  auto evaluate(imtime const &m, auto const &f, double tau) { return m.evaluate(f, tau); }

 
} // namespace triqs::mesh