latest/doxygen/params_8cpp_source.html

/*******************************************************************************

 *

 * nrgljubljana_interface: A TRIQS interface to the nrgljubliana impurity solver

 *

 * Copyright (c) 2019 The Simons foundation

 *   authors: Rok Zitko, Nils Wentzell

 *

 * nrgljubljana_interface 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.

 *

 * nrgljubljana_interface 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

 * nrgljubljana_interface. If not, see <http://www.gnu.org/licenses/>.

 *

 ******************************************************************************/

#include "./params.hpp"


namespace nrgljubljana_interface {


  void h5_write(h5::group h5group, std::string subgroup_name, constr_params_t const &cp) {

    auto grp = h5group.create_group(subgroup_name);

    h5_write(grp, "templatedir", cp.templatedir);

    h5_write(grp, "model", cp.model);

    h5_write(grp, "symtype", cp.symtype);

    h5_write(grp, "mesh_max", cp.mesh_max);

    h5_write(grp, "mesh_min", cp.mesh_min);

    h5_write(grp, "mesh_ratio", cp.mesh_ratio);

    h5_write(grp, "polarized", cp.polarized);

    h5_write(grp, "pol2x2", cp.pol2x2);

    h5_write(grp, "rungs", cp.rungs);

    h5_write(grp, "ops", cp.ops);

    h5_write(grp, "specs", cp.specs);

    h5_write(grp, "specd", cp.specd);

    h5_write(grp, "spect", cp.spect);

    h5_write(grp, "specq", cp.specq);

    h5_write(grp, "specot", cp.specot);

    h5_write(grp, "specchit", cp.specchit);

    h5_write(grp, "specv3", cp.specv3);

    h5_write(grp, "params", cp.params);

  }


  void h5_read(h5::group h5group, std::string subgroup_name, constr_params_t &cp) {

    auto grp = h5group.open_group(subgroup_name);

    h5_read(grp, "templatedir", cp.templatedir);

    h5_read(grp, "model", cp.model);

    h5_read(grp, "symtype", cp.symtype);

    h5_read(grp, "mesh_max", cp.mesh_max);

    h5_read(grp, "mesh_min", cp.mesh_min);

    h5_read(grp, "mesh_ratio", cp.mesh_ratio);

    h5_read(grp, "polarized", cp.polarized);

    h5_read(grp, "pol2x2", cp.pol2x2);

    h5_read(grp, "rungs", cp.rungs);

    h5_read(grp, "ops", cp.ops);

    h5_read(grp, "specs", cp.specs);

    h5_read(grp, "specd", cp.specd);

    h5_read(grp, "spect", cp.spect);

    h5_read(grp, "specq", cp.specq);

    h5_read(grp, "specot", cp.specot);

    h5_read(grp, "specchit", cp.specchit);

    h5_read(grp, "specv3", cp.specv3);

    h5_read(grp, "params", cp.params);

  }


  void h5_write(h5::group h5group, std::string subgroup_name, solve_params_t const &sp) {

    auto grp = h5group.create_group(subgroup_name);

    h5_write(grp, "Lambda", sp.Lambda);

    h5_write(grp, "Nz", sp.Nz);

    h5_write(grp, "Tmin", sp.Tmin);

    h5_write(grp, "keep", sp.keep);

    h5_write(grp, "keepenergy", sp.keepenergy);

    h5_write(grp, "keepmin", sp.keepmin);

    h5_write(grp, "T", sp.T);

    h5_write(grp, "alpha", sp.alpha);

    h5_write(grp, "gamma", sp.gamma);

    h5_write(grp, "method", sp.method);

    h5_write(grp, "bandrescale", sp.bandrescale);

    h5_write(grp, "model_parameters", sp.model_parameters);

  }


  void h5_read(h5::group h5group, std::string subgroup_name, solve_params_t &sp) {

    auto grp = h5group.open_group(subgroup_name);

    h5_read(grp, "Lambda", sp.Lambda);

    h5_read(grp, "Nz", sp.Nz);

    h5_read(grp, "Tmin", sp.Tmin);

    h5_read(grp, "keep", sp.keep);

    h5_read(grp, "keepenergy", sp.keepenergy);

    h5_read(grp, "keepmin", sp.keepmin);

    h5_read(grp, "T", sp.T);

    h5_read(grp, "alpha", sp.alpha);

    h5_read(grp, "gamma", sp.gamma);

    h5_read(grp, "method", sp.method);

    h5_read(grp, "bandrescale", sp.bandrescale);

    h5_read(grp, "model_parameters", sp.model_parameters);

  }


