48 use,
intrinsic :: iso_fortran_env
97 integer,
parameter :: &
98 CASIDA_EPS_DIFF = 1, &
104 integer,
parameter :: &
114 logical :: states_are_real
115 integer,
allocatable :: n_occ(:)
116 integer,
allocatable :: n_unocc(:)
120 integer :: el_per_state
121 character(len=80) :: trandens
122 character(len=80) :: print_exst
123 real(real64) :: weight_thresh
125 logical :: calc_forces
126 logical :: calc_forces_kernel
127 logical :: calc_forces_scf
129 type(restart_t) :: restart_load
130 type(restart_t) :: restart_dump
132 logical,
allocatable :: is_included(:,:,:)
134 type(states_pair_t),
allocatable :: pair(:)
135 integer,
allocatable :: index(:,:,:)
136 integer,
allocatable :: ind(:)
138 real(real64),
allocatable :: dmat(:,:)
139 real(real64),
allocatable :: dmat_save(:,:)
140 complex(real64),
allocatable :: zmat(:,:)
141 complex(real64),
allocatable :: zmat_save(:,:)
142 real(real64),
allocatable :: w(:)
143 real(real64),
allocatable :: dtm(:, :)
144 complex(real64),
allocatable :: ztm(:, :)
145 real(real64),
allocatable :: f(:)
146 real(real64),
allocatable :: s(:)
148 real(real64),
allocatable :: rho(:,:)
149 real(real64),
allocatable :: fxc(:,:,:)
150 real(real64) :: kernel_lrc_alpha
152 real(real64),
allocatable :: fxc_grad(:,:,:,:,:)
153 real(real64),
allocatable :: fxc_grad_spin(:,:,:,:)
155 real(real64),
allocatable :: dmat2(:,:)
156 complex(real64),
allocatable :: zmat2(:,:)
157 real(real64),
allocatable :: dlr_hmat2(:,:)
158 complex(real64),
allocatable :: zlr_hmat2(:,:)
159 real(real64),
allocatable :: forces(:,:,:)
160 real(real64),
allocatable :: dw2(:)
161 real(real64),
allocatable :: zw2(:)
165 real(real64),
allocatable :: qvector(:)
166 real(real64),
allocatable :: qf(:)
167 real(real64),
allocatable :: qf_avg(:)
170 logical :: parallel_in_eh_pairs
171 logical :: parallel_in_domains
172 logical :: distributed_matrix
173 logical :: write_matrix
174 integer :: parallel_solver
175 type(mpi_grp_t) :: mpi_grp
176 logical :: fromScratch
177 logical :: has_photons
179 type(photon_mode_t),
pointer :: photon_modes => null()
181 integer :: n, nb_rows, nb_cols, block_size
182 type(blacs_proc_grid_t) :: proc_grid
183 integer :: desc(BLACS_DLEN)
184 type(MPI_Datatype) :: darray
192 real(real64),
allocatable :: dpot(:)
193 complex(real64),
allocatable :: zpot(:)
228 class(*),
intent(inout) :: system
229 logical,
intent(in) :: from_scratch
235 message(1) =
"CalculationMode = casida not implemented for multi-system calculations"
247 logical,
intent(in) :: fromscratch
251 integer :: idir, theorylevel, iatom, ierr, default_int
252 character(len=100) :: restart_filename
253 logical :: is_frac_occ
259 if (sys%hm%pcm%run_pcm)
then
263 if (sys%space%is_periodic())
then
264 message(1) =
"Casida oscillator strengths will be incorrect in periodic systems."
285 message(1) =
'Info: Starting Casida linear-response calculation.'
293 message(1) =
"Previous gs calculation is required."
297 cas%el_per_state = sys%st%smear%el_per_state
300 cas%space_dim = sys%space%dim
301 safe_allocate(cas%n_occ(1:sys%st%nik))
302 safe_allocate(cas%n_unocc(1:sys%st%nik))
304 call states_elec_count_pairs(sys%st, sys%namespace, cas%n_pairs, cas%n_occ, cas%n_unocc, cas%is_included, is_frac_occ)
305 if (is_frac_occ)
then
310 select case (sys%st%d%ispin)
312 write(
message(1),
'(a,i4,a)')
"Info: Found", cas%n_occ(1),
" occupied states."
313 write(
message(2),
'(a,i4,a)')
"Info: Found", cas%n_unocc(1),
" unoccupied states."
316 write(
message(1),
'(a,i4,a)')
"Info: Found", cas%n_occ(1),
" occupied states with spin up."
317 write(
message(2),
'(a,i4,a)')
"Info: Found", cas%n_unocc(1),
" unoccupied states with spin up."
318 write(
message(3),
'(a,i4,a)')
"Info: Found", cas%n_occ(2),
" occupied states with spin down."
319 write(
message(4),
'(a,i4,a)')
"Info: Found", cas%n_unocc(2),
" unoccupied states with spin down."
325 message(1) =
'Info: Setting up Hamiltonian.'
327 call v_ks_h_setup(sys%namespace, sys%space, sys%gr, sys%ions, sys%ext_partners, sys%st, sys%ks, &
328 sys%hm, calc_eigenval=.false.)
369 message(1) =
"Variational and full Casida theory levels do not apply to complex wavefunctions."
376 call parse_variable(sys%namespace,
'EnablePhotons', .false., cas%has_photons)
378 if (cas%has_photons)
then
380 cas%photon_modes => sys%photons%modes
382 write(
message(1),
'(a,i7,a)')
'INFO: Solving Casida equation with ', &
383 cas%photon_modes%nmodes,
' photon modes.'
384 write(
message(2),
'(a)')
'as described in ACS Photonics 2019, 6, 11, 2757-2778.'
386 cas%pt_nmodes = cas%photon_modes%nmodes
401 call parse_variable(sys%namespace,
'CasidaTransitionDensities',
"0", cas%trandens)
403 if (cas%trandens /=
"0")
then
405 sys%outp%how, sys%outp%output_interval)
418 safe_allocate(cas%qvector(1:cas%space_dim))
419 if (
parse_block(sys%namespace,
'CasidaMomentumTransfer', blk) == 0)
then
420 do idir = 1, cas%space_dim
425 message(1) =
"Info: Calculating IXS/EELS transition rates."
441 call parse_variable(sys%namespace,
'CasidaQuadratureOrder', 5, cas%avg_order)
457 call parse_variable(sys%namespace,
'CasidaCalcTriplet', .false., cas%triplet)
459 cas%triplet = .false.
462 if (cas%triplet)
then
463 message(1) =
"Info: Using triplet kernel. Oscillator strengths will be for spin magnetic-dipole field."
476 call parse_variable(sys%namespace,
'CasidaHermitianConjugate', .false., cas%herm_conj)
491 call parse_variable(sys%namespace,
'CasidaDistributedMatrix', .false., cas%distributed_matrix)
492#ifndef HAVE_SCALAPACK
493 if (cas%distributed_matrix)
then
494 message(1) =
"ScaLAPACK layout requested, but code not compiled with ScaLAPACK"
508 call parse_variable(sys%namespace,
'CasidaWriteDistributedMatrix', .false., cas%write_matrix)
509 if (.not. cas%distributed_matrix .and. cas%write_matrix)
then
510 message(1) =
"CasidaWriteDistributedMatrix con only be used with CasidaDistributedMatrix"
528 default_int = solver_elpa
532 call parse_variable(sys%namespace,
'CasidaParallelEigensolver', default_int, cas%parallel_solver)
537 if (cas%distributed_matrix .and. cas%parallel_solver == solver_elpa)
then
538 message(1) =
"ELPA solver requested, but code not compiled with ELPA"
553 call parse_variable(sys%namespace,
'CasidaPrintExcitations',
"all", cas%print_exst)
554 if (cas%distributed_matrix)
then
556 cas%print_exst =
"none"
557 message(1) =
"Using ScaLAPACK layout, thus disabling output of excited states."
558 message(2) =
"This options creates too many files for large Casida matrices."
574 if (cas%weight_thresh >
m_one)
then
575 message(1) =
'Casida coefficients have values between 0 and 1'
576 message(2) =
'Threshold values reset to default value'
578 cas%weight_thresh = -
m_one
588 call parse_variable(sys%namespace,
'CasidaCalcForces', .false., cas%calc_forces)
589 if (cas%calc_forces)
then
599 call parse_variable(sys%namespace,
'CasidaCalcForcesKernel', .
true., cas%calc_forces_kernel)
609 call parse_variable(sys%namespace,
'CasidaCalcForcesSCF', .false., cas%calc_forces_scf)
611 if (cas%distributed_matrix)
then
612 message(1) =
"Info: Forces calculation not compatible with ScaLAPACK layout."
613 message(2) =
"Using normal layout."
615 cas%distributed_matrix = .false.
622 cas%fromScratch = fromscratch
624 if (cas%fromScratch)
then
625 if (cas%triplet)
then
626 call restart_rm(cas%restart_dump,
'kernel_triplet')
631 if (cas%calc_forces)
then
632 do iatom = 1, sys%ions%natoms
633 do idir = 1, cas%space_dim
634 write(restart_filename,
'(a,i6.6,a,i1)')
'lr_kernel_', iatom,
'_', idir
635 if (cas%triplet) restart_filename = trim(restart_filename)//
'_triplet'
636 call restart_rm(cas%restart_dump, restart_filename)
638 write(restart_filename,
'(a,i6.6,a,i1)')
'lr_hmat1_', iatom,
'_', idir
639 call restart_rm(cas%restart_dump, restart_filename)
646 if (
bitand(theorylevel, casida_eps_diff) /= 0)
then
647 message(1) =
"Info: Approximating resonance energies through KS eigenvalue differences"
649 cas%type = casida_eps_diff
653 if (sys%st%d%ispin /=
spinors)
then
657 message(1) =
"Info: Calculating matrix elements in the Tamm-Dancoff approximation"
665 message(1) =
"Info: Calculating matrix elements with the CV(2)-DFT theory"
672 message(1) =
"Info: Calculating matrix elements with the full Casida method"
681 message(1) =
"Info: Calculating resonance energies via the Petersilka approximation"
698 type(
casida_t),
intent(inout) :: cas
701 integer :: ist, ast, jpair, ik, ierr
703 integer :: np, np_rows, np_cols, ii, info
708 cas%kernel_lrc_alpha = sys%ks%xc%kernel_lrc_alpha
710 if (cas%distributed_matrix .and. .not. cas%states_are_real)
then
714 write(
message(1),
'(a,i9)')
"Number of occupied-unoccupied pairs: ", cas%n_pairs
717 if (cas%n_pairs < 1)
then
718 message(1) =
"No Casida pairs -- maybe there are no unoccupied states?"
726 if (cas%parallel_in_eh_pairs)
then
733 if (cas%distributed_matrix .and. .not. cas%parallel_in_eh_pairs)
then
734 message(1) =
"ScaLAPACK layout requested, but 'Other' parallelization strategy not available."
735 message(2) =
"Please set ParOther to use the ScaLAPACK layout."
736 message(3) =
"Continuing without ScaLAPACK layout."
738 cas%distributed_matrix = .false.
742 cas%n = cas%n_pairs + cas%pt_nmodes
745 if (cas%distributed_matrix)
then
749 np = cas%mpi_grp%size
753 if (mod(np, ii) == 0)
then
759 np_rows = np / np_cols
763 cas%block_size = min(64, cas%n / np_rows)
765 cas%block_size = max(5, cas%block_size)
766 write(
message(1),
'(A,I5,A,I5,A,I5,A)')
'Parallel layout: using block size of ',&
767 cas%block_size,
' and a processor grid with ', np_rows,
'x', np_cols, &
768 ' processors (rows x cols)'
774 cas%nb_rows = numroc(cas%n, cas%block_size, cas%proc_grid%myrow, 0, cas%proc_grid%nprow)
775 cas%nb_cols = numroc(cas%n, cas%block_size, cas%proc_grid%mycol, 0, cas%proc_grid%npcol)
778 call descinit(cas%desc(1), cas%n, cas%n, cas%block_size, cas%block_size, 0, 0, &
779 cas%proc_grid%context, cas%nb_rows, info)
789 safe_allocate(cas%pair(1:cas%n))
790 if (cas%states_are_real)
then
791 safe_allocate( cas%dmat(1:cas%nb_rows, 1:cas%nb_cols))
792 safe_allocate( cas%dtm(1:cas%n, 1:cas%space_dim))
795 safe_allocate( cas%zmat(1:cas%nb_rows, 1:cas%nb_cols))
796 safe_allocate( cas%ztm(1:cas%n, 1:cas%space_dim))
798 safe_allocate( cas%f(1:cas%n))
799 safe_allocate( cas%s(1:cas%n_pairs))
800 safe_allocate( cas%w(1:cas%n))
801 safe_allocate( cas%index(1:maxval(cas%n_occ), cas%nst - maxval(cas%n_unocc) + 1:cas%nst, 1:cas%nik))
802 safe_allocate( cas%ind(1:cas%n))
804 if (cas%calc_forces)
then
805 if (cas%states_are_real)
then
806 safe_allocate(cas%dmat_save(1:cas%n_pairs, 1:cas%n_pairs))
808 safe_allocate(cas%zmat_save(1:cas%n_pairs, 1:cas%n_pairs))
810 safe_allocate(cas%forces(1:cas%space_dim, 1:sys%ions%natoms, 1:cas%n_pairs))
814 safe_allocate( cas%qf (1:cas%n_pairs))
815 safe_allocate( cas%qf_avg(1:cas%n_pairs))
823 do ast = cas%n_occ(ik) + 1, cas%nst
824 do ist = 1, cas%n_occ(ik)
825 if (cas%is_included(ist, ast, ik))
then
826 cas%index(ist, ast, ik) = jpair
827 cas%pair(jpair)%i = ist
828 cas%pair(jpair)%a = ast
829 cas%pair(jpair)%kk = ik
836 if (cas%has_photons)
then
838 do ik = 1, cas%pt_nmodes
839 cas%pair(cas%n_pairs + ik)%i = 1
840 cas%pair(cas%n_pairs + ik)%a = -ik
841 cas%pair(cas%n_pairs + ik)%kk = -ik
845 safe_deallocate_a(cas%is_included)
856 type(
casida_t),
intent(inout) :: cas
860 assert(
allocated(cas%pair))
861 safe_deallocate_a(cas%pair)
862 safe_deallocate_a(cas%index)
863 if (cas%states_are_real)
then
864 safe_deallocate_a(cas%dmat)
865 safe_deallocate_a(cas%dtm)
867 safe_deallocate_a(cas%zmat)
868 safe_deallocate_a(cas%ztm)
870 safe_deallocate_a(cas%s)
871 safe_deallocate_a(cas%f)
872 safe_deallocate_a(cas%w)
873 safe_deallocate_a(cas%ind)
876 safe_deallocate_a(cas%qf)
877 safe_deallocate_a(cas%qf_avg)
880 safe_deallocate_a(cas%n_occ)
881 safe_deallocate_a(cas%n_unocc)
883 if (cas%calc_forces)
then
884 if (cas%states_are_real)
then
885 safe_deallocate_a(cas%dmat_save)
887 safe_deallocate_a(cas%zmat_save)
889 safe_deallocate_a(cas%forces)
895 if (cas%distributed_matrix)
then
901 safe_deallocate_a(cas%qvector)
912 type(
casida_t),
intent(inout) :: cas
915 type(
grid_t),
pointer :: gr
917 real(real64),
allocatable :: rho_spin(:, :)
918 real(real64),
allocatable :: fxc_spin(:,:,:)
919 character(len=100) :: restart_filename
924 assert(cas%type >= casida_eps_diff .and. cas%type <=
casida_casida)
931 if (cas%states_are_real)
then
946 if (cas%type /= casida_eps_diff .or. cas%calc_forces)
then
948 safe_allocate(cas%rho(1:gr%np_part, 1:st%d%nspin))
949 safe_allocate(cas%fxc(1:gr%np, 1:st%d%nspin, 1:st%d%nspin))
950 cas%gga =
in_family(sys%ks%xc%family, [xc_family_gga])
952 safe_allocate(cas%fxc_grad(1:gr%np, 1:gr%der%dim, 1:gr%der%dim, 1:st%d%nspin, 1:st%d%nspin))
954 safe_allocate(cas%fxc_grad_spin(1:gr%np, 1:gr%der%dim, 1:st%d%nspin, 1:st%d%nspin))
956 safe_allocate(cas%fxc_grad_spin(0, 0, 0, 0))
959 safe_allocate(cas%fxc_grad(0, 0, 0, 0, 0))
960 safe_allocate(cas%fxc_grad_spin(0, 0, 0, 0))
964 if (cas%triplet)
then
965 safe_allocate(rho_spin(1:gr%np_part, 1:2))
966 safe_allocate(fxc_spin(1:gr%np, 1:2, 1:2))
968 rho_spin(:, 1) =
m_half * cas%rho(:, 1)
972 cas%fxc(:, 1, 1) =
m_half * (fxc_spin(:, 1, 1) - fxc_spin(:, 1, 2))
974 safe_deallocate_a(rho_spin)
975 safe_deallocate_a(fxc_spin)
978 call xc_get_fxc(sys%ks%xc, gr, sys%namespace, cas%rho, st%d%ispin, cas%fxc, cas%fxc_grad, &
981 call xc_get_fxc(sys%ks%xc, gr, sys%namespace, cas%rho, st%d%ispin, cas%fxc)
991 restart_filename =
'kernel'
992 if (cas%triplet) restart_filename = trim(restart_filename)//
'_triplet'
994 select case (cas%type)
995 case (casida_eps_diff)
998 if (cas%states_are_real)
then
999 call dcasida_get_matrix(cas, sys%namespace, sys%hm, st, sys%ks, gr, cas%dmat, cas%fxc, &
1000 cas%fxc_grad, cas%fxc_grad_spin, restart_filename)
1003 call zcasida_get_matrix(cas, sys%namespace, sys%hm, st, sys%ks, gr, cas%zmat, cas%fxc, &
1004 cas%fxc_grad, cas%fxc_grad_spin, restart_filename)
1011 if (cas%states_are_real)
then
1018 if (cas%calc_forces)
then
1019 if (cas%states_are_real)
then
1026 if (cas%states_are_real)
then
1033 if (cas%type /= casida_eps_diff .or. cas%calc_forces)
then
1034 safe_deallocate_a(cas%fxc)
1035 safe_deallocate_a(cas%fxc_grad)
1036 safe_deallocate_a(cas%fxc_grad_spin)
1037 safe_deallocate_a(cas%rho)
1048 real(real64),
allocatable :: w(:)
1055 do ia = 1, cas%n_pairs
1056 cas%w(ia) = st%eigenval(cas%pair(ia)%a, cas%pair(ia)%kk) - &
1057 st%eigenval(cas%pair(ia)%i, cas%pair(ia)%kk)
1059 message(1) =
"There is a negative unocc-occ KS eigenvalue difference for"
1060 write(
message(2),
'("states ",I5," and ",I5," of k-point ",I5,".")') cas%pair(ia)%i, cas%pair(ia)%a, cas%pair(ia)%kk
1061 message(3) =
"This indicates an inconsistency between gs, unocc, and/or casida calculations."
1067 safe_allocate(w(1:cas%n_pairs))
1069 call sort(w, cas%ind)
1070 safe_deallocate_a(w)
1080 type(
v_ks_t),
intent(in) :: ks
1082 type(
grid_t),
intent(in) :: gr
1083 type(
casida_t),
intent(inout) :: cas
1085 real(real64),
allocatable :: rho(:, :)
1086 real(real64),
allocatable :: fxc_sic(:,:,:)
1092 message(1) =
"Casida calculation with ADSIC not implemented for spin-polarized calculations."
1095 if (cas%triplet)
then
1096 message(1) =
"Casida calculation with ADSIC not implemented for triplet excitations."
1100 message(1) =
"Casida calculation with ADSIC not implemented with GGAs."
1104 safe_allocate(fxc_sic(1:gr%np, 1:st%d%nspin, 1:st%d%nspin))
1105 safe_allocate(rho(1:gr%np, 1:st%d%nspin))
1106 rho = cas%rho/st%qtot
1108 call xc_get_fxc(ks%xc, gr, namespace, rho, 1, fxc_sic)
1110 cas%fxc = cas%fxc - fxc_sic/st%qtot
1112 safe_deallocate_a(rho)
1113 safe_deallocate_a(fxc_sic)
1121 real(real64) function casida_matrix_factor(cas, sys)
1125 push_sub(casida_matrix_factor)
1127 casida_matrix_factor =
m_one
1130 casida_matrix_factor =
m_two * casida_matrix_factor
1134 casida_matrix_factor =
m_two * casida_matrix_factor
1137 pop_sub(casida_matrix_factor)
1144 type(namespace_t),
intent(in) :: namespace
1146 integer :: iunit, ia
1148 if (.not. mpi_grp_is_root(mpi_world))
return
1152 call io_mkdir(casida_dir, namespace)
1153 iunit = io_open(casida_dir//
'q'//trim(
theory_name(cas)), namespace, action=
'write')
1154 write(iunit,
'(a1,a14,1x,a24,1x,a24,1x,a10,3es15.8,a2)')
'#',
'E' ,
'|<f|exp(iq.r)|i>|^2', &
1155 '<|<f|exp(iq.r)|i>|^2>',
'; q = (',cas%qvector(1:cas%space_dim),
')'
1156 write(iunit,
'(a1,a14,1x,a24,1x,a24,1x,10x,a15)')
'#', trim(units_abbrev(units_out%energy)), &
1161 if (cas%avg_order == 0)
then
1162 do ia = 1, cas%n_pairs
1163 write(iunit,
'(es15.8,es15.8)') units_from_atomic(units_out%energy, cas%w(cas%ind(ia))), cas%qf(cas%ind(ia))
1166 do ia = 1, cas%n_pairs
1167 write(iunit,
'(3es15.8)') units_from_atomic(units_out%energy, cas%w(cas%ind(ia))), &
1168 cas%qf (cas%ind(ia)), &
1169 cas%qf_avg(cas%ind(ia))
1173 call io_close(iunit)
1183 select case (cas%type)
1202 type(states_elec_t),
intent(in) :: st
1203 integer,
intent(in) :: ia
1204 integer,
intent(in) :: jb
1208 isnt_degenerate = (abs((st%eigenval(cas%pair(ia)%a, cas%pair(ia)%kk) - st%eigenval(cas%pair(ia)%i, cas%pair(ia)%kk)) &
1209 - (st%eigenval(cas%pair(jb)%a, cas%pair(jb)%kk) - st%eigenval(cas%pair(jb)%i, cas%pair(jb)%kk))) > 1e-8_real64)
1216 type(
casida_t),
intent(inout) :: cas
1217 integer,
intent(in) :: jb_local
1219 if (.not. cas%distributed_matrix)
then
1222#ifdef HAVE_SCALAPACK
1223 jb = indxl2g(jb_local, cas%block_size, cas%proc_grid%myrow, 0, cas%proc_grid%nprow)
1230 type(
casida_t),
intent(inout) :: cas
1231 integer,
intent(in) :: ia_local
1233 if (.not. cas%distributed_matrix)
then
1236#ifdef HAVE_SCALAPACK
1237 ia = indxl2g(ia_local, cas%block_size, cas%proc_grid%mycol, 0, cas%proc_grid%npcol)
1242 subroutine local_indices(cas, ia, jb, on_this_processor, ia_local, jb_local)
1245 integer,
intent(in) :: ia, jb
1246 logical,
intent(out) :: on_this_processor
1247 integer,
intent(out) :: ia_local, jb_local
1248#ifdef HAVE_SCALAPACK
1249 integer :: ia_proc, jb_proc
1252 if (.not. cas%distributed_matrix)
then
1253 on_this_processor = .
true.
1257#ifdef HAVE_SCALAPACK
1258 ia_proc = indxg2p(ia, cas%block_size, cas%proc_grid%mycol, 0, cas%proc_grid%npcol)
1259 jb_proc = indxg2p(jb, cas%block_size, cas%proc_grid%myrow, 0, cas%proc_grid%nprow)
1260 if (cas%proc_grid%mycol == ia_proc .and. cas%proc_grid%myrow == jb_proc)
then
1261 on_this_processor = .
true.
1262 ia_local = indxg2l(ia, cas%block_size, cas%proc_grid%mycol, 0, cas%proc_grid%npcol)
1263 jb_local = indxg2l(jb, cas%block_size, cas%proc_grid%myrow, 0, cas%proc_grid%nprow)
1265 on_this_processor = .false.
1275#include "casida_inc.F90"
1277#include "complex.F90"
1278#include "casida_inc.F90"
subroutine fxc_add_adsic(namespace, ks, st, gr, cas)
subroutine solve_eps_diff
This is the common interface to a sorting routine. It performs the shell algorithm,...
double floor(double __x) __attribute__((__nothrow__
This module implements batches of mesh functions.
This module provides the BLACS processor grid.
subroutine, public blacs_proc_grid_init(this, mpi_grp, procdim)
Initializes a blacs context from an MPI communicator with topological information.
subroutine, public blacs_proc_grid_end(this)
This module handles the calculation mode.
integer, parameter, public p_strategy_kpoints
parallelization in k-points
integer, parameter, public p_strategy_other
something else like e-h pairs
integer, parameter, public p_strategy_domains
parallelization in domains
type(calc_mode_par_t), public calc_mode_par
Singleton instance of parallel calculation mode.
This module implements the Casida equations for excited states.
integer function get_global_col(cas, ia_local)
integer, parameter solver_scalapack
subroutine zoscillator_strengths(cas, mesh, st)
integer, parameter casida_petersilka
subroutine, public casida_run_init()
integer, parameter casida_casida
subroutine casida_type_init(cas, sys)
allocates stuff, and constructs the arrays pair_i and pair_j
integer function get_global_row(cas, jb_local)
integer, parameter casida_eps_diff
character(len=80) pure function theory_name(cas)
subroutine dcasida_forces(cas, sys, gr, st)
subroutine dcasida_get_matrix(cas, namespace, hm, st, ks, gr, matrix, fxc, fxc_grad, fxc_grad_spin, restart_file, is_forces)
subroutine local_indices(cas, ia, jb, on_this_processor, ia_local, jb_local)
subroutine zcasida_solve(cas, sys)
subroutine casida_work(sys, cas)
this subroutine calculates electronic excitation energies using the matrix formulation of M....
subroutine zcasida_get_matrix(cas, namespace, hm, st, ks, gr, matrix, fxc, fxc_grad, fxc_grad_spin, restart_file, is_forces)
integer, parameter casida_variational
subroutine qcasida_write(cas, namespace)
subroutine zcasida_write(cas, sys)
logical function isnt_degenerate(cas, st, ia, jb)
subroutine, public casida_run(system, from_scratch)
subroutine doscillator_strengths(cas, mesh, st)
subroutine dcasida_write(cas, sys)
real(real64) function casida_matrix_factor(cas, sys)
subroutine casida_run_legacy(sys, fromScratch)
integer, parameter casida_tamm_dancoff
subroutine zcasida_forces(cas, sys, gr, st)
subroutine casida_type_end(cas)
subroutine dcasida_solve(cas, sys)
This module implements a calculator for the density and defines related functions.
subroutine, public states_elec_total_density(st, mesh, total_rho)
This routine calculates the total electronic density.
This module calculates the derivatives (gradients, Laplacians, etc.) of a function.
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_epsilon
real(real64), parameter, public m_half
real(real64), parameter, public m_one
This module implements the underlying real-space grid.
subroutine, public io_function_read_what_how_when(namespace, space, what, how, output_interval, what_tag_in, how_tag_in, output_interval_tag_in, ignore_error)
integer pure function, public kpoints_number(this)
A module to handle KS potential, without the external potential.
integer, parameter, public hartree_fock
integer, parameter, public generalized_kohn_sham_dft
integer, parameter, public dft_u_none
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)
subroutine, public messages_warning(no_lines, all_nodes, namespace)
subroutine, public messages_obsolete_variable(namespace, name, rep)
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_comm), parameter, public mpi_comm_undefined
used to indicate a communicator has not been initialized
type(mpi_grp_t), public mpi_world
subroutine mpi_grp_init(grp, comm)
Initialize MPI group instance.
This module handles the communicators for the various parallelization strategies.
logical pure function, public multicomm_strategy_is_parallel(mc, level)
This module implements the basic mulsisystem class, a container system for other systems.
integer function, public parse_block(namespace, name, blk, check_varinfo_)
subroutine, public photon_mode_set_n_electrons(this, qtot)
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, parameter, public restart_casida
subroutine, public restart_rm(restart, name)
Remove directory or file "name" that is located inside the current restart directory.
integer, parameter, public restart_gs
subroutine, public restart_init(restart, namespace, data_type, type, mc, ierr, mesh, dir, exact)
Initializes a restart object.
integer, parameter, public restart_type_dump
integer, parameter, public restart_type_load
subroutine, public restart_end(restart)
This module contains interfaces for ScaLAPACK routines Interfaces are from http:
This module is intended to contain "only mathematical" functions and procedures.
pure logical function, public states_are_complex(st)
pure logical function, public states_are_real(st)
This module handles spin dimensions of the states and the k-point distribution.
subroutine, public states_elec_count_pairs(st, namespace, n_pairs, n_occ, n_unocc, is_included, is_frac_occ)
number of occupied-unoccupied pairs for Casida
This module handles reading and writing restart information for the states_elec_t.
subroutine, public states_elec_look_and_load(restart, namespace, space, st, mesh, kpoints, is_complex, packed)
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.
This module is intended to contain simple general-purpose utility functions and procedures.
subroutine, public v_ks_h_setup(namespace, space, gr, ions, ext_partners, st, ks, hm, calc_eigenval, calc_current)
logical pure function, public family_is_mgga_with_exc(xcs)
Is the xc function part of the mGGA family with an energy functional.
subroutine, public xc_get_fxc(xcs, gr, namespace, rho, ispin, fxc, fxc_grad, fxc_grad_spin)
Returns the exchange-correlation kernel.
pure logical function, public in_family(family, xc_families)
integer, parameter, public sic_adsic
Averaged density SIC.
This class contains all parameters, needed for Casida calculations.
Class describing the electron system.
Description of the grid, containing information on derivatives, stencil, and symmetries.
Container class for lists of system_oct_m::system_t.
The states_elec_t class contains all electronic wave functions.