Code

Caution

This is draft documentation.

Note

INQ is under active development.

Kohn-Sham Hamiltonian

namespace inq

The Kohn-Sham Hamiltonian

This math expression is from source file ks_hamiltonian.hpp

\[ \left(-\frac{\hbar^2}{2m}\nabla^2 + v_\text{eff}(\mathbf r)\right) \varphi_i(\mathbf r) = \varepsilon_i \varphi_i(\mathbf r) \]

This is an example of a code block

auto & uniform_vector_potential() const {
         return uniform_vector_potential_;
     }
auto & uniform_vector_potential() {
         return uniform_vector_potential_;
     }

namespace hamiltonian

template<typename PotentialType>
class ks_hamiltonian

Public Types

using potential_type = PotentialType

Public Functions

inline void update_projectors(const basis::real_space &basis, const atomic_potential &pot, systems::ions const &ions)

inline ks_hamiltonian(const basis::real_space &basis, ions::brillouin const &bzone, states::ks_states const &states, atomic_potential const &pot, systems::ions const &ions, const double exchange_coefficient, bool use_ace = false)

inline void non_local(const states::orbital_set<basis::fourier_space, complex> &phi, states::orbital_set<basis::fourier_space, complex> &vnlphi) const

inline auto non_local(const states::orbital_set<basis::real_space, complex> &phi) const

inline auto operator()(const states::orbital_set<basis::real_space, complex> &phi) const

inline auto operator()(const states::orbital_set<basis::fourier_space, complex> &phi) const

inline auto momentum(const states::orbital_set<basis::real_space, complex> &phi) const

inline auto &projectors_all() const

template<class output_stream>
inline void info(output_stream &out) const

inline auto &scalar_potential()

inline auto &uniform_vector_potential() const

inline auto &uniform_vector_potential()

Public Members

exchange_operator exchange

Private Members

std::vector<basis::field<basis::real_space, PotentialType>> scalar_potential_

vector3<double, covariant> uniform_vector_potential_

projector_all projectors_all_

bool non_local_in_fourier_

std::unordered_map<std::string, projector_fourier> projectors_fourier_map_

std::vector<std::unordered_map<std::string, projector_fourier>::iterator> projectors_fourier_

states::ks_states states_

Friends

friend class self_consistency

class atomic_potential

Public Types

using pseudopotential_type = pseudo::pseudopotential<gpu::array<double, 1>>

Public Functions

template<class atom_array>
inline atomic_potential(const int natoms, const atom_array &atom_list, double gcutoff, options::electrons const &conf = {})

inline int num_species() const

inline const double &num_electrons() const

template<class element_type>
inline const pseudopotential_type &pseudo_for_element(const element_type &el) const

template<class CommType, class basis_type, class ions_type>
inline basis::field<basis_type, double> local_potential(CommType &comm, const basis_type &basis, const ions_type &ions, int single_atom = -1) const

template<class CommType, class basis_type, class ions_type>
inline basis::field<basis_type, double> ionic_density(CommType &comm, const basis_type &basis, const ions_type &ions, int single_atom = -1) const

template<class CommType, class basis_type, class ions_type>
inline basis::field_set<basis_type, double> atomic_electronic_density(CommType &comm, const basis_type &basis, const ions_type &ions, states::ks_states const &states) const

inline auto has_nlcc() const

template<class CommType, class basis_type, class ions_type>
inline basis::field<basis_type, double> nlcc_density(CommType &comm, const basis_type &basis, const ions_type &ions) const

template<class output_stream>
inline void info(output_stream &out) const

inline auto &range_separation() const

inline auto &double_grid() const

inline auto &fourier_pseudo() const

Private Members

pseudo::math::erf_range_separation sep_

int natoms_

double nelectrons_

pseudo::set pseudo_set_

std::unordered_map<std::string, pseudopotential_type> pseudopotential_list_

bool has_nlcc_

basis::double_grid double_grid_

bool fourier_pseudo_

class energy

Public Functions

energy() = default

template<typename HamType, typename ElType>
inline auto calculate(HamType const &ham, ElType &el)

inline auto kinetic() const

inline auto total() const

inline auto &eigenvalues() const

inline void eigenvalues(double const &val)

inline auto &hartree() const

inline void hartree(double const &val)

inline auto &external() const

inline void external(double const &val)

inline auto &nonlocal() const

inline void nonlocal(double const &val)

