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)
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
157 integer :: ia, n, iorb, jj, maxj, idim
158 integer :: ii, ll, mm, norbs, ii_tmp
159 integer :: mode_default
160 real(real64) :: max_orb_radius, maxradius
165 this%initialized = .
true.
169 mode_default = option__lcaostart__lcao_states
170 if (ions%only_user_def) mode_default = option__lcaostart__lcao_none
223 this%alternative = this%mode == option__lcaostart__lcao_states_batch
225 if (this%mode == option__lcaostart__lcao_none)
then
235 if (st%d%ispin ==
spinors .and. this%alternative)
then
236 message(1) =
"LCAOStart = lcao_states_batch is not working for spinors."
239 if (space%is_periodic() .and. this%alternative)
then
257 call parse_variable(namespace,
'LCAOComplexYlms', .false., this%complex_ylms)
259 this%complex_ylms = .false.
270 call parse_variable(namespace,
'LCAOSaveMemory', .false., this%save_memory)
274 call io_mkdir(
'debug/lcao', namespace)
275 iunit_o =
io_open(
'debug/lcao/orbitals', namespace, action=
'write')
276 write(iunit_o,
'(7a6)')
'iorb',
'atom',
'level',
'i',
'l',
'm',
'spin'
279 if (.not. this%alternative)
then
300 call parse_variable(namespace,
'LCAOMaximumOrbitalRadius', 20.0_real64, max_orb_radius, unit =
units_inp%length)
306 do ia = 1, ions%natoms
307 maxj = max(maxj, ions%atom(ia)%species%get_niwfs())
308 this%maxorbs = this%maxorbs + ions%atom(ia)%species%get_niwfs()
311 this%maxorbs = this%maxorbs*st%d%dim
313 if (this%maxorbs == 0)
then
314 call messages_write(
'The are no atomic orbitals available, cannot do LCAO.')
316 this%mode = option__lcaostart__lcao_none
323 safe_allocate( this%atom(1:this%maxorbs))
324 safe_allocate(this%level(1:this%maxorbs))
325 safe_allocate( this%ddim(1:this%maxorbs))
327 safe_allocate(this%is_empty(1:this%maxorbs))
328 this%is_empty = .false.
331 this%lapdist = maxval(abs(gr%idx%enlarge)*gr%spacing)
334 safe_allocate(this%radius(1:ions%natoms))
336 do ia = 1, ions%natoms
337 norbs = ions%atom(ia)%species%get_niwfs()
341 call ions%atom(ia)%species%get_iwf_ilm(iorb, 1, ii, ll, mm)
343 if(ions%atom(ia)%species%is_full())
call ions%atom(ia)%species%get_iwf_n( iorb, 1, ii)
344 maxradius = max(maxradius, ions%atom(ia)%species%get_iwf_radius( ii, is = 1))
347 maxradius = min(maxradius,
m_two*maxval(gr%box%bounding_box_l(1:space%dim)))
349 this%radius(ia) = maxradius
381 do ia = 1, ions%natoms
383 if (jj > ions%atom(ia)%species%get_niwfs()) cycle
384 call ions%atom(ia)%species%get_iwf_ilm(jj, idim, ii, ll, mm)
386 if(ions%atom(ia)%species%is_full())
then
388 call ions%atom(ia)%species%get_iwf_n( ii_tmp, 1, ii)
390 if (this%orbital_scale_factor*ions%atom(ia)%species%get_iwf_radius( ii, is = 1) >= max_orb_radius) cycle
393 this%level(iorb) = jj
394 this%ddim(iorb) = idim
397 write(iunit_o,
'(7i6)') iorb, this%atom(iorb), this%level(iorb), ii, ll, mm, this%ddim(iorb)
410 if (this%maxorbs /= iorb - 1)
then
415 call messages_write(
' orbitals cannot be used for the LCAO calculation,')
417 call messages_write(
' their radii exceeds LCAOMaximumOrbitalRadius (')
422 this%maxorbs = iorb - 1
425 if (this%maxorbs < st%nst)
then
426 call messages_write(
'Cannot do LCAO for all states because there are not enough atomic orbitals.')
466 if (n > 0 .and. n <= st%nst .and. st%nst <= this%maxorbs)
then
469 else if (n > st%nst .and. n <= this%maxorbs)
then
472 else if (n == 0)
then
474 this%norbs = min(this%maxorbs, 2*st%nst)
477 this%norbs = this%maxorbs
480 assert(this%norbs <= this%maxorbs)
482 safe_allocate(this%cst(1:this%norbs, 1:st%d%spin_channels))
483 safe_allocate(this%ck(1:this%norbs, 1:st%d%spin_channels))
484 this%initialized_orbitals = .false.
494 integer :: iatom, iorb, norbs
495 real(real64) :: maxradius
498 integer :: jatom, jorb, jbasis, ilbasis, jlbasis, proc(1:2),
info, nbl
502 call messages_write(
'Info: Using LCAO alternative implementation.')
539 call parse_variable(namespace,
'LCAOExtraOrbitals', .false., this%derivative)
546 if (this%derivative)
then
549 if (st%nst * st%smear%el_per_state > st%qtot)
then
550 message(1) =
"Lower-lying empty states may be missed with LCAOExtraOrbitals."
563 call parse_variable(namespace,
'LCAODiagTol', 1e-10_real64, this%diag_tol)
565 if (this%derivative)
then
571 safe_allocate(this%sphere(1:ions%natoms))
572 safe_allocate(this%orbitals(1:ions%natoms))
573 safe_allocate(this%is_orbital_initialized(1:ions%natoms))
574 this%is_orbital_initialized = .false.
576 safe_allocate(this%norb_atom(1:ions%natoms))
580 do iatom = 1, ions%natoms
581 this%norb_atom(iatom) = this%mult*ions%atom(iatom)%species%get_niwfs()
582 this%maxorb = max(this%maxorb, ions%atom(iatom)%species%get_niwfs())
583 this%norbs = this%norbs + ions%atom(iatom)%species%get_niwfs()
586 this%maxorb = this%maxorb*this%mult
587 this%norbs = this%norbs*this%mult
589 safe_allocate(this%basis_atom(1:this%norbs))
590 safe_allocate(this%basis_orb(1:this%norbs))
591 safe_allocate(this%atom_orb_basis(1:ions%natoms, 1:this%maxorb))
596 do iatom = 1, ions%natoms
597 norbs = ions%atom(iatom)%species%get_niwfs()
599 do iorb = 1, this%mult*norbs
601 this%atom_orb_basis(iatom, iorb) = ibasis
602 this%basis_atom(ibasis) = iatom
603 this%basis_orb(ibasis) = iorb
607 call ions%atom(iatom)%species%get_iwf_ilm(iorb, 1, ii, ll, mm)
608 write(iunit_o,
'(7i6)') ibasis, iatom, iorb, ii, ll, mm, 1
618 this%lapdist = maxval(abs(gr%idx%enlarge)*gr%spacing)
621 safe_allocate(this%radius(1:ions%natoms))
623 do iatom = 1, ions%natoms
624 norbs = ions%atom(iatom)%species%get_niwfs()
628 call ions%atom(iatom)%species%get_iwf_ilm(iorb, 1, ii, ll, mm)
630 if(ions%atom(iatom)%species%is_full())
call ions%atom(iatom)%species%get_iwf_n( iorb, 1, ii)
631 maxradius = max(maxradius, ions%atom(iatom)%species%get_iwf_radius( ii, is = 1))
634 if (this%derivative) maxradius = maxradius + this%lapdist
636 maxradius = min(maxradius,
m_two*maxval(gr%box%bounding_box_l(1:space%dim)))
638 this%radius(iatom) = maxradius
641 safe_allocate(this%calc_atom(1:ions%natoms))
642 this%calc_atom = .
true.
645#ifndef HAVE_SCALAPACK
646 this%parallel = .false.
648 this%parallel = (st%parallel_in_states .or. gr%parallel_in_domains) &
651 if (this%parallel)
then
652 nbl = min(16, this%norbs)
655 this%lsize(1) = max(1,
numroc(this%norbs, nbl, st%dom_st_proc_grid%myrow, 0, st%dom_st_proc_grid%nprow))
656 this%lsize(2) = max(1,
numroc(this%norbs, nbl, st%dom_st_proc_grid%mycol, 0, st%dom_st_proc_grid%npcol))
658 this%nproc(1) = st%dom_st_proc_grid%nprow
659 this%nproc(2) = st%dom_st_proc_grid%npcol
660 this%myroc(1) = st%dom_st_proc_grid%myrow
661 this%myroc(2) = st%dom_st_proc_grid%mycol
663 call descinit(this%desc(1), this%norbs, this%norbs, nbl, nbl, 0, 0, &
664 st%dom_st_proc_grid%context, this%lsize(1),
info)
667 write(
message(1),
'(a,i6)')
'descinit for BLACS failed with error code ',
info
671 this%calc_atom = .false.
672 do iatom = 1, ions%natoms
673 ibasis = this%atom_orb_basis(iatom, 1)
675 do jatom = 1, ions%natoms
676 jbasis = this%atom_orb_basis(jatom, 1)
678 do iorb = 1, this%norb_atom(iatom)
679 do jorb = 1, this%norb_atom(jatom)
681 ilbasis, jlbasis, proc(1), proc(2))
683 this%calc_atom(this%basis_atom(jbasis)) = &
684 this%calc_atom(this%basis_atom(jbasis)) .or. proc(2) == this%myroc(2)
702 subroutine lcao_run(namespace, space, gr, ions, ext_partners, st, ks, hm, st_start, lmm_r)
705 type(
grid_t),
intent(in) :: gr
706 type(
ions_t),
intent(in) :: ions
709 type(
v_ks_t),
intent(inout) :: ks
711 integer,
optional,
intent(in) :: st_start
712 real(real64),
optional,
intent(in) :: lmm_r
715 integer :: st_start_random, required_min_nst
717 logical :: is_orbital_dependent
721 if (
present(st_start))
then
724 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
725 calc_eigenval=.not.
present(st_start), calc_current=.false.)
727 assert(st_start >= 1)
728 if (st_start > st%nst)
then
736 call lcao_init(lcao, namespace, space, gr, ions, st)
744 .or. (ks%theory_level ==
kohn_sham_dft .and. xc_is_orbital_dependent(ks%xc)) &
748 if (.not.
present(st_start))
then
749 call lcao_guess_density(lcao, namespace, st, gr, hm, ions, st%qtot, st%d%ispin, st%d%spin_channels, st%rho)
752 assert(
present(lmm_r))
758 message(1) =
'Info: Setting up Hamiltonian.'
762 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.false., &
763 calc_current=.false., calc_energy=.false., force_semilocal=is_orbital_dependent)
766 st%eigenval = 1e10_real64
775 if (
present(st_start))
then
776 write(
message(1),
'(a,i8,a)')
'Performing LCAO for states ', st_start,
' and above'
780 call lcao_wf(lcao, st, gr, ions, hm, namespace, start = st_start)
786 select case (st%d%ispin)
788 required_min_nst = int(st%qtot/2)
790 required_min_nst = int(st%qtot/2)
792 required_min_nst = int(st%qtot)
795 if (lcao%norbs <= required_min_nst .and. lcao%norbs < st%nst)
then
796 st%eigenval(lcao%norbs+1:,:) =
m_zero
800 if (.not.
present(st_start))
then
805 if (lcao%mode == option__lcaostart__lcao_full)
then
806 call v_ks_h_setup(namespace, space, gr, ions, ext_partners, st, ks, hm, &
807 calc_eigenval = .false., calc_current=.false.)
809 assert(
present(lmm_r))
816 if (.not. lcao_done .or. lcao%norbs < st%nst)
then
819 st_start_random = lcao%norbs + 1
823 if (
present(st_start)) st_start_random = max(st_start, st_start_random)
825 if (st_start_random > 1)
then
826 write(
message(1),
'(a,i8,a)')
'Generating random wavefunctions for states ', st_start_random,
' and above'
837 if (.not. lcao_done)
then
840 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
841 calc_eigenval=.not.
present(st_start), calc_current=.false.)
842 if (.not.
present(st_start))
then
848 else if (
present(st_start))
then
850 if (st_start > 1)
then
867 type(
lcao_t),
intent(inout) :: this
871 safe_deallocate_a(this%calc_atom)
872 safe_deallocate_a(this%norb_atom)
873 safe_deallocate_a(this%basis_atom)
874 safe_deallocate_a(this%basis_orb)
875 safe_deallocate_a(this%atom_orb_basis)
876 safe_deallocate_a(this%radius)
877 safe_deallocate_a(this%sphere)
878 safe_deallocate_a(this%orbitals)
880 safe_deallocate_a(this%atom)
881 safe_deallocate_a(this%level)
882 safe_deallocate_a(this%ddim)
883 safe_deallocate_a(this%cst)
884 safe_deallocate_a(this%ck)
885 safe_deallocate_a(this%dbuff_single)
886 safe_deallocate_a(this%zbuff_single)
887 safe_deallocate_a(this%dbuff)
888 safe_deallocate_a(this%zbuff)
890 this%initialized = .false.
896 subroutine lcao_wf(this, st, gr, ions, hm, namespace, start)
897 type(
lcao_t),
intent(inout) :: this
899 type(
grid_t),
intent(in) :: gr
900 type(
ions_t),
intent(in) :: ions
903 integer,
optional,
intent(in) :: start
907 assert(this%initialized)
913 if (
present(start)) start_ = start
915 if (this%alternative)
then
917 call dlcao_alt_wf(this, st, gr, ions, hm, namespace, start_)
919 call zlcao_alt_wf(this, st, gr, ions, hm, namespace, start_)
923 call dlcao_wf(this, st, gr, ions, hm, namespace, start_)
925 call zlcao_wf(this, st, gr, ions, hm, namespace, start_)
935 type(
lcao_t),
intent(in) :: this
939 available = this%initialized .and. this%mode /= option__lcaostart__lcao_none
947 type(
lcao_t),
intent(in) :: this
958 type(
lcao_t),
intent(in) :: this
959 integer,
intent(in) :: ig
960 integer,
intent(in) :: jg
961 integer,
intent(out) :: il
962 integer,
intent(out) :: jl
963 integer,
intent(out) :: prow
964 integer,
intent(out) :: pcol
968 call infog2l(ig, jg, this%desc(1), this%nproc(1), this%nproc(2), this%myroc(1), this%myroc(2), &
985 type(
lcao_t),
intent(inout) :: this
986 integer,
intent(in) :: iatom
990 if (this%is_orbital_initialized(iatom))
then
991 call this%orbitals(iatom)%end()
992 this%is_orbital_initialized(iatom) = .false.
1002 type(
lcao_t),
intent(inout) :: this
1004 class(
mesh_t),
intent(in) :: mesh
1005 type(
ions_t),
target,
intent(in) :: ions
1006 integer,
intent(in) :: iatom
1007 integer,
intent(in) :: spin_channels
1008 real(real64),
intent(inout) :: rho(:, :)
1010 real(real64),
allocatable :: dorbital(:, :)
1011 complex(real64),
allocatable :: zorbital(:, :)
1012 real(real64),
allocatable :: factors(:)
1013 real(real64) :: factor, aa
1014 integer :: iorb, ip, ii, ll, mm, ispin
1015 type(
ps_t),
pointer :: ps
1016 logical :: use_stored_orbitals
1022 use_stored_orbitals = ions%atom(iatom)%species%is_ps() &
1024 .and. st%d%dim == 1 .and. .not. ions%space%is_periodic()
1028 if (use_stored_orbitals)
then
1030 assert(.not. ions%space%is_periodic())
1032 select type(spec=>ions%atom(iatom)%species)
1039 if (.not. this%alternative)
then
1042 safe_allocate(dorbital(1:mesh%np, 1:st%d%dim))
1044 safe_allocate(zorbital(1:mesh%np, 1:st%d%dim))
1047 do iorb = 1, this%norbs
1048 if (iatom /= this%atom(iorb)) cycle
1050 call ions%atom(iatom)%species%get_iwf_ilm(this%level(iorb), 1, ii, ll, mm)
1051 factor = ps%conf%occ(ii, 1)/(
m_two*ll +
m_one)
1054 call dget_ao(this, st, mesh, ions, iorb, 1, dorbital, use_psi = .
true.)
1057 rho(ip, 1) = rho(ip, 1) + factor*dorbital(ip, 1)**2
1060 call zget_ao(this, st, mesh, ions, iorb, 1, zorbital, use_psi = .
true.)
1063 rho(ip, 1) = rho(ip, 1) + factor*abs(zorbital(ip, 1))**2
1069 safe_deallocate_a(dorbital)
1070 safe_deallocate_a(zorbital)
1078 safe_allocate(factors(1:this%norb_atom(iatom)/this%mult))
1080 do iorb = 1, this%norb_atom(iatom)/this%mult
1081 call ions%atom(iatom)%species%get_iwf_ilm(iorb, 1, ii, ll, mm)
1082 factors(iorb) = ps%conf%occ(ii, 1)/(
m_two*ll +
m_one)
1086 do ip = 1, this%sphere(iatom)%np
1088 do iorb = 1, this%norb_atom(iatom)/this%mult
1089 aa = aa + factors(iorb)*this%orbitals(iatom)%dff_linear(ip, iorb)**2
1091 rho(this%sphere(iatom)%map(ip), 1) = rho(this%sphere(iatom)%map(ip), 1) + aa
1094 safe_deallocate_a(factors)
1100 ions%pos(:, iatom), mesh, spin_channels, rho)
1105 do ispin = 1, spin_channels
1108 rho(ip, ispin) = max(rho(ip, ispin),
m_zero)
1117 subroutine lcao_guess_density(this, namespace, st, gr, hm, ions, qtot, ispin, spin_channels, rho)
1118 type(
lcao_t),
intent(inout) :: this
1121 type(
grid_t),
intent(in) :: gr
1123 type(
ions_t),
intent(in) :: ions
1124 real(real64),
intent(in) :: qtot
1125 integer,
intent(in) :: ispin, spin_channels
1126 real(real64),
contiguous,
intent(out) :: rho(:, :)
1128 integer :: ia, is, idir, gmd_opt, ip
1131 real(real64) :: rr, rnd, phi, theta, mag(1:3), lmag, n1, n2,arg
1132 real(real64),
allocatable :: atom_rho(:,:)
1133 logical :: parallelized_in_atoms
1137 parallelized_in_atoms = .false.
1139 if (spin_channels == 1)
then
1140 gmd_opt = initrho_paramagnetic
1173 message(1) =
"GuessMagnetDensity cannot be used for Hartree-Fock and generalized Kohn-Sham calculation."
1174 message(2) =
"Please perform a LDA or GGA calculation first and restart from this calculation."
1179 select case (gmd_opt)
1180 case (initrho_paramagnetic)
1181 safe_allocate(atom_rho(1:gr%np, 1:spin_channels))
1183 parallelized_in_atoms = .
true.
1185 do ia = ions%atoms_dist%start, ions%atoms_dist%end
1190 if (spin_channels == 2)
then
1193 rho(ip, 1) =
m_half*(rho(ip, 1) + rho(ip, 2))
1194 rho(ip, 2) = rho(ip, 1)
1199 safe_allocate(atom_rho(1:gr%np, 1:2))
1201 parallelized_in_atoms = .
true.
1204 do ia = ions%atoms_dist%start, ions%atoms_dist%end
1206 rho(1:gr%np, 1:2) = rho(1:gr%np, 1:2) + atom_rho(1:gr%np, 1:2)
1210 safe_allocate(atom_rho(1:gr%np, 1:2))
1211 do ia = 1, ions%natoms
1226 call lalg_axpy(gr%np, (lmag - n1 + n2)/
m_two/n2, atom_rho(:, 2), atom_rho(:, 1))
1235 rho(1:gr%np, 1:2) = rho(1:gr%np, 1:2) + atom_rho(1:gr%np, 1:2)
1237 rho(1:gr%np, 1) = rho(1:gr%np, 1) + atom_rho(1:gr%np, 2)
1238 rho(1:gr%np, 2) = rho(1:gr%np, 2) + atom_rho(1:gr%np, 1)
1240 elseif (ispin ==
spinors)
then
1271 if (
parse_block(namespace,
'AtomsMagnetDirection', blk) < 0)
then
1272 message(1) =
"AtomsMagnetDirection block is not defined."
1277 message(1) =
"AtomsMagnetDirection block has the wrong number of rows."
1281 safe_allocate(atom_rho(1:gr%np, 1:2))
1282 do ia = 1, ions%natoms
1288 elseif (ispin ==
spinors)
then
1291 if (abs(mag(idir)) < 1.0e-20_real64) mag(idir) =
m_zero
1293 lmag = norm2(mag(1:3))
1303 if (lmag > n1 + n2)
then
1304 mag = mag*(n1 + n2)/lmag
1312 atom_rho(ip, 1) =
m_half*(atom_rho(ip, 1) + atom_rho(ip, 2))
1313 rho(ip, 1) = rho(ip, 1) + atom_rho(ip, 1)
1314 rho(ip, 2) = rho(ip, 2) + atom_rho(ip, 1)
1321 if (n1 - n2 < lmag)
then
1322 call lalg_axpy(gr%np, (lmag - n1 + n2)/
m_two/n2, atom_rho(:, 2), atom_rho(:, 1))
1324 elseif (n1 - n2 > lmag)
then
1325 call lalg_axpy(gr%np, (n1 - n2 - lmag)/
m_two/n1, atom_rho(:, 1), atom_rho(:, 2))
1333 if (mag(1) >
m_zero)
then
1340 elseif (ispin ==
spinors)
then
1342 theta =
acos(mag(3)/lmag)
1346 elseif (mag(2) <
m_zero)
then
1348 elseif (mag(2) >
m_zero)
then
1353 arg = mag(1)/
sin(theta)/lmag
1356 if (mag(2) <
m_zero)
then
1370 if (ions%atoms_dist%parallel .and. parallelized_in_atoms)
then
1372 do is = 1, spin_channels
1373 call lalg_copy(gr%np, rho(:,is), atom_rho(:,1))
1374 call ions%atoms_dist%mpi_grp%allreduce(atom_rho(1, 1), rho(1, is), gr%np, mpi_double_precision, mpi_sum)
1380 do is = 1, spin_channels
1383 if (gr%parallel_in_domains)
then
1384 call gr%allreduce(rr)
1387 write(
message(1),
'(a,f13.6)')
'Info: Unnormalized total charge = ', rr
1395 do is = 1, spin_channels
1398 if (gr%parallel_in_domains)
then
1399 call gr%allreduce(rr)
1402 write(
message(1),
'(a,f13.6)')
'Info: Renormalized total charge = ', rr
1405 if (st%symmetrize_density)
then
1406 do is = 1, st%d%nspin
1411 safe_deallocate_a(atom_rho)
1417 class(
mesh_t),
intent(in) :: mesh
1418 real(real64),
intent(inout) :: rho(:,:)
1419 real(real64),
intent(in) :: atom_rho(:,:)
1420 real(real64),
intent(in) :: theta, phi
1428 rho(ip, 1) = rho(ip, 1) +
cos(theta)**2*atom_rho(ip, 1) +
sin(theta)**2*atom_rho(ip, 2)
1429 rho(ip, 2) = rho(ip, 2) +
sin(theta)**2*atom_rho(ip, 1) +
cos(theta)**2*atom_rho(ip, 2)
1430 rho(ip, 3) = rho(ip, 3) +
cos(theta)*
sin(theta)*
cos(phi)*(atom_rho(ip, 1)-atom_rho(ip, 2))
1431 rho(ip, 4) = rho(ip, 4) -
cos(theta)*
sin(theta)*
sin(phi)*(atom_rho(ip, 1)-atom_rho(ip, 2))
1440 type(
lcao_t),
intent(inout) :: this
1443 type(
grid_t),
intent(in) :: gr
1444 type(
ions_t),
intent(in) :: ions
1445 integer,
optional,
intent(in) :: start
1451 if (.not. this%alternative)
then
1471#include "lcao_inc.F90"
1474#include "complex.F90"
1475#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, public lcao_init(this, namespace, space, gr, ions, st)
subroutine zlcao_wf(this, st, gr, ions, hm, namespace, start)
subroutine dlcao_alt_wf(this, st, gr, ions, hm, namespace, start)
The alternative implementation.
subroutine lcao_guess_density(this, namespace, st, gr, hm, ions, qtot, ispin, spin_channels, rho)
builds a density which is the sum of the atomic densities
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)
subroutine dinit_orbitals(this, namespace, st, gr, ions, start)
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 accumulate_rotated_density(mesh, rho, atom_rho, theta, phi)
integer, parameter initrho_ferromagnetic
logical function, public lcao_is_available(this)
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.
real(real64) function, public dmf_integrate(mesh, ff, mask, reduce)
Integrate a function on the mesh.
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)
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.