  void h5_write(h5::group h5group, std::string subgroup_name, nrg_params_t const &np) {

    auto grp = h5group.create_group(subgroup_name);

    h5_write(grp, "dmnrg", np.dmnrg);

    h5_write(grp, "cfs", np.cfs);

    h5_write(grp, "fdm", np.fdm);

    h5_write(grp, "fdmexpv", np.fdmexpv);

    h5_write(grp, "dmnrgmats", np.dmnrgmats);

    h5_write(grp, "fdmmats", np.fdmmats);

    h5_write(grp, "mats", np.mats);

    h5_write(grp, "specgt", np.specgt);

    h5_write(grp, "speci1t", np.speci1t);

    h5_write(grp, "speci2t", np.speci2t);

    h5_write(grp, "v3mm", np.v3mm);

    h5_write(grp, "mMAX", np.mMAX);

    h5_write(grp, "Nmax", np.Nmax);

    h5_write(grp, "xmax", np.xmax);

    h5_write(grp, "discretization", np.discretization);

    h5_write(grp, "z", np.z);

    h5_write(grp, "tri", np.tri);

    h5_write(grp, "preccpp", np.preccpp);

    h5_write(grp, "diag", np.diag);

    h5_write(grp, "diagratio", np.diagratio);

    h5_write(grp, "dsyevrlimit", np.dsyevrlimit);

    h5_write(grp, "zheevrlimit", np.zheevrlimit);

    h5_write(grp, "restart", np.restart);

    h5_write(grp, "restartfactor", np.restartfactor);

    h5_write(grp, "safeguard", np.safeguard);

    h5_write(grp, "safeguardmax", np.safeguardmax);

    h5_write(grp, "fixeps", np.fixeps);

    h5_write(grp, "betabar", np.betabar);

    h5_write(grp, "gtp", np.gtp);

    h5_write(grp, "chitp", np.chitp);

    h5_write(grp, "finite", np.finite);

    h5_write(grp, "cfsgt", np.cfsgt);

    h5_write(grp, "cfsls", np.cfsls);

    h5_write(grp, "fdmgt", np.fdmgt);

    h5_write(grp, "fdmls", np.fdmls);

    h5_write(grp, "fdmexpvn", np.fdmexpvn);

    h5_write(grp, "finitemats", np.finitemats);

    h5_write(grp, "dm", np.dm);

    h5_write(grp, "broaden_min_ratio", np.broaden_min_ratio);

    h5_write(grp, "omega0", np.omega0);

    h5_write(grp, "omega0_ratio", np.omega0_ratio);

    h5_write(grp, "diagth", np.diagth);

    h5_write(grp, "substeps", np.substeps);

    h5_write(grp, "strategy", np.strategy);

    h5_write(grp, "Ninit", np.Ninit);

    h5_write(grp, "reim", np.reim);

    h5_write(grp, "dumpannotated", np.dumpannotated);

    h5_write(grp, "dumpabs", np.dumpabs);

    h5_write(grp, "dumpscaled", np.dumpscaled);

    h5_write(grp, "dumpprecision", np.dumpprecision);

    h5_write(grp, "dumpgroups", np.dumpgroups);

    h5_write(grp, "grouptol", np.grouptol);

    h5_write(grp, "dumpdiagonal", np.dumpdiagonal);

    h5_write(grp, "savebins", np.savebins);

    h5_write(grp, "broaden", np.broaden);

    h5_write(grp, "emin", np.emin);

    h5_write(grp, "emax", np.emax);

    h5_write(grp, "bins", np.bins);

    h5_write(grp, "accumulation", np.accumulation);

    h5_write(grp, "linstep", np.linstep);

    h5_write(grp, "discard_trim", np.discard_trim);

    h5_write(grp, "discard_immediately", np.discard_immediately);

    h5_write(grp, "goodE", np.goodE);

    h5_write(grp, "NN1", np.NN1);

    h5_write(grp, "NN2even", np.NN2even);

    h5_write(grp, "NN2avg", np.NN2avg);

    h5_write(grp, "NNtanh", np.NNtanh);

    h5_write(grp, "width_td", np.width_td);

    h5_write(grp, "width_custom", np.width_custom);

    h5_write(grp, "prec_td", np.prec_td);

    h5_write(grp, "prec_custom", np.prec_custom);

    h5_write(grp, "prec_xy", np.prec_xy);

    h5_write(grp, "resume", np.resume);

    h5_write(grp, "log", np.log);

    h5_write(grp, "logall", np.logall);

    h5_write(grp, "done", np.done);

    h5_write(grp, "calc0", np.calc0);

    h5_write(grp, "lastall", np.lastall);

    h5_write(grp, "lastalloverride", np.lastalloverride);

    h5_write(grp, "dumpsubspaces", np.dumpsubspaces);

    h5_write(grp, "dump_f", np.dump_f);

    h5_write(grp, "dumpenergies", np.dumpenergies);

    h5_write(grp, "logenumber", np.logenumber);

    h5_write(grp, "stopafter", np.stopafter);

    h5_write(grp, "forcestop", np.forcestop);

    h5_write(grp, "removefiles", np.removefiles);

    h5_write(grp, "noimag", np.noimag);

    h5_write(grp, "checksumrules", np.checksumrules);

    h5_write(grp, "checkdiag", np.checkdiag);

    h5_write(grp, "checkrho", np.checkrho);

  }


