mc_move.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 <cstdint>
#include <map>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
 
namespace triqs::mc_tools {
 
  // Forward declaration.
  template <DoubleOrComplex MCSignType> class move_set;

  template <DoubleOrComplex MCSignType> class move {
    private:
    // MC move concept defines the interface for MC moves.
    struct move_concept {
      virtual ~move_concept()                                    = default;
      virtual MCSignType attempt()                               = 0;
      virtual MCSignType accept()                                = 0;
      virtual void reject()                                      = 0;
      virtual void calibrate(mpi::communicator const &)          = 0;
      virtual void collect_statistics(mpi::communicator 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 move_set.
      virtual void ms_clear_statistics()                                                  = 0;
      [[nodiscard]] virtual std::string ms_get_statistics(std::string const &) const      = 0;
      [[nodiscard]] virtual std::map<std::string, double> ms_get_acceptance_rates() const = 0;
      [[nodiscard]] virtual std::string ms_get_timings(std::string const &) const         = 0;
    };
 
    // MC move model implements the MC move concept by calling the appropriate methods of the type erased object.
    template <typename T>
      requires MCMove<T, MCSignType>
    struct move_model : public move_concept {
      static constexpr bool is_move_set = std::is_same_v<T, move_set<MCSignType>>;
      T move_;
      move_model(T m) : move_{std::move(m)} {}
      MCSignType attempt() override { return move_.attempt(); }
      MCSignType accept() override { return move_.accept(); }
      void reject() override {
        if constexpr (requires { move_.reject(); }) move_.reject();
      }
      void calibrate(mpi::communicator const &c) override {
        if constexpr (requires { move_.calibrate(c); }) move_.calibrate(c);
      }
      void collect_statistics(mpi::communicator const &c) override {
        if constexpr (requires { move_.collect_statistics(c); }) move_.collect_statistics(c);
      }
      void h5write(h5::group g, std::string const &name) const override {
        if constexpr (h5::Storable<T>) h5::write(g, name, move_);
      }
      void h5read(h5::group g, std::string const &name) override {
        if constexpr (h5::Storable<T>) h5::read(g, name, move_);
      }
 
      // Methods only implemented in move_set.
      void ms_clear_statistics() override {
        if constexpr (is_move_set) move_.clear_statistics();
      }
      [[nodiscard]] std::string ms_get_statistics(std::string const &prefix) const override {
        if constexpr (is_move_set) return move_.get_statistics(prefix);
        return {};
      }
      [[nodiscard]] std::map<std::string, double> ms_get_acceptance_rates() const override {
        if constexpr (is_move_set) return move_.get_acceptance_rates();
        return {};
      }
      [[nodiscard]] std::string ms_get_timings(std::string const &prefix) const override {
        if constexpr (is_move_set) return move_.get_timings(prefix);
        return {};
      }
    };
 
    public:
    template <typename T>
      requires(MCMove<T, MCSignType> && !std::is_same_v<T, move>)
    move(T m) : ptr_{std::make_unique<move_model<T>>(std::move(m))}, is_move_set_{std::is_same_v<T, move_set<MCSignType>>} {}

    move(move const &) = delete;

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

    move(move &&) = default;

    move &operator=(move &&) = default;

    MCSignType attempt() {
      ++nprop_;
      timer_.start();
      auto result = ptr_->attempt();
      timer_.stop();
      return result;
    }

    MCSignType accept() {
      ++nacc_;
      timer_.start();
      auto result = ptr_->accept();
      timer_.stop();
      return result;
    }

    void reject() {
      timer_.start();
      ptr_->reject();
      timer_.stop();
    }

    void calibrate(mpi::communicator const &c) { ptr_->calibrate(c); }

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

    [[nodiscard]] auto acceptance_rate() const { return acc_rate_; }

    [[nodiscard]] auto n_proposed_config() const { return nprop_; }

    [[nodiscard]] auto n_accepted_config() const { return nacc_; }

    void clear_statistics();

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

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

    [[nodiscard]] double duration() const { return static_cast<double>(timer_); }

    [[nodiscard]] std::map<std::string, double> get_acceptance_rates() const { return ptr_->ms_get_acceptance_rates(); }

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

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

    friend void h5_read(h5::group g, std::string const &name, move &m) { m.ptr_->h5read(g, name); }
 
    private:
    std::unique_ptr<move_concept> ptr_;
    std::uint64_t nprop_{0};
    std::uint64_t nacc_{0};
    double acc_rate_{-1};
    bool is_move_set_{false};
    triqs::utility::timer timer_;
  };
 
  // Explicit template instantiation declarations.
  extern template class move<double>;
  extern template class move<std::complex<double>>;
 
} // namespace triqs::mc_tools