abacus-develop/input__parameter_8h_source.html

#ifndef INPUT_PARAMETER_H

#define INPUT_PARAMETER_H

#include "md_parameter.h"

#include "source_base/vector3.h"


#include <string>

#include <vector>


// It stores all input parameters both defined in INPUT file and not defined in

// INPUT file


struct Input_para

{

    // ---------------------------------------------------------------

    // --------------       INPUT  Parameters         ----------------

    // ---------------------------------------------------------------

    // ==============   #Parameters (1.System)  =====================

    std::string suffix = "ABACUS";

    int ntype = 0;

    std::string calculation = "scf";

    std::string esolver_type = "ksdft";

    /* symmetry level:

      -1, no symmetry at all;

      0, only basic time reversal would be considered;

      1, point group symmetry would be considered*/

    std::string symmetry = "default";

    double symmetry_prec = 1.0e-6;

    bool symmetry_autoclose = true;

    bool cal_force = false;

    bool cal_stress = false;

    int kpar = 1;

    int bndpar = 1;

    std::string latname = "user_defined_lattice";

    double ecutwfc = 0;

    double ecutrho = 0;


    int nx = 0, ny = 0, nz = 0;

    int ndx = 0, ndy = 0, ndz = 0;


    double cell_factor = 1.2;

    double erf_ecut = 0;

    double erf_height = 0;

    double erf_sigma = 0.1;

    int fft_mode = 0;

    std::string init_wfc = "atomic";

    int pw_seed = 0;

    std::string init_chg = "atomic";

    bool dm_to_rho = false;

    std::string chg_extrap = "default";

    bool init_vel = false;


    std::string input_file = "INPUT";

    std::string stru_file = "STRU";

    std::string kpoint_file = "KPT";

    std::string pseudo_dir = "";

    std::string orbital_dir = "";

    std::string read_file_dir = "auto";

    bool restart_load = false;

    std::string wannier_card = "none";

    int mem_saver = 0;

    int diago_proc = 0;

    int nbspline = -1;

    std::vector<double> kspacing = {0.0, 0.0, 0.0};

    std::vector<double> koffset = {0.0, 0.0, 0.0};

    std::string kmesh_type = "gamma";

    double min_dist_coef = 0.2;


    std::string device = "auto";

    std::string precision = "double";

    std::string gint_precision = "double";

    bool timer_enable_nvtx = false;


    // ==============   #Parameters (2.Electronic structure) ===========================

    std::string ks_solver = "default";

    std::string basis_type = "pw";

    int nbands = 0;

    double nelec = 0.0;

    double nelec_delta = 0.0;

    double nupdown = 0.0;

    std::string dft_functional = "default";

    double xc_temperature = 0.0;

    double pseudo_rcut = 15.0;

    bool pseudo_mesh = false;

    int nspin = 1;

    int pw_diag_nmax = 50;

    double pw_diag_thr = 0.01;

    bool diago_smooth_ethr = false;

    int pw_diag_ndim = 4;

    int diago_cg_prec = 1;

    int diag_subspace = 0;          // 0: Lapack, 1: elpa, 2: scalapack

    bool use_k_continuity = false;


    std::string smearing_method = "gauss";

    double smearing_sigma = 0.015;


    std::string mixing_mode = "broyden";

    double mixing_beta = -1.0;

    int mixing_ndim = 8;

    double mixing_restart = 0.0;

    double mixing_gg0 = 1.0;

    double mixing_beta_mag = -10.0;

    double mixing_gg0_mag = 0.0;

    double mixing_gg0_min = 0.1;

    double mixing_angle = -10.0;

    bool mixing_tau = false;

    bool mixing_dftu = false;

    bool mixing_dmr = false;


    bool gamma_only = false;

    int scf_nmax = 100;

    double scf_thr = -1.0;

    double scf_ene_thr = -1.0;

    int scf_thr_type = -1;

//    bool final_scf = false;    ///< whether to do final scf

    bool scf_os_stop = false;

    double scf_os_thr = -0.01;

    int scf_os_ndim = 0;

    int sc_os_ndim = 5;


    bool lspinorb = false;

    bool noncolin = false;

    double soc_lambda = 1.0;

    int dfthalf_type = 0;


    // ==============   #Parameters (3.LCAO) ===========================

    int nb2d = 0;

    int lmaxmax = 2;

    double lcao_ecut = 0.0;

    double lcao_dk = 0.01;

    double lcao_dr = 0.01;

    double lcao_rmax = 30.0;

    double search_radius = -1.0;

    int bx = 0, by = 0, bz = 0;

    int elpa_num_thread = -1;

    int nstream = 4;

    std::string bessel_nao_ecut = "default";

    double bessel_nao_tolerence = 1e-12;

    std::vector<double> bessel_nao_rcuts = {};

    bool bessel_nao_smooth = true;

    double bessel_nao_sigma = 0.1;

    // ==========================================================

    //  spherical bessel  Peize Lin added on 2022-12-15

    // ==========================================================

    //  the following are used when generating orb_matrix.dat

    //  int     bessel_nao_lmax;        ///< lmax used in descriptor


    // ==============   #Parameters (4.Relaxation) ===========================

    std::vector<std::string> relax_method = {"cg", "1"};

    bool relax_new = true;

    bool relax = false;

    double relax_scale_force = 0.5;

    int relax_nmax = -1;

    double relax_cg_thr = 0.5;

    double force_thr = -1;

    double force_thr_ev = -1;

    double force_zero_out = 0;

    double stress_thr = 0.5;

    double press1 = 0;

    double press2 = 0;

    double press3 = 0;

    double relax_bfgs_w1 = 0.01;

    double relax_bfgs_w2 = 0.5;

    double relax_bfgs_rmax = 0.2;

    double relax_bfgs_rmin = 1e-05;

    double relax_bfgs_init = 0.5;

    std::string fixed_axes = "None";

    bool fixed_ibrav = false;

    bool fixed_atoms = false;


    // ==============   #Parameters (5.Molecular dynamics) ===========================

    MD_para mdp;

    double ref_cell_factor = 1;

    std::vector<int> cal_syns = {0, 8};

    double dmax = 0.01;


    // ==============   #Parameters (6.OFDFT) ===========================

    // OFDFT  sunliang added on 2022-05-05

    std::string of_kinetic = "wt";

    std::string of_method = "tn";

    std::string of_conv = "energy";

    double of_tole = 1e-06;

    double of_tolp = 1e-05;

    double of_tf_weight = 1.0;

    double of_vw_weight = 1.0;

    double of_wt_alpha = 5. / 6.;

    double of_wt_beta = 5. / 6.;

    double of_extwt_kappa = 1.0

                            / (2.0 * std::pow(4. / 3., 1. / 3.) - 1.0);

    double of_wt_rho0 = 0.0;

    bool of_hold_rho0 = false;

    double of_lkt_a = 1.3;

    bool of_full_pw = true;

    int of_full_pw_dim = 0;

    bool of_read_kernel = false;

    std::string of_kernel_file = "WTkernel.txt";

    double of_xwm_kappa = 0.0;

    double of_xwm_rho_ref = 0.0;


    // ML KEDF, sunliang added on 2022-11-07

    bool of_ml_gene_data = false;

    // device

    std::string of_ml_device = "cpu";

    int of_ml_feg = 0;

    // kernel

    int of_ml_nkernel = 1;

    std::vector<int> of_ml_kernel = {1};


    std::vector<double> of_ml_kernel_scaling

        = {1.0};


    std::vector<double> of_ml_yukawa_alpha = {1.0};

    std::vector<std::string> of_ml_kernel_file = {"none"};

    // semi-local descriptors

    bool of_ml_gamma = false;

    bool of_ml_p = false;

    bool of_ml_q = false;

    bool of_ml_tanhp = false;

    bool of_ml_tanhq = false;

    double of_ml_chi_p = 1.0;

    double of_ml_chi_q = 1.0;

    // non-local descriptors

    // of_ml_gammanl should be a vector of bool, but here we use a vector of int for convinience

    std::vector<int> of_ml_gammanl = {0};

    std::vector<int> of_ml_pnl = {0};

    std::vector<int> of_ml_qnl = {0};

    std::vector<int> of_ml_xi = {0};

    std::vector<int> of_ml_tanhxi = {0};

    std::vector<int> of_ml_tanhxi_nl = {0};

    std::vector<int> of_ml_tanh_pnl = {0};

    std::vector<int> of_ml_tanh_qnl = {0};

    std::vector<int> of_ml_tanhp_nl = {0};

    std::vector<int> of_ml_tanhq_nl = {0};

    std::vector<double> of_ml_chi_xi = {1.0};

    std::vector<double> of_ml_chi_pnl = {1.0};

    std::vector<double> of_ml_chi_qnl = {1.0};

    bool of_ml_local_test = false;


    // ==============   #Parameters (7.stochastic DFT) ===========================

    int method_sto = 2;

    int npart_sto = 1;

    int nbands_sto = 256;

    int nche_sto = 100;

    double emin_sto = 0;

    double emax_sto = 0;

    int seed_sto = 0;

    double initsto_ecut = 0.0;

    int initsto_freq = 0;

    bool ml_exx = false;


    // ==============   #Parameters (8.DeepKS) ===========================

    //==========================================================

    // DeepKS -- added by caoyu and mohan

    //==========================================================

    int deepks_out_labels = 0;

    int deepks_out_freq_elec = 0;

    std::string deepks_out_base = "none";

    bool deepks_scf = false;

    int deepks_bandgap = 0;

    std::vector<int> deepks_band_range = {-1, 0};

    int deepks_v_delta = 0;

    bool deepks_equiv = false;

    bool deepks_out_unittest = false;

    std::string deepks_model = "None";


    int bessel_descriptor_lmax = 2;

    std::string bessel_descriptor_ecut = "default";

    double bessel_descriptor_tolerence = 1e-12;

    double bessel_descriptor_rcut = 6.0;

    bool bessel_descriptor_smooth = true;

    double bessel_descriptor_sigma = 0.1;


    // ==============   #Parameters (9.rt-tddft) ===========================

    double td_dt = -1.0;

    int estep_per_md = 1;