  void h5_read(h5::group h5group, std::string subgroup_name, nrg_params_t &np) {

    auto grp = h5group.open_group(subgroup_name);

    h5_read(grp, "dmnrg", np.dmnrg);

    h5_read(grp, "cfs", np.cfs);

    h5_read(grp, "fdm", np.fdm);

    h5_read(grp, "fdmexpv", np.fdmexpv);

    h5_read(grp, "dmnrgmats", np.dmnrgmats);

    h5_read(grp, "fdmmats", np.fdmmats);

    h5_read(grp, "mats", np.mats);

    h5_read(grp, "specgt", np.specgt);

    h5_read(grp, "speci1t", np.speci1t);

    h5_read(grp, "speci2t", np.speci2t);

    h5_read(grp, "v3mm", np.v3mm);

    h5_read(grp, "mMAX", np.mMAX);

    h5_read(grp, "Nmax", np.Nmax);

    h5_read(grp, "xmax", np.xmax);

    h5_read(grp, "discretization", np.discretization);

    h5_read(grp, "z", np.z);

    h5_read(grp, "tri", np.tri);

    h5_read(grp, "preccpp", np.preccpp);

    h5_read(grp, "diag", np.diag);

    h5_read(grp, "diagratio", np.diagratio);

    h5_read(grp, "dsyevrlimit", np.dsyevrlimit);

    h5_read(grp, "zheevrlimit", np.zheevrlimit);

    h5_read(grp, "restart", np.restart);

    h5_read(grp, "restartfactor", np.restartfactor);

    h5_read(grp, "safeguard", np.safeguard);

    h5_read(grp, "safeguardmax", np.safeguardmax);

    h5_read(grp, "fixeps", np.fixeps);

    h5_read(grp, "betabar", np.betabar);

    h5_read(grp, "gtp", np.gtp);

    h5_read(grp, "chitp", np.chitp);

    h5_read(grp, "finite", np.finite);

    h5_read(grp, "cfsgt", np.cfsgt);

    h5_read(grp, "cfsls", np.cfsls);

    h5_read(grp, "fdmgt", np.fdmgt);

    h5_read(grp, "fdmls", np.fdmls);

    h5_read(grp, "fdmexpvn", np.fdmexpvn);

    h5_read(grp, "finitemats", np.finitemats);

    h5_read(grp, "dm", np.dm);

    h5_read(grp, "broaden_min_ratio", np.broaden_min_ratio);

    h5_read(grp, "omega0", np.omega0);

    h5_read(grp, "omega0_ratio", np.omega0_ratio);

    h5_read(grp, "diagth", np.diagth);

    h5_read(grp, "substeps", np.substeps);

    h5_read(grp, "strategy", np.strategy);

    h5_read(grp, "Ninit", np.Ninit);

    h5_read(grp, "reim", np.reim);

    h5_read(grp, "dumpannotated", np.dumpannotated);

    h5_read(grp, "dumpabs", np.dumpabs);

    h5_read(grp, "dumpscaled", np.dumpscaled);

    h5_read(grp, "dumpprecision", np.dumpprecision);

    h5_read(grp, "dumpgroups", np.dumpgroups);

    h5_read(grp, "grouptol", np.grouptol);

    h5_read(grp, "dumpdiagonal", np.dumpdiagonal);

    h5_read(grp, "savebins", np.savebins);

    h5_read(grp, "broaden", np.broaden);

    h5_read(grp, "emin", np.emin);

    h5_read(grp, "emax", np.emax);

    h5_read(grp, "bins", np.bins);

    h5_read(grp, "accumulation", np.accumulation);

    h5_read(grp, "linstep", np.linstep);

    h5_read(grp, "discard_trim", np.discard_trim);

    h5_read(grp, "discard_immediately", np.discard_immediately);

    h5_read(grp, "goodE", np.goodE);

    h5_read(grp, "NN1", np.NN1);

    h5_read(grp, "NN2even", np.NN2even);

    h5_read(grp, "NN2avg", np.NN2avg);

    h5_read(grp, "NNtanh", np.NNtanh);

    h5_read(grp, "width_td", np.width_td);

    h5_read(grp, "width_custom", np.width_custom);

    h5_read(grp, "prec_td", np.prec_td);

    h5_read(grp, "prec_custom", np.prec_custom);

    h5_read(grp, "prec_xy", np.prec_xy);

    h5_read(grp, "resume", np.resume);

    h5_read(grp, "log", np.log);

    h5_read(grp, "logall", np.logall);

    h5_read(grp, "done", np.done);

    h5_read(grp, "calc0", np.calc0);

    h5_read(grp, "lastall", np.lastall);

    h5_read(grp, "lastalloverride", np.lastalloverride);

    h5_read(grp, "dumpsubspaces", np.dumpsubspaces);

    h5_read(grp, "dump_f", np.dump_f);

    h5_read(grp, "dumpenergies", np.dumpenergies);

    h5_read(grp, "logenumber", np.logenumber);

    h5_read(grp, "stopafter", np.stopafter);

    h5_read(grp, "forcestop", np.forcestop);

    h5_read(grp, "removefiles", np.removefiles);

    h5_read(grp, "noimag", np.noimag);

    h5_read(grp, "checksumrules", np.checksumrules);

    h5_read(grp, "checkdiag", np.checkdiag);

    h5_read(grp, "checkrho", np.checkrho);

  }


} // namespace nrgljubljana_interface