inline auto &xc() const

inline void xc(double const &val)

inline auto &nvxc() const

inline void nvxc(double const &val)

inline auto &hf_exchange() const

inline void hf_exchange(double const &val)

inline auto &ion() const

inline void ion(double const &val)

inline auto &ion_kinetic() const

inline void ion_kinetic(double const &val)

template<class out_type>
inline void print(out_type &out) const

Private Members

double ion_ = 0.0

double ion_kinetic_ = 0.0

double eigenvalues_ = 0.0

double external_ = 0.0

double nonlocal_ = 0.0

double hartree_ = 0.0

double xc_ = 0.0

double nvxc_ = 0.0

double hf_exchange_ = 0.0

Friends

template<class OStream>
inline friend OStream &operator<<(OStream &os, energy const &self)

class exchange_operator

Public Functions

inline exchange_operator(systems::cell const &cell, ions::brillouin const &bzone, double const exchange_coefficient, bool const use_ace)

template<class ElectronsType>
inline double update(ElectronsType const &el)

inline auto direct(const states::orbital_set<basis::real_space, complex> &phi, double scale = 1.0) const

template<class HFType, class HFOccType, class KptType, class IdxType, class PhiType, class ExxphiType>
inline void block_exchange(double factor, HFType const &hf, HFOccType const &hfocc, KptType const &kpt, IdxType const &idx, PhiType const &phi, ExxphiType &exxphi) const

inline void direct(const states::orbital_set<basis::real_space, complex> &phi, states::orbital_set<basis::real_space, complex> &exxphi, double scale = 1.0) const

inline auto ace(const states::orbital_set<basis::real_space, complex> &phi) const

inline auto operator()(const states::orbital_set<basis::real_space, complex> &phi) const

inline void operator()(const states::orbital_set<basis::real_space, complex> &phi, states::orbital_set<basis::real_space, complex> &exxphi) const

inline void ace(const states::orbital_set<basis::real_space, complex> &phi, states::orbital_set<basis::real_space, complex> &exxphi) const

inline bool enabled() const

Private Members

gpu::array<double, 1> occupations_

gpu::array<vector3<double, covariant>, 1> kpoints_

gpu::array<int, 1> kpoint_indices_

std::optional<basis::field_set<basis::real_space, complex, parallel::arbitrary_partition>> orbitals_

std::vector<states::orbital_set<basis::real_space, complex>> ace_orbitals_

solvers::poisson poisson_solver_

double exchange_coefficient_

bool use_ace_

singularity_correction sing_

states::index orbital_index_

template<typename OcType, typename PhiType, typename GPhiType>
struct force_term

Public Functions

inline constexpr auto operator()(int ist, int ip) const

Public Members

OcType oc

PhiType phi

GPhiType gphi

template<typename OcType, typename PhiType, typename GPhiType>
struct force_term

Public Functions

inline constexpr auto operator()(int ist, int ip) const

Public Members

OcType oc

PhiType phi

GPhiType gphi

template<typename PotentialType>
class ks_hamiltonian

Public Types

using potential_type = PotentialType

Public Functions

inline void update_projectors(const basis::real_space &basis, const atomic_potential &pot, systems::ions const &ions)

inline ks_hamiltonian(const basis::real_space &basis, ions::brillouin const &bzone, states::ks_states const &states, atomic_potential const &pot, systems::ions const &ions, const double exchange_coefficient, bool use_ace = false)

inline void non_local(const states::orbital_set<basis::fourier_space, complex> &phi, states::orbital_set<basis::fourier_space, complex> &vnlphi) const

inline auto non_local(const states::orbital_set<basis::real_space, complex> &phi) const

inline auto operator()(const states::orbital_set<basis::real_space, complex> &phi) const

inline auto operator()(const states::orbital_set<basis::fourier_space, complex> &phi) const

inline auto momentum(const states::orbital_set<basis::real_space, complex> &phi) const

inline auto &projectors_all() const

template<class output_stream>
inline void info(output_stream &out) const

inline auto &scalar_potential()

inline auto &uniform_vector_potential() const

inline auto &uniform_vector_potential()

Public Members

exchange_operator exchange

Private Members

std::vector<basis::field<basis::real_space, PotentialType>> scalar_potential_

vector3<double, covariant> uniform_vector_potential_

projector_all projectors_all_

bool non_local_in_fourier_