    double td_force_dt = 0.02;

    bool td_vext = false;

    // std::string td_vext_dire = "1";   ///< vext direction

    std::vector<int> td_vext_dire = {1};


    bool init_vecpot_file = false;

    double td_print_eij = -1.0;

    int td_edm = 0;

    int propagator = 0;

    int td_stype = 0;

    std::string td_ttype = "0";

    int td_tstart = 1;

    int td_tend = 1000;


    double td_lcut1 = 0.05;

    double td_lcut2 = 0.95;


    std::string td_gauss_freq = "22.13";

    std::string td_gauss_phase = "0.0";

    std::string td_gauss_sigma = "30.0";

    std::string td_gauss_t0 = "100.0";

    std::string td_gauss_amp = "0.25";


    std::string td_trape_freq = "1.60";

    // Trapezoidal

    std::string td_trape_phase = "0.0";

    std::string td_trape_t1 = "1875.0";

    std::string td_trape_t2 = "5625.0";

    std::string td_trape_t3 = "7500.0";

    std::string td_trape_amp = "2.74"; // V/A


    // Trigonometric

    std::string td_trigo_freq1 = "1.164656"; // time(fs)^-1

    std::string td_trigo_freq2 = "0.029116"; // time(fs)^-1

    std::string td_trigo_phase1 = "0.0";

    std::string td_trigo_phase2 = "0.0";

    std::string td_trigo_amp = "2.74"; // V/A


    // Heaviside

    std::string td_heavi_t0 = "100.0";

    std::string td_heavi_amp = "1.0"; // V/A


    bool ocp = false;

    // std::string ocp_set = "";

    std::vector<double> ocp_kb = {};


    // ==============   #Parameters (10.lr-tddft) ===========================

    int lr_nstates = 1;

    std::vector<std::string> lr_init_xc_kernel = {};

    int nocc = -1;

    int nvirt = 1;

    std::string xc_kernel = "LDA";

    std::string lr_solver = "dav";

    double lr_thr = 1e-2;

    bool out_wfc_lr = false;

    bool lr_unrestricted = false;

    std::vector<double> abs_wavelen_range = {};

    double abs_broadening = 0.01;

    std::string abs_gauge

        = "length";

    std::string ri_hartree_benchmark = "none";


    std::vector<int> aims_nbasis

        = {};


    // ==============   #Parameters (11.Output) ===========================

    bool out_stru = false;

    int out_freq_elec = 0;

    int out_freq_ion = 0;

    int out_freq_td = 0;

    std::vector<int> out_chg = {0, 3};

    std::vector<int> out_xc_r = {-1, 3};

    std::vector<int> out_pot = {0, 8};

    int out_wfc_pw = 0;

    std::vector<int> out_band = {0, 8};

    int out_dos = 0;

    std::vector<int> out_ldos = {0, 3};

    bool out_mul = false;

    bool out_proj_band = false;

    std::string out_level = "ie";

    std::vector<int> out_dmr = {0, 8};

    std::vector<int> out_dmk = {0, 8};

    bool out_bandgap = false;

    std::vector<int> out_mat_hs = {0, 8};

    std::vector<int> out_mat_tk = {0, 8};

    std::vector<int> out_mat_l = {0, 8};

    std::vector<int> out_mat_hs2 = {0, 8};

    std::vector<int> out_mat_dh = {0, 8};

    std::vector<int> out_mat_ds = {0, 8};

    bool out_mat_xc = false;

    std::vector<int> out_mat_xc2 = {0, 8};

    bool out_eband_terms = false;

    int out_interval = 1;

    bool out_app_flag = true;

    int out_ndigits = 8;

    std::vector<int> out_mat_t = {0, 8};

    bool out_element_info = false;

    std::vector<int> out_mat_r = {0, 8};

    int out_wfc_lcao = 0;

    bool out_dipole = false;

    bool out_efield = false;

    int out_current = 0;

    bool out_current_k = false;

    bool out_vecpot = false;

    std::vector<int> cal_symm_repr = {0, 3};

    bool restart_save = false;

    bool rpa = false;

    std::vector<int> out_pchg = {};

    std::vector<int> out_wfc_norm = {};

    std::vector<int> out_wfc_re_im = {};

    bool if_separate_k = false;

    std::vector<int> out_elf = {0, 3};

    int out_spillage = 0;

    std::string spillage_outdir = "./";


    // ==============   #Parameters (12.Postprocess) ===========================

    double dos_emin_ev = -15.0;

    double dos_emax_ev = 15.0;

    double dos_edelta_ev = 0.01;

    double dos_scale = 0.01;

    double dos_sigma = 0.07;

    int dos_nche = 100;

    std::vector<double> stm_bias = {1.0, 0.1, 1};


    std::vector<double> ldos_line

        = {0.0,

           0.0,

           0.0,

           0.0,

           0.0,

           1.0,

           100};


    bool cal_cond = false;

    double cond_che_thr = 1e-8;

    double cond_dw = 0.1;

    double cond_wcut = 10;

    double cond_dt = 0.02;

    int cond_dtbatch = 0;

    int cond_smear = 1;

    double cond_fwhm = 0.4;

    bool cond_nonlocal = true;


    bool berry_phase = false;

    int gdir = 3;


    bool towannier90 = false;

    std::string nnkpfile = "seedname.nnkp";

    std::string wannier_spin = "up";

    int wannier_method = 1;

    bool out_wannier_mmn = true;

    bool out_wannier_amn = true;

    bool out_wannier_unk = false;

    bool out_wannier_eig = true;

    bool out_wannier_wvfn_formatted = true;


    // ==============   #Parameters (13.Model) ===========================

    // ==========================================================

    //  efield and dipole correction

    //  Yu Liu add 2022-05-18

    // ==========================================================

    bool efield_flag = false;

    bool dip_cor_flag = false;

    int efield_dir = 2;

    double efield_pos_max = -1;

    double efield_pos_dec = -1;

    double efield_amp = 0;


    // ==========================================================

    //  gatefield (compensating charge)

    //  Yu Liu add 2022-09-13

    // ==========================================================

    bool gate_flag = false;

    double zgate = 0.5;

    bool block = false;

    double block_down = 0.45;

    double block_up = 0.55;

    double block_height = 0.1;


    //    implicit solvation model       Menglin Sun added on 2022-04-04

    bool imp_sol = false;

    double eb_k = 80;

    double tau = 1.0798e-05;

    double sigma_k = 0.6;

    double nc_k = 0.00037;


    // ==============  #Parameters (14.vdW Correction) ===========================

    // ==========================================================

    //  vdw

    //  Peize Lin add 2014-03-31, jiyy update 2019-08-01

    // ==========================================================

    std::string vdw_method = "none";

    std::string vdw_s6 = "default";

    std::string vdw_s8 = "default";

    std::string vdw_a1 = "default";

    std::string vdw_a2 = "default";

    double vdw_d = 20.0;

    bool vdw_abc = false;

    std::string vdw_C6_file = "default";

    std::string vdw_C6_unit = "Jnm6/mol";

    std::string vdw_R0_file = "default";

    std::string vdw_R0_unit = "A";

    std::string vdw_cutoff_type = "radius";

    std::string vdw_cutoff_radius = "default";

    std::string vdw_radius_unit = "Bohr";

    double vdw_cn_thr = 40.0;

    std::string vdw_cn_thr_unit = "Bohr";

    ModuleBase::Vector3<int> vdw_cutoff_period = {3, 3, 3};


    // ==============   #Parameters (15.exx) ====================

    // ==========================================================

    //  exx

    //  Peize Lin add 2018-06-20

    // ==========================================================

    std::vector<std::string> exx_fock_alpha = {"default"};

    std::vector<std::string> exx_fock_lambda = {"default"};

    std::vector<std::string> exx_erfc_alpha = {"default"};

    std::vector<std::string> exx_erfc_omega = {"default"};

    bool exx_separate_loop = true;

    std::string exx_singularity_correction = "default";

    int exx_hybrid_step = 100;

    double exx_mixing_beta = 1.0;

    std::string exx_real_number = "default";

    double exx_pca_threshold = 0.0001;

    double exx_c_threshold = 0.0001;

    double exx_v_threshold = 0.1;

    double exx_dm_threshold = 0.0001;

    double exx_c_grad_threshold = 0.0001;

    double exx_v_grad_threshold = 0.1;

    double exx_c_grad_r_threshold = 0.0001;

    double exx_v_grad_r_threshold = 0.1;

    std::string exx_ccp_rmesh_times = "default";

    int exx_opt_orb_lmax = 0;

    double exx_opt_orb_ecut = 0.0;

    double exx_opt_orb_tolerence = 0.0;

    bool exx_symmetry_realspace

        = true;

    double rpa_ccp_rmesh_times = 10.0;

    double exx_cs_inv_thr = -1;

    double shrink_abfs_pca_thr = -1;

    double shrink_LU_inv_thr

        = 1e-6;

    bool out_ri_cv = false;

    bool out_unshrinked_v = false;

    bool exx_coul_moment = false;

    bool exx_rotate_abfs = false;

    double exx_multip_moments_threshold = 1e-10;

    // ==============   #Parameters (16.dft+u) ======================

    //    DFT+U       Xin Qu added on 2020-10-29

    int dft_plus_u = 0;

    bool dft_plus_dmft = false;

    bool yukawa_potential = false;

    double yukawa_lambda = -1.0;

    double uramping_eV = -1.0;

    int omc = 0;

    double onsite_radius = 0.0;

    std::vector<double> hubbard_u_eV = {};

    std::vector<int> orbital_corr = {};


    // ==============   #Parameters (17.non-collinear spin-constrained DFT) =========

    bool sc_mag_switch = false;

    bool decay_grad_switch = false;

    double sc_thr = 1e-06;

    int nsc = 100;

    int nsc_min = 2;

    int sc_scf_nmin = 2;

    double alpha_trial = 0.01;

    double sccut = 3.0;

    double sc_scf_thr = 1e-3;

    double sc_drop_thr = 1e-3;


    // ==============   #Parameters (18.Quasiatomic Orbital analysis) =========

    bool qo_switch = false;

