parameters.hpp

/*******************************************************************************
 *
 * TRIQS: a Toolbox for Research in Interacting Quantum Systems
 *
 * Copyright (C) 2017, H. U.R. Strand, M. Ferrero and O. Parcollet
 *
 * TRIQS 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.
 *
 * TRIQS 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 should have received a copy of the GNU General Public License along with
 * TRIQS. If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/
 
#pragma once
 
#include <climits>
 
#include "./config.hpp"
#include "./types.hpp"
#include "./configuration.hpp"
 
namespace triqs_cthyb {
 
  using namespace triqs::operators;
  using indices_map_t = std::map<triqs::operators::indices_t, triqs::operators::indices_t>;

  struct constr_parameters_t {

    double beta;

    gf_struct_t gf_struct;

    int n_iw = 1025;

    int n_tau = 10001;

    int n_l = 50;

    bool delta_interface = false;
 
    bool operator==(constr_parameters_t const &) const = default;

    friend void h5_write(h5::group h5group, std::string subgroup_name, constr_parameters_t const &sp);

    friend void h5_read(h5::group h5group, std::string subgroup_name, constr_parameters_t &sp);
  };

  struct solve_parameters_t {

    many_body_op_t h_int;

    long n_cycles;

    std::string partition_method = "autopartition";

    std::vector<many_body_op_t> quantum_numbers = {};

    int loc_n_min = 0;

    int loc_n_max = INT_MAX;

    long length_cycle = 50;

    long n_warmup_cycles = 5000;

    long random_seed = 34788 + 928374 * mpi::communicator().rank();

    std::string random_name = "";

    long max_time = -1;

    int verbosity = ((mpi::communicator().rank() == 0) ? 3 : 0); // silence the slave nodes

    bool move_shift = true;

    bool move_double = true;

    bool use_trace_estimator = false;

    bool measure_G_tau = true;

    bool measure_G_l = false;

    std::optional<std::pair<many_body_op_t, many_body_op_t>> measure_O_tau = {};

    int measure_O_tau_min_ins = 10;

    bool measure_G2_tau = false;

    bool measure_G2_iw = false;

    bool measure_G2_iw_nfft = false;

    bool measure_G2_iw_pp = false;

    bool measure_G2_iw_pp_nfft = false;

    bool measure_G2_iw_ph = false;

    bool measure_G2_iw_ph_nfft = false;

    bool measure_G2_iwll_pp = false;

    bool measure_G2_iwll_ph = false;

    block_order measure_G2_block_order = block_order::AABB;

    std::set<std::pair<std::string, std::string>> measure_G2_blocks = {};

    int measure_G2_n_tau = 10;

    int measure_G2_n_bosonic = 30;

    int measure_G2_n_fermionic = 30;

    int measure_G2_n_l = 20;

    int measure_G2_iwll_nfft_buf_size = 100;

    std::map<std::string, long> nfft_buf_sizes = {};

    bool measure_pert_order = false;

    bool measure_density_matrix = false;

    bool use_norm_as_weight = false;

    std::optional<configuration> initial_configuration = {};

    bool performance_analysis = false;

    std::map<std::string, double> proposal_prob = {};

    std::map<std::string, indices_map_t> move_global = {};

    double move_global_prob = 0.05;

    double imag_threshold = 1.e-13;

    int det_init_size = 100;

    int det_n_operations_before_check = 100;

    double det_precision_warning = 1.e-8;

    double det_precision_error = 1.e-5;

    double det_singular_threshold = -1;
 
    bool operator==(solve_parameters_t const &) const = default;

    friend void h5_write(h5::group h5group, std::string subgroup_name, solve_parameters_t const &sp);

    friend void h5_read(h5::group h5group, std::string subgroup_name, solve_parameters_t &sp);

    double off_diag_threshold = 0.0;

    std::optional<many_body_op_t> h_loc0 = {};
  };

  struct params_t : constr_parameters_t, solve_parameters_t {
    params_t(constr_parameters_t constr_parameters_, solve_parameters_t solve_parameters_)
       : constr_parameters_t(constr_parameters_), solve_parameters_t(solve_parameters_) {}
  };
} // namespace triqs_cthyb