std::unordered_map<std::string, projector_fourier> projectors_fourier_map_

std::vector<std::unordered_map<std::string, projector_fourier>::iterator> projectors_fourier_

states::ks_states states_

Friends

friend class self_consistency

template<typename LongRangeType, typename ShortRangeType, typename GDensityType>
struct loc_pot

Public Functions

inline GPU_FUNCTION auto operator()(long ip) const

Public Members

LongRangeType v1

ShortRangeType v2

GDensityType gdensityp

class projector

Public Functions

inline projector(const basis::real_space &basis, basis::double_grid const &double_grid, atomic_potential::pseudopotential_type const &ps, vector3<double> atom_position, int iatom)

projector(projector const&) = delete

inline auto empty() const

inline auto locally_empty() const

inline int num_projectors() const

inline auto kb_coeff(int iproj)

inline auto iatom() const

inline auto &sphere() const

inline auto &matrix() const

Private Functions

inline void build(basis::real_space const &basis, basis::double_grid const &double_grid, atomic_potential::pseudopotential_type const &ps)

Private Members

basis::spherical_grid sphere_

int nproj_

gpu::array<double, 2> matrix_

gpu::array<double, 1> kb_coeff_

int iatom_

Friends

friend class projector_all

class projector_all

Public Functions

inline projector_all()

template<typename ProjectorsType>
inline projector_all(ProjectorsType const &projectors)

template<typename KpointType>
inline gpu::array<complex, 3> project(states::orbital_set<basis::real_space, complex> const &phi, KpointType const &kpoint) const

template<typename SpherePhiType, typename KpointType>
inline void apply(SpherePhiType &sphere_vnlphi, states::orbital_set<basis::real_space, complex> &vnlphi, KpointType const &kpoint) const

template<typename PhiType, typename GPhiType, typename MetricType, typename OccsType>
inline void force(PhiType &phi, GPhiType const &gphi, MetricType const &metric, OccsType const &occs, vector3<double, covariant> const &vector_potential, gpu::array<vector3<double>, 1> &forces_non_local) const

template<typename KpointType>
inline void position_commutator(states::orbital_set<basis::real_space, complex> const &phi, states::orbital_set<basis::real_space, vector3<complex, covariant>> &cphi, KpointType const &kpoint) const

Private Functions

template<typename ProjectorsType>
inline void constructor(ProjectorsType const &projectors)

Private Members

int nprojs_

long max_sphere_size_

int max_nlm_

gpu::array<vector3<int>, 2> points_

gpu::array<vector3<float, contravariant>, 2> positions_

gpu::array<double, 2> coeff_

gpu::array<double, 3> matrices_

gpu::array<int, 1> nlm_

gpu::array<int, 1> iatom_

gpu::array<bool, 1> locally_empty_

class projector_fourier

Public Functions

inline projector_fourier(const basis::real_space &basis, atomic_potential::pseudopotential_type const &ps)

inline void add_coord(vector3<double, contravariant> const &coord)

inline void operator()(states::orbital_set<basis::fourier_space, complex> const &phi, states::orbital_set<basis::fourier_space, complex> &vnlphi) const

inline int num_projectors() const

inline auto kb_coeff(int iproj)

Private Members

int nproj_

gpu::array<double, 1> kb_coeff_

basis::field_set<basis::fourier_space, complex> beta_

std::vector<vector3<double, contravariant>> coords_

template<typename Perturbation = perturbations::none>
class self_consistency

Public Functions

inline self_consistency(options::theory interaction, basis::real_space const &potential_basis, basis::real_space const &density_basis, int const spin_components, Perturbation const &pert = {})

inline self_consistency(self_consistency &&old, parallel::communicator new_comm)

template<class CommType, class ions_type>
inline void update_ionic_fields(CommType &comm, const ions_type &ions, const hamiltonian::atomic_potential &atomic_pot)

template<typename HamiltonianType, typename EnergyType, typename FieldType>
inline void update_hamiltonian(HamiltonianType &hamiltonian, EnergyType &energy, FieldType const &spin_density, double time = 0.0) const

inline void propagate_induced_vector_potential(double const dt, vector3<double, covariant> const &current)

inline void propagate_induced_vector_potential_derivative(double const dt, vector3<double, covariant> const &current)

inline auto exx_coefficient()

inline bool has_induced_vector_potential() const

Private Members

options::theory theory_

hamiltonian::xc_term xc_