    std::string qo_basis = "szv";

    double qo_thr = 1e-06;

    std::vector<std::string> qo_strategy = {};

    std::vector<double> qo_screening_coeff = {};


    // ==============   #Parameters (19.PEXSI) =====================

    int pexsi_npole = 40;

    bool pexsi_inertia = true;

    int pexsi_nmax = 80;

    bool pexsi_comm = true;

    bool pexsi_storage = true;

    int pexsi_ordering = 0;

    int pexsi_row_ordering = 1;

    int pexsi_nproc = 1;

    bool pexsi_symm = true;

    bool pexsi_trans = false;

    int pexsi_method = 1;

    int pexsi_nproc_pole = 1;

    double pexsi_temp = 0.015;

    double pexsi_gap = 0;

    double pexsi_delta_e = 20.0;

    double pexsi_mu_lower = -10;

    double pexsi_mu_upper = 10;

    double pexsi_mu = 0.0;

    double pexsi_mu_thr = 0.05;

    double pexsi_mu_expand = 0.3;

    double pexsi_mu_guard = 0.2;

    double pexsi_elec_thr = 0.001;

    double pexsi_zero_thr = 1e-10;


    // ==============   #Parameters (20.Test) ====================

    bool out_alllog = false;

    int nurse = 0;

    bool t_in_h = true;

    bool vl_in_h = true;

    bool vnl_in_h = true;

    bool vh_in_h = true;

    bool vion_in_h = true;

    bool test_force = false;

    bool test_stress = false;

    bool test_skip_ewald = false;

    int test_atom_input = false;

    int test_symmetry = false;

    int test_wf = 0;

    int test_grid = false;

    int test_charge = false;

    int test_energy = false;

    int test_gridt = false;

    int test_pseudo_cell = false;

    int test_pp = 0;

    int test_relax_method = false;

    int test_deconstructor = false;


    // ==============   #Parameters (21.RDMFT) =====================

    // RDMFT    jghan added on 2024-07-06

    bool rdmft = false;               // rdmft, reduced density matrix funcional theory

    double rdmft_power_alpha = 0.656; // the alpha parameter of power-functional, g(occ_number) = occ_number^alpha

    // double rdmft_wp22_omega;                 // the omega parameter of wp22-functional = exx_erfc_omega


    // ==============   #Parameters (22.EXX PW) =====================

    // EXX for planewave basis, rhx0820 2025-03-10

    bool exxace = true; // exxace, exact exchange for planewave basis, https://doi.org/10.1021/acs.jctc.6b00092

    bool exx_gamma_extrapolation = true; // gamma point extrapolation for exx, https://doi.org/10.1103/PhysRevB.79.205114

    std::string exx_thr_type = "density";

    double exx_ene_thr = 1e-5;

    double ecutexx = 0.0;


    // ====   #Parameters (23.XC external parameterization) ========

    /*

     * the following two sets of parameters are for the XC parameterization.

     * The first element should be the LibXC id, to assign the analytical

     * form of the eXchange and Correlation part of the functional.

     *

     * Starting from the second parameter, the parameters are the coefficients

     * of the functional. For example the M06-L functional, one should refer

     * to the source file (source code of LibXC)

     *

     * src/mgga_x_m06l.c

     *

     * the implementation can be found in the file

     *

     * src/maple2c/mgga_exc/mgga_x_m06l.c.

     *

     * There are 18 parameters for the exchange part, so the whole length of

     * the xc_exch_ext should be 19. (MGGA_X_M06L, id = 203)

     *

     * Likewise, the correlation part can be found in corresponding files.

     *

     * PBE functional is used as the default functional for XCPNet.

     */

    // src/gga_x_pbe.c


    std::vector<double> xc_exch_ext = {

        101, 0.8040, 0.2195149727645171};


    // src/gga_c_pbe.c


    std::vector<double> xc_corr_ext = {

        130, 0.06672455060314922, 0.031090690869654895034, 1.00000};


    // ==============   #Parameters (24.td-ofdft) ===========================

    bool of_cd = false;

    double of_mCD_alpha = 1.0;


    // ==============   #Parameters (25.uncommon hardware) ==================

    int dsp_count = 4;

};


#endif

ModuleBase::Vector3
3 elements vector
Definition vector3.h:24

md_parameter.h

rdmft
Reduced Density Matrix Functional Theory (RDMFT)
Definition rdmft.cpp:22

Input_para
Definition input_parameter.h:12

Input_para::noncolin
bool noncolin
using non-collinear-spin
Definition input_parameter.h:129

Input_para::lcao_dr
double lcao_dr
dr used in two center integral
Definition input_parameter.h:139

Input_para::out_alllog
bool out_alllog
output all logs.
Definition input_parameter.h:643

Input_para::td_trigo_phase1
std::string td_trigo_phase1
Definition input_parameter.h:344

Input_para::relax_bfgs_w2
double relax_bfgs_w2
wolfe condition 2
Definition input_parameter.h:171

Input_para::exx_opt_orb_tolerence
double exx_opt_orb_tolerence
Definition input_parameter.h:560

Input_para::ri_hartree_benchmark
std::string ri_hartree_benchmark
Definition input_parameter.h:370

Input_para::test_skip_ewald
bool test_skip_ewald
variables for test only
Definition input_parameter.h:653