nrgljubljana_interface::constr_params_t
Construction parameters for the NRGLjubljana solver.
Definition params.hpp:28

nrgljubljana_interface::constr_params_t::h5_write
friend void h5_write(h5::group h5group, std::string subgroup_name, constr_params_t const &cp)
Write constr_params_t to HDF5.
Definition params.cpp:26

nrgljubljana_interface::constr_params_t::mesh_max
double mesh_max
Maximum frequency of the logarithmic mesh.
Definition params.hpp:56

nrgljubljana_interface::constr_params_t::params
std::string params
List of model parameters that need to be specified.
Definition params.hpp:98

nrgljubljana_interface::constr_params_t::specd
std::string specd
Spectral functions of doublet operators to compute.
Definition params.hpp:80

nrgljubljana_interface::constr_params_t::symtype
std::string symtype
Symmetry type (NRGLjubljana symmetry code, e.g. QS, QSZ, ISO).
Definition params.hpp:37

nrgljubljana_interface::constr_params_t::specq
std::string specq
Spectral functions of quadruplet operators to compute.
Definition params.hpp:86

nrgljubljana_interface::constr_params_t::model
std::string model
Impurity model to solve (selects a template directory).
Definition params.hpp:34

nrgljubljana_interface::constr_params_t::specv3
std::string specv3
3-leg vertex functions to compute.
Definition params.hpp:95

nrgljubljana_interface::constr_params_t::specot
std::string specot
Spectral functions of orbital-triplet operators to compute.
Definition params.hpp:89

nrgljubljana_interface::constr_params_t::specs
std::string specs
Spectral functions of singlet operators to compute.
Definition params.hpp:77

nrgljubljana_interface::constr_params_t::h5_read
friend void h5_read(h5::group h5group, std::string subgroup_name, constr_params_t &cp)
Read constr_params_t from HDF5.
Definition params.cpp:48