basis::field<basis::real_space, double> vion_

basis::field<basis::real_space, double> core_density_

basis::real_space potential_basis_

basis::real_space density_basis_

Perturbation pert_

vector3<double, covariant> induced_vector_potential_vel_

vector3<double, covariant> induced_vector_potential_

class singularity_correction

Public Functions

inline singularity_correction(systems::cell const &cell, ions::brillouin const &bzone)

inline auto fk(int ik) const

inline auto fzero() const

inline auto operator()(int ik) const

Public Static Functions

static inline auto auxiliary(systems::cell const &cell, vector3<double, covariant> const &qpoint)

Private Members

gpu::array<double, 1> fk_

double fzero_

int nkpoints_

double cell_volume_

class xc_functional

Public Functions

inline auto true_functional() const

inline xc_functional(const int functional_id, int spin_components)

inline xc_functional(xc_functional const &other)

inline xc_functional operator=(xc_functional const &other)

inline ~xc_functional()

inline auto &family() const

inline auto &libxc_func() const

inline auto libxc_func_ptr() const

inline auto requires_gradient() const

inline auto exx_coefficient() const

Private Members

int id_

int nspin_

xc_func_type func_

class xc_term

Public Functions

inline xc_term(options::theory interaction, int const spin_components)

template<typename SpinDensityType, typename CoreDensityType>
inline SpinDensityType process_density(SpinDensityType const &spin_density, CoreDensityType const &core_density) const

template<typename SpinDensityType, typename CoreDensityType, typename VKSType>
inline void operator()(SpinDensityType const &spin_density, CoreDensityType const &core_density, VKSType &vks, double &exc, double &nvxc) const

inline auto &exchange() const

Public Static Functions

template<typename DensityType, typename DensityGradientType>
static inline void evaluate_functional(hamiltonian::xc_functional const &functional, DensityType const &density, DensityGradientType const &density_gradient, double &efunctional, basis::field_set<basis::real_space, double> &vfunctional)

Private Members

hamiltonian::xc_functional exchange_

hamiltonian::xc_functional correlation_

namespace inq

The Kohn-Sham Hamiltonian

This math expression is from source file ks_hamiltonian.hpp

\[ \left(-\frac{\hbar^2}{2m}\nabla^2 + v_\text{eff}(\mathbf r)\right) \varphi_i(\mathbf r) = \varepsilon_i \varphi_i(\mathbf r) \]

This is an example of a code block

auto & uniform_vector_potential() const {
         return uniform_vector_potential_;
     }
auto & uniform_vector_potential() {
         return uniform_vector_potential_;
     }

namespace hamiltonian

Functions

template<typename HamiltonianType>
gpu::array<vector3<double>, 1> calculate_forces(const systems::ions &ions, systems::electrons const &electrons, HamiltonianType const &ham)

template<class PotentialType, class ShiftType>
void scalar_potential_add(basis::field<basis::real_space, PotentialType> const &potential, ShiftType shift, states::orbital_set<basis::real_space, complex> const &phi, states::orbital_set<basis::real_space, complex> &vphi)

template<class PotentialType, class ShiftType>
states::orbital_set<basis::real_space, complex> scalar_potential(basis::field<basis::real_space, PotentialType> const &potential, ShiftType shift, states::orbital_set<basis::real_space, complex> const &phi)

file atomic_potential.hpp

#include <stdexcept>

#include <utils/raw_pointer_cast.hpp>

#include <config/path.hpp>

#include <pseudopod/set.hpp>

#include <pseudopod/pseudopotential.hpp>

#include <basis/spherical_grid.hpp>

#include <basis/double_grid.hpp>

#include <gpu/array.hpp>

#include <operations/integral.hpp>

#include <options/electrons.hpp>

#include <parallel/partition.hpp>

#include <solvers/poisson.hpp>

#include <states/ks_states.hpp>

#include <unordered_map>

#include <mpi3/environment.hpp>

#include <utils/profiling.hpp>

file energy.hpp

#include <operations/shift.hpp>

#include <tinyformat/tinyformat.h>

file exchange_operator.hpp

#include <basis/real_space.hpp>

#include <hamiltonian/singularity_correction.hpp>

#include <input/parallelization.hpp>

#include <matrix/diagonal.hpp>

#include <matrix/cholesky.hpp>

#include <operations/overlap.hpp>