Input_para::of_ml_tanhxi_nl
std::vector< int > of_ml_tanhxi_nl
Descriptor: tanhxi_nl = int{tanhxi(r') * w(r-r') dr'}.
Definition input_parameter.h:247

Input_para::mixing_tau
bool mixing_tau
whether to mix tau in mgga
Definition input_parameter.h:113

Input_para::relax
bool relax
allow relaxation along the specific direction
Definition input_parameter.h:159

Input_para::deepks_v_delta
int deepks_v_delta
for v_delta label. xuan added
Definition input_parameter.h:284

Input_para::nocc
int nocc
the number of occupied orbitals to form the 2-particle basis
Definition input_parameter.h:359

Input_para::nurse
int nurse
used for debug.
Definition input_parameter.h:644

Input_para::erf_height
double erf_height
the height of the energy step for reciprocal vectors
Definition input_parameter.h:44

Input_para::lcao_ecut
double lcao_ecut
ecut of two center integral
Definition input_parameter.h:137

Input_para::bessel_descriptor_tolerence
double bessel_descriptor_tolerence
tolerance for spherical bessel root
Definition input_parameter.h:292

Input_para::out_mul
bool out_mul
qifeng add 2019-9-10
Definition input_parameter.h:387

Input_para::gint_precision
std::string gint_precision
Definition input_parameter.h:73

Input_para::td_lcut2
double td_lcut2
Definition input_parameter.h:322

Input_para::emin_sto
double emin_sto
Emin to normalize H.
Definition input_parameter.h:264

Input_para::td_heavi_t0
std::string td_heavi_t0
Definition input_parameter.h:349

Input_para::alpha_trial
double alpha_trial
initial trial step size for lambda in eV/uB^2
Definition input_parameter.h:601

Input_para::out_wannier_amn
bool out_wannier_amn
output .amn file or not
Definition input_parameter.h:470

Input_para::out_interval
int out_interval
Definition input_parameter.h:403

Input_para::abs_wavelen_range
std::vector< double > abs_wavelen_range
the range of wavelength(nm) to output the absorption spectrum
Definition input_parameter.h:366

Input_para::nvirt
int nvirt
the number of virtual orbitals to form the 2-particle basis (nocc + nvirt <= nbands)
Definition input_parameter.h:360

Input_para::td_ttype
std::string td_ttype
Definition input_parameter.h:310

Input_para::exx_erfc_omega
std::vector< std::string > exx_erfc_omega
range-separation parameter in HSE functional
Definition input_parameter.h:540

Input_para::block_height
double block_height
height of the block
Definition input_parameter.h:497

Input_para::tau
double tau
the effective surface tension parameter
Definition input_parameter.h:503

Input_para::cond_che_thr
double cond_che_thr
Definition input_parameter.h:445

Input_para::td_trigo_freq2
std::string td_trigo_freq2
Definition input_parameter.h:343

Input_para::bessel_nao_smooth
bool bessel_nao_smooth
spherical bessel smooth or not
Definition input_parameter.h:148

Input_para::of_ml_tanh_qnl
std::vector< int > of_ml_tanh_qnl
Descriptor: tanh_qnl = tanh(chi_qnl * qnl)
Definition input_parameter.h:249

Input_para::latname
std::string latname
lattice name
Definition input_parameter.h:35

Input_para::out_wfc_norm
std::vector< int > out_wfc_norm
specify the bands to be calculated for norm of wfc
Definition input_parameter.h:420

Input_para::lcao_rmax
double lcao_rmax
rmax(a.u.) to make table.
Definition input_parameter.h:140

Input_para::ks_solver
std::string ks_solver
xiaohui add 2013-09-01
Definition input_parameter.h:77

Input_para::calculation
std::string calculation
Definition input_parameter.h:19

Input_para::efield_pos_dec
double efield_pos_dec
zone in the unit cell where the saw-like potential decreases
Definition input_parameter.h:485

Input_para::of_ml_gene_data
bool of_ml_gene_data
Generate training data or not.
Definition input_parameter.h:221

Input_para::fft_mode
int fft_mode
fftw mode 0: estimate, 1: measure, 2: patient, 3: exhaustive
Definition input_parameter.h:46

Input_para::mixing_restart
double mixing_restart
Definition input_parameter.h:106

Input_para::orbital_corr
std::vector< int > orbital_corr
Definition input_parameter.h:585

Input_para::fixed_ibrav
bool fixed_ibrav
Definition input_parameter.h:176

Input_para::mixing_dmr
bool mixing_dmr
whether to mix real space density matrix
Definition input_parameter.h:115

Input_para::nbspline
int nbspline
the order of B-spline basis(>=0) if it is -1 (default)
Definition input_parameter.h:65

Input_para::seed_sto
int seed_sto
random seed for sDFT
Definition input_parameter.h:266

Input_para::of_tolp
double of_tolp
Definition input_parameter.h:195

Input_para::dos_sigma
double dos_sigma
pengfei 2014-10-13
Definition input_parameter.h:432

Input_para::dsp_count
int dsp_count
count of DSP hardwares in one node
Definition input_parameter.h:715

Input_para::of_kinetic
std::string of_kinetic
Kinetic energy functional, such as TF, VW, WT, TF+.
Definition input_parameter.h:189

Input_para::fixed_atoms
bool fixed_atoms
whether to fix atoms during vc-relax
Definition input_parameter.h:178

Input_para::exx_fock_alpha
std::vector< std::string > exx_fock_alpha
fraction of Fock exchange 1/r in hybrid functionals
Definition input_parameter.h:536

Input_para::cond_wcut
double cond_wcut
cutoff \omega for conductivities
Definition input_parameter.h:448

Input_para::td_tend
int td_tend
Definition input_parameter.h:317

Input_para::td_trigo_phase2
std::string td_trigo_phase2
Definition input_parameter.h:345

Input_para::gdir
int gdir
Definition input_parameter.h:456

Input_para::of_ml_chi_xi
std::vector< double > of_ml_chi_xi
Hyperparameter: tanhpxi = tanh(chi_xi * xi)
Definition input_parameter.h:252

Input_para::pexsi_npole
int pexsi_npole
Definition input_parameter.h:618

Input_para::exx_ene_thr
double exx_ene_thr
threshold when exx_thr_type = energy
Definition input_parameter.h:677

Input_para::onsite_radius
double onsite_radius
radius of the sphere for onsite projection (Bohr)
Definition input_parameter.h:583

Input_para::koffset
std::vector< double > koffset
koffset for kspacing-generated k-point mesh
Definition input_parameter.h:67

Input_para::pseudo_rcut
double pseudo_rcut
cut-off radius for calculating msh
Definition input_parameter.h:85

Input_para::pexsi_trans
bool pexsi_trans
Definition input_parameter.h:627

Input_para::nz
int nz
three dimension of FFT wavefunc
Definition input_parameter.h:39

Input_para::exx_symmetry_realspace
bool exx_symmetry_realspace
whether to reduce the real-space sector in when using symmetry=1 in EXX calculation
Definition input_parameter.h:563

Input_para::test_force
bool test_force
test the force.
Definition input_parameter.h:651

Input_para::cond_dtbatch
int cond_dtbatch
exp(iH*dt*cond_dtbatch) is expanded with Chebyshev expansion.
Definition input_parameter.h:450

Input_para::by
int by
Definition input_parameter.h:142

Input_para::erf_ecut
double erf_ecut
the value of the constant energy cutoff
Definition input_parameter.h:43

Input_para::lr_thr
double lr_thr
convergence threshold of the LR-TDDFT eigensolver
Definition input_parameter.h:363

Input_para::yukawa_lambda
double yukawa_lambda
default: -1.0, which means we calculate lambda
Definition input_parameter.h:580

Input_para::symmetry
std::string symmetry
Definition input_parameter.h:27

Input_para::pexsi_mu_expand
double pexsi_mu_expand
Definition input_parameter.h:637

Input_para::of_extwt_kappa
double of_extwt_kappa
parameter kappa of EXT-WT KEDF
Definition input_parameter.h:201

Input_para::exx_pca_threshold
double exx_pca_threshold
threshold to screen on-site ABFs in exx
Definition input_parameter.h:548

Input_para::lr_solver
std::string lr_solver
the eigensolver for LR-TDDFT
Definition input_parameter.h:362

Input_para::td_heavi_amp
std::string td_heavi_amp
Definition input_parameter.h:350

Input_para::td_edm
int td_edm
0: new edm method 1: old edm method
Definition input_parameter.h:307

Input_para::of_ml_p
bool of_ml_p
Descriptor: p = |nabla rho|^2 / [2 (3 pi^2)^(1/3) rho^(4/3)]^2.
Definition input_parameter.h:234

Input_para::pexsi_nmax
int pexsi_nmax
Definition input_parameter.h:620

Input_para::mixing_gg0_mag
double mixing_gg0_mag
Definition input_parameter.h:110

Input_para::out_dipole
bool out_dipole
output the dipole or not
Definition input_parameter.h:411

Input_para::deepks_scf
bool deepks_scf
Definition input_parameter.h:280

Input_para::nstream
int nstream
Number of streams in CUDA as per input data.
Definition input_parameter.h:144

Input_para::orbital_dir
std::string orbital_dir
directory of orbital file
Definition input_parameter.h:59

Input_para::out_level
std::string out_level
control the output information.
Definition input_parameter.h:389

Input_para::read_file_dir
std::string read_file_dir
directory of files for reading
Definition input_parameter.h:60

Input_para::lr_nstates
int lr_nstates
the number of 2-particle states to be solved
Definition input_parameter.h:357

Input_para::cell_factor
double cell_factor
LiuXh add 20180619.
Definition input_parameter.h:42

Input_para::out_xc_r
std::vector< int > out_xc_r
output xc(r). -1: no; >=0: output the order of xc(r)
Definition input_parameter.h:381

Input_para::pexsi_mu_upper
double pexsi_mu_upper
Definition input_parameter.h:634

Input_para::block
bool block
add a block potential or not
Definition input_parameter.h:494

Input_para::bessel_descriptor_lmax
int bessel_descriptor_lmax
lmax used in descriptor
Definition input_parameter.h:290

Input_para::efield_dir
int efield_dir
the direction of the electric field or dipole correction
Definition input_parameter.h:482

Input_para::init_wfc
std::string init_wfc
"file","atomic","random"
Definition input_parameter.h:47

Input_para::out_mat_l
std::vector< int > out_mat_l
output L matrix in local basis.
Definition input_parameter.h:395

Input_para::of_ml_tanh_pnl
std::vector< int > of_ml_tanh_pnl
Descriptor: tanh_pnl = tanh(chi_pnl * pnl)
Definition input_parameter.h:248

Input_para::method_sto
int method_sto
Definition input_parameter.h:258

Input_para::pseudo_mesh
bool pseudo_mesh
Definition input_parameter.h:86

Input_para::of_ml_kernel_scaling
std::vector< double > of_ml_kernel_scaling
Scaling parameter of kernel, w(r-r') = lambda^3 * w(lambda (r-r')), lambda = 1/scaling.
Definition input_parameter.h:229

Input_para::out_wannier_mmn
bool out_wannier_mmn
add by renxi for wannier90: output .mmn file or not
Definition input_parameter.h:469

Input_para::relax_bfgs_w1
double relax_bfgs_w1
wolfe condition 1
Definition input_parameter.h:170

Input_para::vdw_R0_unit
std::string vdw_R0_unit
unit of R0, A or Bohr
Definition input_parameter.h:522

Input_para::out_bandgap
bool out_bandgap
QO added for bandgap printing.
Definition input_parameter.h:392

Input_para::td_trigo_freq1
std::string td_trigo_freq1
Definition input_parameter.h:342

Input_para::of_ml_chi_qnl
std::vector< double > of_ml_chi_qnl
Hyperparameter: tanh_qnl = tanh(chi_qnl * qnl)
Definition input_parameter.h:254

Input_para::td_trape_t2
std::string td_trape_t2
Definition input_parameter.h:337

Input_para::cal_syns
std::vector< int > cal_syns
calculate asynchronous S matrix to output {enable, precision}
Definition input_parameter.h:184

Input_para::of_read_kernel
bool of_read_kernel
Definition input_parameter.h:213

Input_para::vion_in_h
bool vion_in_h
Definition input_parameter.h:649

Input_para::hubbard_u_eV
std::vector< double > hubbard_u_eV
Hubbard Coulomb interaction parameter U(ev)
Definition input_parameter.h:584

Input_para::td_vext
bool td_vext
add extern potential or not
Definition input_parameter.h:301

Input_para::test_grid
int test_grid
variables for test_grid only
Definition input_parameter.h:657

Input_para::scf_thr_type
int scf_thr_type
type of the criterion of scf_thr, 1: reci drho, 2: real drho
Definition input_parameter.h:121

Input_para::cond_dt
double cond_dt
dt to integrate conductivities
Definition input_parameter.h:449

Input_para::out_mat_dh
std::vector< int > out_mat_dh
output dH/dR matrices with precision
Definition input_parameter.h:397

Input_para::abs_broadening
double abs_broadening
the broadening (eta) for LR-TDDFT absorption spectrum
Definition input_parameter.h:367

Input_para::td_gauss_phase
std::string td_gauss_phase
Definition input_parameter.h:327

Input_para::out_vecpot
bool out_vecpot
output the vector potential or not
Definition input_parameter.h:415

Input_para::qo_switch
bool qo_switch
0: no QO analysis; 1: QO analysis
Definition input_parameter.h:610

Input_para::out_app_flag
bool out_app_flag
Definition input_parameter.h:404

Input_para::pexsi_storage
bool pexsi_storage
Definition input_parameter.h:622

Input_para::exx_c_grad_r_threshold
double exx_c_grad_r_threshold
threshold to screen nabla C * R matrix in exx
Definition input_parameter.h:554

Input_para::relax_bfgs_init
double relax_bfgs_init
initial move
Definition input_parameter.h:174

Input_para::restart_save
bool restart_save
restart //Peize Lin add 2020-04-04
Definition input_parameter.h:417

Input_para::out_wfc_lcao
int out_wfc_lcao
output the wave functions in local basis.
Definition input_parameter.h:410

Input_para::of_tf_weight
double of_tf_weight
weight of TF KEDF
Definition input_parameter.h:197