nrgljubljana_interface::constr_params_t::specchit
std::string specchit
Susceptibilities to compute.
Definition params.hpp:92

nrgljubljana_interface::constr_params_t::mesh_min
double mesh_min
Minimum frequency of the logarithmic mesh.
Definition params.hpp:59

nrgljubljana_interface::constr_params_t::pol2x2
bool pol2x2
Use a 2x2 spin structure in the Wilson chain.
Definition params.hpp:68

nrgljubljana_interface::constr_params_t::polarized
bool polarized
Use a spin-polarized Wilson chain.
Definition params.hpp:65

nrgljubljana_interface::constr_params_t::ops
std::string ops
Operators whose expectation values are to be calculated.
Definition params.hpp:74

nrgljubljana_interface::constr_params_t::rungs
bool rungs
Include channel-mixing terms in the Wilson chain.
Definition params.hpp:71

nrgljubljana_interface::constr_params_t::mesh_ratio
double mesh_ratio
Common ratio of the geometric (logarithmic) frequency mesh.
Definition params.hpp:62

nrgljubljana_interface::constr_params_t::templatedir
std::string templatedir
Path to the template library (defaults to the bundled templates).
Definition params.hpp:31

nrgljubljana_interface::constr_params_t::spect
std::string spect
Spectral functions of triplet operators to compute.
Definition params.hpp:83

nrgljubljana_interface::nrg_params_t
Low-level NRG parameters.
Definition params.hpp:154

nrgljubljana_interface::nrg_params_t::fdmmats
bool fdmmats
Perform the FDM calculation on the Matsubara axis.
Definition params.hpp:172

nrgljubljana_interface::nrg_params_t::logall
bool logall
Log everything.
Definition params.hpp:379

nrgljubljana_interface::nrg_params_t::z
double z
Parameter  (twist) in the logarithmic discretization.
Definition params.hpp:202

nrgljubljana_interface::nrg_params_t::h5_read
friend void h5_read(h5::group h5group, std::string subgroup_name, nrg_params_t &sp)
Read nrg_params_t from HDF5.
Definition params.cpp:196

nrgljubljana_interface::nrg_params_t::discard_trim
double discard_trim
Peak clipping at the end of the run.
Definition params.hpp:337

nrgljubljana_interface::nrg_params_t::dsyevrlimit
size_t dsyevrlimit
Minimal matrix size for dsyevr.
Definition params.hpp:217

nrgljubljana_interface::nrg_params_t::discretization
std::string discretization
Discretization scheme.
Definition params.hpp:199

nrgljubljana_interface::nrg_params_t::mMAX
int mMAX
Number of sites in the star representation ( : automatically determined).
Definition params.hpp:190

nrgljubljana_interface::nrg_params_t::checkdiag
bool checkdiag
Test the diagonalisation results.
Definition params.hpp:421

nrgljubljana_interface::nrg_params_t::fdm
bool fdm
Perform an FDM (full-density-matrix) calculation.
Definition params.hpp:163

nrgljubljana_interface::nrg_params_t::omega0_ratio
double omega0_ratio
Sets .
Definition params.hpp:277

nrgljubljana_interface::nrg_params_t::betabar
double betabar
Parameter  for thermodynamics.
Definition params.hpp:238

nrgljubljana_interface::nrg_params_t::dumpabs
bool dumpabs
Dump in terms of absolute energies.
Definition params.hpp:298

nrgljubljana_interface::nrg_params_t::removefiles
bool removefiles
Remove temporary data files.
Definition params.hpp:412

nrgljubljana_interface::nrg_params_t::diagratio
double diagratio
Ratio of eigenstates computed in partial diagonalisation.
Definition params.hpp:214

nrgljubljana_interface::nrg_params_t::tri
std::string tri
Tridiagonalisation approach.
Definition params.hpp:205

nrgljubljana_interface::nrg_params_t::emin
double emin
Lower binning limit.
Definition params.hpp:322

nrgljubljana_interface::nrg_params_t::v3mm
bool v3mm
Compute the 3-leg vertex on the Matsubara/Matsubara axis.
Definition params.hpp:187

nrgljubljana_interface::nrg_params_t::dump_f
bool dump_f
Dump  matrix elements.
Definition params.hpp:397

