38 use,
intrinsic :: iso_fortran_env
92 logical :: complex_ylms
93 logical :: initialized
96 integer,
allocatable :: atom(:)
97 integer,
allocatable :: level(:)
98 integer,
allocatable :: ddim(:)
99 logical :: alternative
100 logical :: derivative
101 integer,
allocatable :: cst(:, :)
102 integer,
allocatable :: ck(:, :)
103 real(4),
allocatable :: dbuff_single(:, :, :, :)
104 complex(4),
allocatable :: zbuff_single(:, :, :, :)
105 real(real64),
allocatable :: dbuff(:, :, :, :)
106 complex(real64),
allocatable :: zbuff(:, :, :, :)
107 logical :: save_memory
108 logical :: initialized_orbitals
109 real(real64) :: orbital_scale_factor
112 logical,
allocatable :: is_empty(:)
118 real(real64),
allocatable :: radius(:)
119 real(real64) :: lapdist
123 integer,
allocatable :: basis_atom(:)
124 integer,
allocatable :: basis_orb(:)
125 integer,
allocatable :: atom_orb_basis(:, :)
126 integer,
allocatable :: norb_atom(:)
128 integer :: lsize(1:2)
129 integer :: nproc(1:2)
130 integer :: myroc(1:2)
131 integer :: desc(1:BLACS_DLEN)
132 logical,
allocatable :: calc_atom(:)
133 real(real64) :: diag_tol
134 type(submesh_t),
allocatable :: sphere(:)
135 type(batch_t),
allocatable :: orbitals(:)
136 logical,
allocatable :: is_orbital_initialized(:)
140 integer,
parameter :: &
141 INITRHO_PARAMAGNETIC = 1, &
149 subroutine lcao_init(this, namespace, space, gr, ions, st, st_start)
150 type(lcao_t),
intent(out) :: this
151 type(namespace_t),
intent(in) :: namespace
152 type(electron_space_t),
intent(in) :: space
153 type(grid_t),
intent(in) :: gr
154 type(ions_t),
intent(in) :: ions
155 type(states_elec_t),
intent(in) :: st
156 integer,
intent(in) :: st_start
158 integer :: ia, n, iorb, jj, maxj, idim
159 integer :: ii, ll, mm, norbs, ii_tmp
160 integer :: mode_default
161 real(real64) :: max_orb_radius, maxradius
166 this%initialized = .
true.
170 mode_default = option__lcaostart__lcao_states
171 if (ions%only_user_def) mode_default = option__lcaostart__lcao_none
228 if (this%mode == option__lcaostart__lcao_states_batch .and. st_start > 1)
then
229 message(1) =
"LCAOStart = lcao_states_batch not compatible with this run."
230 message(2) =
"Please use LCAOStart = lcao_states instead"
235 this%alternative = this%mode == option__lcaostart__lcao_states_batch
237 if (this%mode == option__lcaostart__lcao_none)
then
247 if (st%d%ispin ==
spinors .and. this%alternative)
then
248 message(1) =
"LCAOStart = lcao_states_batch is not working for spinors."
251 if (space%is_periodic() .and. this%alternative)
then
269 call parse_variable(namespace,
'LCAOComplexYlms', .false., this%complex_ylms)
271 this%complex_ylms = .false.
282 call parse_variable(namespace,
'LCAOSaveMemory', .false., this%save_memory)
286 call io_mkdir(
'debug/lcao', namespace)
287 iunit_o =
io_open(
'debug/lcao/orbitals', namespace, action=
'write')
288 write(iunit_o,
'(7a6)')
'iorb',
'atom',
'level',
'i',
'l',
'm',
'spin'
291 if (.not. this%alternative)
then
312 call parse_variable(namespace,
'LCAOMaximumOrbitalRadius', 20.0_real64, max_orb_radius, unit =
units_inp%length)
318 do ia = 1, ions%natoms
319 maxj = max(maxj, ions%atom(ia)%species%get_niwfs())
320 this%maxorbs = this%maxorbs + ions%atom(ia)%species%get_niwfs()
323 this%maxorbs = this%maxorbs*st%d%dim
325 if (this%maxorbs == 0)
then
326 call messages_write(
'The are no atomic orbitals available, cannot do LCAO.')
328 this%mode = option__lcaostart__lcao_none
335 safe_allocate( this%atom(1:this%maxorbs))
336 safe_allocate(this%level(1:this%maxorbs))
337 safe_allocate( this%ddim(1:this%maxorbs))
339 safe_allocate(this%is_empty(1:this%maxorbs))
340 this%is_empty = .false.
343 this%lapdist = maxval(abs(gr%idx%enlarge)*gr%spacing)
346 safe_allocate(this%radius(1:ions%natoms))
348 do ia = 1, ions%natoms
349 norbs = ions%atom(ia)%species%get_niwfs()
353 call ions%atom(ia)%species%get_iwf_ilm(iorb, 1, ii, ll, mm)
355 if(ions%atom(ia)%species%is_full())
call ions%atom(ia)%species%get_iwf_n( iorb, 1, ii)
356 maxradius = max(maxradius, ions%atom(ia)%species%get_iwf_radius( ii, is = 1))
359 maxradius = min(maxradius,
m_two*maxval(gr%box%bounding_box_l(1:space%dim)))
361 this%radius(ia) = maxradius
393 do ia = 1, ions%natoms
395 if (jj > ions%atom(ia)%species%get_niwfs()) cycle
396 call ions%atom(ia)%species%get_iwf_ilm(jj, idim, ii, ll, mm)
398 if(ions%atom(ia)%species%is_full())
then
400 call ions%atom(ia)%species%get_iwf_n( ii_tmp, 1, ii)
402 if (this%orbital_scale_factor*ions%atom(ia)%species%get_iwf_radius( ii, is = 1) >= max_orb_radius) cycle
405 this%level(iorb) = jj
406 this%ddim(iorb) = idim
409 write(iunit_o,
'(7i6)') iorb, this%atom(iorb), this%level(iorb), ii, ll, mm, this%ddim(iorb)
422 if (this%maxorbs /= iorb - 1)
then
427 call messages_write(
' orbitals cannot be used for the LCAO calculation,')
429 call messages_write(
' their radii exceeds LCAOMaximumOrbitalRadius (')
434 this%maxorbs = iorb - 1
437 if (this%maxorbs < st%nst)
then
438 call messages_write(
'Cannot do LCAO for all states because there are not enough atomic orbitals.')
478 if (n > 0 .and. n <= st%nst .and. st%nst <= this%maxorbs)
then
481 else if (n > st%nst .and. n <= this%maxorbs)
then
484 else if (n == 0)
then
486 this%norbs = min(this%maxorbs, 2*st%nst)
489 this%norbs = this%maxorbs
492 assert(this%norbs <= this%maxorbs)
494 safe_allocate(this%cst(1:this%norbs, 1:st%d%spin_channels))
495 safe_allocate(this%ck(1:this%norbs, 1:st%d%spin_channels))
496 this%initialized_orbitals = .false.
506 integer :: iatom, iorb, norbs
507 real(real64) :: maxradius
510 integer :: jatom, jorb, jbasis, ilbasis, jlbasis, proc(1:2),
info, nbl
551 call parse_variable(namespace,
'LCAOExtraOrbitals', .false., this%derivative)
558 if (this%derivative)
then
561 if (st%nst * st%smear%el_per_state > st%qtot)
then
562 message(1) =
"Lower-lying empty states may be missed with LCAOExtraOrbitals."
575 call parse_variable(namespace,
'LCAODiagTol', 1e-10_real64, this%diag_tol)
577 if (this%derivative)
then
583 safe_allocate(this%sphere(1:ions%natoms))
584 safe_allocate(this%orbitals(1:ions%natoms))
585 safe_allocate(this%is_orbital_initialized(1:ions%natoms))
586 this%is_orbital_initialized = .false.
588 safe_allocate(this%norb_atom(1:ions%natoms))
592 do iatom = 1, ions%natoms
593 this%norb_atom(iatom) = this%mult*ions%atom(iatom)%species%get_niwfs()
594 this%maxorb = max(this%maxorb, ions%atom(iatom)%species%get_niwfs())
595 this%norbs = this%norbs + ions%atom(iatom)%species%get_niwfs()
598 this%maxorb = this%maxorb*this%mult
599 this%norbs = this%norbs*this%mult
601 safe_allocate(this%basis_atom(1:this%norbs))
602 safe_allocate(this%basis_orb(1:this%norbs))
603 safe_allocate(this%atom_orb_basis(1:ions%natoms, 1:this%maxorb))
608 do iatom = 1, ions%natoms
609 norbs = ions%atom(iatom)%species%get_niwfs()
611 do iorb = 1, this%mult*norbs
613 this%atom_orb_basis(iatom, iorb) = ibasis
614 this%basis_atom(ibasis) = iatom
615 this%basis_orb(ibasis) = iorb
619 call ions%atom(iatom)%species%get_iwf_ilm(iorb, 1, ii, ll, mm)
620 write(iunit_o,
'(7i6)') ibasis, iatom, iorb, ii, ll, mm, 1
630 this%lapdist = maxval(abs(gr%idx%enlarge)*gr%spacing)
633 safe_allocate(this%radius(1:ions%natoms))
635 do iatom = 1, ions%natoms
636 norbs = ions%atom(iatom)%species%get_niwfs()
640 call ions%atom(iatom)%species%get_iwf_ilm(iorb, 1, ii, ll, mm)
642 if(ions%atom(iatom)%species%is_full())
call ions%atom(iatom)%species%get_iwf_n( iorb, 1, ii)
643 maxradius = max(maxradius, ions%atom(iatom)%species%get_iwf_radius( ii, is = 1))
646 if (this%derivative) maxradius = maxradius + this%lapdist
648 maxradius = min(maxradius,
m_two*maxval(gr%box%bounding_box_l(1:space%dim)))
650 this%radius(iatom) = maxradius
653 safe_allocate(this%calc_atom(1:ions%natoms))
654 this%calc_atom = .
true.
657#ifndef HAVE_SCALAPACK
658 this%parallel = .false.
660 this%parallel = (st%parallel_in_states .or. gr%parallel_in_domains) &
663 if (this%parallel)
then
664 nbl = min(16, this%norbs)
667 this%lsize(1) = max(1,
numroc(this%norbs, nbl, st%dom_st_proc_grid%myrow, 0, st%dom_st_proc_grid%nprow))
668 this%lsize(2) = max(1,
numroc(this%norbs, nbl, st%dom_st_proc_grid%mycol, 0, st%dom_st_proc_grid%npcol))
670 this%nproc(1) = st%dom_st_proc_grid%nprow
671 this%nproc(2) = st%dom_st_proc_grid%npcol
672 this%myroc(1) = st%dom_st_proc_grid%myrow
673 this%myroc(2) = st%dom_st_proc_grid%mycol
675 call descinit(this%desc(1), this%norbs, this%norbs, nbl, nbl, 0, 0, &
676 st%dom_st_proc_grid%context, this%lsize(1),
info)
679 write(
message(1),
'(a,i6)')
'descinit for BLACS failed with error code ',
info
683 this%calc_atom = .false.
684 do iatom = 1, ions%natoms
685 ibasis = this%atom_orb_basis(iatom, 1)
687 do jatom = 1, ions%natoms
688 jbasis = this%atom_orb_basis(jatom, 1)
690 do iorb = 1, this%norb_atom(iatom)
691 do jorb = 1, this%norb_atom(jatom)
693 ilbasis, jlbasis, proc(1), proc(2))
695 this%calc_atom(this%basis_atom(jbasis)) = &
696 this%calc_atom(this%basis_atom(jbasis)) .or. proc(2) == this%myroc(2)
714 subroutine lcao_run(namespace, space, gr, ions, ext_partners, st, ks, hm, st_start, lmm_r)
717 type(
grid_t),
intent(in) :: gr
718 type(
ions_t),
intent(in) :: ions
721 type(
v_ks_t),
intent(inout) :: ks
723 integer,
optional,
intent(in) :: st_start
724 real(real64),
optional,
intent(in) :: lmm_r
727 integer :: st_start_random, required_min_nst
729 logical :: is_orbital_dependent
733 if (
present(st_start))
then
736 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
737 calc_eigenval=.not.
present(st_start), calc_current=.false.)
739 assert(st_start >= 1)
740 if (st_start > st%nst)
then
760 if (.not.
present(st_start))
then
761 call lcao_guess_density(lcao, namespace, st, gr, hm, ions, st%qtot, st%d%ispin, st%rho)
764 assert(
present(lmm_r))
770 message(1) =
'Info: Setting up Hamiltonian.'
774 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.false., &
775 calc_current=.false., calc_energy=.false., force_semilocal=is_orbital_dependent)
778 st%eigenval = 1e10_real64
787 if (
present(st_start))
then
788 write(
message(1),
'(a,i8,a)')
'Performing LCAO for states ', st_start,
' and above'
792 call lcao_wf(lcao, st, gr, ions, hm, namespace, start = st_start)
798 select case (st%d%ispin)
800 required_min_nst = int(st%qtot/2)
802 required_min_nst = int(st%qtot/2)
804 required_min_nst = int(st%qtot)
807 if (lcao%norbs <= required_min_nst .and. lcao%norbs < st%nst)
then
808 st%eigenval(lcao%norbs+1:,:) =
m_zero
812 if (.not.
present(st_start))
then
817 if (lcao%mode == option__lcaostart__lcao_full)
then
818 call v_ks_h_setup(namespace, space, gr, ions, ext_partners, st, ks, hm, &
819 calc_eigenval = .false., calc_current=.false.)
821 assert(
present(lmm_r))
828 if (.not. lcao_done .or. lcao%norbs < st%nst)
then
831 st_start_random = lcao%norbs + 1
835 if (
present(st_start)) st_start_random = max(st_start, st_start_random)
837 if (st_start_random > 1)
then
838 write(
message(1),
'(a,i8,a)')
'Generating random wavefunctions for states ', st_start_random,
' and above'
849 if (.not. lcao_done)
then
852 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
853 calc_eigenval=.not.
present(st_start), calc_current=.false.)
854 if (.not.
present(st_start))
then
860 else if (
present(st_start))
then
862 if (st_start > 1)
then
879 type(
lcao_t),
intent(inout) :: this
883 safe_deallocate_a(this%calc_atom)
884 safe_deallocate_a(this%norb_atom)
885 safe_deallocate_a(this%basis_atom)
886 safe_deallocate_a(this%basis_orb)
887 safe_deallocate_a(this%atom_orb_basis)
888 safe_deallocate_a(this%radius)
889 safe_deallocate_a(this%sphere)
890 safe_deallocate_a(this%orbitals)
892 safe_deallocate_a(this%atom)
893 safe_deallocate_a(this%level)
894 safe_deallocate_a(this%ddim)
895 safe_deallocate_a(this%cst)
896 safe_deallocate_a(this%ck)
897 safe_deallocate_a(this%dbuff_single)
898 safe_deallocate_a(this%zbuff_single)
899 safe_deallocate_a(this%dbuff)
900 safe_deallocate_a(this%zbuff)
902 this%initialized = .false.
908 subroutine lcao_wf(this, st, gr, ions, hm, namespace, start)
909 type(
lcao_t),
intent(inout) :: this
911 type(
grid_t),
intent(in) :: gr
912 type(
ions_t),
intent(in) :: ions
915 integer,
optional,
intent(in) :: start
919 assert(this%initialized)
925 if (
present(start)) start_ = start
927 if (this%alternative)
then
929 call dlcao_alt_wf(this, st, gr, ions, hm, namespace, start_)
931 call zlcao_alt_wf(this, st, gr, ions, hm, namespace, start_)
935 call dlcao_wf(this, st, gr, ions, hm, namespace, start_)
937 call zlcao_wf(this, st, gr, ions, hm, namespace, start_)
948 type(
lcao_t),
intent(in) :: this
952 available = this%initialized .and. this%mode /= option__lcaostart__lcao_none &
962 type(
lcao_t),
intent(in) :: this
973 type(
lcao_t),
intent(in) :: this
974 integer,
intent(in) :: ig
975 integer,
intent(in) :: jg
976 integer,
intent(out) :: il
977 integer,
intent(out) :: jl
978 integer,
intent(out) :: prow
979 integer,
intent(out) :: pcol
983 call infog2l(ig, jg, this%desc(1), this%nproc(1), this%nproc(2), this%myroc(1), this%myroc(2), &
1000 type(
lcao_t),
intent(inout) :: this
1001 integer,
intent(in) :: iatom
1005 if (this%is_orbital_initialized(iatom))
then
1006 call this%orbitals(iatom)%end()
1007 this%is_orbital_initialized(iatom) = .false.
1017 type(
lcao_t),
intent(inout) :: this
1019 class(
mesh_t),
intent(in) :: mesh
1020 type(
ions_t),
target,
intent(in) :: ions
1021 integer,
intent(in) :: iatom
1022 integer,
intent(in) :: spin_channels
1023 real(real64),
intent(inout) :: rho(:, :)
1025 real(real64),
allocatable :: dorbital(:, :)
1026 complex(real64),
allocatable :: zorbital(:, :)
1027 real(real64),
allocatable :: factors(:)
1028 real(real64) :: factor, aa
1029 integer :: iorb, ip, ii, ll, mm, ispin
1030 type(
ps_t),
pointer :: ps
1031 logical :: use_stored_orbitals
1037 use_stored_orbitals = ions%atom(iatom)%species%is_ps() &
1039 .and. st%d%dim == 1 .and. .not. ions%space%is_periodic()
1043 if (use_stored_orbitals)
then
1045 assert(.not. ions%space%is_periodic())
1047 select type(spec=>ions%atom(iatom)%species)
1054 if (.not. this%alternative)
then
1057 safe_allocate(dorbital(1:mesh%np, 1:st%d%dim))
1059 safe_allocate(zorbital(1:mesh%np, 1:st%d%dim))
1062 do iorb = 1, this%norbs
1063 if (iatom /= this%atom(iorb)) cycle
1065 call ions%atom(iatom)%species%get_iwf_ilm(this%level(iorb), 1, ii, ll, mm)
1066 factor = ps%conf%occ(ii, 1)/(
m_two*ll +
m_one)
1069 call dget_ao(this, st, mesh, ions, iorb, 1, dorbital, use_psi = .
true.)
1072 rho(ip, 1) = rho(ip, 1) + factor*dorbital(ip, 1)**2
1075 call zget_ao(this, st, mesh, ions, iorb, 1, zorbital, use_psi = .
true.)
1078 rho(ip, 1) = rho(ip, 1) + factor*abs(zorbital(ip, 1))**2
1084 safe_deallocate_a(dorbital)
1085 safe_deallocate_a(zorbital)
1093 safe_allocate(factors(1:this%norb_atom(iatom)/this%mult))
1095 do iorb = 1, this%norb_atom(iatom)/this%mult
1096 call ions%atom(iatom)%species%get_iwf_ilm(iorb, 1, ii, ll, mm)
1097 factors(iorb) = ps%conf%occ(ii, 1)/(
m_two*ll +
m_one)
1101 do ip = 1, this%sphere(iatom)%np
1103 do iorb = 1, this%norb_atom(iatom)/this%mult
1104 aa = aa + factors(iorb)*this%orbitals(iatom)%dff_linear(ip, iorb)**2
1106 rho(this%sphere(iatom)%map(ip), 1) = rho(this%sphere(iatom)%map(ip), 1) + aa
1109 safe_deallocate_a(factors)
1115 ions%pos(:, iatom), mesh, spin_channels, rho)
1120 do ispin = 1, spin_channels
1123 rho(ip, ispin) = max(rho(ip, ispin),
m_zero)
1133 type(
lcao_t),
intent(inout) :: this
1136 type(
grid_t),
intent(in) :: gr
1138 type(
ions_t),
intent(in) :: ions
1139 real(real64),
intent(in) :: qtot
1140 integer,
intent(in) :: ispin
1141 real(real64),
contiguous,
intent(out) :: rho(:, :)
1143 integer :: ia, is, idir, gmd_opt, ip, m_dim
1146 real(real64) :: rr, rnd, phi, theta, lmag, n1, n2,arg
1147 real(real64),
allocatable :: atom_rho(:,:), mag(:,:)
1148 real(real64),
parameter :: tol_min_mag = 1.0e-20_real64
1152 if (st%d%spin_channels == 1)
then
1153 gmd_opt = initrho_paramagnetic
1186 message(1) =
"GuessMagnetDensity cannot be used for Hartree-Fock and generalized Kohn-Sham calculation."
1187 message(2) =
"Please perform a LDA or GGA calculation first and restart from this calculation."
1211 if (
parse_block(namespace,
'AtomsMagnetDirection', blk) < 0)
then
1212 message(1) =
"AtomsMagnetDirection block is not defined."
1217 message(1) =
"The number of rows in the AtomsMagnetDirection block does not equal the number of atoms."
1227 safe_allocate(mag(1:m_dim, 1:ions%natoms))
1228 do ia = 1, ions%natoms
1232 if (abs(mag(idir, ia)) < tol_min_mag) mag(idir, ia) =
m_zero
1240 safe_allocate(atom_rho(1:gr%np, 1:st%d%spin_channels))
1241 select case (gmd_opt)
1242 case (initrho_paramagnetic)
1243 do ia = ions%atoms_dist%start, ions%atoms_dist%end
1248 if (st%d%spin_channels == 2)
then
1251 rho(ip, 1) =
m_half*(rho(ip, 1) + rho(ip, 2))
1252 rho(ip, 2) = rho(ip, 1)
1257 do ia = ions%atoms_dist%start, ions%atoms_dist%end
1259 rho(1:gr%np, 1:2) = rho(1:gr%np, 1:2) + atom_rho(1:gr%np, 1:2)
1263 do ia = ions%atoms_dist%start, ions%atoms_dist%end
1278 call lalg_axpy(gr%np, (lmag - n1 + n2)/
m_two/n2, atom_rho(:, 2), atom_rho(:, 1))
1287 rho(1:gr%np, 1:2) = rho(1:gr%np, 1:2) + atom_rho(1:gr%np, 1:2)
1289 rho(1:gr%np, 1) = rho(1:gr%np, 1) + atom_rho(1:gr%np, 2)
1290 rho(1:gr%np, 2) = rho(1:gr%np, 2) + atom_rho(1:gr%np, 1)
1292 elseif (ispin ==
spinors)
then
1303 do ia = ions%atoms_dist%start, ions%atoms_dist%end
1311 lmag = norm2(mag(:, ia))
1312 if (lmag > n1 + n2)
then
1313 mag = mag*(n1 + n2)/lmag
1321 atom_rho(ip, 1) =
m_half*(atom_rho(ip, 1) + atom_rho(ip, 2))
1322 rho(ip, 1) = rho(ip, 1) + atom_rho(ip, 1)
1323 rho(ip, 2) = rho(ip, 2) + atom_rho(ip, 1)
1330 if (n1 - n2 < lmag)
then
1331 call lalg_axpy(gr%np, (lmag - n1 + n2)/
m_two/n2, atom_rho(:, 2), atom_rho(:, 1))
1333 elseif (n1 - n2 > lmag)
then
1334 call lalg_axpy(gr%np, (n1 - n2 - lmag)/
m_two/n1, atom_rho(:, 1), atom_rho(:, 2))
1342 if (mag(1, ia) >
m_zero)
then
1349 elseif (ispin ==
spinors)
then
1351 theta =
acos(mag(3, ia)/lmag)
1355 elseif (mag(2, ia) <
m_zero)
then
1357 elseif (mag(2, ia) >
m_zero)
then
1362 arg = mag(1, ia)/
sin(theta)/lmag
1365 if (mag(2, ia) <
m_zero)
then
1377 if (ions%atoms_dist%parallel)
then
1378 do is = 1, st%d%nspin
1379 call lalg_copy(gr%np, rho(:,is), atom_rho(:,1))
1380 call ions%atoms_dist%mpi_grp%allreduce(atom_rho(1, 1), rho(1, is), gr%np, mpi_double_precision, mpi_sum)
1386 write(
message(1),
'(a,f13.6)')
'Info: Unnormalized total charge = ', rr
1391 call lalg_scal(gr%np, st%d%nspin, qtot/rr, rho)
1393 write(
message(1),
'(a,f13.6)')
'Info: Renormalized total charge = ', rr
1398 if (st%symmetrize_density)
then
1399 do is = 1, st%d%nspin
1404 safe_deallocate_a(atom_rho)
1405 safe_deallocate_a(mag)
1411 real(real64) function integrated_charge_density(gr, st, rho) result(rr)
1412 type(
grid_t),
intent(in) :: gr
1414 real(real64),
intent(in) :: rho(:,:)
1419 do is = 1, st%d%spin_channels
1423 call gr%allreduce(rr)
1428 class(mesh_t),
intent(in) :: mesh
1429 real(real64),
intent(inout) :: rho(:,:)
1430 real(real64),
intent(in) :: atom_rho(:,:)
1431 real(real64),
intent(in) :: theta, phi
1439 rho(ip, 1) = rho(ip, 1) +
cos(theta)**2*atom_rho(ip, 1) +
sin(theta)**2*atom_rho(ip, 2)
1440 rho(ip, 2) = rho(ip, 2) +
sin(theta)**2*atom_rho(ip, 1) +
cos(theta)**2*atom_rho(ip, 2)
1441 rho(ip, 3) = rho(ip, 3) +
cos(theta)*
sin(theta)*
cos(phi)*(atom_rho(ip, 1)-atom_rho(ip, 2))
1442 rho(ip, 4) = rho(ip, 4) -
cos(theta)*
sin(theta)*
sin(phi)*(atom_rho(ip, 1)-atom_rho(ip, 2))
1451 type(
lcao_t),
intent(inout) :: this
1452 type(namespace_t),
intent(in) :: namespace
1453 type(states_elec_t),
intent(inout) :: st
1454 type(grid_t),
intent(in) :: gr
1455 type(ions_t),
intent(in) :: ions
1456 integer,
optional,
intent(in) :: start
1462 if (.not. this%alternative)
then
1463 if (states_are_real(st))
then
1469 if (states_are_real(st))
then
1482#include "lcao_inc.F90"
1485#include "complex.F90"
1486#include "lcao_inc.F90"
constant times a vector plus a vector
Copies a vector x, to a vector y.
scales a vector by a constant
Prints out to iunit a message in the form: ["InputVariable" = value] where "InputVariable" is given b...
double acos(double __x) __attribute__((__nothrow__
double sin(double __x) __attribute__((__nothrow__
double cos(double __x) __attribute__((__nothrow__
This module implements batches of mesh functions.
This module contains interfaces for BLACS routines Interfaces are from http:
This module provides the BLACS processor grid.
logical pure function, public blacs_proc_grid_null(this)
Module implementing boundary conditions in Octopus.
type(debug_t), save, public debug
integer, parameter, public unpolarized
Parameters...
integer, parameter, public spinors
integer, parameter, public spin_polarized
real(real64), parameter, public m_two
real(real64), parameter, public m_zero
real(real64), parameter, public m_pi
some mathematical constants
real(real64), parameter, public m_epsilon
real(real64), parameter, public m_half
real(real64), parameter, public m_one
real(real64), parameter, public m_three
This module implements the underlying real-space grid.
subroutine, public dgrid_symmetrize_scalar_field(gr, field, suppress_warning)
This module defines classes and functions for interaction partners.
subroutine, public io_close(iunit, grp)
subroutine, public io_mkdir(fname, namespace, parents)
integer function, public io_open(file, namespace, action, status, form, position, die, recl, grp)
A module to handle KS potential, without the external potential.
integer, parameter, public hartree
integer, parameter, public hartree_fock
integer, parameter, public generalized_kohn_sham_dft
integer, parameter, public kohn_sham_dft
This module contains interfaces for LAPACK routines.
subroutine, public lcao_init_orbitals(this, namespace, st, gr, ions, start)
subroutine, public lcao_wf(this, st, gr, ions, hm, namespace, start)
subroutine zlcao_alt_init_orbitals(this, namespace, st, gr, ions, start)
subroutine zget_ao(this, st, mesh, ions, iorb, ispin, ao, use_psi)
subroutine, public lcao_end(this)
subroutine, public lcao_run(namespace, space, gr, ions, ext_partners, st, ks, hm, st_start, lmm_r)
subroutine zlcao_alt_wf(this, st, gr, ions, hm, namespace, start)
The alternative implementation.
subroutine dlcao_wf(this, st, gr, ions, hm, namespace, start)
subroutine dlcao_alt_init_orbitals(this, namespace, st, gr, ions, start)
subroutine zlcao_wf(this, st, gr, ions, hm, namespace, start)
subroutine dlcao_alt_wf(this, st, gr, ions, hm, namespace, start)
The alternative implementation.
integer, parameter initrho_userdef
integer, parameter initrho_random
subroutine lcao_alt_end_orbital(this, iatom)
This function deallocates a set of an atomic orbitals for an atom. It can be called when the batch is...
subroutine lcao_local_index(this, ig, jg, il, jl, prow, pcol)
integer function, public lcao_num_orbitals(this)
Returns the number of LCAO orbitas.
subroutine lcao_guess_density(this, namespace, st, gr, hm, ions, qtot, ispin, rho)
builds a density which is the sum of the atomic densities
subroutine dinit_orbitals(this, namespace, st, gr, ions, start)
real(real64) function integrated_charge_density(gr, st, rho)
Computes the integral of rho, summed over spin channels.
subroutine dget_ao(this, st, mesh, ions, iorb, ispin, ao, use_psi)
subroutine dlcao_alt_get_orbital(this, sphere, ions, ispin, iatom, norbs)
This function generates the set of an atomic orbitals for an atom and stores it in the batch orbitalb...
subroutine zinit_orbitals(this, namespace, st, gr, ions, start)
subroutine lcao_atom_density(this, st, mesh, ions, iatom, spin_channels, rho)
subroutine, public lcao_init(this, namespace, space, gr, ions, st, st_start)
subroutine accumulate_rotated_density(mesh, rho, atom_rho, theta, phi)
integer, parameter initrho_ferromagnetic
logical function, public lcao_is_available(this)
Returns true if LCAO can be done.
subroutine, public write_magnetic_moments(mesh, st, ions, boundaries, lmm_r, iunit, namespace)
This module is intended to contain "only mathematical" functions and procedures.
This module defines various routines, operating on mesh functions.
This module defines the meshes, which are used in Octopus.
subroutine, public messages_warning(no_lines, all_nodes, namespace)
subroutine, public messages_obsolete_variable(namespace, name, rep)
subroutine, public messages_new_line()
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
subroutine, public messages_input_error(namespace, var, details, row, column)
subroutine, public messages_experimental(name, namespace)
subroutine, public messages_info(no_lines, iunit, debug_only, stress, all_nodes, namespace)
logical function mpi_grp_is_root(grp)
Is the current MPI process of grpcomm, root.
type(mpi_grp_t), public mpi_world
logical function, public parse_is_defined(namespace, name)
integer function, public parse_block(namespace, name, blk, check_varinfo_)
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.
integer(int64), parameter, public splitmix64_321
This module contains interfaces for ScaLAPACK routines Interfaces are from http:
integer, parameter, public smear_semiconductor
integer, parameter, public smear_fixed_occ
subroutine, public species_atom_density(species, namespace, space, latt, pos, mesh, spin_channels, rho)
pure logical function, public states_are_complex(st)
pure logical function, public states_are_real(st)
subroutine, public states_elec_orthogonalize(st, namespace, mesh)
Orthonormalizes nst orbitals in mesh (honours state parallelization).
This module defines routines to write information about states.
subroutine, public states_elec_write_eigenvalues(nst, st, space, kpoints, error, st_start, compact, iunit, namespace)
write the eigenvalues for some states to a file.
subroutine, public states_elec_fermi(st, namespace, mesh, compute_spin)
calculate the Fermi level for the states in this object
subroutine, public states_elec_generate_random(st, mesh, kpoints, ist_start_, ist_end_, ikpt_start_, ikpt_end_, normalized)
randomize states
brief This module defines the class unit_t which is used by the unit_systems_oct_m module.
This module defines the unit system, used for input and output.
type(unit_system_t), public units_out
type(unit_system_t), public units_inp
the units systems for reading and writing
subroutine, public v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval, time, calc_energy, calc_current, force_semilocal)
subroutine, public v_ks_h_setup(namespace, space, gr, ions, ext_partners, st, ks, hm, calc_eigenval, calc_current)
logical pure function, public xc_is_orbital_dependent(xcs)
Is the xc family orbital dependent.
integer, parameter, public sic_pz_oep
Perdew-Zunger SIC (OEP way)
Extension of space that contains the knowledge of the spin dimension.
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.