#include <operations/overlap_diagonal.hpp>

#include <operations/rotate.hpp>

#include <parallel/arbitrary_partition.hpp>

#include <parallel/array_iterator.hpp>

#include <solvers/poisson.hpp>

#include <states/index.hpp>

#include <states/orbital_set.hpp>

#include <optional>

file forces.hpp

#include <observables/density.hpp>

#include <operations/gradient.hpp>

#include <solvers/poisson.hpp>

#include <systems/ions.hpp>

#include <systems/electrons.hpp>

#include <utils/raw_pointer_cast.hpp>

file ks_hamiltonian.hpp

#include <basis/field.hpp>

#include <multi/adaptors/fftw.hpp>

#include <hamiltonian/atomic_potential.hpp>

#include <hamiltonian/exchange_operator.hpp>

#include <hamiltonian/projector.hpp>

#include <hamiltonian/projector_all.hpp>

#include <hamiltonian/projector_fourier.hpp>

#include <hamiltonian/scalar_potential.hpp>

#include <input/environment.hpp>

#include <operations/transform.hpp>

#include <operations/laplacian.hpp>

#include <operations/gradient.hpp>

#include <states/ks_states.hpp>

#include <states/orbital_set.hpp>

#include <utils/profiling.hpp>

#include <list>

#include <unordered_map>

file projector.hpp

#include <pseudopod/math/sharmonic.hpp>

#include <gpu/array.hpp>

#include <math/vector3.hpp>

#include <ions/periodic_replicas.hpp>

#include <basis/double_grid.hpp>

#include <basis/real_space.hpp>

#include <basis/spherical_grid.hpp>

#include <hamiltonian/atomic_potential.hpp>

#include <utils/profiling.hpp>

#include <utils/raw_pointer_cast.hpp>

file projector_all.hpp

#include <gpu/array.hpp>

#include <math/vector3.hpp>

#include <ions/periodic_replicas.hpp>

#include <basis/real_space.hpp>

#include <basis/spherical_grid.hpp>

#include <hamiltonian/atomic_potential.hpp>

#include <utils/profiling.hpp>

#include <utils/raw_pointer_cast.hpp>

file projector_fourier.hpp

#include <utils/profiling.hpp>

#include <config/path.hpp>

#include <pseudopod/math/sharmonic.hpp>

#include <gpu/array.hpp>

#include <math/vector3.hpp>

#include <ions/periodic_replicas.hpp>

#include <basis/real_space.hpp>

#include <basis/spherical_grid.hpp>

#include <operations/transform.hpp>

#include <hamiltonian/atomic_potential.hpp>

#include <utils/raw_pointer_cast.hpp>

file scalar_potential.hpp

#include <gpu/run.hpp>

#include <basis/field.hpp>

#include <states/orbital_set.hpp>

#include <cassert>

#include <utils/profiling.hpp>

file self_consistency.hpp

#include <basis/field.hpp>

#include <solvers/poisson.hpp>

#include <observables/density.hpp>

#include <operations/add.hpp>

#include <operations/integral.hpp>

#include <hamiltonian/xc_term.hpp>

#include <hamiltonian/atomic_potential.hpp>

#include <options/theory.hpp>

#include <perturbations/none.hpp>

#include <solvers/velocity_verlet.hpp>

#include <utils/profiling.hpp>

file singularity_correction.hpp

#include <ions/brillouin.hpp>

file xc_functional.hpp

#include <stdexcept>

#include <xc.h>

#include <observables/density.hpp>

#include <operations/gradient.hpp>

#include <operations/integral.hpp>

#include <operations/divergence.hpp>

#include <operations/laplacian.hpp>

#include <basis/field.hpp>

#include <utils/profiling.hpp>

#include <utils/raw_pointer_cast.hpp>

file xc_term.hpp

#include <basis/field.hpp>

#include <solvers/poisson.hpp>

#include <observables/density.hpp>

#include <operations/add.hpp>

#include <operations/integral.hpp>

#include <options/theory.hpp>

#include <hamiltonian/xc_functional.hpp>

#include <hamiltonian/atomic_potential.hpp>

#include <perturbations/none.hpp>

#include <utils/profiling.hpp>

dir /home/docs/checkouts/readthedocs.org/user_builds/inq/checkouts/latest/src/hamiltonian

dir /home/docs/checkouts/readthedocs.org/user_builds/inq/checkouts/latest/src