nrgljubljana_interface::nrg_params_t::fdmls
bool fdmls
Compute the FDM lesser correlation function.
Definition params.hpp:259

nrgljubljana_interface::nrg_params_t::Ninit
size_t Ninit
Number of initial Wilson chain operators.
Definition params.hpp:289

nrgljubljana_interface::nrg_params_t::Nmax
int Nmax
Number of sites in the Wilson chain ( : automatically determined).
Definition params.hpp:193

nrgljubljana_interface::nrg_params_t::dmnrgmats
bool dmnrgmats
Perform the DMNRG calculation on the Matsubara axis.
Definition params.hpp:169

nrgljubljana_interface::nrg_params_t::NN1
bool NN1
Perform N/N+1 patching.
Definition params.hpp:346

nrgljubljana_interface::nrg_params_t::safeguardmax
size_t safeguardmax
Maximal number of additional states to keep.
Definition params.hpp:232

nrgljubljana_interface::nrg_params_t::dumpprecision
size_t dumpprecision
Number of digits of precision used when dumping.
Definition params.hpp:304

nrgljubljana_interface::nrg_params_t::cfsgt
bool cfsgt
Compute the CFS greater correlation function.
Definition params.hpp:250

nrgljubljana_interface::nrg_params_t::noimag
bool noimag
Do not output the imaginary parts of expectation values.
Definition params.hpp:415

nrgljubljana_interface::nrg_params_t::discard_immediately
double discard_immediately
Peak clipping on the fly.
Definition params.hpp:340

nrgljubljana_interface::nrg_params_t::resume
bool resume
Attempt to restart the calculation.
Definition params.hpp:373

nrgljubljana_interface::nrg_params_t::fixeps
double fixeps
Threshold value for eigenvalue splitting corrections.
Definition params.hpp:235

nrgljubljana_interface::nrg_params_t::cfs
bool cfs
Perform a CFS (complete Fock space) calculation.
Definition params.hpp:160

nrgljubljana_interface::nrg_params_t::restartfactor
double restartfactor
Rescale factor used when restart is true.
Definition params.hpp:226

nrgljubljana_interface::nrg_params_t::reim
bool reim
Output the imaginary parts of the correlators.
Definition params.hpp:292

nrgljubljana_interface::nrg_params_t::h5_write
friend void h5_write(h5::group h5group, std::string subgroup_name, nrg_params_t const &sp)
Write nrg_params_t to HDF5.
Definition params.cpp:102

nrgljubljana_interface::nrg_params_t::checkrho
bool checkrho
Test that .
Definition params.hpp:424

nrgljubljana_interface::nrg_params_t::dm
bool dm
Compute density matrices.
Definition params.hpp:268

nrgljubljana_interface::nrg_params_t::logenumber
size_t logenumber
Number of eigenvalues to show for log=e.
Definition params.hpp:403

nrgljubljana_interface::nrg_params_t::forcestop
int forcestop
Force stop at the given iteration (-1: disabled).
Definition params.hpp:409

nrgljubljana_interface::nrg_params_t::specgt
std::string specgt
Conductance curves to compute.
Definition params.hpp:178

nrgljubljana_interface::nrg_params_t::stopafter
std::string stopafter
Stop the calculation at a given point.
Definition params.hpp:406

nrgljubljana_interface::nrg_params_t::dumpdiagonal
size_t dumpdiagonal
Dump diagonal matrix elements.
Definition params.hpp:313

nrgljubljana_interface::nrg_params_t::chitp
double chitp
Parameter  for  calculations.
Definition params.hpp:244

nrgljubljana_interface::nrg_params_t::dumpsubspaces
bool dumpsubspaces
Save detailed subspace info.
Definition params.hpp:394

nrgljubljana_interface::nrg_params_t::broaden_min_ratio
double broaden_min_ratio
Auto-tune the broaden_min parameter.
Definition params.hpp:271

nrgljubljana_interface::nrg_params_t::prec_td
size_t prec_td
Precision of columns in the 'td' output file.
Definition params.hpp:364

nrgljubljana_interface::nrg_params_t::checksumrules
bool checksumrules
Check operator sum rules.
Definition params.hpp:418

nrgljubljana_interface::nrg_params_t::dumpenergies
bool dumpenergies
Dump all energies to a file.
Definition params.hpp:400

