mc_generic.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
// Copyright (c) 2017 Hugo U.R. Strand
//
// 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, Henri Menke, Olivier Parcollet, Priyanka Seth, Hugo U. R. Strand, Nils Wentzell, Thomas Ayral

 
#pragma once
 
#include "./concepts.hpp"
#include "./mc_measure_aux_set.hpp"
#include "./mc_measure_set.hpp"
#include "./mc_move_set.hpp"
#include "./random_generator.hpp"
#include "../utility/report_stream.hpp"
#include "../utility/timer.hpp"
#include "../utility/timestamp.hpp"
 
#include <h5/h5.hpp>
 
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace triqs::mc_tools {

  enum class mc_phase { warmup, accumulation };

  template <DoubleOrComplex MCSignType> class mc_generic {
    private:
    // Value to indicate that the initial sign of the user-provided parameters should not be used.
    static constexpr MCSignType default_initial_sign = std::numeric_limits<double>::infinity();
 
    public:
    struct run_param_t {
      std::int64_t ncycles = -1;

      std::int64_t cycle_length = 1;

      std::function<bool()> stop_callback = []() { return false; };

      MCSignType initial_sign = default_initial_sign;

      mpi::communicator comm = mpi::communicator{};

      std::function<void()> after_cycle_duty = []() {};

      bool propagate_exception = true;

      bool enable_measures = true;

      bool enable_calibration = false;

      mc_phase phase = mc_phase::accumulation;

      bool continue_after_ncycles_done = true;

      double check_exception_interval = 1;

      double check_cycles_interval = 1;
    };

    mc_generic(const std::string &rng_name, int rng_seed, int verbosity_lvl)
       : rng_(rng_name, rng_seed), moves_(rng_), report_(&std::cout, verbosity_lvl), verbosity_lvl_(verbosity_lvl) {}

    void set_verbosity(int v) {
      verbosity_lvl_ = v;
      report_        = utility::report_stream(&std::cout, v);
    }

    [[nodiscard]] MCSignType get_sign() const { return sign_; }

    template <typename T> void add_move(T &&m, std::string name, double weight = 1.0) { moves_.add(std::forward<T>(m), name, weight); }

    template <typename T> auto add_measure(T &&m, std::string name, bool enable_timer = true, bool enable_report = false) {
      return measures_.insert(std::forward<T>(m), name, enable_timer, enable_report);
    }

    template <typename T> void add_measure_aux(std::shared_ptr<T> const &m_ptr) { measures_aux_.emplace_back(m_ptr); }

    void rm_measure(typename measure_set<MCSignType>::measure_itr_t const &it) { measures_.remove(it); }

    void clear_measures() { measures_.clear(); }

    int run(run_param_t const &params);

    int warmup(run_param_t const &params);

    int accumulate(run_param_t const &params);

    int run(std::int64_t ncycles, std::int64_t cycle_length, std::function<bool()> stop_callback, bool enable_measures,
            mpi::communicator c = mpi::communicator{}, bool enable_calibration = false);

    int warmup(std::int64_t ncycles, std::int64_t cycle_length, std::function<bool()> stop_callback, MCSignType initial_sign,
               mpi::communicator c = mpi::communicator{});

    int warmup(std::int64_t ncycles, std::int64_t cycle_length, std::function<bool()> stop_callback, mpi::communicator c = mpi::communicator{});

    int accumulate(std::int64_t ncycles, std::int64_t cycle_length, std::function<bool()> stop_callback, mpi::communicator c = mpi::communicator{});

    int warmup_and_accumulate(std::int64_t ncycles_warmup, std::int64_t ncycles_acc, std::int64_t cycle_length, std::function<bool()> stop_callback,
                              MCSignType initial_sign, mpi::communicator c = mpi::communicator{});

    int warmup_and_accumulate(std::int64_t ncycles_warmup, std::int64_t ncycles_acc, std::int64_t cycle_length, std::function<bool()> stop_callback,
                              mpi::communicator c = mpi::communicator{});

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

    [[nodiscard]] auto get_run_params() const { return run_param_t{}; }

    [[nodiscard]] std::map<std::string, double> get_acceptance_rates() const { return moves_.get_acceptance_rates(); }

    [[nodiscard]] double get_percent() const { return percentage_done_; }

    random_generator &get_rng() { return rng_; }

    [[nodiscard]] int get_current_cycle_number() const { return ncycles_done_; }

    [[nodiscard]] int get_config_id() const { return config_id_; }

    [[nodiscard]] double get_duration() const { return get_total_time(); }

    [[nodiscard]] int get_nmeasures() const { return nmeasures_done_; }

    [[nodiscard]] double get_total_time() const { return get_warmup_time() + get_accumulation_time(); }

    [[nodiscard]] double get_warmup_time() const { return static_cast<double>(warmup_timer_); }

    [[nodiscard]] auto get_warmup_time_HHMMSS() const { return hours_minutes_seconds_from_seconds(warmup_timer_); }

    [[nodiscard]] double get_accumulation_time() const { return static_cast<double>(acc_timer_); }

    [[nodiscard]] std::string get_accumulation_time_HHMMSS() const { return hours_minutes_seconds_from_seconds(acc_timer_); }

    friend void h5_write(h5::group g, std::string const &name, mc_generic const &mc) {
      auto gr = g.create_group(name);
      h5_write(gr, "moves", mc.moves_);
      h5_write(gr, "measures", mc.measures_);
      h5_write(gr, "number_cycle_done", mc.ncycles_done_);
      h5_write(gr, "number_measure_done", mc.nmeasures_done_);
      h5_write(gr, "sign", mc.sign_);
    }

    friend void h5_read(h5::group g, std::string const &name, mc_generic &mc) {
      auto gr = g.open_group(name);
      h5_read(gr, "moves", mc.moves_);
      h5_read(gr, "measures", mc.measures_);
      h5_read(gr, "number_cycle_done", mc.ncycles_done_);
      h5_read(gr, "number_measure_done", mc.nmeasures_done_);
      h5_read(gr, "sign", mc.sign_);
    }
 
    private:
    // Print simulation info.
    void print_sim_info(run_param_t const &params, std::int64_t cycle_counter);
 
    // Do a single Metropolis accept/reject step.
    void metropolis_step();
 
    // Perform after-cycle duties: the user-provided duty and move calibration. Both may communicate,
    // so this must be called the same number of times on every rank (it is skipped in overtime cycles).
    void after_cycle_duties(run_param_t const &params);
 
    // Perform all measurements and update their counter.
    void do_measurements();
 
    private:
    random_generator rng_;
    move_set<MCSignType> moves_;
    measure_set<MCSignType> measures_;
    std::vector<measure_aux> measures_aux_;
    utility::report_stream report_;
    utility::timer run_timer_;
    utility::timer acc_timer_;
    utility::timer warmup_timer_;
    MCSignType sign_{1};
    std::int64_t nmeasures_done_{0};
    std::int64_t ncycles_done_{0};
    double percentage_done_{0};
    std::int64_t config_id_{0};
    int verbosity_lvl_{0};
  };
 
  // Explicit template instantiation declarations.
  extern template class mc_generic<double>;
  extern template class mc_generic<std::complex<double>>;
 
} // namespace triqs::mc_tools