mc_measure.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-2022 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: Michel Ferrero, Olivier Parcollet, Nils Wentzell

 
#pragma once
 
#include "./concepts.hpp"
#include "../utility/timer.hpp"
 
#include <h5/h5.hpp>
#include <mpi/communicator.hpp>
 
#include <complex>
#include <concepts>
#include <cstdint>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace triqs::mc_tools {
 
  // Forward declaration.
  template <DoubleOrComplex MCSignType> class measure_set;

  template <DoubleOrComplex MCSignType> class measure {
    private:
    // MC measure concept defines the interface for MC measures.
    struct measure_concept {
      virtual ~measure_concept()                                 = default;
      virtual void accumulate(MCSignType)                        = 0;
      virtual void collect_results(mpi::communicator const &)    = 0;
      [[nodiscard]] virtual std::string report() const           = 0;
      virtual void h5write(h5::group, std::string const &) const = 0;
      virtual void h5read(h5::group, std::string const &)        = 0;
 
      // // Methods only implemented in measure_set.
      [[nodiscard]] virtual std::string ms_get_timings(std::string const &) const = 0;
      [[nodiscard]] virtual std::vector<std::string> ms_names() const             = 0;
    };
 
    // MC measure model implements the MC measure concept by calling the appropriate methods of the type erased object.
    template <typename T>
      requires MCMeasure<T, MCSignType>
    struct measure_model : public measure_concept {
      static constexpr bool is_measure_set = std::is_same_v<T, measure_set<MCSignType>>;
      T measure_;
      measure_model(T m) : measure_{std::move(m)} {}
      void accumulate(MCSignType sign) override { return measure_.accumulate(sign); }
      void collect_results(mpi::communicator const &c) override { measure_.collect_results(c); }
      [[nodiscard]] std::string report() const override {
        if constexpr (requires {
                        { measure_.report() } -> std::convertible_to<std::string>;
                      })
          return measure_.report();
        return {};
      }
      void h5write(h5::group g, std::string const &name) const override {
        if constexpr (h5::Storable<T>) h5::write(g, name, measure_);
      }
      void h5read(h5::group g, std::string const &name) override {
        if constexpr (h5::Storable<T>) h5::read(g, name, measure_);
      }
 
      // Methods only implemented in measure_set.
      [[nodiscard]] std::string ms_get_timings(std::string const &prefix) const override {
        if constexpr (is_measure_set) return measure_.get_timings(prefix);
        return {};
      }
      [[nodiscard]] std::vector<std::string> ms_names() const override {
        if constexpr (is_measure_set) return measure_.names();
        return {};
      }
    };
 
    public:
    template <typename T>
      requires(MCMeasure<T, MCSignType> && !std::is_same_v<T, measure>)
    measure(T m, bool enable_timer, bool enable_report)
       : ptr_{std::make_unique<measure_model<T>>(std::move(m))},
         enable_timer_(enable_timer),
         enable_report_(enable_report),
         is_measure_set_{std::is_same_v<T, measure_set<MCSignType>>} {}

    measure(measure const &) = delete;

    measure &operator=(measure const &) = delete;

    measure(measure &&) = default;

    measure &operator=(measure &&) = default;

    void accumulate(MCSignType sign) {
      ++count_;
      if (enable_timer_) timer_.start();
      ptr_->accumulate(sign);
      if (enable_timer_) timer_.stop();
    }

    void collect_results(mpi::communicator const &c);

    [[nodiscard]] std::string report() const;

    [[nodiscard]] std::string get_timings(std::string const &name, std::string const &prefix = "") const;

    [[nodiscard]] std::vector<std::string> names() const;

    [[nodiscard]] double duration() const;

    [[nodiscard]] auto count() const { return count_; }

    [[nodiscard]] auto is_set() const { return is_measure_set_; }

    friend void h5_write(h5::group g, std::string const &name, measure const &m) { m.ptr_->h5write(g, name); }

    friend void h5_read(h5::group g, std::string const &name, measure &m) { m.ptr_->h5read(g, name); }
 
    private:
    std::unique_ptr<measure_concept> ptr_;
    std::uint64_t count_{0};
    triqs::utility::timer timer_;
    bool enable_timer_{false};
    bool enable_report_{false};
    bool is_measure_set_{false};
  };
 
  // Explicit template instantiation declarations.
  extern template class measure<double>;
  extern template class measure<std::complex<double>>;
 
} // namespace triqs::mc_tools