nrgljubljana_interface::nrg_params_t::restart
bool restart
Restart the calculation to achieve the truncation goal.
Definition params.hpp:223

nrgljubljana_interface::nrg_params_t::speci1t
std::string speci1t
curves to compute.
Definition params.hpp:181

nrgljubljana_interface::nrg_params_t::NNtanh
double NNtanh
Parameter  in the  window function.
Definition params.hpp:355

nrgljubljana_interface::nrg_params_t::NN2avg
bool NN2avg
Average over even and odd N/N+2 spectra.
Definition params.hpp:352

nrgljubljana_interface::nrg_params_t::strategy
std::string strategy
Recalculation strategy.
Definition params.hpp:286

nrgljubljana_interface::nrg_params_t::calc0
bool calc0
Perform calculations at the 0-th iteration.
Definition params.hpp:385

nrgljubljana_interface::nrg_params_t::gtp
double gtp
Parameter  for  calculations.
Definition params.hpp:241

nrgljubljana_interface::nrg_params_t::fdmexpv
bool fdmexpv
Calculate expectation values using the FDM algorithm.
Definition params.hpp:166

nrgljubljana_interface::nrg_params_t::grouptol
double grouptol
Energy tolerance for considering two states as degenerate.
Definition params.hpp:310

nrgljubljana_interface::nrg_params_t::finitemats
bool finitemats
Perform a  calculation on the Matsubara axis.
Definition params.hpp:265

nrgljubljana_interface::nrg_params_t::width_custom
size_t width_custom
Width of columns in the 'custom' output file.
Definition params.hpp:361

nrgljubljana_interface::nrg_params_t::dumpscaled
bool dumpscaled
Dump using omega_N energy units.
Definition params.hpp:301

nrgljubljana_interface::nrg_params_t::width_td
size_t width_td
Width of columns in the 'td' output file.
Definition params.hpp:358

nrgljubljana_interface::nrg_params_t::dumpgroups
bool dumpgroups
Dump by grouping degenerate states.
Definition params.hpp:307

nrgljubljana_interface::nrg_params_t::preccpp
size_t preccpp
Precision for tridiagonalisation.
Definition params.hpp:208

nrgljubljana_interface::nrg_params_t::lastalloverride
bool lastalloverride
Override the automatic lastall setting.
Definition params.hpp:391

nrgljubljana_interface::nrg_params_t::goodE
double goodE
Energy window parameter for patching.
Definition params.hpp:343

nrgljubljana_interface::nrg_params_t::linstep
double linstep
Bin width for the linear mesh.
Definition params.hpp:334

nrgljubljana_interface::nrg_params_t::savebins
bool savebins
Save binned (unbroadened) data.
Definition params.hpp:316

nrgljubljana_interface::nrg_params_t::NN2even
bool NN2even
Use even iterations in N/N+2 patching.
Definition params.hpp:349

nrgljubljana_interface::nrg_params_t::emax
double emax
Upper binning limit.
Definition params.hpp:325

nrgljubljana_interface::nrg_params_t::xmax
double xmax
Largest  in the discretization ODE solver ( : automatically determined).
Definition params.hpp:196

nrgljubljana_interface::nrg_params_t::cfsls
bool cfsls
Compute the CFS lesser correlation function.
Definition params.hpp:253

nrgljubljana_interface::nrg_params_t::fdmgt
bool fdmgt
Compute the FDM greater correlation function.
Definition params.hpp:256

nrgljubljana_interface::nrg_params_t::bins
size_t bins
Number of bins per decade for spectral data.
Definition params.hpp:328

nrgljubljana_interface::nrg_params_t::mats
size_t mats
Number of Matsubara points to collect.
Definition params.hpp:175

nrgljubljana_interface::nrg_params_t::broaden
bool broaden
Enable broadening of spectra.
Definition params.hpp:319

nrgljubljana_interface::nrg_params_t::lastall
bool lastall
Keep all states in the last iteration for DMNRG.
Definition params.hpp:388

nrgljubljana_interface::nrg_params_t::diag
std::string diag
Eigensolver routine (dsyev|dsyevr|zheev|zheevr|default).
Definition params.hpp:211

nrgljubljana_interface::nrg_params_t::speci2t
std::string speci2t
curves to compute.
Definition params.hpp:184