Input_para::of_ml_qnl
std::vector< int > of_ml_qnl
Descriptor: qnl = int{q(r') * w(r-r') dr'}.
Definition input_parameter.h:244

Input_para::td_trape_amp
std::string td_trape_amp
Definition input_parameter.h:339

Input_para::deepks_out_freq_elec
int deepks_out_freq_elec
Definition input_parameter.h:277

Input_para::of_ml_yukawa_alpha
std::vector< double > of_ml_yukawa_alpha
Parameter alpha of yukawa kernel.
Definition input_parameter.h:230

Input_para::diago_cg_prec
int diago_cg_prec
mohan add 2012-03-31
Definition input_parameter.h:93

Input_para::out_element_info
bool out_element_info
output information of all elements
Definition input_parameter.h:408

Input_para::out_wfc_lr
bool out_wfc_lr
whether to output the eigenvectors (excitation amplitudes) in the particle-hole basis
Definition input_parameter.h:364

Input_para::vdw_cutoff_radius
std::string vdw_cutoff_radius
radius cutoff for periodic structure
Definition input_parameter.h:525

Input_para::symmetry_autoclose
bool symmetry_autoclose
Definition input_parameter.h:29

Input_para::efield_flag
bool efield_flag
add electric field
Definition input_parameter.h:480

Input_para::dft_plus_u
int dft_plus_u
0: standard DFT calculation (default)
Definition input_parameter.h:577

Input_para::pexsi_nproc
int pexsi_nproc
Definition input_parameter.h:625

Input_para::of_ml_gamma
bool of_ml_gamma
Descriptor: gamma = (rho / rho0)^(1/3)
Definition input_parameter.h:233

Input_para::td_trape_t1
std::string td_trape_t1
Definition input_parameter.h:336

Input_para::chg_extrap
std::string chg_extrap
xiaohui modify 2015-02-01
Definition input_parameter.h:51

Input_para::nx
int nx
Definition input_parameter.h:39

Input_para::td_gauss_sigma
std::string td_gauss_sigma
time(fs)
Definition input_parameter.h:328

Input_para::pexsi_row_ordering
int pexsi_row_ordering
Definition input_parameter.h:624

Input_para::exx_real_number
std::string exx_real_number
exx calculated in real or complex
Definition input_parameter.h:547

Input_para::ldos_line
std::vector< double > ldos_line
start and end point of the line (direct coordinates) and number of points
Definition input_parameter.h:436

Input_para::berry_phase
bool berry_phase
berry phase calculation: calculate berry phase or not
Definition input_parameter.h:455

Input_para::td_trape_phase
std::string td_trape_phase
Definition input_parameter.h:335

Input_para::mixing_ndim
int mixing_ndim
used in Broyden method
Definition input_parameter.h:105

Input_para::out_pchg
std::vector< int > out_pchg
specify the bands to be calculated for partial charge
Definition input_parameter.h:419

Input_para::out_mat_xc2
std::vector< int > out_mat_xc2
output Vxc(R) matrix with precision
Definition input_parameter.h:401

Input_para::if_separate_k
bool if_separate_k
whether to write partial charge for all k-points to individual files or merge them
Definition input_parameter.h:422

Input_para::cal_cond
bool cal_cond
calculate electronic conductivities
Definition input_parameter.h:444

Input_para::bx
int bx
Definition input_parameter.h:142

Input_para::exx_mixing_beta
double exx_mixing_beta
mixing_beta for outer-loop when exx_separate_loop=1
Definition input_parameter.h:546

Input_para::ocp
bool ocp
Definition input_parameter.h:352

Input_para::imp_sol
bool imp_sol
Definition input_parameter.h:500

Input_para::vdw_s8
std::string vdw_s8
scale parameter of d3_0/d3_bj
Definition input_parameter.h:514

Input_para::out_eband_terms
bool out_eband_terms
output the band energy terms separately
Definition input_parameter.h:402

Input_para::init_chg
std::string init_chg
"file","atomic"
Definition input_parameter.h:49

Input_para::relax_cg_thr
double relax_cg_thr
threshold when cg to bfgs, pengfei add 2011-08-15
Definition input_parameter.h:162

Input_para::pexsi_ordering
int pexsi_ordering
Definition input_parameter.h:623

Input_para::init_vel
bool init_vel
read velocity from STRU or not liuyu 2021-07-14
Definition input_parameter.h:52

Input_para::xc_temperature
double xc_temperature
only relevant if finite temperature functional is used
Definition input_parameter.h:84

Input_para::out_wfc_pw
int out_wfc_pw
0: no; 1: txt; 2: dat
Definition input_parameter.h:383

Input_para::dip_cor_flag
bool dip_cor_flag
dipole correction
Definition input_parameter.h:481

Input_para::vdw_d
double vdw_d
damping parameter of d2
Definition input_parameter.h:517

Input_para::mdp
MD_para mdp
Definition input_parameter.h:181

Input_para::cond_fwhm
double cond_fwhm
FWHM for conductivities.
Definition input_parameter.h:452

Input_para::force_zero_out
double force_zero_out
invalid force threshold, mohan add 2011-04-17
Definition input_parameter.h:165

Input_para::of_ml_tanhq
bool of_ml_tanhq
Descriptor: tanhq = tanh(chi_q * q)
Definition input_parameter.h:237

Input_para::exx_fock_lambda
std::vector< std::string > exx_fock_lambda
Definition input_parameter.h:537

Input_para::out_stru
bool out_stru
outut stru file each ion step
Definition input_parameter.h:375

Input_para::estep_per_md
int estep_per_md
number of electronic steps per MD step
Definition input_parameter.h:299

Input_para::press2
double press2
Definition input_parameter.h:168

Input_para::relax_method
std::vector< std::string > relax_method
methods to move_ion: sd, bfgs, cg...
Definition input_parameter.h:157

Input_para::mixing_gg0_min
double mixing_gg0_min
Definition input_parameter.h:111

Input_para::out_ndigits
int out_ndigits
Assuming 8 digits precision is needed for matrices output.
Definition input_parameter.h:406

Input_para::ocp_kb
std::vector< double > ocp_kb
OCP kb values.
Definition input_parameter.h:354

Input_para::relax_new
bool relax_new
Definition input_parameter.h:158

Input_para::ecutwfc
double ecutwfc
energy cutoff for wavefunctions
Definition input_parameter.h:36

Input_para::bndpar
int bndpar
parallel for stochastic/deterministic bands
Definition input_parameter.h:34

Input_para::dfthalf_type
int dfthalf_type
DFT-1/2 type, 0:off, 1:shell DFT-1/2.
Definition input_parameter.h:132

Input_para::ndz
int ndz
three dimension of FFT smooth charge density
Definition input_parameter.h:40

Input_para::deepks_out_unittest
bool deepks_out_unittest
Definition input_parameter.h:286

Input_para::out_mat_hs
std::vector< int > out_mat_hs
output H matrix and S matrix in local basis.
Definition input_parameter.h:393

Input_para::of_ml_feg
int of_ml_feg
The Free Electron Gas limit: 0: no, 3: yes.
Definition input_parameter.h:224

Input_para::force_thr_ev
double force_thr_ev
threshold of force in unit (eV/Angstrom)
Definition input_parameter.h:164

Input_para::vdw_C6_file
std::string vdw_C6_file
filename of C6
Definition input_parameter.h:519

Input_para::kpar
int kpar
ecch pool is for one k point
Definition input_parameter.h:33

Input_para::scf_os_thr
double scf_os_thr
drho threshold for oscillation
Definition input_parameter.h:124

Input_para::timer_enable_nvtx
bool timer_enable_nvtx
Definition input_parameter.h:74

Input_para::vdw_cutoff_type
std::string vdw_cutoff_type
Definition input_parameter.h:523

Input_para::exx_cs_inv_thr
double exx_cs_inv_thr
threshold to inverse Vq in abfs for generating Cs
Definition input_parameter.h:566

Input_para::td_vext_dire
std::vector< int > td_vext_dire
vector of vext direction
Definition input_parameter.h:303

Input_para::out_freq_elec
int out_freq_elec
the frequency of electronic iter to output charge and wavefunction
Definition input_parameter.h:376

Input_para::of_ml_pnl
std::vector< int > of_ml_pnl
Descriptor: pnl = int{p(r') * w(r-r') dr'}.
Definition input_parameter.h:243

Input_para::use_k_continuity
bool use_k_continuity
whether to use k-point continuity for initializing wave functions
Definition input_parameter.h:95

Input_para::of_ml_tanhxi
std::vector< int > of_ml_tanhxi
Descriptor: tanhxi = tanh(chi_xi * xi)
Definition input_parameter.h:246

Input_para::erf_sigma
double erf_sigma
the width of the energy step for reciprocal vectors
Definition input_parameter.h:45

Input_para::of_cd
bool of_cd
add CD potential or not
Definition input_parameter.h:711

Input_para::ref_cell_factor
double ref_cell_factor
Definition input_parameter.h:182

Input_para::of_lkt_a
double of_lkt_a
parameter a of LKT KEDF
Definition input_parameter.h:208

Input_para::pexsi_nproc_pole
int pexsi_nproc_pole
Definition input_parameter.h:629

Input_para::lcao_dk
double lcao_dk
delta k used in two center integral
Definition input_parameter.h:138

Input_para::of_ml_xi
std::vector< int > of_ml_xi
Descriptor: xi = int{rho(r')^(1/3) * w(r-r') dr'} / rho^(1/3)
Definition input_parameter.h:245

Input_para::vdw_a1
std::string vdw_a1
damping parameter of d3_0/d3_bj
Definition input_parameter.h:515

Input_para::nc_k
double nc_k
the cut-off charge density
Definition input_parameter.h:505

Input_para::diag_subspace
int diag_subspace
Definition input_parameter.h:94

Input_para::xc_exch_ext
std::vector< double > xc_exch_ext
Definition input_parameter.h:704

Input_para::dft_functional
std::string dft_functional
input DFT functional.
Definition input_parameter.h:83

Input_para::td_tstart
int td_tstart
Definition input_parameter.h:316

Input_para::pw_diag_thr
double pw_diag_thr
used in cg method
Definition input_parameter.h:90

Input_para::pexsi_elec_thr
double pexsi_elec_thr
Definition input_parameter.h:639

Input_para::exx_c_grad_threshold
double exx_c_grad_threshold
threshold to screen nabla C matrix in exx
Definition input_parameter.h:552

Input_para::ecutrho
double ecutrho
energy cutoff for charge/potential
Definition input_parameter.h:37

Input_para::symmetry_prec
double symmetry_prec
LiuXh add 2021-08-12, accuracy for symmetry.
Definition input_parameter.h:28

Input_para::td_print_eij
double td_print_eij
threshold to output Eij elements
Definition input_parameter.h:306

Input_para::of_ml_tanhp
bool of_ml_tanhp
Descriptor: tanhp = tanh(chi_p * p)
Definition input_parameter.h:236

Input_para::exx_coul_moment
bool exx_coul_moment
whether to use moment method for Coulomb calculation
Definition input_parameter.h:572

Input_para::relax_bfgs_rmax
double relax_bfgs_rmax
trust radius max
Definition input_parameter.h:172

Input_para::cond_dw
double cond_dw
d\omega for conductivities
Definition input_parameter.h:447

Input_para::elpa_num_thread
int elpa_num_thread
Number of threads need to use in elpa.
Definition input_parameter.h:143

Input_para::out_mat_hs2
std::vector< int > out_mat_hs2
output H(R) and S(R) matrix with precision
Definition input_parameter.h:396

Input_para::cal_force
bool cal_force
calculate the force
Definition input_parameter.h:31

Input_para::pexsi_gap
double pexsi_gap
Definition input_parameter.h:631

Input_para::of_ml_tanhq_nl
std::vector< int > of_ml_tanhq_nl
Descriptor: tanhq_nl = int{tanhq(r') * w(r-r') dr'}.
Definition input_parameter.h:251

Input_para::stress_thr
double stress_thr
Pengfei Li 2017-11-01 ///<LiuXh update 20180515.
Definition input_parameter.h:166

Input_para::vdw_method
std::string vdw_method
the method of calculating vdw (none; d2; d3_0; d3_bj)
Definition input_parameter.h:512

Input_para::vdw_s6
std::string vdw_s6
scale parameter of d2/d3_0/d3_bj
Definition input_parameter.h:513

Input_para::pexsi_mu
double pexsi_mu
Definition input_parameter.h:635

Input_para::propagator
int propagator
method of propagator
Definition input_parameter.h:308

Input_para::relax_bfgs_rmin
double relax_bfgs_rmin
trust radius min
Definition input_parameter.h:173

Input_para::out_wannier_unk
bool out_wannier_unk
output UNK. file or not
Definition input_parameter.h:471

Input_para::qo_strategy
std::vector< std::string > qo_strategy
No specific values provided for qo_strategy.
Definition input_parameter.h:614

Input_para::td_trigo_amp
std::string td_trigo_amp
Definition input_parameter.h:346

Input_para::of_xwm_kappa
double of_xwm_kappa
The parameter kappa of XWM KEDF.
Definition input_parameter.h:217

Input_para::search_radius
double search_radius
11.1
Definition input_parameter.h:141

Input_para::t_in_h
bool t_in_h
calculate the T or not.
Definition input_parameter.h:645

Input_para::dos_scale
double dos_scale
Definition input_parameter.h:431

Input_para::of_full_pw_dim
int of_full_pw_dim
Definition input_parameter.h:211

Input_para::deepks_model
std::string deepks_model
needed when deepks_scf=1
Definition input_parameter.h:288

Input_para::out_chg
std::vector< int > out_chg
output charge density. 0: no; 1: yes
Definition input_parameter.h:380

Input_para::initsto_ecut
double initsto_ecut
maximum ecut to init stochastic bands
Definition input_parameter.h:267

Input_para::out_wannier_eig
bool out_wannier_eig
output .eig file or not
Definition input_parameter.h:472

Input_para::suffix
std::string suffix
suffix of out put dir
Definition input_parameter.h:17

Input_para::exx_gamma_extrapolation
bool exx_gamma_extrapolation
Definition input_parameter.h:675

Input_para::td_gauss_t0
std::string td_gauss_t0
Definition input_parameter.h:329

Input_para::emax_sto
double emax_sto
Emax to normalize H.
Definition input_parameter.h:265

Input_para::of_wt_rho0
double of_wt_rho0
set the average density of system, in Bohr^-3
Definition input_parameter.h:204

Input_para::ndy
int ndy
Definition input_parameter.h:40

Input_para::xc_kernel
std::string xc_kernel
exchange correlation (XC) kernel for LR-TDDFT
Definition input_parameter.h:361

Input_para::test_relax_method
int test_relax_method
variables for test_relax_method only
Definition input_parameter.h:663

Input_para::rpa_ccp_rmesh_times
double rpa_ccp_rmesh_times
Definition input_parameter.h:564

Input_para::exx_v_grad_r_threshold
double exx_v_grad_r_threshold
threshold to screen nabla V * R matrix in exx
Definition input_parameter.h:555

Input_para::exx_hybrid_step
int exx_hybrid_step
Definition input_parameter.h:544

Input_para::vdw_cn_thr
double vdw_cn_thr
radius cutoff for cn
Definition input_parameter.h:527

Input_para::deepks_out_labels
int deepks_out_labels
Definition input_parameter.h:275

Input_para::wannier_method
int wannier_method
different implementation methods under Lcao basis set
Definition input_parameter.h:468

Input_para::deepks_band_range
std::vector< int > deepks_band_range
the range of bands to calculate bandgap
Definition input_parameter.h:283

Input_para::vdw_C6_unit
std::string vdw_C6_unit
unit of C6, Jnm6/mol or eVA6
Definition input_parameter.h:520

Input_para::out_ldos
std::vector< int > out_ldos
ldos calculation
Definition input_parameter.h:386

Input_para::efield_pos_max
double efield_pos_max
Definition input_parameter.h:483

Input_para::out_spillage
int out_spillage
output the spillage of the wave function
Definition input_parameter.h:424

Input_para::nspin
int nspin
LDA ; LSDA ; non-linear spin.
Definition input_parameter.h:88

Input_para::ndx
int ndx
Definition input_parameter.h:40

Input_para::out_mat_xc
bool out_mat_xc
Definition input_parameter.h:399

Input_para::press1
double press1
Definition input_parameter.h:167

Input_para::mem_saver
int mem_saver
1: save psi when nscf calculation.
Definition input_parameter.h:63

Input_para::sigma_k
double sigma_k
the width of the diffuse cavity
Definition input_parameter.h:504

Input_para::kspacing
std::vector< double > kspacing
kspacing for k-point generation
Definition input_parameter.h:66

Input_para::lr_unrestricted
bool lr_unrestricted
whether to use the unrestricted construction for LR-TDDFT
Definition input_parameter.h:365

Input_para::relax_scale_force
double relax_scale_force
Definition input_parameter.h:160

Input_para::test_atom_input
int test_atom_input
variables for test_atom_input only
Definition input_parameter.h:654

Input_para::vdw_abc
bool vdw_abc
third-order term?
Definition input_parameter.h:518

Input_para::nnkpfile
std::string nnkpfile
Definition input_parameter.h:464

Input_para::out_current
int out_current
output the current or not
Definition input_parameter.h:413

Input_para::bz
int bz
big mesh ball. 0: auto set bx/by/bz
Definition input_parameter.h:142

Input_para::dos_emin_ev
double dos_emin_ev
Definition input_parameter.h:428

Input_para::of_ml_chi_p
double of_ml_chi_p
Hyperparameter: tanhp = tanh(chi_p * p)
Definition input_parameter.h:238

Input_para::deepks_bandgap
int deepks_bandgap
for bandgap label. QO added 2021-12-15
Definition input_parameter.h:282

Input_para::rdmft_power_alpha
double rdmft_power_alpha
Definition input_parameter.h:669

Input_para::exx_dm_threshold
double exx_dm_threshold
threshold to screen density matrix in exx
Definition input_parameter.h:551

Input_para::out_dos
int out_dos
dos calculation. mohan add 20090909
Definition input_parameter.h:385

Input_para::vdw_radius_unit
std::string vdw_radius_unit
unit of radius cutoff for periodic structure
Definition input_parameter.h:526

Input_para::diago_smooth_ethr
bool diago_smooth_ethr
smooth ethr for iter methods
Definition input_parameter.h:91

Input_para::out_freq_ion
int out_freq_ion
Definition input_parameter.h:377

Input_para::exx_erfc_alpha
std::vector< std::string > exx_erfc_alpha
fraction of exchange erfc(wr)/r in hybrid functionals
Definition input_parameter.h:539

Input_para::scf_thr
double scf_thr
\sum |rhog_out - rhog_in |^2
Definition input_parameter.h:119

Input_para::bessel_nao_sigma
double bessel_nao_sigma
spherical bessel smearing_sigma
Definition input_parameter.h:149

Input_para::wannier_spin
std::string wannier_spin
Definition input_parameter.h:466

Input_para::test_gridt
int test_gridt
variables for test_gridt only
Definition input_parameter.h:660

Input_para::out_wannier_wvfn_formatted
bool out_wannier_wvfn_formatted
output UNK. file in text format or in binary format
Definition input_parameter.h:473

Input_para::vdw_a2
std::string vdw_a2
damping parameter of d3_bj
Definition input_parameter.h:516

Input_para::of_xwm_rho_ref
double of_xwm_rho_ref
The reference density of XWM KEDF.
Definition input_parameter.h:218

Input_para::test_wf
int test_wf
variables for test_wf only
Definition input_parameter.h:656

Input_para::precision
std::string precision
Definition input_parameter.h:72

Input_para::test_stress
bool test_stress
test the stress.
Definition input_parameter.h:652

Input_para::exx_multip_moments_threshold
double exx_multip_moments_threshold
threshold to screen multipole moments in Coulomb calculation
Definition input_parameter.h:574

Input_para::out_ri_cv
bool out_ri_cv
Whether to output the coefficient tensor C and ABFs-representation Coulomb matrix V.
Definition input_parameter.h:570

Input_para::exx_separate_loop
bool exx_separate_loop
Definition input_parameter.h:541

Input_para::soc_lambda
double soc_lambda
Definition input_parameter.h:130

Input_para::nelec
double nelec
total number of electrons
Definition input_parameter.h:80

Input_para::pw_diag_ndim
int pw_diag_ndim
dimension of workspace for Davidson diagonalization
Definition input_parameter.h:92

Input_para::scf_os_ndim
int scf_os_ndim
number of old iterations used for oscillation detection
Definition input_parameter.h:125

Input_para::out_pot
std::vector< int > out_pot
output potential
Definition input_parameter.h:382

Input_para::of_ml_chi_q
double of_ml_chi_q
Hyperparameter: tanhq = tanh(chi_q * q)
Definition input_parameter.h:239

Input_para::pexsi_delta_e
double pexsi_delta_e
Definition input_parameter.h:632

Input_para::exx_opt_orb_ecut
double exx_opt_orb_ecut
the cut-off of plane wave expansion for opt ABFs
Definition input_parameter.h:559

Input_para::pseudo_dir
std::string pseudo_dir
directory of pseudopotential
Definition input_parameter.h:58

Input_para::press3
double press3
Definition input_parameter.h:169

Input_para::of_conv
std::string of_conv
Definition input_parameter.h:191

Input_para::test_deconstructor
int test_deconstructor
variables for test_deconstructor only
Definition input_parameter.h:664

Input_para::mixing_dftu
bool mixing_dftu
whether to mix locale in DFT+U
Definition input_parameter.h:114

Input_para::relax_nmax
int relax_nmax
number of max ionic iter
Definition input_parameter.h:161

Input_para::pexsi_mu_thr
double pexsi_mu_thr
Definition input_parameter.h:636

Input_para::cal_stress
bool cal_stress
calculate the stress
Definition input_parameter.h:32

Input_para::pexsi_method
int pexsi_method
Definition input_parameter.h:628

Input_para::scf_os_stop
bool scf_os_stop
whether to stop scf when oscillation is detected
Definition input_parameter.h:123

Input_para::of_wt_beta
double of_wt_beta
parameter beta of WT KEDF
Definition input_parameter.h:200

Input_para::td_stype
int td_stype
type of space domain 0 : length gauge 1: velocity gauge
Definition input_parameter.h:309

Input_para::mixing_angle
double mixing_angle
Definition input_parameter.h:112

Input_para::pexsi_symm
bool pexsi_symm
Definition input_parameter.h:626

Input_para::out_proj_band
bool out_proj_band
projected band structure calculation jiyy add 2022-05-11
Definition input_parameter.h:388

Input_para::deepks_out_base
std::string deepks_out_base
(need libnpy) base functional for output files
Definition input_parameter.h:279

Input_para::input_file
std::string input_file
input file name
Definition input_parameter.h:54

Input_para::pexsi_zero_thr
double pexsi_zero_thr
Definition input_parameter.h:640

Input_para::td_gauss_amp
std::string td_gauss_amp
V/A.
Definition input_parameter.h:330

Input_para::pexsi_temp
double pexsi_temp
Definition input_parameter.h:630

Input_para::out_mat_t
std::vector< int > out_mat_t
output T(R) matrix with precision
Definition input_parameter.h:407

Input_para::scf_ene_thr
double scf_ene_thr
energy threshold for scf convergence, in eV
Definition input_parameter.h:120

Input_para::sccut
double sccut
restriction of step size in eV/uB
Definition input_parameter.h:602

Input_para::exxace
bool exxace
Definition input_parameter.h:674

Input_para::vdw_R0_file
std::string vdw_R0_file
filename of R0
Definition input_parameter.h:521

Input_para::td_lcut1
double td_lcut1
Definition input_parameter.h:321

Input_para::ecutexx
double ecutexx
energy cutoff for exx calculation, Ry
Definition input_parameter.h:678

Input_para::test_charge
int test_charge
variables for test_vloc only
Definition input_parameter.h:658

Input_para::bessel_nao_rcuts
std::vector< double > bessel_nao_rcuts
No specific values provided for bessel_nao_rcuts.
Definition input_parameter.h:147

Input_para::of_ml_device
std::string of_ml_device
Run NN on GPU or CPU.
Definition input_parameter.h:223

Input_para::omc
int omc
the mode of occupation matrix control
Definition input_parameter.h:582

Input_para::qo_basis
std::string qo_basis
Definition input_parameter.h:611

Input_para::of_method
std::string of_method
optimization method, include cg1, cg2, tn (default), bfgs
Definition input_parameter.h:190

Input_para::of_wt_alpha
double of_wt_alpha
parameter alpha of WT KEDF
Definition input_parameter.h:199

Input_para::stru_file
std::string stru_file
Definition input_parameter.h:55

Input_para::lspinorb
bool lspinorb
consider the spin-orbit interaction
Definition input_parameter.h:128

Input_para::spillage_outdir
std::string spillage_outdir
output directory for spillage
Definition input_parameter.h:425

Input_para::nche_sto
int nche_sto
Definition input_parameter.h:262

Input_para::nbands
int nbands
number of bands
Definition input_parameter.h:79

Input_para::dos_emax_ev
double dos_emax_ev
Definition input_parameter.h:429

Input_para::of_hold_rho0
bool of_hold_rho0
Definition input_parameter.h:205

Input_para::out_unshrinked_v
bool out_unshrinked_v
whether to output the large Vq matrix in unshrinked auxiliary basis
Definition input_parameter.h:571

Input_para::bessel_descriptor_smooth
bool bessel_descriptor_smooth
spherical bessel smooth or not
Definition input_parameter.h:294

Input_para::npart_sto
int npart_sto
for method_sto = 2, reduce memory
Definition input_parameter.h:260

Input_para::scf_nmax
int scf_nmax
number of max elec iter
Definition input_parameter.h:118

Input_para::ntype
int ntype
number of atom types
Definition input_parameter.h:18

Input_para::smearing_sigma
double smearing_sigma
Definition input_parameter.h:101

Input_para::yukawa_potential
bool yukawa_potential
default: false
Definition input_parameter.h:579

Input_para::out_mat_tk
std::vector< int > out_mat_tk
output T(k) matrix in local basis.
Definition input_parameter.h:394

Input_para::kpoint_file
std::string kpoint_file
file contains k-points – xiaohui modify 2015-02-01
Definition input_parameter.h:57

Input_para::out_mat_r
std::vector< int > out_mat_r
output r(R) matrix with precision
Definition input_parameter.h:409

Input_para::cond_nonlocal
bool cond_nonlocal
if calculate nonlocal effects
Definition input_parameter.h:453

Input_para::td_force_dt
double td_force_dt
"fs"
Definition input_parameter.h:300

Input_para::td_trape_t3
std::string td_trape_t3
Definition input_parameter.h:338

Input_para::rpa
bool rpa
rpa calculation
Definition input_parameter.h:418

Input_para::vdw_cutoff_period
ModuleBase::Vector3< int > vdw_cutoff_period
periods of periodic structure
Definition input_parameter.h:529

Input_para::pw_diag_nmax
int pw_diag_nmax
Definition input_parameter.h:89

Input_para::sc_thr
double sc_thr
threshold for spin-constrained DFT in uB
Definition input_parameter.h:597

Input_para::wannier_card
std::string wannier_card
input card for wannier functions.
Definition input_parameter.h:62

Input_para::mixing_beta_mag
double mixing_beta_mag
Definition input_parameter.h:109

Input_para::dos_edelta_ev
double dos_edelta_ev
Definition input_parameter.h:430

Input_para::out_dmr
std::vector< int > out_dmr
output density matrix in real space DM(R)
Definition input_parameter.h:390

Input_para::of_ml_kernel_file
std::vector< std::string > of_ml_kernel_file
The file of TKK.
Definition input_parameter.h:231

Input_para::pexsi_comm
bool pexsi_comm
Definition input_parameter.h:621

Input_para::force_thr
double force_thr
threshold of force in unit (Ry/Bohr)
Definition input_parameter.h:163

Input_para::nsc_min
int nsc_min
minimum number of inner lambda loop
Definition input_parameter.h:599

Input_para::qo_screening_coeff
std::vector< double > qo_screening_coeff
No specific values provided for qo_screening_coeff.
Definition input_parameter.h:615

Input_para::vnl_in_h
bool vnl_in_h
calculate the vnl or not.
Definition input_parameter.h:647

Input_para::mixing_beta
double mixing_beta
0 : no_mixing
Definition input_parameter.h:104

Input_para::sc_scf_thr
double sc_scf_thr
minimum number of outer scf loop before initial lambda loop
Definition input_parameter.h:603

Input_para::td_trape_freq
std::string td_trape_freq
time(fs)^-1
Definition input_parameter.h:333

Input_para::exx_ccp_rmesh_times
std::string exx_ccp_rmesh_times
Definition input_parameter.h:556

Input_para::block_down
double block_down
low bound of the block
Definition input_parameter.h:495

Input_para::shrink_LU_inv_thr
double shrink_LU_inv_thr
threshold to get inverse of overlap matrix by LU decomposition in auxiliary basis representation
Definition input_parameter.h:569

Input_para::exx_singularity_correction
std::string exx_singularity_correction
set the scheme of Coulomb singularity correction
Definition input_parameter.h:543

Input_para::vl_in_h
bool vl_in_h
calculate the vloc or not.
Definition input_parameter.h:646

Input_para::kmesh_type
std::string kmesh_type
k-point mesh type for kspacing-generated k-point mesh: gamma or mp
Definition input_parameter.h:68

Input_para::exx_v_grad_threshold
double exx_v_grad_threshold
threshold to screen nabla V matrix in exx
Definition input_parameter.h:553

Input_para::test_symmetry
int test_symmetry
variables for test_lattice only
Definition input_parameter.h:655

Input_para::cal_symm_repr
std::vector< int > cal_symm_repr
output the symmetry representation matrix
Definition input_parameter.h:416

Input_para::of_mCD_alpha
double of_mCD_alpha
parameter of modified CD potential
Definition input_parameter.h:712

Input_para::zgate
double zgate
position of charged plate
Definition input_parameter.h:493

Input_para::abs_gauge
std::string abs_gauge
whether to use length or velocity gauge to calculate the absorption spectrum in LR-TDDFT
Definition input_parameter.h:369

Input_para::xc_corr_ext
std::vector< double > xc_corr_ext
Definition input_parameter.h:707

Input_para::out_current_k
bool out_current_k
output tddft current for all k points
Definition input_parameter.h:414

Input_para::dos_nche
int dos_nche
orders of Chebyshev expansions for dos
Definition input_parameter.h:433

Input_para::smearing_method
std::string smearing_method
Definition input_parameter.h:97

Input_para::basis_type
std::string basis_type
xiaohui add 2013-09-01, for structural adjustment
Definition input_parameter.h:78

Input_para::of_kernel_file
std::string of_kernel_file
The name of WT kernel file.
Definition input_parameter.h:216

Input_para::nsc
int nsc
maximum number of inner lambda loop
Definition input_parameter.h:598

Input_para::efield_amp
double efield_amp
amplitude of the electric field
Definition input_parameter.h:486

Input_para::vh_in_h
bool vh_in_h
calculate the hartree potential or not
Definition input_parameter.h:648

Input_para::out_dmk
std::vector< int > out_dmk
output density matrix in reciprocal space DM(k)
Definition input_parameter.h:391

Input_para::gate_flag
bool gate_flag
compensating charge or not
Definition input_parameter.h:492

Input_para::of_ml_nkernel
int of_ml_nkernel
Number of kernels.
Definition input_parameter.h:226

Input_para::out_efield
bool out_efield
output the efield or not
Definition input_parameter.h:412

Input_para::mixing_mode
std::string mixing_mode
"plain","broyden",...
Definition input_parameter.h:103

Input_para::cond_smear
int cond_smear
smearing method for conductivities 1: Gaussian 2: Lorentzian
Definition input_parameter.h:451

Input_para::esolver_type
std::string esolver_type
the energy solver: ksdft, sdft, ofdft, tddft, lj, dp
Definition input_parameter.h:22

Input_para::of_vw_weight
double of_vw_weight
weight of vW KEDF
Definition input_parameter.h:198

Input_para::min_dist_coef
double min_dist_coef
allowed minimum distance between two atoms
Definition input_parameter.h:69

Input_para::dft_plus_dmft
bool dft_plus_dmft
true:DFT+DMFT; false: standard DFT calcullation(default)
Definition input_parameter.h:578

Input_para::dm_to_rho
bool dm_to_rho
read density matrix from npz format and calculate charge density
Definition input_parameter.h:50

Input_para::of_ml_gammanl
std::vector< int > of_ml_gammanl
Descriptor: gammanl = int{gamma(r') * w(r-r') dr'}.
Definition input_parameter.h:242

Input_para::nelec_delta
double nelec_delta
change in the number of total electrons
Definition input_parameter.h:81

Input_para::exx_rotate_abfs
bool exx_rotate_abfs
whether to rotate auxiliary basis for Coulomb calculation
Definition input_parameter.h:573

Input_para::exx_thr_type
std::string exx_thr_type
threshold type for exx outer loop
Definition input_parameter.h:676

Input_para::of_ml_kernel
std::vector< int > of_ml_kernel
Type of kernel, 1 for wt, 2 for yukawa, and 3 for TKK.
Definition input_parameter.h:227

Input_para::nbands_sto
int nbands_sto
number of stochastic bands //qianrui 2021-2-5
Definition input_parameter.h:261

Input_para::decay_grad_switch
bool decay_grad_switch
Definition input_parameter.h:595

Input_para::exx_opt_orb_lmax
int exx_opt_orb_lmax
the maximum l of the spherical Bessel functions for opt ABFs
Definition input_parameter.h:558

Input_para::sc_os_ndim
int sc_os_ndim
number of old iterations used for oscillation detection in Spin-Constrained DFT
Definition input_parameter.h:126

Input_para::bessel_nao_tolerence
double bessel_nao_tolerence
tolerance for spherical bessel root
Definition input_parameter.h:146

Input_para::bessel_nao_ecut
std::string bessel_nao_ecut
energy cutoff for spherical bessel functions(Ry)
Definition input_parameter.h:145

Input_para::lr_init_xc_kernel
std::vector< std::string > lr_init_xc_kernel
The method to initalize the xc kernel.
Definition input_parameter.h:358

Input_para::dmax
double dmax
maximum displacement of all atoms in one step (bohr)
Definition input_parameter.h:185

Input_para::diago_proc
int diago_proc
the number of procs used to diag. mohan add 2012-01-13
Definition input_parameter.h:64

Input_para::pw_seed
int pw_seed
random seed for initializing wave functions
Definition input_parameter.h:48

Input_para::exx_v_threshold
double exx_v_threshold
threshold to screen C matrix in exx
Definition input_parameter.h:550

Input_para::mixing_gg0
double mixing_gg0
used in kerker method
Definition input_parameter.h:108

Input_para::of_ml_tanhp_nl
std::vector< int > of_ml_tanhp_nl
Descriptor: tanhp_nl = int{tanhp(r') * w(r-r') dr'}.
Definition input_parameter.h:250

Input_para::sc_mag_switch
bool sc_mag_switch
Definition input_parameter.h:593

Input_para::aims_nbasis
std::vector< int > aims_nbasis
the number of basis functions for each atom type used in FHI-aims (for benchmark)
Definition input_parameter.h:373

Input_para::nb2d
int nb2d
matrix 2d division.
Definition input_parameter.h:135

Input_para::bessel_descriptor_rcut
double bessel_descriptor_rcut
radial cutoff for spherical bessel functions(a.u.)
Definition input_parameter.h:293

Input_para::exx_c_threshold
double exx_c_threshold
threshold to screen C matrix in exx
Definition input_parameter.h:549

Input_para::fixed_axes
std::string fixed_axes
which axes are fixed
Definition input_parameter.h:175

Input_para::out_wfc_re_im
std::vector< int > out_wfc_re_im
specify the bands to be calculated for real and imaginary parts of wfc
Definition input_parameter.h:421

Input_para::out_mat_ds
std::vector< int > out_mat_ds
output dS/dR matrices with precision
Definition input_parameter.h:398

Input_para::init_vecpot_file
bool init_vecpot_file
initialize the vector potential, though file or integral
Definition input_parameter.h:305

Input_para::sc_drop_thr
double sc_drop_thr
threshold for lambda-loop threshold cutoff in spin-constrained DFT
Definition input_parameter.h:604

Input_para::of_ml_q
bool of_ml_q
Descriptor: q = nabla^2 rho / [4 (3 pi^2)^(2/3) rho^(5/3)].
Definition input_parameter.h:235

Input_para::of_full_pw
bool of_full_pw
Definition input_parameter.h:209

Input_para::sc_scf_nmin
int sc_scf_nmin
minimum number of outer scf loop before initial lambda loop
Definition input_parameter.h:600

Input_para::bessel_descriptor_ecut
std::string bessel_descriptor_ecut
energy cutoff for spherical bessel functions(Ry)
Definition input_parameter.h:291

Input_para::out_freq_td
int out_freq_td
output interval in RT-TDDFT
Definition input_parameter.h:379

Input_para::nupdown
double nupdown
Definition input_parameter.h:82

Input_para::td_dt
double td_dt
time step for propagation
Definition input_parameter.h:298

Input_para::ny
int ny
Definition input_parameter.h:39

Input_para::of_ml_local_test
bool of_ml_local_test
Test: read in the density, and output the F and Pauli potential.
Definition input_parameter.h:255

Input_para::pexsi_inertia
bool pexsi_inertia
Definition input_parameter.h:619

Input_para::pexsi_mu_lower
double pexsi_mu_lower
Definition input_parameter.h:633

Input_para::restart_load
bool restart_load
Definition input_parameter.h:61

Input_para::pexsi_mu_guard
double pexsi_mu_guard
Definition input_parameter.h:638

Input_para::block_up
double block_up
high bound of the block
Definition input_parameter.h:496

Input_para::test_energy
int test_energy
variables for test_energy only
Definition input_parameter.h:659

Input_para::out_elf
std::vector< int > out_elf
output the electron localization function (ELF). 0: no; 1: yes
Definition input_parameter.h:423

Input_para::uramping_eV
double uramping_eV
U-Ramping method (eV)
Definition input_parameter.h:581

Input_para::test_pseudo_cell
int test_pseudo_cell
variables for test_pseudo_cell only
Definition input_parameter.h:661

Input_para::initsto_freq
int initsto_freq
frequency to init stochastic orbitals when running md
Definition input_parameter.h:268

Input_para::device
std::string device
Definition input_parameter.h:71

Input_para::out_band
std::vector< int > out_band
band calculation pengfei 2014-10-13
Definition input_parameter.h:384

Input_para::stm_bias
std::vector< double > stm_bias
bias voltage for STM (start value, step, number)
Definition input_parameter.h:434

Input_para::vdw_cn_thr_unit
std::string vdw_cn_thr_unit
unit of cn_thr, Bohr or Angstrom
Definition input_parameter.h:528

Input_para::of_ml_chi_pnl
std::vector< double > of_ml_chi_pnl
Hyperparameter: tanh_pnl = tanh(chi_pnl * pnl)
Definition input_parameter.h:253

Input_para::deepks_equiv
bool deepks_equiv
whether to use equivariant version of DeePKS
Definition input_parameter.h:285

Input_para::td_gauss_freq
std::string td_gauss_freq
time(fs)^-1
Definition input_parameter.h:326

Input_para::shrink_abfs_pca_thr
double shrink_abfs_pca_thr
threshold to shrink auxiliary basis for GW/RPA
Definition input_parameter.h:567

Input_para::towannier90
bool towannier90
Definition input_parameter.h:462

Input_para::eb_k
double eb_k
the relative permittivity of the bulk solvent
Definition input_parameter.h:502

Input_para::lmaxmax
int lmaxmax
maximum of l channels used
Definition input_parameter.h:136

Input_para::ml_exx
bool ml_exx
use ML EXX or not
Definition input_parameter.h:269

Input_para::of_tole
double of_tole
Definition input_parameter.h:193

Input_para::gamma_only
bool gamma_only
for plane wave.
Definition input_parameter.h:117

Input_para::bessel_descriptor_sigma
double bessel_descriptor_sigma
spherical bessel smearing_sigma
Definition input_parameter.h:295

Input_para::test_pp
int test_pp
variables for test_pp only
Definition input_parameter.h:662

Input_para::qo_thr
double qo_thr
Definition input_parameter.h:613

MD_para
input parameters used in md
Definition md_parameter.h:12

vector3.h