43 use,
intrinsic :: iso_fortran_env
93 type(namespace_t),
intent(in) :: namespace
94 type(grid_t),
intent(inout) :: gr
95 type(hamiltonian_elec_t),
intent(inout) :: hm
96 type(states_elec_t),
target,
intent(inout) :: st
97 type(ions_t),
intent(inout) :: ions
98 type(v_ks_t),
intent(in) :: ks
99 type(partner_list_t),
intent(in) :: ext_partners
101 real(real64),
allocatable :: rho_total(:)
102 real(real64) :: stress(3,3)
103 real(real64) :: stress_kin(3,3), stress_Hartree(3,3), stress_xc(3,3), stress_xc_nlcc(3,3)
104 real(real64) :: stress_ps(3,3), stress_ps_nl(3,3), stress_ps_local(3,3), stress_ii(3,3)
105 real(real64) :: stress_hubbard(3,3)
107 real(real64),
allocatable :: vh(:)
108 real(real64),
allocatable :: grad_vh(:,:)
109 real(real64) :: ehartree
110 real(real64),
contiguous,
pointer :: rho(:)
116 write(
message(1),
'(a)')
'The stress tensors for real wavefunctions has not been implemented!'
118 if (hm%kpoints%full%npoints == 1)
then
119 write(
message(2),
'(a)')
'For testing this feature, you can add ForceComplex=yes to the input file'
126 if (ions%space%periodic_dim == 1)
then
130 if (.not. ions%space%is_periodic())
then
131 write(
message(1),
'(a)')
'The stress tensor cannot be computed for isolated systems'
135 if (ks%vdw%vdw_correction /= option__vdwcorrection__none .and. .not. any(ks%vdw%vdw_correction ==
d3_lib_options))
then
136 write(
message(1),
'(a)')
'The stress tensor is currently only implemented with DFT-D3 vdW correction'
140 if (hm%pcm%run_pcm)
then
144 if (
allocated(hm%v_static))
then
148 if (ks%has_photons)
then
152 if (.not. hm%vnl%apply_projector_matrices)
then
166 if ( .not.
in_family(hm%xc%family, [xc_family_lda, xc_family_gga]))
then
167 write(
message(1),
'(a)')
'The stress tensor computation is currently only possible at the Kohn-Sham DFT level'
168 write(
message(2),
'(a)')
'with LDA and GGA functionals or for independent particles.'
172 if (
in_family(hm%xc%family, [xc_family_gga]) .and. st%d%ispin ==
spinors)
then
183 safe_allocate(rho_total(1:gr%np_part))
185 rho_total(ip) = sum(st%rho(ip, 1:st%d%nspin))
194 safe_allocate(vh(1:gr%np_part))
195 safe_allocate(grad_vh(1:gr%np, 1:gr%der%dim))
197 call lalg_copy(gr%np, hm%ks_pot%vhartree, vh)
199 if (hm%d%spin_channels > 1)
then
200 safe_allocate(rho(1:gr%np_part))
208 if (hm%d%spin_channels > 1)
then
209 safe_deallocate_p(rho)
214 ehartree = hm%energy%hartree
221 call stress_from_kinetic(gr, ions%space, hm, st, gr%symm, ions%latt%rcell_volume, stress_kin)
222 stress = stress + stress_kin
228 call stress_from_hartree(gr, ions%space, ions%latt%rcell_volume, grad_vh, ehartree, stress_hartree)
229 stress = stress + stress_hartree
231 call stress_from_xc(hm%energy, ions%latt%rcell_volume, ions%space%periodic_dim, stress_xc)
234 if (
allocated(st%rho_core))
then
235 call stress_from_xc_nlcc(ions%latt%rcell_volume, gr, st, ions, hm%ks_pot%vxc, stress_xc_nlcc)
236 stress_xc = stress_xc + stress_xc_nlcc
239 stress_xc = stress_xc + ks%stress_xc_gga / ions%latt%rcell_volume
240 stress = stress + stress_xc
244 stress_ps = stress_ps_local
245 stress = stress + stress_ps_local
247 safe_deallocate_a(vh)
248 safe_deallocate_a(grad_vh)
251 stress_ps = stress_ps + stress_ps_nl
252 stress = stress + stress_ps_nl
254 call stress_from_hubbard(namespace, gr, st, hm, ions%space, ions%latt%rcell_volume, stress_hubbard)
255 stress = stress + stress_hubbard
257 call ion_interaction_stress(ions%ion_interaction, ions%space, ions%latt, ions%atom, ions%natoms, ions%pos, stress_ii)
258 stress = stress + stress_ii
265 st%stress_tensors%kinetic = stress_kin
266 st%stress_tensors%Hartree = stress_hartree
267 st%stress_tensors%xc = stress_xc
268 st%stress_tensors%ps_local = stress_ps_local
269 st%stress_tensors%ps_nl = stress_ps_nl
270 st%stress_tensors%hubbard = stress_hubbard
271 st%stress_tensors%ion_ion = stress_ii
274 if (ks%vdw%vdw_correction /= option__vdwcorrection__none)
then
275 st%stress_tensors%vdw = hm%ep%vdw_stress
277 st%stress_tensors%vdw =
m_zero
279 stress = stress + st%stress_tensors%vdw
282 if (hm%kpoints%use_symmetries)
then
288 st%stress_tensors%total = stress
292 st%stress_tensors%kinetic_sumrule =
m_zero
294 st%stress_tensors%Hartree_sumrule =
m_zero
295 if(ions%space%periodic_dim == 3)
then
296 st%stress_tensors%kinetic_sumrule = (stress_kin(1,1) + stress_kin(2,2) + stress_kin(3,3))*ions%latt%rcell_volume
297 st%stress_tensors%kinetic_sumrule = st%stress_tensors%kinetic_sumrule -
m_two * hm%energy%kinetic
299 st%stress_tensors%hartree_sumrule = (stress_hartree(1,1) + stress_hartree(2,2) + stress_hartree(3,3))*ions%latt%rcell_volume
300 st%stress_tensors%hartree_sumrule = st%stress_tensors%hartree_sumrule - hm%energy%hartree
303 safe_deallocate_a(rho_total)
325 type(
grid_t),
intent(in) :: gr
326 class(
space_t),
intent(in) :: space
330 real(real64),
intent(in) :: rcell_volume
331 real(real64),
intent(out) :: stress_kin(3, 3)
333 integer :: ik, ist, idir, jdir, ib, minst, maxst
334 complex(real64),
allocatable :: stress_l_block(:)
342 safe_allocate(stress_l_block(1:st%block_size))
344 do ik = st%d%kpt%start, st%d%kpt%end
347 do ib = st%group%block_start, st%group%block_end
357 do idir = 1, space%periodic_dim
358 do jdir = idir, space%periodic_dim
361 do ist = minst, maxst
362 stress_kin(idir,jdir) = stress_kin(idir,jdir) &
363 + st%kweights(ik) * st%occ(ist, ik) &
364 * real(stress_l_block(ist - minst + 1), real64)
369 do idir = 1, space%dim
370 call gpsib(idir)%end()
377 if (st%parallel_in_states .or. st%d%kpt%parallel)
then
386 if (hm%kpoints%use_symmetries)
then
390 stress_kin = stress_kin / rcell_volume
414 type(
grid_t),
intent(in) :: gr
415 class(
space_t),
intent(in) :: space
416 real(real64),
intent(in) :: volume
417 real(real64),
intent(in) :: grad_vh(:,:)
418 real(real64),
intent(in) :: ehartree
419 real(real64),
intent(out) :: stress_Hartree(3, 3)
421 integer :: idir, jdir
426 stress_hartree(:,:) =
m_zero
428 do idir = 1, space%periodic_dim
429 do jdir = idir, space%periodic_dim
430 stress_hartree(idir, jdir) = -
dmf_dotp(gr, grad_vh(:,idir), grad_vh(:, jdir))/
m_four/
m_pi
432 stress_hartree(idir, idir) = stress_hartree(idir, idir) + ehartree
437 stress_hartree = stress_hartree/volume
461 subroutine stress_from_xc(energy, rcell_volume, periodic_dim, stress_xc)
462 type(
energy_t),
intent(in) :: energy
463 real(real64),
intent(in) :: rcell_volume
464 integer,
intent(in) :: periodic_dim
465 real(real64),
intent(out) :: stress_xc(3, 3)
473 do idir = 1, periodic_dim
474 stress_xc(idir, idir) = - energy%exchange - energy%correlation + energy%intnvxc
476 stress_xc(:,:) = stress_xc(:,:) / rcell_volume
492 real(real64),
intent(in) :: rcell_volume
493 type(
grid_t),
intent(in) :: gr
495 type(
ions_t),
intent(in) :: ions
496 real(real64),
intent(in) :: vxc(:,:)
497 real(real64),
intent(out) :: stress_xc_nlcc(3, 3)
499 integer :: idir, jdir, iat
500 real(real64),
allocatable :: gnlcc(:,:), gnlcc_x(:,:,:), vxc_tot(:)
505 assert(
allocated(st%rho_core))
510 safe_allocate(gnlcc(gr%np, gr%der%dim))
511 safe_allocate(gnlcc_x(gr%np, gr%der%dim, gr%der%dim))
513 do iat = ions%atoms_dist%start, ions%atoms_dist%end
514 assert(ions%atom(iat)%species%is_ps())
516 ions%pos(:,iat), gr, gnlcc, gnlcc_x)
518 safe_deallocate_a(gnlcc)
520 if (ions%atoms_dist%parallel)
then
525 safe_allocate(vxc_tot(1:gr%np))
526 call lalg_copy(gr%np, vxc(:, 1), vxc_tot)
527 if(st%d%nspin > 1)
call lalg_axpy(gr%np,
m_one, vxc(:, 2), vxc_tot)
529 do idir = 1, ions%space%periodic_dim
530 do jdir = idir, ions%space%periodic_dim
531 stress_xc_nlcc(idir, jdir) =
dmf_dotp(gr, vxc_tot, gnlcc_x(:,idir, jdir))
534 safe_deallocate_a(vxc_tot)
535 safe_deallocate_a(gnlcc_x)
539 stress_xc_nlcc(:,:) = stress_xc_nlcc(:,:) / rcell_volume
566 type(
grid_t),
target,
intent(in) :: gr
569 type(
ions_t),
intent(in) :: ions
570 real(real64),
intent(out) :: stress_ps_nl(3, 3)
572 integer :: ik, ist, idir, jdir
573 integer :: ib, minst, maxst
574 type(
wfs_elec_t) :: psib, rvnl_psib(3), gpsib(3)
575 complex(real64),
allocatable :: stress_tmp(:)
582 safe_allocate(stress_tmp(1:st%block_size))
586 do ik = st%d%kpt%start, st%d%kpt%end
590 do ib = st%group%block_start, st%group%block_end
601 do idir = 1, gr%der%dim
602 call psib%copy_to(rvnl_psib(idir))
605 call hm%vnl%zr_vn_local(gr, st%d, gr%der%boundaries%spiral, psib, rvnl_psib)
607 do idir = 1, ions%space%periodic_dim
608 do jdir = idir, ions%space%periodic_dim
611 do ist = minst, maxst
612 stress_ps_nl(idir, jdir) = stress_ps_nl(idir, jdir) &
613 +
m_two * st%kweights(ik) * st%occ(ist, ik) * real(stress_tmp(ist-minst+1), real64)
619 do idir = 1, gr%der%dim
620 call rvnl_psib(idir)%end()
621 call gpsib(idir)%end()
627 safe_deallocate_a(stress_tmp)
629 if (st%parallel_in_states .or. st%d%kpt%parallel)
then
637 if (hm%kpoints%use_symmetries)
then
642 do idir = 1, ions%space%periodic_dim
643 stress_ps_nl(idir, idir) = stress_ps_nl(idir, idir) + hm%energy%extern_non_local
646 stress_ps_nl = stress_ps_nl/ions%latt%rcell_volume
675 type(
grid_t),
target,
intent(in) :: gr
677 type(
ions_t),
intent(in) :: ions
678 real(real64),
contiguous,
intent(inout) :: rho_total(:)
679 real(real64),
intent(in) :: grad_vh(:,:)
680 real(real64),
intent(out) :: stress_ps_local(3, 3)
683 real(real64) :: stress_SR(3, 3), stress_LR(3, 3)
684 real(real64) :: energy_ps_SR, charge, zi
685 real(real64),
allocatable :: vloc(:), rvloc(:,:), rho_local_lr(:), rho_lr(:)
686 real(real64),
allocatable :: grad_rho(:,:), rho_lr_x(:,:), vlr(:), grad_vlr(:,:)
687 integer :: idir, jdir, iatom
688 type(
ps_t),
pointer :: spec_ps
696 safe_allocate(vloc(1:gr%np))
698 safe_allocate(rvloc(1:gr%np, 1:gr%der%dim))
700 do iatom = 1, ions%natoms
703 safe_deallocate_a(vloc)
705 safe_allocate(grad_rho(1:gr%np,1:gr%der%dim))
708 energy_ps_sr = hm%energy%extern_local
709 do idir = 1, ions%space%periodic_dim
710 do jdir = idir, ions%space%periodic_dim
711 stress_sr(idir, jdir) = stress_sr(idir, jdir) &
712 +
dmf_dotp(gr, rvloc(:, jdir), grad_rho(:, idir))
714 stress_sr(idir,idir) = stress_sr(idir,idir) + energy_ps_sr
719 stress_sr = stress_sr/ions%latt%rcell_volume
721 safe_deallocate_a(rvloc)
722 safe_deallocate_a(grad_rho)
730 safe_allocate(rho_lr(1:gr%np_part))
731 safe_allocate(rho_lr_x(1:gr%np, 1:gr%der%dim))
734 safe_allocate(rho_local_lr(1:gr%np))
735 do iatom = ions%atoms_dist%start, ions%atoms_dist%end
736 assert(ions%atom(iatom)%species%is_ps())
738 ions%pos(:, iatom), gr, rho_local_lr, nlr_x=rho_lr_x)
742 safe_deallocate_a(rho_local_lr)
744 if (ions%atoms_dist%parallel)
then
749 do idir = 1, ions%space%periodic_dim
750 do jdir = idir, ions%space%periodic_dim
751 stress_lr(idir, jdir) = stress_lr(idir, jdir) +
dmf_dotp(gr, rho_lr_x(:,jdir), grad_vh(:, idir))
754 safe_deallocate_a(rho_lr_x)
756 safe_allocate(vlr(1:gr%np_part))
758 safe_deallocate_a(rho_lr)
760 safe_allocate(grad_vlr(1:gr%np, 1:gr%der%dim))
762 safe_deallocate_a(vlr)
764 do idir = 1, ions%space%periodic_dim
765 do jdir = idir, ions%space%periodic_dim
766 stress_lr(idir, jdir) = stress_lr(idir, jdir) -
dmf_dotp(gr, grad_vh(:,idir), grad_vlr(:, jdir))/
m_two/
m_pi
772 safe_deallocate_a(grad_vlr)
776 if (ions%space%periodic_dim == 3)
then
778 do iatom = 1, ions%natoms
779 charge = charge + ions%atom(iatom)%species%get_zval()
782 do iatom = 1, ions%natoms
783 select type(spec => ions%atom(iatom)%species)
788 do idir = 1, ions%space%periodic_dim
789 stress_lr(idir, idir) = stress_lr(idir, idir) &
790 +
m_two*
m_pi*spec_ps%sigma_erf**2*charge*zi /ions%latt%rcell_volume
796 stress_lr = stress_lr/ions%latt%rcell_volume
798 stress_ps_local = stress_sr + stress_lr
807 class(
mesh_t),
intent(in) :: mesh
808 type(
ions_t),
intent(in) :: ions
809 integer,
intent(in) :: iatom
810 real(real64),
intent(inout) :: vpsl(:)
811 real(real64),
intent(inout) :: rvpsl(:,:)
814 real(real64) :: radius, vl_ip
816 type(
ps_t),
pointer :: ps
820 if (.not. ions%atom(iatom)%species%is_ps())
then
827 select type(spec=>ions%atom(iatom)%species)
832 radius = ps%vl%x_threshold*1.05_real64
834 call submesh_init(sphere, ions%space, mesh, ions%latt, ions%pos(:, iatom), radius)
840 vpsl(sphere%map(ip)) = vpsl(sphere%map(ip)) + vl_ip
841 rvpsl(sphere%map(ip), 1:ions%space%periodic_dim) = rvpsl(sphere%map(ip), 1:ions%space%periodic_dim) &
842 + sphere%rel_x(1:ions%space%periodic_dim, ip) * vl_ip
873 type(
grid_t),
target,
intent(in) :: gr
876 type(
space_t),
intent(in) :: space
877 real(real64),
intent(in) :: rcell_volume
878 real(real64),
intent(out) :: stress_hubbard(3, 3)
880 integer :: ik, ist, idir, jdir
881 integer :: ib, minst, maxst
882 type(
wfs_elec_t) :: psib, rvu_psib(3), gpsib(3)
883 complex(real64),
allocatable :: stress_tmp(:)
894 safe_allocate(stress_tmp(1:st%block_size))
898 do ik = st%d%kpt%start, st%d%kpt%end
902 do ib = st%group%block_start, st%group%block_end
912 do idir = 1, gr%der%dim
913 call psib%copy_to(rvu_psib(idir))
917 call zlda_u_rvu(hm%lda_u, gr, space, hm%d, namespace, psib, rvu_psib)
923 do ist = minst, maxst
924 stress_hubbard(idir, jdir) = stress_hubbard(idir, jdir) &
925 +
m_two * st%kweights(ik) * st%occ(ist, ik) * real(stress_tmp(ist-minst+1), real64)
931 do idir = 1, gr%der%dim
932 call rvu_psib(idir)%end()
933 call gpsib(idir)%end()
939 safe_deallocate_a(stress_tmp)
941 if (st%parallel_in_states .or. st%d%kpt%parallel)
then
949 if (hm%kpoints%use_symmetries)
then
955 stress_hubbard(idir, idir) = stress_hubbard(idir, idir) + hm%energy%int_dft_u
958 stress_hubbard = stress_hubbard/rcell_volume
965 subroutine output_stress(iunit, space_dim, stress_tensors, all_terms)
966 integer,
intent(in) :: iunit
967 integer,
intent(in) :: space_dim
968 type(
stress_t),
intent(in) :: stress_tensors
969 logical,
optional,
intent(in) :: all_terms
971 logical :: write_all_terms
972 character(len=16) :: stress_unit
981 if (write_all_terms)
then
982 write(iunit,
'(3a)')
'Kinetic stress tensor [', trim(stress_unit),
'] ='
984 if (space_dim == 3)
then
985 write(iunit,
'(a, es15.6, 3a)')
'Kinetic pressure sumrule violation: ', &
992 write(iunit,
'(3a)')
'Hartree stress tensor [', trim(stress_unit),
'] ='
994 if (space_dim == 3)
then
995 write(iunit,
'(a, es15.6, 3a)')
'Hartree pressure sumrule violation: ', &
1001 write(iunit,
'(3a)')
'XC stress tensor [', trim(stress_unit),
'] ='
1004 write(iunit,
'(3a)')
'Local pseudo. stress tensor [', trim(stress_unit),
'] ='
1007 write(iunit,
'(3a)')
'Nonlocal pseudo. stress tensor [', trim(stress_unit),
'] ='
1010 write(iunit,
'(3a)')
'Ion-ion stress tensor [', trim(stress_unit),
'] ='
1013 write(iunit,
'(3a)')
'vdW stress tensor [', trim(stress_unit),
'] ='
1016 write(iunit,
'(3a)')
'Hubbard stress tensor [', trim(stress_unit),
'] ='
1020 write(iunit,
'(3a)')
'Total stress tensor [', trim(stress_unit),
'] ='
1028 integer,
intent(in) :: iunit
1029 integer,
intent(in) :: space_dim
1030 real(real64),
intent(in) :: total_stress_tensor(3,3)
1033 real(real64) :: pressure
1034 character(len=16) :: stress_unit
1040 do idim = 1, space_dim
1041 pressure = pressure - total_stress_tensor(idim, idim) / real(space_dim, real64)
1044 write(iunit,
'(3a,es16.8)', advance=
"no")
'Pressure [', trim(stress_unit),
'] = ', &
1046 if (space_dim == 3)
then
1055 integer,
intent(in) :: ounit
1056 integer,
intent(in) :: space_dim
1057 real(real64),
intent(in) :: tensor(3,3)
1059 real(real64) :: tensor_with_unit(3,3)
1060 integer :: idim, jdim
1064 write(ounit,
'(a9,2x)', advance=
"no")
"T_{ij}"
1065 do jdim = 1, space_dim
1066 write(ounit,
'(i18)', advance=
"no") jdim
1069 do idim = 1, space_dim
1070 write(ounit,
'(i9,2x)', advance=
"no") idim
1071 do jdim = 1, space_dim
1072 write(ounit,
'(es18.9)', advance=
"no") tensor_with_unit(idim, jdim)
constant times a vector plus a vector
Copies a vector x, to a vector y.
This module implements common operations on batches of mesh functions.
subroutine, public batch_set_zero(this, np, async)
fill all mesh functions of the batch with zero
Module implementing boundary conditions in Octopus.
This module implements a calculator for the density and defines related functions.
This module calculates the derivatives (gradients, Laplacians, etc.) of a function.
subroutine, public dderivatives_grad(der, ff, op_ff, ghost_update, set_bc, to_cartesian)
apply the gradient to a mesh function
subroutine, public zderivatives_batch_grad(der, ffb, opffb, ghost_update, set_bc, to_cartesian, factor)
apply the gradient to a batch of mesh functions
integer, parameter, public spinors
subroutine, public energy_calc_total(namespace, space, hm, gr, st, ext_partners, iunit, full)
This subroutine calculates the total energy of the system. Basically, it adds up the KS eigenvalues,...
integer, parameter, public scalar_relativistic_zora
integer, parameter, public fully_relativistic_zora
real(real64), parameter, public m_two
real(real64), parameter, public m_zero
real(real64), parameter, public m_four
real(real64), parameter, public m_pi
some mathematical constants
integer, parameter, public independent_particles
Theory level.
integer, parameter, public generalized_kohn_sham_dft
integer, parameter, public kohn_sham_dft
real(real64), parameter, public m_epsilon
real(real64), parameter, public m_one
This module implements the underlying real-space grid.
subroutine, public hamiltonian_elec_copy_and_set_phase(hm, gr, kpt, psib, psib_with_phase)
Copy a batch to another batch and apply the Bloch phase to it.
This module defines classes and functions for interaction partners.
subroutine, public ion_interaction_stress(this, space, latt, atom, natoms, pos, stress_ii)
Computes the contribution to the stress tensor the ion-ion energy.
A module to handle KS potential, without the external potential.
integer, parameter, public dft_u_none
subroutine, public zlda_u_rvu(this, mesh, space, d, namespace, psib, gpsib)
This routine computes .
This modules implements the routines for doing constrain DFT for noncollinear magnetism.
integer, parameter, public constrain_none
This module is intended to contain "only mathematical" functions and procedures.
This module defines functions over batches of mesh functions.
subroutine, public zmesh_batch_dotp_vector(mesh, aa, bb, dot, reduce, cproduct)
calculate the vector of dot-products of mesh functions between two batches
This module defines various routines, operating on mesh functions.
This module defines the meshes, which are used in Octopus.
subroutine, public messages_not_implemented(feature, namespace)
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
type(mpi_grp_t), public mpi_world
subroutine, public dpoisson_solve(this, namespace, pot, rho, all_nodes, kernel, reset)
Calculates the Poisson equation. Given the density returns the corresponding potential.
subroutine, public profiling_out(label)
Increment out counter and sum up difference between entry and exit time.
subroutine, public profiling_in(label, exclude)
Increment in counter and save entry time.
subroutine, public species_get_long_range_density(species, namespace, space, latt, pos, mesh, rho, sphere_inout, nlr_x)
subroutine, public species_get_nlcc_grad(species, space, latt, pos, mesh, rho_core_grad, gnlcc_x)
real(real64) function, public spline_eval(spl, x)
This module handles spin dimensions of the states and the k-point distribution.
integer pure function, public states_elec_block_max(st, ib)
return index of last state in block ib
integer pure function, public states_elec_block_min(st, ib)
return index of first state in block ib
This module implements the calculation of the stress tensor.
subroutine stress_from_hartree(gr, space, volume, grad_vh, ehartree, stress_Hartree)
Computes the contribution to the stress tensor from the Hartree energy.
subroutine stress_from_kinetic(gr, space, hm, st, symm, rcell_volume, stress_kin)
Computes the contribution to the stress tensor from the kinetic energy.
subroutine stress_from_pseudo_local(gr, hm, ions, rho_total, grad_vh, stress_ps_local)
Computes the contribution from the local part of the pseudopotential.
subroutine stress_from_xc(energy, rcell_volume, periodic_dim, stress_xc)
Computes the contribution to the stress tensor from the xc energy.
subroutine print_stress_tensor(ounit, space_dim, tensor)
subroutine, public output_pressure(iunit, space_dim, total_stress_tensor)
subroutine epot_local_pseudopotential_sr(mesh, ions, iatom, vpsl, rvpsl)
subroutine, public stress_calculate(namespace, gr, hm, st, ions, ks, ext_partners)
This computes the total stress on the lattice.
subroutine stress_from_hubbard(namespace, gr, st, hm, space, rcell_volume, stress_hubbard)
Computes the contribution to the stress tensor from the Hubbard energy.
subroutine stress_from_xc_nlcc(rcell_volume, gr, st, ions, vxc, stress_xc_nlcc)
Computes the NLCC contribution to the stress tensor from the xc energy.
subroutine stress_from_pseudo_nonloc(gr, st, hm, ions, stress_ps_nl)
Computes the contribution to the stress tensor from the nonlocal part of the pseudopotentials.
subroutine, public output_stress(iunit, space_dim, stress_tensors, all_terms)
subroutine, public submesh_end(this)
subroutine, public submesh_init(this, space, mesh, latt, center, rc)
subroutine, public dsymmetrize_tensor_cart(symm, tensor, use_non_symmorphic)
Symmetric a rank-2 tensor defined in Cartesian space.
type(type_t), public type_cmplx
brief This module defines the class unit_t which is used by the unit_systems_oct_m module.
character(len=20) pure function, public units_abbrev(this)
This module defines the unit system, used for input and output.
type(unit_system_t), public units_out
type(unit_t), public unit_gpa
For output pressure in GPa.
logical pure function, public xc_is_energy_functional(xcs)
Is one of the x or c functional is not an energy functional.
pure logical function, public in_family(family, xc_families)
A module that takes care of xc contribution from vdW interactions.
integer(int64), dimension(5), parameter, public d3_lib_options
VDWCORRECTION options that correspond to the DFT-D3 library.
Description of the grid, containing information on derivatives, stencil, and symmetries.
Describes mesh distribution to nodes.
A type storing the information and data about a pseudopotential.
The states_elec_t class contains all electronic wave functions.
A submesh is a type of mesh, used for the projectors in the pseudopotentials It contains points on a ...
batches of electronic states