nrgljubljana_interface::nrg_params_t::omega0
double omega0
Smallest energy scale in the problem, .
Definition params.hpp:274

nrgljubljana_interface::nrg_params_t::prec_xy
size_t prec_xy
Precision of the spectral function output.
Definition params.hpp:370

nrgljubljana_interface::nrg_params_t::dumpannotated
size_t dumpannotated
Number of eigenvalues to dump.
Definition params.hpp:295

nrgljubljana_interface::nrg_params_t::zheevrlimit
size_t zheevrlimit
Minimal matrix size for zheevr.
Definition params.hpp:220

nrgljubljana_interface::nrg_params_t::accumulation
double accumulation
Shift of the accumulation points for binning.
Definition params.hpp:331

nrgljubljana_interface::nrg_params_t::fdmexpvn
size_t fdmexpvn
Iteration at which the expectation values are evaluated.
Definition params.hpp:262

nrgljubljana_interface::nrg_params_t::done
bool done
Create a DONE file.
Definition params.hpp:382

nrgljubljana_interface::nrg_params_t::safeguard
double safeguard
Additional states to keep in case of a near degeneracy.
Definition params.hpp:229

nrgljubljana_interface::nrg_params_t::finite
bool finite
Perform a Costi-Hewson-Zlatic finite-T calculation.
Definition params.hpp:247

nrgljubljana_interface::nrg_params_t::diagth
int diagth
Number of diagonalisation threads.
Definition params.hpp:280

nrgljubljana_interface::nrg_params_t::prec_custom
size_t prec_custom
Precision of columns in the 'custom' output file.
Definition params.hpp:367

nrgljubljana_interface::nrg_params_t::log
std::string log
List of tokens defining what to log.
Definition params.hpp:376

nrgljubljana_interface::nrg_params_t::dmnrg
bool dmnrg
Perform a DMNRG (density-matrix NRG) calculation.
Definition params.hpp:157

nrgljubljana_interface::nrg_params_t::substeps
bool substeps
Use the interleaved diagonalization scheme.
Definition params.hpp:283

nrgljubljana_interface::solve_params_t
Parameters for the solve() method.
Definition params.hpp:108

nrgljubljana_interface::solve_params_t::Lambda
double Lambda
Logarithmic discretization parameter.
Definition params.hpp:111

nrgljubljana_interface::solve_params_t::Nz
int Nz
Number of discretization meshes (interleaved twist parameters z).
Definition params.hpp:114

nrgljubljana_interface::solve_params_t::keepmin
size_t keepmin
Minimum number of states to keep at each NRG step.
Definition params.hpp:126

nrgljubljana_interface::solve_params_t::bandrescale
double bandrescale
Band rescaling factor (half-width of the support of the hybridisation function); set to mesh_max if n...
Definition params.hpp:141

nrgljubljana_interface::solve_params_t::model_parameters
std::map< std::string, double > model_parameters
Model parameters (name to value map, e.g. U1, eps1).
Definition params.hpp:144

nrgljubljana_interface::solve_params_t::h5_read
friend void h5_read(h5::group h5group, std::string subgroup_name, solve_params_t &sp)
Read solve_params_t from HDF5.
Definition params.cpp:86

nrgljubljana_interface::solve_params_t::gamma
double gamma
Parameter for the Gaussian convolution step.
Definition params.hpp:135

nrgljubljana_interface::solve_params_t::T
double T
Temperature, .
Definition params.hpp:129

nrgljubljana_interface::solve_params_t::h5_write
friend void h5_write(h5::group h5group, std::string subgroup_name, solve_params_t const &sp)
Write solve_params_t to HDF5.
Definition params.cpp:70

nrgljubljana_interface::solve_params_t::method
std::string method
Method for calculating the dynamical quantities.
Definition params.hpp:138

nrgljubljana_interface::solve_params_t::alpha
double alpha
Width of the logarithmic gaussian used for broadening.
Definition params.hpp:132

nrgljubljana_interface::solve_params_t::keepenergy
double keepenergy
Cut-off energy for truncation.
Definition params.hpp:123

nrgljubljana_interface::solve_params_t::Tmin
double Tmin
Lowest energy scale on the Wilson chain.
Definition params.hpp:117

nrgljubljana_interface::solve_params_t::keep
size_t keep
Maximum number of states to keep at each NRG step.
Definition params.hpp:120