Octopus
states_elec.F90
Go to the documentation of this file.
1!! Copyright (C) 2002-2006 M. Marques, A. Castro, A. Rubio, G. Bertsch
2!!
3!! This program is free software; you can redistribute it and/or modify
4!! it under the terms of the GNU General Public License as published by
5!! the Free Software Foundation; either version 2, or (at your option)
6!! any later version.
7!!
8!! This program is distributed in the hope that it will be useful,
9!! but WITHOUT ANY WARRANTY; without even the implied warranty of
10!! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11!! GNU General Public License for more details.
12!!
13!! You should have received a copy of the GNU General Public License
14!! along with this program; if not, write to the Free Software
15!! Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
16!! 02110-1301, USA.
17!!
18#include "global.h"
19
21 use accel_oct_m
22 use batch_oct_m
26 use batch_oct_m
29 use comm_oct_m
30 use debug_oct_m
34 use global_oct_m
35 use grid_oct_m
36 use io_oct_m
37 use, intrinsic :: iso_fortran_env
40 use loct_oct_m
41 use math_oct_m
42 use mesh_oct_m
47 use mpi_oct_m
50#ifdef HAVE_OPENMP
51 use omp_lib
52#endif
53 use parser_oct_m
57 use smear_oct_m
58 use space_oct_m
62 use types_oct_m
63 use unit_oct_m
67
68 implicit none
69
70 private
71
72 public :: &
103 stress_t, &
105
106
107 ! this type must be moved to stress module but due to circular dependency it is not possible now
108 type stress_t
109 real(real64) :: total(3,3) = m_zero
110 real(real64) :: kinetic(3,3) = m_zero
111 real(real64) :: Hartree(3,3) = m_zero
112 real(real64) :: xc(3,3) = m_zero
113 real(real64) :: xc_nlcc(3,3) = m_zero
114 real(real64) :: ps_local(3,3) = m_zero
115 real(real64) :: ps_nl(3,3) = m_zero
116 real(real64) :: ps_aug(3,3) = m_zero
117 real(real64) :: ion_ion(3,3) = m_zero
118 real(real64) :: vdw(3,3) = m_zero
119 real(real64) :: hubbard(3,3) = m_zero
120
121 real(real64) :: kinetic_sumrule = m_zero
122 real(real64) :: hartree_sumrule = m_zero
123 end type stress_t
124
125 ! TODO(Alex) Issue #672 Decouple k-point info from `states_elec_dim_t`
126
134 !
135 type, extends(states_abst_t) :: states_elec_t
136 ! Components are public by default
137 type(states_elec_dim_t) :: d
138 integer :: nst_conv
139
140 logical :: only_userdef_istates
141 logical :: requires_generalized_overlap = .false.
142
143 type(states_elec_group_t) :: group
144 integer :: block_size
148 logical :: pack_states
152
153
154 character(len=1024), allocatable :: user_def_states(:,:,:)
157
158 ! TODO(Alex) Issue #821. Collate current quantities into an object.
159 ! the densities and currents (after all we are doing DFT :)
160 real(real64), allocatable :: rho(:,:)
161 real(real64), allocatable :: rho_core(:)
162
163 ! Buffer density
164 type(accel_mem_t) :: buff_density
165
166 real(real64), allocatable :: current(:, :, :)
167 real(real64), allocatable :: current_para(:, :, :)
168 real(real64), allocatable :: current_dia(:, :, :)
169 real(real64), allocatable :: current_mag(:, :, :)
170 real(real64), allocatable :: current_kpt(:,:,:)
171
172 ! TODO(Alex) Issue #673. Create frozen density class and replace in states_elec_t
173 ! It may be required to "freeze" the deepest orbitals during the evolution; the density
174 ! of these orbitals is kept in frozen_rho. It is different from rho_core.
175 real(real64), allocatable :: frozen_rho(:, :)
176 real(real64), allocatable :: frozen_tau(:, :)
177 real(real64), allocatable :: frozen_gdens(:,:,:)
178 real(real64), allocatable :: frozen_ldens(:,:)
179
180 logical :: uniform_occ
182 real(real64), allocatable :: eigenval(:,:)
183 logical :: fixed_occ
184 logical :: restart_fixed_occ
185 logical :: restart_reorder_occs
186 real(real64), allocatable :: occ(:,:)
187 real(real64), allocatable :: kweights(:)
188 integer :: nik
190 logical :: fixed_spins
192 real(real64), allocatable :: spin(:, :, :)
194 real(real64) :: qtot
195 real(real64) :: val_charge
196
197 type(stress_t) :: stress_tensors
198
199 logical :: fromscratch
200 type(smear_t) :: smear
201
202 ! TODO(Alex) Issue #823 Move modelmbparticles out of states_elec_t
203 type(modelmb_particle_t) :: modelmbparticles
204
205 ! TODO(Alex) Issue #824. Package the communicators in a single instance prior to removing
206 ! or consider creating a distributed_t instance for each (as distributed_t contains the an instance of mpi_grp_t)
207 type(mpi_grp_t) :: mpi_grp
208 type(mpi_grp_t) :: dom_st_mpi_grp
209 type(mpi_grp_t) :: st_kpt_mpi_grp
210 type(mpi_grp_t) :: dom_st_kpt_mpi_grp
211 type(mpi_grp_t) :: system_grp
212 type(blacs_proc_grid_t) :: dom_st_proc_grid
214 type(distributed_t) :: dist
215 logical :: scalapack_compatible
216 logical :: parallel_in_states = .false.
217
218 ! TODO(Alex) Issue #820. Remove lnst, st_start, st_end and node, as they are all contained within dist
219 integer :: lnst
220 integer :: st_start, st_end
221 integer, allocatable :: node(:)
222
223 ! TODO(Alex) Issue #824. Either change from data to a method, or package with `st_kpt_mpi_grp`
224 integer, allocatable :: st_kpt_task(:,:)
225
226 type(multicomm_all_pairs_t), private :: ap
227 logical :: symmetrize_density
228 integer :: randomization
229 integer :: orth_method = 0
230
231 real(real64) :: gpu_states_mem
233 contains
234 procedure :: nullify => states_elec_null
235 procedure :: write_info => states_elec_write_info
236 procedure :: pack => states_elec_pack
237 procedure :: unpack => states_elec_unpack
239 procedure :: dipole => states_elec_calculate_dipole
243 integer, public, parameter :: &
244 par_independent = 1, &
245 par_dependent = 2
246
251 end interface states_elec_get_state
253 interface states_elec_set_state
261
264 end interface
265
266contains
268 ! TODO(Alex): Issue #826. Rename to something like "states_elec_default_wfs_type", or remove
269 subroutine states_elec_null(st)
270 class(states_elec_t), intent(inout) :: st
273
274 st%wfs_type = type_float ! By default, calculations use real wavefunctions
276 st%packed = .false.
277 st%requires_generalized_overlap = .false.
278
280 end subroutine states_elec_null
284 subroutine states_elec_init(st, namespace, space, valence_charge, kpoints, calc_mode_id)
285 type(states_elec_t), target, intent(inout) :: st
286 type(namespace_t), intent(in) :: namespace
287 type(electron_space_t), intent(in) :: space
288 real(real64), intent(in) :: valence_charge
289 type(kpoints_t), intent(in) :: kpoints
290 integer, optional, intent(in) :: calc_mode_id
292 real(real64) :: excess_charge, nempty_percent
293 integer :: nempty, ntot, default
294 integer :: nempty_conv, nempty_conv_default
295 logical :: force, adapt_for_chebyshev
296 real(real64), parameter :: tol = 1e-13_real64
297 integer :: es
298 integer, parameter :: rs_chebyshev = 12
299 integer(int64), parameter :: chebyshev_compatible_modes(3) = &
300 [option__calculationmode__gs, option__calculationmode__go, option__calculationmode__unocc]
302 push_sub_with_profile(states_elec_init)
304 st%fromScratch = .true. ! this will be reset if restart_read is called
305 call states_elec_null(st)
307 ! We get the spin dimension from the electronic space
308 ! TODO: Remove spin space information from states_elec_dim
309 st%d%ispin = space%ispin
311 ! Use of spinors requires complex wavefunctions.
312 if (st%d%ispin == spinors) call states_set_complex(st)
313
314 if (st%d%ispin /= unpolarized .and. kpoints%use_time_reversal) then
315 message(1) = "Time reversal symmetry is only implemented for unpolarized spins."
316 message(2) = "Use KPointsUseTimeReversal = no."
317 call messages_fatal(2, namespace=namespace)
318 end if
319
321 !%Variable ExcessCharge
322 !%Type float
323 !%Default 0.0
324 !%Section States
325 !%Description
326 !% The net charge of the system. A negative value means that we are adding
327 !% electrons, while a positive value means we are taking electrons
328 !% from the system.
329 !%End
330 call parse_variable(namespace, 'ExcessCharge', m_zero, excess_charge)
331
332 !%Variable TotalStates
333 !%Type integer
334 !%Default 0
335 !%Section States
336 !%Description
337 !% This variable sets the total number of states that Octopus will
338 !% use. This is normally not necessary since by default Octopus
339 !% sets the number of states to the minimum necessary to hold the
340 !% electrons present in the system. (This default behavior is
341 !% obtained by setting <tt>TotalStates</tt> to 0).
342 !%
343 !% If you want to add some unoccupied states, probably it is more convenient to use the variable
344 !% <tt>ExtraStates</tt>.
345 !%End
346 call parse_variable(namespace, 'TotalStates', 0, ntot)
347 if (ntot < 0) then
348 write(message(1), '(a,i5,a)') "Input: '", ntot, "' is not a valid value for TotalStates."
349 call messages_fatal(1, namespace=namespace)
350 end if
351
352 !%Variable ExtraStates
353 !%Type integer
354 !%Default 0
355 !%Section States
356 !%Description
357 !% The number of states is in principle calculated considering the minimum
358 !% numbers of states necessary to hold the electrons present in the system.
359 !% The number of electrons is
360 !% in turn calculated considering the nature of the species supplied in the
361 !% <tt>Species</tt> block, and the value of the <tt>ExcessCharge</tt> variable.
362 !% However, one may command <tt>Octopus</tt> to use more states, which is necessary if one wants to
363 !% use fractional occupational numbers, either fixed from the beginning through
364 !% the <tt>Occupations</tt> block or by prescribing
365 !% an electronic temperature with <tt>Smearing</tt>, or in order to calculate
366 !% excited states (including with <tt>CalculationMode = unocc</tt>).
367 !%End
368 call parse_variable(namespace, 'ExtraStates', 0, nempty)
369 if (nempty < 0) then
370 write(message(1), '(a,i5,a)') "Input: '", nempty, "' is not a valid value for ExtraStates."
371 message(2) = '(0 <= ExtraStates)'
372 call messages_fatal(2, namespace=namespace)
373 end if
374
375 if (ntot > 0 .and. nempty > 0) then
376 message(1) = 'You cannot set TotalStates and ExtraStates at the same time.'
377 call messages_fatal(1, namespace=namespace)
378 end if
379
380 !%Variable ExtraStatesInPercent
381 !%Type float
382 !%Default 0
383 !%Section States
384 !%Description
385 !% This variable allows to set the number of extra/empty states as percentage of the
386 !% used occupied states. For example, a value 35 for ExtraStatesInPercent would amount
387 !% to ceiling(35/100 * nstates) extra states, where nstates denotes the amount of occupied
388 !% states Octopus is using for the system at hand.
389 !%End
390 call parse_variable(namespace, 'ExtraStatesInPercent', m_zero, nempty_percent)
391 if (nempty_percent < 0) then
392 write(message(1), '(a,f8.6,a)') "Input: '", nempty_percent, &
393 "' should be a percentage value x (where x is parts in hundred) larger or equal 0"
394 call messages_fatal(1, namespace=namespace)
395 end if
396
397 if (nempty > 0 .and. nempty_percent > 0) then
398 message(1) = 'You cannot set ExtraStates and ExtraStatesInPercent at the same time.'
399 call messages_fatal(1, namespace=namespace)
400 end if
401
402 ! Only use extra states for Chebyshev filtering in ground state or geometry optimization runs
403 adapt_for_chebyshev = .false.
404 if (present(calc_mode_id)) then
405 if (any(calc_mode_id == chebyshev_compatible_modes)) then
406 ! this variable is documented in electrons/eigensolver.F90
407 call parse_variable(namespace, 'Eigensolver', rs_chebyshev, es)
408 if (es == rs_chebyshev) then
409 ! reuse this condition below
410 adapt_for_chebyshev = .true.
411 end if
412 end if
413 end if
414 if (adapt_for_chebyshev) then
415 if (nempty == 0 .and. is_close(nempty_percent, m_zero)) then
416 nempty_percent = 15
417 message(1) = 'Chebyshev filtering eigensolver detected. Setting ExtraStatesInPercent = 15'
418 call messages_info(1, namespace=namespace)
419 end if
420 end if
421
422 ! For non-periodic systems this should just return the Gamma point
423 call states_elec_choose_kpoints(st, kpoints, namespace)
424
425 st%val_charge = valence_charge
426
427 st%qtot = -(st%val_charge + excess_charge)
428
429 if (st%qtot < -m_epsilon) then
430 write(message(1),'(a,f12.6,a)') 'Total charge = ', st%qtot, ' < 0'
431 message(2) = 'Check Species and ExcessCharge.'
432 call messages_fatal(2, only_root_writes = .true., namespace=namespace)
433 end if
434
435 select case (st%d%ispin)
436 case (unpolarized)
437 st%d%dim = 1
438 st%nst = nint(st%qtot/2)
439 if (st%nst*2 - st%qtot < -tol) st%nst = st%nst + 1
440 st%d%nspin = 1
441 st%d%spin_channels = 1
442 case (spin_polarized)
443 st%d%dim = 1
444 st%nst = nint(st%qtot/2)
445 if (st%nst*2 - st%qtot < -tol) st%nst = st%nst + 1
446 st%d%nspin = 2
447 st%d%spin_channels = 2
448 case (spinors)
449 st%d%dim = 2
450 st%nst = nint(st%qtot)
451 if (st%nst - st%qtot < -tol) st%nst = st%nst + 1
452 st%d%nspin = 4
453 st%d%spin_channels = 2
454 end select
455
456 if (nempty_percent > 0) then
457 nempty = ceiling(nempty_percent * st%nst / 100)
458 end if
459
460 !%Variable ExtraStatesToConverge
461 !%Type integer
462 !%Default <tt>ExtraStates</tt> (Default 0)
463 !%Section States
464 !%Description
465 !% For <tt>gs</tt> and <tt>unocc</tt> calculations.
466 !% (For the <tt>gs</tt> calculation one needs to set <tt>ConvEigenError=yes</tt>)
467 !% Specifies the number of extra states that will be considered for reaching the convergence.
468 !% The calculation will consider the number off occupied states plus
469 !% <tt>ExtraStatesToConverge</tt> for the convergence criteria.
470 !% By default, all extra states need to be converged (For <tt>gs</tt> calculations only with <tt>ConvEigenError=yes</tt>).
471 !% Thus, together with <tt>ExtraStates</tt>, one can have some more states which will not be
472 !% considered for the convergence criteria, thus making the convergence of the
473 !% unocc calculation faster.
474 !%
475 !% If chebyshev filtering is used, the default is <tt>min(0.8*ExtraStates, ExtraStates - 1)</tt>.
476 !%End
477 nempty_conv_default = nempty
478 if (adapt_for_chebyshev) then
479 ! use 80% of the extra states, but at least do not converge one extra state
480 nempty_conv_default = min(int(0.8*nempty), nempty - 1)
481 end if
482 call parse_variable(namespace, 'ExtraStatesToConverge', nempty_conv_default, nempty_conv)
483 if (nempty_conv < 0) then
484 write(message(1), '(a,i5,a)') "Input: '", nempty_conv, "' is not a valid value for ExtraStatesToConverge."
485 message(2) = '(0 <= ExtraStatesToConverge)'
486 call messages_fatal(2, namespace=namespace)
487 end if
488
489 if (nempty_conv > nempty) then
490 nempty_conv = nempty
491 message(1) = 'You cannot set ExtraStatesToConverge to a higher value than ExtraStates.'
492 message(2) = 'Capping ExtraStatesToConverge to ExtraStates.'
493 call messages_warning(2, namespace=namespace)
494 endif
495
496 if (ntot > 0) then
497 if (ntot < st%nst) then
498 message(1) = 'TotalStates is smaller than the number of states required by the system.'
499 call messages_fatal(1, namespace=namespace)
500 end if
501
502 st%nst = ntot
503 end if
504
505 st%nst_conv = st%nst + nempty_conv
506 st%nst = st%nst + nempty
507 if (st%nst == 0) then
508 message(1) = "Cannot run with number of states = zero."
509 call messages_fatal(1, namespace=namespace)
510 end if
511
512 !%Variable StatesBlockSize
513 !%Type integer
514 !%Section Execution::Optimization
515 !%Description
516 !% Some routines work over blocks of eigenfunctions, which
517 !% generally improves performance at the expense of increased
518 !% memory consumption. This variable selects the size of the
519 !% blocks to be used. If GPUs are used, the default is the
520 !% warp size (32 for NVIDIA, 32 or 64 for AMD);
521 !% otherwise it is 4.
522 !%End
523
524 if (accel_is_enabled()) then
525 ! use the warp size (usually 32, for some AMD GPUs it is 64)
526 default = accel%warp_size
527 else
528 default = 4
529 end if
530
531 if (default > pad_pow2(st%nst)) default = pad_pow2(st%nst)
532
533 assert(default > 0)
534
535 call parse_variable(namespace, 'StatesBlockSize', default, st%block_size)
536 if (st%block_size < 1) then
537 call messages_write("The variable 'StatesBlockSize' must be greater than 0.")
538 call messages_fatal(namespace=namespace)
539 end if
540
541 st%block_size = min(st%block_size, st%nst)
542 conf%target_states_block_size = st%block_size
543
544 safe_allocate(st%eigenval(1:st%nst, 1:st%nik))
545 st%eigenval = huge(st%eigenval)
546
547 ! Periodic systems require complex wavefunctions
548 ! but not if it is Gamma-point only
549 if (.not. kpoints%gamma_only()) then
550 call states_set_complex(st)
551 end if
552
553 !%Variable OnlyUserDefinedInitialStates
554 !%Type logical
555 !%Default no
556 !%Section States
557 !%Description
558 !% If true, then only user-defined states from the block <tt>UserDefinedStates</tt>
559 !% will be used as initial states for a time-propagation. No attempt is made
560 !% to load ground-state orbitals from a previous ground-state run.
561 !%End
562 call parse_variable(namespace, 'OnlyUserDefinedInitialStates', .false., st%only_userdef_istates)
563
564 ! we now allocate some arrays
565 safe_allocate(st%occ (1:st%nst, 1:st%nik))
566 st%occ = m_zero
567 ! allocate space for formula strings that define user-defined states
568 if (parse_is_defined(namespace, 'UserDefinedStates') .or. parse_is_defined(namespace, 'OCTInitialUserdefined') &
569 .or. parse_is_defined(namespace, 'OCTTargetUserdefined')) then
570 safe_allocate(st%user_def_states(1:st%d%dim, 1:st%nst, 1:st%nik))
571 ! initially we mark all 'formulas' as undefined
572 st%user_def_states(1:st%d%dim, 1:st%nst, 1:st%nik) = 'undefined'
573 end if
574
575 if (st%d%ispin == spinors) then
576 safe_allocate(st%spin(1:3, 1:st%nst, 1:st%nik))
577 end if
578
579 !%Variable StatesRandomization
580 !%Type integer
581 !%Default par_independent
582 !%Section States
583 !%Description
584 !% The randomization of states can be done in two ways:
585 !% i) a parallelisation independent way (default), where the random states are identical,
586 !% irrespectively of the number of tasks and
587 !% ii) a parallelisation dependent way, which can prevent linear dependency
588 !% to occur for large systems.
589 !%Option par_independent 1
590 !% Parallelisation-independent randomization of states.
591 !%Option par_dependent 2
592 !% The randomization depends on the number of taks used in the calculation.
593 !%End
594 call parse_variable(namespace, 'StatesRandomization', par_independent, st%randomization)
595
596
597 call states_elec_read_initial_occs(st, namespace, excess_charge, kpoints)
598 call states_elec_read_initial_spins(st, namespace)
599
600 ! This test can only be done here, as smear_init is called inside states_elec_read_initial_occs, and
601 ! only there smear%photodop is set.
602
603 if (st%smear%photodop) then
604 if (nempty == 0) then
605 write(message(1), '(a,i5,a)') "PhotoDoping requires to specify ExtraStates."
606 message(2) = '(0 == ExtraStates)'
607 call messages_fatal(2, namespace=namespace)
608 end if
609 end if
610
611 st%st_start = 1
612 st%st_end = st%nst
613 st%lnst = st%nst
614 safe_allocate(st%node(1:st%nst))
615 st%node(1:st%nst) = 0
616
617 call mpi_grp_init(st%mpi_grp, mpi_comm_undefined)
618 st%parallel_in_states = .false.
619
620 call distributed_init_serial(st%d%kpt, st%nik)
621
622 call modelmb_particles_init(st%modelmbparticles, namespace, space, st%nst)
623
624 !%Variable SymmetrizeDensity
625 !%Type logical
626 !%Default no
627 !%Section States
628 !%Description
629 !% When enabled the density is symmetrized. Currently, this can
630 !% only be done for periodic systems. (Experimental.)
631 !%End
632 call parse_variable(namespace, 'SymmetrizeDensity', kpoints%use_symmetries, st%symmetrize_density)
633 call messages_print_var_value('SymmetrizeDensity', st%symmetrize_density, namespace=namespace)
634
635 !%Variable ForceComplex
636 !%Type logical
637 !%Default no
638 !%Section Execution::Debug
639 !%Description
640 !% Normally <tt>Octopus</tt> determines automatically the type necessary
641 !% for the wavefunctions. When set to yes this variable will
642 !% force the use of complex wavefunctions.
643 !%
644 !% Warning: This variable is designed for testing and
645 !% benchmarking and normal users need not use it.
646 !%End
647 call parse_variable(namespace, 'ForceComplex', .false., force)
648
649 if (force) call states_set_complex(st)
650
651 st%packed = .false.
652
653 pop_sub_with_profile(states_elec_init)
654 end subroutine states_elec_init
655
656 ! ---------------------------------------------------------
659 !
660 subroutine states_elec_look(restart, nik, dim, nst, ierr)
661 class(restart_t), intent(in) :: restart
662 integer, intent(out) :: nik
663 integer, intent(out) :: dim
664 integer, intent(out) :: nst
665 integer, intent(out) :: ierr
666
667 character(len=256) :: lines(3)
668 character(len=20) :: char
669 integer :: iunit
670
671 push_sub(states_elec_look)
672
673 ierr = 0
674
675 iunit = restart%open('states')
676 call restart%read(iunit, lines, 3, ierr)
677 if (ierr == 0) then
678 read(lines(1), *) char, nst
679 read(lines(2), *) char, dim
680 read(lines(3), *) char, nik
681 end if
682 call restart%close(iunit)
683
684 pop_sub(states_elec_look)
685 end subroutine states_elec_look
686
687 ! ---------------------------------------------------------
696 !
697 subroutine states_elec_read_initial_occs(st, namespace, excess_charge, kpoints)
698 type(states_elec_t), intent(inout) :: st
699 type(namespace_t), intent(in) :: namespace
700 real(real64), intent(in) :: excess_charge
701 type(kpoints_t), intent(in) :: kpoints
702
703 integer :: ik, ist, ispin, nspin, ncols, nrows, el_per_state, icol, start_pos, spin_n
704 type(block_t) :: blk
705 real(real64) :: rr, charge
706 logical :: integral_occs, unoccupied_states
707 real(real64), allocatable :: read_occs(:, :)
708 real(real64) :: charge_in_block
709
711
712 !%Variable RestartFixedOccupations
713 !%Type logical
714 !%Section States
715 !%Description
716 !% Setting this variable will make the restart proceed as
717 !% if the occupations from the previous calculation had been set via the <tt>Occupations</tt> block,
718 !% <i>i.e.</i> fixed. Otherwise, occupations will be determined by smearing.
719 !%
720 !% Linear response calculations and self-consistent calculations are unaffected by this variable.
721 !% This is however used for Sternheimer calculations.
722 !%End
723 call parse_variable(namespace, 'RestartFixedOccupations', .true., st%restart_fixed_occ)
724 ! we will turn on st%fixed_occ if restart_read is ever called
725
726 !%Variable Occupations
727 !%Type block
728 !%Section States
729 !%Description
730 !% The occupation numbers of the orbitals can be fixed through the use of this
731 !% variable. For example:
732 !%
733 !% <tt>%Occupations
734 !% <br>&nbsp;&nbsp;2 | 2 | 2 | 2 | 2
735 !% <br>%</tt>
736 !%
737 !% would fix the occupations of the five states to 2. There can be
738 !% at most as many columns as states in the calculation. If there are fewer columns
739 !% than states, then the code will assume that the user is indicating the occupations
740 !% of the uppermost states where all lower states have full occupation (i.e. 2 for spin-unpolarized
741 !% calculations, 1 otherwise) and all higher states have zero occupation. The first column
742 !% will be taken to refer to the lowest state such that the occupations would be consistent
743 !% with the correct total charge. For example, if there are 8 electrons and 10 states (from
744 !% <tt>ExtraStates = 6</tt>), then an abbreviated specification
745 !%
746 !% <tt>%Occupations
747 !% <br>&nbsp;&nbsp;1 | 0 | 1
748 !% <br>%</tt>
749 !%
750 !% would be equivalent to a full specification
751 !%
752 !% <tt>%Occupations
753 !% <br>&nbsp;&nbsp;2 | 2 | 2 | 1 | 0 | 1 | 0 | 0 | 0 | 0
754 !% <br>%</tt>
755 !%
756 !% This is an example of use for constrained density-functional theory,
757 !% crudely emulating a HOMO->LUMO+1 optical excitation.
758 !% The number of rows should be equal
759 !% to the number of k-points times the number of spins. For example, for a finite system
760 !% with <tt>SpinComponents == spin_polarized</tt>,
761 !% this block should contain two lines, one for each spin channel.
762 !% All rows must have the same number of columns.
763 !%
764 !% The <tt>Occupations</tt> block is useful for the ground state of highly symmetric
765 !% small systems (like an open-shell atom), to fix the occupation numbers
766 !% of degenerate states in order to help <tt>octopus</tt> to converge. This is to
767 !% be used in conjuction with <tt>ExtraStates</tt>. For example, to calculate the
768 !% carbon atom, one would do:
769 !%
770 !% <tt>ExtraStates = 2
771 !% <br>%Occupations
772 !% <br>&nbsp;&nbsp;2 | 2/3 | 2/3 | 2/3
773 !% <br>%</tt>
774 !%
775 !% If you want the calculation to be spin-polarized (which makes more sense), you could do:
776 !%
777 !% <tt>ExtraStates = 2
778 !% <br>%Occupations
779 !% <br>&nbsp;&nbsp; 2/3 | 2/3 | 2/3
780 !% <br>&nbsp;&nbsp; 0 | 0 | 0
781 !% <br>%</tt>
782 !%
783 !% Note that in this case the first state is absent, the code will calculate four states
784 !% (two because there are four electrons, plus two because <tt>ExtraStates</tt> = 2), and since
785 !% it finds only three columns, it will occupy the first state with one electron for each
786 !% of the spin options.
787 !%
788 !% If the sum of occupations is not equal to the total charge set by <tt>ExcessCharge</tt>,
789 !% an error message is printed.
790 !% If <tt>FromScratch = no</tt> and <tt>RestartFixedOccupations = yes</tt>,
791 !% this block will be ignored.
792 !%End
793
794 integral_occs = .true.
795
796 occ_fix: if (parse_block(namespace, 'Occupations', blk) == 0) then
797 ! read in occupations
798 st%fixed_occ = .true.
799
800 ncols = parse_block_cols(blk, 0)
801 if (ncols > st%nst) then
802 call messages_input_error(namespace, "Occupations", "Too many columns in block Occupations.")
803 end if
804
805 nrows = parse_block_n(blk)
806 if (nrows /= st%nik) then
807 call messages_input_error(namespace, "Occupations", "Wrong number of rows in block Occupations.")
808 end if
809
810 do ik = 1, st%nik - 1
811 if (parse_block_cols(blk, ik) /= ncols) then
812 call messages_input_error(namespace, "Occupations", &
813 "All rows in block Occupations must have the same number of columns.")
814 end if
815 end do
816
817 ! Now we fill all the "missing" states with the maximum occupation.
818 if (st%d%ispin == unpolarized) then
819 el_per_state = 2
820 else
821 el_per_state = 1
822 end if
823
824 safe_allocate(read_occs(1:ncols, 1:st%nik))
825
826 charge_in_block = m_zero
827 do ik = 1, st%nik
828 do icol = 1, ncols
829 call parse_block_float(blk, ik - 1, icol - 1, read_occs(icol, ik))
830 charge_in_block = charge_in_block + read_occs(icol, ik) * st%kweights(ik)
831 end do
832 end do
833
834 spin_n = 2
835 select case (st%d%ispin)
836 case (unpolarized)
837 spin_n = 2
838 case (spin_polarized)
839 spin_n = 2
840 case (spinors)
841 spin_n = 1
842 end select
843
844 start_pos = nint((st%qtot - charge_in_block)/spin_n)
845
846 if (start_pos + ncols > st%nst) then
847 message(1) = "To balance charge, the first column in block Occupations is taken to refer to state"
848 write(message(2),'(a,i6,a)') "number ", start_pos, " but there are too many columns for the number of states."
849 write(message(3),'(a,i6,a)') "Solution: set ExtraStates = ", start_pos + ncols - st%nst
850 call messages_fatal(3, namespace=namespace)
851 end if
852
853 do ik = 1, st%nik
854 do ist = 1, start_pos
855 st%occ(ist, ik) = el_per_state
856 end do
857 end do
858
859 do ik = 1, st%nik
860 do ist = start_pos + 1, start_pos + ncols
861 st%occ(ist, ik) = read_occs(ist - start_pos, ik)
862 integral_occs = integral_occs .and. &
863 abs((st%occ(ist, ik) - el_per_state) * st%occ(ist, ik)) <= m_epsilon
864 end do
865 end do
866
867 do ik = 1, st%nik
868 do ist = start_pos + ncols + 1, st%nst
869 st%occ(ist, ik) = m_zero
870 end do
871 end do
872
873 call parse_block_end(blk)
874
875 safe_deallocate_a(read_occs)
876
877 else
878 st%fixed_occ = .false.
879 integral_occs = .false.
880
881 ! first guess for occupation...paramagnetic configuration
882 rr = m_one
883 if (st%d%ispin == unpolarized) rr = m_two
884
885 st%occ = m_zero
886 st%qtot = -(st%val_charge + excess_charge)
887
888 nspin = 1
889 if (st%d%nspin == 2) nspin = 2
890
891 do ik = 1, st%nik, nspin
892 charge = m_zero
893 do ist = 1, st%nst
894 do ispin = ik, ik + nspin - 1
895 st%occ(ist, ispin) = min(rr, -(st%val_charge + excess_charge) - charge)
896 charge = charge + st%occ(ist, ispin)
897 end do
898 end do
899 end do
900
901 end if occ_fix
902
903 !%Variable RestartReorderOccs
904 !%Type logical
905 !%Default no
906 !%Section States
907 !%Description
908 !% Consider doing a ground-state calculation, and then restarting with new occupations set
909 !% with the <tt>Occupations</tt> block, in an attempt to populate the orbitals of the original
910 !% calculation. However, the eigenvalues may reorder as the density changes, in which case the
911 !% occupations will now be referring to different orbitals. Setting this variable to yes will
912 !% try to solve this issue when the restart data is being read, by reordering the occupations
913 !% according to the order of the expectation values of the restart wavefunctions.
914 !%End
915 if (st%fixed_occ) then
916 call parse_variable(namespace, 'RestartReorderOccs', .false., st%restart_reorder_occs)
917 else
918 st%restart_reorder_occs = .false.
919 end if
920
921 call smear_init(st%smear, namespace, st%d%ispin, st%fixed_occ, integral_occs, kpoints)
922
923 unoccupied_states = (st%d%ispin /= spinors .and. st%nst*2 > st%qtot) .or. (st%d%ispin == spinors .and. st%nst > st%qtot)
924
925 if (.not. smear_is_semiconducting(st%smear) .and. .not. st%smear%method == smear_fixed_occ) then
926 if (.not. unoccupied_states) then
927 call messages_write('Smearing needs unoccupied states (via ExtraStates or TotalStates) to be useful.')
928 call messages_warning(namespace=namespace)
929 end if
930 end if
931
932 ! sanity check
933 charge = m_zero
934 do ist = 1, st%nst
935 charge = charge + sum(st%occ(ist, 1:st%nik) * st%kweights(1:st%nik))
936 end do
937 if (abs(charge - st%qtot) > 1e-6_real64) then
938 message(1) = "Initial occupations do not integrate to total charge."
939 write(message(2), '(6x,f12.6,a,f12.6)') charge, ' != ', st%qtot
940 call messages_fatal(2, only_root_writes = .true., namespace=namespace)
941 end if
942
943 st%uniform_occ = smear_is_semiconducting(st%smear) .and. .not. unoccupied_states
944
946 end subroutine states_elec_read_initial_occs
947
948
949 ! ---------------------------------------------------------
956 !
957 subroutine states_elec_read_initial_spins(st, namespace)
958 type(states_elec_t), intent(inout) :: st
959 type(namespace_t), intent(in) :: namespace
960
961 integer :: i, j, nrows
962 type(block_t) :: blk
963
965
966 st%fixed_spins = .false.
967 if (st%d%ispin /= spinors) then
969 return
970 end if
971
972 !%Variable InitialSpins
973 !%Type block
974 !%Section States
975 !%Description
976 !% The spin character of the initial random guesses for the spinors can
977 !% be fixed by making use of this block. Note that this will not "fix" the
978 !% the spins during the calculation (this cannot be done in spinors mode, in
979 !% being able to change the spins is why the spinors mode exists in the first
980 !% place).
981 !%
982 !% This block is meaningless and ignored if the run is not in spinors mode
983 !% (<tt>SpinComponents = spinors</tt>).
984 !%
985 !% The structure of the block is very simple: each column contains the desired
986 !% <math>\left< S_x \right>, \left< S_y \right>, \left< S_z \right> </math> for each spinor.
987 !% If the calculation is for a periodic system
988 !% and there is more than one <i>k</i>-point, the spins of all the <i>k</i>-points are
989 !% the same.
990 !%
991 !% For example, if we have two spinors, and we want one in the <math>S_x</math> "down" state,
992 !% and another one in the <math>S_x</math> "up" state:
993 !%
994 !% <tt>%InitialSpins
995 !% <br>&nbsp;&nbsp;&nbsp; 0.5 | 0.0 | 0.0
996 !% <br>&nbsp;&nbsp; -0.5 | 0.0 | 0.0
997 !% <br>%</tt>
998 !%
999 !% WARNING: if the calculation is for a system described by pseudopotentials (as
1000 !% opposed to user-defined potentials or model systems), this option is
1001 !% meaningless since the random spinors are overwritten by the atomic orbitals.
1002 !%
1003 !% This constraint must be fulfilled:
1004 !% <br><math> \left< S_x \right>^2 + \left< S_y \right>^2 + \left< S_z \right>^2 = \frac{1}{4} </math>
1005 !%End
1006 spin_fix: if (parse_block(namespace, 'InitialSpins', blk) == 0) then
1007 nrows = parse_block_n(blk)
1008 if (nrows < st%nst) then
1009 message(1) = "Please specify one row for each state in InitialSpins, also for extra states."
1010 call messages_fatal(1, namespace=namespace)
1011 end if
1012 do i = 1, st%nst
1013 do j = 1, 3
1014 call parse_block_float(blk, i-1, j-1, st%spin(j, i, 1))
1015 end do
1016 if (abs(sum(st%spin(1:3, i, 1)**2) - m_fourth) > 1.0e-6_real64) call messages_input_error(namespace, 'InitialSpins')
1017 end do
1018 call parse_block_end(blk)
1019 st%fixed_spins = .true.
1020 do i = 2, st%nik
1021 st%spin(:, :, i) = st%spin(:, :, 1)
1022 end do
1023 end if spin_fix
1024
1026 end subroutine states_elec_read_initial_spins
1027
1028
1029 ! ---------------------------------------------------------
1031 !
1032 subroutine states_elec_allocate_wfns(st, mesh, wfs_type, skip, packed)
1033 type(states_elec_t), intent(inout) :: st
1034 class(mesh_t), intent(in) :: mesh
1035 type(type_t), optional, intent(in) :: wfs_type
1036 logical, contiguous, optional, intent(in) :: skip(:)
1037 logical, optional, intent(in) :: packed
1038
1040
1041 if (present(wfs_type)) then
1042 assert(wfs_type == type_float .or. wfs_type == type_cmplx)
1043 st%wfs_type = wfs_type
1044 end if
1045
1046 call states_elec_init_block(st, mesh, skip = skip, packed=packed)
1047 call states_elec_set_zero(st)
1048
1050 end subroutine states_elec_allocate_wfns
1051
1052 !---------------------------------------------------------------------
1069 subroutine states_elec_init_block(st, mesh, verbose, skip, packed)
1070 type(states_elec_t), intent(inout) :: st
1071 type(mesh_t), intent(in) :: mesh
1072 logical, optional, intent(in) :: verbose
1073 logical, contiguous, optional, intent(in) :: skip(:)
1074 logical, optional, intent(in) :: packed
1075
1076 integer :: ib, iqn, ist, istmin, istmax
1077 logical :: same_node, verbose_, packed_
1078 integer, allocatable :: bstart(:), bend(:)
1079
1080 push_sub(states_elec_init_block)
1081
1082 safe_allocate(bstart(1:st%nst))
1083 safe_allocate(bend(1:st%nst))
1084 safe_allocate(st%group%iblock(1:st%nst))
1085
1086 st%group%iblock = 0
1087
1088 verbose_ = optional_default(verbose, .true.)
1089 packed_ = optional_default(packed, .false.)
1090
1091 !In case we have a list of state to skip, we do not allocate them
1092 istmin = 1
1093 if (present(skip)) then
1094 do ist = 1, st%nst
1095 if (.not. skip(ist)) then
1096 istmin = ist
1097 exit
1098 end if
1099 end do
1100 end if
1101
1102 istmax = st%nst
1103 if (present(skip)) then
1104 do ist = st%nst, istmin, -1
1105 if (.not. skip(ist)) then
1106 istmax = ist
1107 exit
1108 end if
1109 end do
1110 end if
1111
1112 if (present(skip) .and. verbose_) then
1113 call messages_write('Info: Allocating states from ')
1114 call messages_write(istmin, fmt = 'i8')
1115 call messages_write(' to ')
1116 call messages_write(istmax, fmt = 'i8')
1117 call messages_info()
1118 end if
1119
1120 ! count and assign blocks
1121 ib = 0
1122 st%group%nblocks = 0
1123 bstart(1) = istmin
1124 do ist = istmin, istmax
1125 ib = ib + 1
1126
1127 st%group%iblock(ist) = st%group%nblocks + 1
1128
1129 same_node = .true.
1130 if (st%parallel_in_states .and. ist /= istmax) then
1131 ! We have to avoid that states that are in different nodes end
1132 ! up in the same block
1133 same_node = (st%node(ist + 1) == st%node(ist))
1134 end if
1135
1136 if (ib == st%block_size .or. ist == istmax .or. .not. same_node) then
1137 ib = 0
1138 st%group%nblocks = st%group%nblocks + 1
1139 bend(st%group%nblocks) = ist
1140 if (ist /= istmax) bstart(st%group%nblocks + 1) = ist + 1
1141 end if
1142 end do
1143
1144 safe_allocate(st%group%psib(1:st%group%nblocks, st%d%kpt%start:st%d%kpt%end))
1145
1146 safe_allocate(st%group%block_is_local(1:st%group%nblocks, 1:st%nik))
1147 st%group%block_is_local = .false.
1148 st%group%block_start = -1
1149 st%group%block_end = -2 ! this will make that loops block_start:block_end do not run if not initialized
1150
1151 do ib = 1, st%group%nblocks
1152 if (bstart(ib) >= st%st_start .and. bend(ib) <= st%st_end) then
1153 if (st%group%block_start == -1) st%group%block_start = ib
1154 st%group%block_end = ib
1155 do iqn = st%d%kpt%start, st%d%kpt%end
1156 st%group%block_is_local(ib, iqn) = .true.
1157
1158 if (states_are_real(st)) then
1159 call dwfs_elec_init(st%group%psib(ib, iqn), st%d%dim, bstart(ib), bend(ib), mesh%np_part, iqn, &
1160 special=.true., packed=packed_)
1161 else
1162 call zwfs_elec_init(st%group%psib(ib, iqn), st%d%dim, bstart(ib), bend(ib), mesh%np_part, iqn, &
1163 special=.true., packed=packed_)
1164 end if
1165
1166 end do
1167 end if
1168 end do
1169
1170 safe_allocate(st%group%block_range(1:st%group%nblocks, 1:2))
1171 safe_allocate(st%group%block_size(1:st%group%nblocks))
1172
1173 st%group%block_range(1:st%group%nblocks, 1) = bstart(1:st%group%nblocks)
1174 st%group%block_range(1:st%group%nblocks, 2) = bend(1:st%group%nblocks)
1175 st%group%block_size(1:st%group%nblocks) = bend(1:st%group%nblocks) - bstart(1:st%group%nblocks) + 1
1176
1177 st%group%block_initialized = .true.
1178
1179 safe_allocate(st%group%block_node(1:st%group%nblocks, 1:st%nik))
1180 st%group%block_node = 0
1181
1182 assert(allocated(st%node))
1183 assert(all(st%node >= 0) .and. all(st%node < st%mpi_grp%size))
1184
1185 do iqn = st%d%kpt%start, st%d%kpt%end
1186 do ib = st%group%block_start, st%group%block_end
1187 st%group%block_node(ib, iqn) = st%st_kpt_mpi_grp%rank
1188 end do
1189 end do
1190
1191 call comm_allreduce(st%st_kpt_mpi_grp, st%group%block_node)
1192
1193 if (verbose_) then
1194 call messages_write('Info: Blocks of states')
1195 call messages_info()
1196 do ib = 1, st%group%nblocks
1197 call messages_write(' Block ')
1198 call messages_write(ib, fmt = 'i8')
1199 call messages_write(' contains ')
1200 call messages_write(st%group%block_size(ib), fmt = 'i8')
1201 call messages_write(' states')
1202 if (st%group%block_size(ib) > 0) then
1203 call messages_write(':')
1204 call messages_write(st%group%block_range(ib, 1), fmt = 'i8')
1205 call messages_write(' - ')
1206 call messages_write(st%group%block_range(ib, 2), fmt = 'i8')
1207 end if
1208 call messages_info()
1209 end do
1210 end if
1211
1212!!$!!!!DEBUG
1213!!$ ! some debug output that I will keep here for the moment
1214!!$ if (st%system_grp%is_root()) then
1215!!$ print*, "NST ", st%nst
1216!!$ print*, "BLOCKSIZE ", st%block_size
1217!!$ print*, "NBLOCKS ", st%group%nblocks
1218!!$
1219!!$ print*, "==============="
1220!!$ do ist = 1, st%nst
1221!!$ print*, st%node(ist), ist, st%group%iblock(ist)
1222!!$ end do
1223!!$ print*, "==============="
1224!!$
1225!!$ do ib = 1, st%group%nblocks
1226!!$ print*, ib, bstart(ib), bend(ib)
1227!!$ end do
1228!!$
1229!!$ end if
1230!!$!!!!ENDOFDEBUG
1231
1232 safe_deallocate_a(bstart)
1233 safe_deallocate_a(bend)
1234 pop_sub(states_elec_init_block)
1235 end subroutine states_elec_init_block
1236
1237
1238 ! ---------------------------------------------------------
1240 subroutine states_elec_deallocate_wfns(st)
1241 type(states_elec_t), intent(inout) :: st
1242
1244
1245 call states_elec_group_end(st%group, st%d)
1246 ! The wave functions (and their device buffers) are gone, so the batches
1247 ! are no longer packed. Reset the flag so a subsequent st%pack() actually
1248 ! repacks instead of returning early on a stale value.
1249 st%packed = .false.
1250
1252 end subroutine states_elec_deallocate_wfns
1253
1254
1255 ! ---------------------------------------------------------
1256 subroutine states_elec_densities_init(st, gr)
1257 type(states_elec_t), target, intent(inout) :: st
1258 type(grid_t), intent(in) :: gr
1259
1260 real(real64) :: fsize
1261
1263
1264 safe_allocate(st%rho(1:gr%np_part, 1:st%d%nspin))
1265 st%rho = m_zero
1266
1267 fsize = gr%np_part*8.0_real64*st%block_size
1268
1269 call messages_write('Info: states-block size = ')
1270 call messages_write(fsize, fmt = '(f10.1)', align_left = .true., units = unit_megabytes, print_units = .true.)
1271 call messages_info()
1272
1274 end subroutine states_elec_densities_init
1275
1276 !---------------------------------------------------------------------
1277 subroutine states_elec_allocate_current(st, space, mesh)
1278 type(states_elec_t), intent(inout) :: st
1279 class(space_t), intent(in) :: space
1280 class(mesh_t), intent(in) :: mesh
1281
1283
1284 if (.not. allocated(st%current)) then
1285 safe_allocate(st%current(1:mesh%np_part, 1:space%dim, 1:st%d%nspin))
1286 st%current = m_zero
1287 end if
1288
1289 if (.not. allocated(st%current_para)) then
1290 safe_allocate(st%current_para(1:mesh%np_part, 1:space%dim, 1:st%d%nspin))
1291 st%current_para = m_zero
1292 end if
1293
1294 if (.not. allocated(st%current_dia)) then
1295 safe_allocate(st%current_dia(1:mesh%np_part, 1:space%dim, 1:st%d%nspin))
1296 st%current_dia= m_zero
1297 end if
1298
1299 if (.not. allocated(st%current_mag)) then
1300 safe_allocate(st%current_mag(1:mesh%np_part, 1:space%dim, 1:st%d%nspin))
1301 st%current_mag= m_zero
1302 end if
1303
1304 if (.not. allocated(st%current_kpt)) then
1305 safe_allocate(st%current_kpt(1:mesh%np,1:space%dim,st%d%kpt%start:st%d%kpt%end))
1306 st%current_kpt = m_zero
1307 end if
1308
1310 end subroutine states_elec_allocate_current
1311
1312 !---------------------------------------------------------------------
1320 subroutine states_elec_exec_init(st, namespace, mc)
1321 type(states_elec_t), intent(inout) :: st
1322 type(namespace_t), intent(in) :: namespace
1323 type(multicomm_t), intent(in) :: mc
1324
1325 integer :: default
1326
1327 push_sub(states_elec_exec_init)
1329 !%Variable StatesPack
1330 !%Type logical
1331 !%Section Execution::Optimization
1332 !%Description
1333 !% When set to yes, states are stored in packed mode, which improves
1334 !% performance considerably. Not all parts of the code will profit from
1335 !% this, but should nevertheless work regardless of how the states are
1336 !% stored.
1337 !%
1338 !% If GPUs are used and this variable is set to yes, Octopus
1339 !% will store the wave-functions in device (GPU) memory. If
1340 !% there is not enough memory to store all the wave-functions,
1341 !% execution will stop with an error.
1342 !%
1343 !% See also the related <tt>HamiltonianApplyPacked</tt> variable.
1344 !%
1345 !% The default is yes.
1346 !%End
1347
1348 call parse_variable(namespace, 'StatesPack', .true., st%pack_states)
1350 call messages_print_var_value('StatesPack', st%pack_states, namespace=namespace)
1351
1352 call messages_obsolete_variable(namespace, 'StatesMirror')
1353
1354 !%Variable StatesOrthogonalization
1355 !%Type integer
1356 !%Section SCF::Eigensolver
1357 !%Description
1358 !% The full orthogonalization method used by some
1359 !% eigensolvers. The default is <tt>cholesky_serial</tt>, except with state
1360 !% parallelization, the default is <tt>cholesky_parallel</tt>.
1361 !%Option cholesky_serial 1
1362 !% Cholesky decomposition implemented using
1363 !% BLAS/LAPACK. Can be used with domain parallelization but not
1364 !% state parallelization.
1365 !%Option cholesky_parallel 2
1366 !% Cholesky decomposition implemented using
1367 !% ScaLAPACK. Compatible with states parallelization.
1368 !%Option cgs 3
1369 !% Classical Gram-Schmidt (CGS) orthogonalization.
1370 !% Can be used with domain parallelization but not state parallelization.
1371 !% The algorithm is defined in Giraud et al., Computers and Mathematics with Applications 50, 1069 (2005).
1372 !%Option mgs 4
1373 !% Modified Gram-Schmidt (MGS) orthogonalization.
1374 !% Can be used with domain parallelization but not state parallelization.
1375 !% The algorithm is defined in Giraud et al., Computers and Mathematics with Applications 50, 1069 (2005).
1376 !%Option drcgs 5
1377 !% Classical Gram-Schmidt orthogonalization with double-step reorthogonalization.
1378 !% Can be used with domain parallelization but not state parallelization.
1379 !% The algorithm is taken from Giraud et al., Computers and Mathematics with Applications 50, 1069 (2005).
1380 !% According to this reference, this is much more precise than CGS or MGS algorithms.
1381 !% The MGS version seems not to improve much the stability and would require more communications over the domains.
1382 !%End
1383
1384 default = option__statesorthogonalization__cholesky_serial
1385#ifdef HAVE_SCALAPACK
1387 default = option__statesorthogonalization__cholesky_parallel
1388 end if
1389#endif
1390
1391 call parse_variable(namespace, 'StatesOrthogonalization', default, st%orth_method)
1393 if (.not. varinfo_valid_option('StatesOrthogonalization', st%orth_method)) then
1394 call messages_input_error(namespace, 'StatesOrthogonalization')
1395 end if
1396 call messages_print_var_option('StatesOrthogonalization', st%orth_method, namespace=namespace)
1397
1398 !%Variable StatesDeviceMemory
1399 !%Type float
1400 !%Section Execution::Optimization
1401 !%Default -512
1402 !%Description
1403 !% This variable selects the amount of device memory that
1404 !% will be used by Octopus to store the states.
1405 !%
1406 !% A positive number smaller than 1 indicates a fraction of the total
1407 !% device memory. A number larger than one indicates an absolute
1408 !% amount of memory in megabytes. A negative number indicates an
1409 !% amount of memory in megabytes that would be subtracted from
1410 !% the total device memory.
1411 !%End
1412 call parse_variable(namespace, 'StatesDeviceMemory', -512.0_real64, st%gpu_states_mem)
1413 call messages_obsolete_variable(namespace, 'StatesCLDeviceMemory', 'StatesDeviceMemory')
1414
1415 pop_sub(states_elec_exec_init)
1416 end subroutine states_elec_exec_init
1417
1418
1419 ! ---------------------------------------------------------
1421 !
1422 subroutine states_elec_copy(stout, stin, exclude_wfns, exclude_eigenval, special, dest_type, copy_data)
1423 type(states_elec_t), target, intent(inout) :: stout
1424 type(states_elec_t), intent(in) :: stin
1425 logical, optional, intent(in) :: exclude_wfns
1426 logical, optional, intent(in) :: exclude_eigenval
1427 logical, optional, intent(in) :: special
1428 type(type_t), optional, intent(in) :: dest_type
1430 logical, optional, intent(in) :: copy_data
1433
1434 logical :: exclude_wfns_
1435
1436 push_sub(states_elec_copy)
1437
1438 exclude_wfns_ = optional_default(exclude_wfns, .false.)
1439
1440 call states_elec_null(stout)
1441
1442 call states_elec_dim_copy(stout%d, stin%d)
1443 safe_allocate_source_a(stout%kweights, stin%kweights)
1444 stout%nik = stin%nik
1445
1446 call modelmb_particles_copy(stout%modelmbparticles, stin%modelmbparticles)
1447
1448 stout%wfs_type = stin%wfs_type
1449 if (present(dest_type)) then
1450 stout%wfs_type = dest_type
1451 end if
1452 stout%nst = stin%nst
1453 stout%block_size = stin%block_size
1454 stout%orth_method = stin%orth_method
1455
1456 stout%gpu_states_mem = stin%gpu_states_mem
1457 stout%pack_states = stin%pack_states
1458
1459 stout%only_userdef_istates = stin%only_userdef_istates
1460 stout%requires_generalized_overlap = stin%requires_generalized_overlap
1461
1462 if (.not. exclude_wfns_) then
1463 safe_allocate_source_a(stout%rho, stin%rho)
1464 end if
1465
1466 stout%uniform_occ = stin%uniform_occ
1467
1468 if (.not. optional_default(exclude_eigenval, .false.)) then
1469 safe_allocate_source_a(stout%eigenval, stin%eigenval)
1470 safe_allocate_source_a(stout%occ, stin%occ)
1471 safe_allocate_source_a(stout%spin, stin%spin)
1472 end if
1473
1474 ! the call to init_block is done at the end of this subroutine
1475 ! it allocates iblock, psib, block_is_local
1476 stout%group%nblocks = stin%group%nblocks
1477
1478 safe_allocate_source_a(stout%user_def_states, stin%user_def_states)
1479
1480 safe_allocate_source_a(stout%current, stin%current)
1481 safe_allocate_source_a(stout%current_kpt, stin%current_kpt)
1482 safe_allocate_source_a(stout%rho_core, stin%rho_core)
1483 safe_allocate_source_a(stout%frozen_rho, stin%frozen_rho)
1484 safe_allocate_source_a(stout%frozen_tau, stin%frozen_tau)
1485 safe_allocate_source_a(stout%frozen_gdens, stin%frozen_gdens)
1486 safe_allocate_source_a(stout%frozen_ldens, stin%frozen_ldens)
1487
1488 stout%fixed_occ = stin%fixed_occ
1489 stout%restart_fixed_occ = stin%restart_fixed_occ
1490
1491 stout%fixed_spins = stin%fixed_spins
1492
1493 stout%qtot = stin%qtot
1494 stout%val_charge = stin%val_charge
1495
1496 call smear_copy(stout%smear, stin%smear)
1497
1498 stout%parallel_in_states = stin%parallel_in_states
1499 call mpi_grp_copy(stout%mpi_grp, stin%mpi_grp)
1500 call mpi_grp_copy(stout%system_grp, stin%system_grp)
1501 call mpi_grp_copy(stout%dom_st_kpt_mpi_grp, stin%dom_st_kpt_mpi_grp)
1502 call mpi_grp_copy(stout%st_kpt_mpi_grp, stin%st_kpt_mpi_grp)
1503 call mpi_grp_copy(stout%dom_st_mpi_grp, stin%dom_st_mpi_grp)
1504 safe_allocate_source_a(stout%node, stin%node)
1505 safe_allocate_source_a(stout%st_kpt_task, stin%st_kpt_task)
1506
1507#ifdef HAVE_SCALAPACK
1508 call blacs_proc_grid_copy(stin%dom_st_proc_grid, stout%dom_st_proc_grid)
1509#endif
1510
1511 call distributed_copy(stin%dist, stout%dist)
1512
1513 stout%scalapack_compatible = stin%scalapack_compatible
1514
1515 stout%lnst = stin%lnst
1516 stout%st_start = stin%st_start
1517 stout%st_end = stin%st_end
1518
1519 if (stin%parallel_in_states) call multicomm_all_pairs_copy(stout%ap, stin%ap)
1520
1521 stout%symmetrize_density = stin%symmetrize_density
1522
1523 if (.not. exclude_wfns_) call states_elec_group_copy(stin%d, stin%group, stout%group, &
1524 copy_data=copy_data, special=special, dest_type=dest_type)
1525
1526 stout%packed = stin%packed
1527
1528 stout%randomization = stin%randomization
1529
1530 pop_sub(states_elec_copy)
1531 end subroutine states_elec_copy
1532
1533
1534 ! ---------------------------------------------------------
1536 !
1537 subroutine states_elec_end(st)
1538 type(states_elec_t), intent(inout) :: st
1539
1540 push_sub(states_elec_end)
1541
1542 call states_elec_dim_end(st%d)
1543
1544 call modelmb_particles_end(st%modelmbparticles)
1545
1546 ! this deallocates dpsi, zpsi, psib, iblock, iblock
1548
1549 safe_deallocate_a(st%user_def_states)
1550
1551 safe_deallocate_a(st%rho)
1552 safe_deallocate_a(st%eigenval)
1553
1554 safe_deallocate_a(st%current)
1555 safe_deallocate_a(st%current_para)
1556 safe_deallocate_a(st%current_dia)
1557 safe_deallocate_a(st%current_mag)
1558 safe_deallocate_a(st%current_kpt)
1559 safe_deallocate_a(st%rho_core)
1560 safe_deallocate_a(st%frozen_rho)
1561 safe_deallocate_a(st%frozen_tau)
1562 safe_deallocate_a(st%frozen_gdens)
1563 safe_deallocate_a(st%frozen_ldens)
1564 safe_deallocate_a(st%occ)
1565 safe_deallocate_a(st%spin)
1566 safe_deallocate_a(st%kweights)
1567
1568
1569#ifdef HAVE_SCALAPACK
1570 call blacs_proc_grid_end(st%dom_st_proc_grid)
1571#endif
1572
1573 call distributed_end(st%dist)
1574
1575 safe_deallocate_a(st%node)
1576 safe_deallocate_a(st%st_kpt_task)
1577
1578 if (st%parallel_in_states) then
1579 safe_deallocate_a(st%ap%schedule)
1580 end if
1581
1582 if (st%buff_density%allocated) call accel_free_buffer(st%buff_density)
1583
1584 pop_sub(states_elec_end)
1585 end subroutine states_elec_end
1586
1587
1588 ! TODO(Alex) Issue #684. Abstract duplicate code in states_elec_generate_random, to get it to
1589 ! a point where it can be refactored.
1591 subroutine states_elec_generate_random(st, mesh, kpoints, ist_start_, ist_end_, ikpt_start_, ikpt_end_, normalized)
1592 type(states_elec_t), intent(inout) :: st
1593 class(mesh_t), intent(in) :: mesh
1594 type(kpoints_t), intent(in) :: kpoints
1595 integer, optional, intent(in) :: ist_start_
1596 integer, optional, intent(in) :: ist_end_
1597 integer, optional, intent(in) :: ikpt_start_
1598 integer, optional, intent(in) :: ikpt_end_
1599 logical, optional, intent(in) :: normalized
1601
1602 integer :: ist, ik, id, ist_start, ist_end, jst, ikpt_start, ikpt_end
1603 complex(real64) :: alpha, beta, zdotp_tmp
1604 real(real64), allocatable :: dpsi(:, :)
1605 complex(real64), allocatable :: zpsi(:, :), zpsi2(:)
1606 integer :: ikpoint, ip
1607 type(batch_t) :: ffb
1608
1609 logical :: normalized_
1610
1611 normalized_ = optional_default(normalized, .true.)
1612
1614
1615 ist_start = optional_default(ist_start_, 1)
1616 ist_end = optional_default(ist_end_, st%nst)
1617 ikpt_start = optional_default(ikpt_start_, 1)
1618 ikpt_end = optional_default(ikpt_end_, st%nik)
1619
1620 safe_allocate(dpsi(1:mesh%np, 1:st%d%dim))
1621 if (states_are_complex(st)) then
1622 safe_allocate(zpsi(1:mesh%np, 1:st%d%dim))
1623 end if
1624
1625 select case (st%d%ispin)
1627
1628 do ik = ikpt_start, ikpt_end
1629 ikpoint = st%d%get_kpoint_index(ik)
1630 do ist = ist_start, ist_end
1631 if (states_are_real(st).or.kpoints_point_is_gamma(kpoints, ikpoint)) then
1632 if (st%randomization == par_independent) then
1633 call dmf_random(mesh, dpsi(:, 1), &
1634 pre_shift = mesh%pv%xlocal-1, &
1635 post_shift = mesh%pv%np_global - mesh%pv%xlocal - mesh%np + 1, &
1636 normalized = normalized)
1637 ! Ensures that the grid points are properly distributed in the domain parallel case
1638 if(mesh%parallel_in_domains) then
1639 call batch_init(ffb, dpsi(:,1))
1640 call dmesh_batch_exchange_points(mesh, ffb, backward_map = .true.)
1641 call ffb%end()
1642 end if
1643 else
1644 call dmf_random(mesh, dpsi(:, 1), normalized = normalized)
1645 end if
1646 if (.not. state_kpt_is_local(st, ist, ik)) cycle
1647 if (states_are_complex(st)) then !Gamma point
1648 do ip = 1, mesh%np
1649 zpsi(ip,1) = cmplx(dpsi(ip,1), m_zero, real64)
1650 end do
1651 call states_elec_set_state(st, mesh, ist, ik, zpsi)
1652 else
1653 call states_elec_set_state(st, mesh, ist, ik, dpsi)
1654 end if
1655 else
1656 if (st%randomization == par_independent) then
1657 call zmf_random(mesh, zpsi(:, 1), &
1658 pre_shift = mesh%pv%xlocal-1, &
1659 post_shift = mesh%pv%np_global - mesh%pv%xlocal - mesh%np + 1, &
1660 normalized = normalized)
1661 ! Ensures that the grid points are properly distributed in the domain parallel case
1662 if(mesh%parallel_in_domains) then
1663 call batch_init(ffb, zpsi(:,1))
1664 call zmesh_batch_exchange_points(mesh, ffb, backward_map = .true.)
1665 call ffb%end()
1666 end if
1667 else
1668 call zmf_random(mesh, zpsi(:, 1), normalized = normalized)
1669 end if
1670 if (.not. state_kpt_is_local(st, ist, ik)) cycle
1671 call states_elec_set_state(st, mesh, ist, ik, zpsi)
1672 end if
1673 end do
1674 end do
1675
1676 case (spinors)
1677
1678 assert(states_are_complex(st))
1679
1680 if (st%fixed_spins) then
1681
1682 do ik = ikpt_start, ikpt_end
1683 ikpoint = st%d%get_kpoint_index(ik)
1684 do ist = ist_start, ist_end
1685 if (kpoints_point_is_gamma(kpoints, ikpoint)) then
1686 if (st%randomization == par_independent) then
1687 call dmf_random(mesh, dpsi(:, 1), &
1688 pre_shift = mesh%pv%xlocal-1, &
1689 post_shift = mesh%pv%np_global - mesh%pv%xlocal - mesh%np + 1, &
1690 normalized = normalized)
1691 ! Ensures that the grid points are properly distributed in the domain parallel case
1692 if(mesh%parallel_in_domains) then
1693 call batch_init(ffb, dpsi(:,1))
1694 call dmesh_batch_exchange_points(mesh, ffb, backward_map = .true.)
1695 call ffb%end()
1696 end if
1697 else
1698 call dmf_random(mesh, dpsi(:, 1), normalized = normalized)
1699 if (.not. state_kpt_is_local(st, ist, ik)) cycle
1700 end if
1701 do ip = 1, mesh%np
1702 zpsi(ip,1) = cmplx(dpsi(ip,1), m_zero, real64)
1703 end do
1704 call states_elec_set_state(st, mesh, ist, ik, zpsi)
1705 else
1706 if (st%randomization == par_independent) then
1707 call zmf_random(mesh, zpsi(:, 1), &
1708 pre_shift = mesh%pv%xlocal-1, &
1709 post_shift = mesh%pv%np_global - mesh%pv%xlocal - mesh%np + 1, &
1710 normalized = normalized)
1711 ! Ensures that the grid points are properly distributed in the domain parallel case
1712 if(mesh%parallel_in_domains) then
1713 call batch_init(ffb, zpsi(:,1))
1714 call zmesh_batch_exchange_points(mesh, ffb, backward_map = .true.)
1715 call ffb%end()
1716 end if
1717 else
1718 call zmf_random(mesh, zpsi(:, 1), normalized = normalized)
1719 if (.not. state_kpt_is_local(st, ist, ik)) cycle
1720 end if
1721 end if
1722 if (.not. state_kpt_is_local(st, ist, ik)) cycle
1723 ! In this case, the spinors are made of a spatial part times a vector [alpha beta]^T in
1724 ! spin space (i.e., same spatial part for each spin component). So (alpha, beta)
1725 ! determines the spin values. The values of (alpha, beta) can be be obtained
1726 ! with simple formulae from <Sx>, <Sy>, <Sz>.
1727 !
1728 ! Note that here we orthonormalize the orbital part. This ensures that the spinors
1729 ! are untouched later in the general orthonormalization, and therefore the spin values
1730 ! of each spinor remain the same.
1731 safe_allocate(zpsi2(1:mesh%np))
1732 do jst = ist_start, ist - 1
1733 call states_elec_get_state(st, mesh, 1, jst, ik, zpsi2)
1734 zdotp_tmp = zmf_dotp(mesh, zpsi(:, 1), zpsi2)
1735 call lalg_axpy(mesh%np, -zdotp_tmp, zpsi2, zpsi(:, 1))
1736 end do
1737 safe_deallocate_a(zpsi2)
1738
1739 call zmf_normalize(mesh, 1, zpsi)
1740 zpsi(1:mesh%np, 2) = zpsi(1:mesh%np, 1)
1741
1742 alpha = cmplx(sqrt(m_half + st%spin(3, ist, ik)), m_zero, real64)
1743 beta = cmplx(sqrt(m_one - abs(alpha)**2), m_zero, real64)
1744 if (abs(alpha) > m_epsilon) then
1745 beta = cmplx(st%spin(1, ist, ik) / abs(alpha), st%spin(2, ist, ik) / abs(alpha), real64)
1746 end if
1747 call lalg_scal(mesh%np, alpha, zpsi(:, 1))
1748 call lalg_scal(mesh%np, beta, zpsi(:, 2))
1749 call states_elec_set_state(st, mesh, ist, ik, zpsi)
1750 end do
1751 end do
1752 else
1753 do ik = ikpt_start, ikpt_end
1754 do ist = ist_start, ist_end
1755 do id = 1, st%d%dim
1756 if (st%randomization == par_independent) then
1757 call zmf_random(mesh, zpsi(:, id), &
1758 pre_shift = mesh%pv%xlocal-1, &
1759 post_shift = mesh%pv%np_global - mesh%pv%xlocal - mesh%np + 1, &
1760 normalized = .false.)
1761 ! Ensures that the grid points are properly distributed in the domain parallel case
1762 if(mesh%parallel_in_domains) then
1763 call batch_init(ffb, zpsi(:, id))
1764 call zmesh_batch_exchange_points(mesh, ffb, backward_map = .true.)
1765 call ffb%end()
1766 end if
1767 else
1768 call zmf_random(mesh, zpsi(:, id), normalized = .false.)
1769 end if
1770 end do
1771 ! We need to generate the wave functions even if not using them in order to be consistent
1772 ! with the random seed in parallel runs.
1773 if (.not. state_kpt_is_local(st, ist, ik)) cycle
1774 ! Note that mf_random normalizes each spin channel independently to 1.
1775 ! Therefore we need to renormalize the spinor:
1776 if (normalized_) call zmf_normalize(mesh, st%d%dim, zpsi)
1777 call states_elec_set_state(st, mesh, ist, ik, zpsi)
1778 end do
1779 end do
1780 end if
1781
1782 end select
1783
1784 safe_deallocate_a(dpsi)
1785 safe_deallocate_a(zpsi)
1786
1788 end subroutine states_elec_generate_random
1789
1790 ! ---------------------------------------------------------
1792 !
1793 subroutine states_elec_fermi(st, namespace, mesh, compute_spin)
1794 type(states_elec_t), intent(inout) :: st
1795 type(namespace_t), intent(in) :: namespace
1796 class(mesh_t), intent(in) :: mesh
1797 logical, optional, intent(in) :: compute_spin
1798
1800 integer :: ist, ik
1801 real(real64) :: charge
1802 complex(real64), allocatable :: zpsi(:, :)
1803
1804 push_sub(states_elec_fermi)
1805
1806 call smear_find_fermi_energy(st%smear, namespace, st%eigenval, st%occ, st%qtot, &
1807 st%nik, st%nst, st%kweights)
1808
1809 call smear_fill_occupations(st%smear, st%eigenval, st%occ, st%kweights, st%nik, st%nst)
1810
1811 ! check if everything is OK
1812 charge = m_zero
1813 do ist = 1, st%nst
1814 charge = charge + sum(st%occ(ist, 1:st%nik) * st%kweights(1:st%nik))
1815 end do
1816 if (abs(charge-st%qtot) > 1e-6_real64) then
1817 message(1) = 'Occupations do not integrate to total charge.'
1818 write(message(2), '(6x,f12.8,a,f12.8)') charge, ' != ', st%qtot
1819 call messages_warning(2, namespace=namespace)
1820 if (charge < m_epsilon) then
1821 message(1) = "There don't seem to be any electrons at all!"
1822 call messages_fatal(1, namespace=namespace)
1823 end if
1824 end if
1825
1826 if (st%d%ispin == spinors .and. optional_default(compute_spin,.true.)) then
1827 assert(states_are_complex(st))
1828
1829 st%spin(:,:,:) = m_zero
1830
1831 safe_allocate(zpsi(1:mesh%np, st%d%dim))
1832 do ik = st%d%kpt%start, st%d%kpt%end
1833 do ist = st%st_start, st%st_end
1834 call states_elec_get_state(st, mesh, ist, ik, zpsi)
1835 st%spin(1:3, ist, ik) = state_spin(mesh, zpsi)
1836 end do
1837 end do
1838 safe_deallocate_a(zpsi)
1839
1840 if (st%parallel_in_states .or. st%d%kpt%parallel) then
1841 call comm_allreduce(st%st_kpt_mpi_grp, st%spin)
1842 end if
1843
1844 end if
1845
1846 pop_sub(states_elec_fermi)
1847 end subroutine states_elec_fermi
1848
1849
1850 ! ---------------------------------------------------------
1852 !
1853 function states_elec_eigenvalues_sum(st, alt_eig) result(tot)
1854 type(states_elec_t), intent(in) :: st
1855 real(real64), optional, intent(in) :: alt_eig(st%st_start:, st%d%kpt%start:)
1857 real(real64) :: tot
1858
1859 integer :: ik
1860
1862
1863 tot = m_zero
1864 do ik = st%d%kpt%start, st%d%kpt%end
1865 if (present(alt_eig)) then
1866 tot = tot + st%kweights(ik) * sum(st%occ(st%st_start:st%st_end, ik) * &
1867 alt_eig(st%st_start:st%st_end, ik))
1868 else
1869 tot = tot + st%kweights(ik) * sum(st%occ(st%st_start:st%st_end, ik) * &
1870 st%eigenval(st%st_start:st%st_end, ik))
1871 end if
1872 end do
1873
1874 if (st%parallel_in_states .or. st%d%kpt%parallel) call comm_allreduce(st%st_kpt_mpi_grp, tot)
1875
1877 end function states_elec_eigenvalues_sum
1878
1879
1881 subroutine states_elec_distribute_nodes(st, namespace, mc)
1882 type(states_elec_t), intent(inout) :: st
1883 type(namespace_t), intent(in) :: namespace
1884 type(multicomm_t), intent(in) :: mc
1885
1886 logical :: default_scalapack_compatible
1887
1889
1890 ! TODO(Alex) Issue #820. This is superflous. These defaults are set in initialisation of
1891 ! states, and in the state distribution instance
1892 ! Defaults.
1893 st%node(:) = 0
1894 st%st_start = 1
1895 st%st_end = st%nst
1896 st%lnst = st%nst
1897 st%parallel_in_states = .false.
1898
1899 call mpi_grp_init(st%mpi_grp, mc%group_comm(p_strategy_states))
1900 call mpi_grp_init(st%system_grp, mc%master_comm)
1901 call mpi_grp_init(st%dom_st_kpt_mpi_grp, mc%dom_st_kpt_comm)
1902 call mpi_grp_init(st%dom_st_mpi_grp, mc%dom_st_comm)
1903 call mpi_grp_init(st%st_kpt_mpi_grp, mc%st_kpt_comm)
1904
1905 default_scalapack_compatible = calc_mode_par%scalapack_compat() .and. .not. st%d%kpt%parallel
1906
1907 !%Variable ScaLAPACKCompatible
1908 !%Type logical
1909 !%Section Execution::Parallelization
1910 !%Description
1911 !% Whether to use a layout for states parallelization which is compatible with ScaLAPACK.
1912 !% The default is yes for <tt>CalculationMode = gs, unocc, go</tt> without k-point parallelization,
1913 !% and no otherwise. (Setting to other than default is experimental.)
1914 !% The value must be yes if any ScaLAPACK routines are called in the course of the run;
1915 !% it must be set by hand for <tt>td</tt> with <tt>TDDynamics = bo</tt>.
1916 !% This variable has no effect unless you are using states parallelization and have linked ScaLAPACK.
1917 !% Note: currently, use of ScaLAPACK is not compatible with task parallelization (<i>i.e.</i> slaves).
1918 !%End
1919 call parse_variable(namespace, 'ScaLAPACKCompatible', default_scalapack_compatible, st%scalapack_compatible)
1920
1921#ifdef HAVE_SCALAPACK
1922 if (default_scalapack_compatible .neqv. st%scalapack_compatible) then
1923 call messages_experimental('Setting ScaLAPACKCompatible to other than default', namespace=namespace)
1924 end if
1926 if (st%scalapack_compatible) then
1927 if (multicomm_have_slaves(mc)) then
1928 call messages_not_implemented("ScaLAPACK usage with task parallelization (slaves)", namespace=namespace)
1929 end if
1930 call blacs_proc_grid_init(st%dom_st_proc_grid, st%dom_st_mpi_grp)
1931 end if
1932#else
1933 st%scalapack_compatible = .false.
1934#endif
1935
1937
1938#ifdef HAVE_MPI
1939 call multicomm_create_all_pairs(st%mpi_grp, st%ap)
1940#endif
1941
1942 if (st%nst < st%mpi_grp%size) then
1943 message(1) = "Have more processors than necessary"
1944 write(message(2),'(i4,a,i4,a)') st%mpi_grp%size, " processors and ", st%nst, " states."
1945 call messages_fatal(2, namespace=namespace)
1946 end if
1947
1948 call distributed_init(st%dist, st%nst, st%mpi_grp%comm, "states", scalapack_compat = st%scalapack_compatible)
1949
1950 st%parallel_in_states = st%dist%parallel
1951
1952 ! TODO(Alex) Issue #820. Remove lnst, st_start, st_end and node, as they are all contained within dist
1953 st%st_start = st%dist%start
1954 st%st_end = st%dist%end
1955 st%lnst = st%dist%nlocal()
1956 st%node(1:st%nst) = st%dist%process(1:st%nst)
1957
1958 end if
1959
1961
1963 end subroutine states_elec_distribute_nodes
1964
1965
1971 !
1972 subroutine states_elec_calc_quantities(gr, st, kpoints, nlcc, &
1973 kinetic_energy_density, paramagnetic_current, density_gradient, density_laplacian, &
1974 gi_kinetic_energy_density, st_end)
1975 type(grid_t), intent(in) :: gr
1976 type(states_elec_t), intent(in) :: st
1977 type(kpoints_t), intent(in) :: kpoints
1978 logical, intent(in) :: nlcc
1979 real(real64), contiguous, optional, target, intent(out) :: kinetic_energy_density(:,:)
1980 real(real64), contiguous, optional, target, intent(out) :: paramagnetic_current(:,:,:)
1981 real(real64), contiguous, optional, intent(out) :: density_gradient(:,:,:)
1982 real(real64), contiguous, optional, intent(out) :: density_laplacian(:,:)
1983 real(real64), contiguous, optional, intent(out) :: gi_kinetic_energy_density(:,:)
1984 integer, optional, intent(in) :: st_end
1985
1986 real(real64), pointer, contiguous :: jp(:, :, :)
1987 real(real64), pointer, contiguous :: tau(:, :)
1988 complex(real64), allocatable :: wf_psi(:,:), gwf_psi(:,:,:), wf_psi_conj(:,:), lwf_psi(:,:)
1989 real(real64), allocatable :: abs_wf_psi(:,:), abs_gwf_psi(:,:)
1990 complex(real64), allocatable :: psi_gpsi(:,:)
1991 complex(real64) :: c_tmp
1992 integer :: is, ik, ist, i_dim, st_dim, ii, st_end_
1993 real(real64) :: ww, kpoint(gr%der%dim)
1994 logical :: something_to_do
1995
1996 call profiling_in("STATES_CALC_QUANTITIES")
1997
1999
2000 st_end_ = min(st%st_end, optional_default(st_end, st%st_end))
2001
2002 something_to_do = present(kinetic_energy_density) .or. present(gi_kinetic_energy_density) .or. &
2003 present(paramagnetic_current) .or. present(density_gradient) .or. present(density_laplacian)
2004 assert(something_to_do)
2005
2006 safe_allocate( wf_psi(1:gr%np_part, 1:st%d%dim))
2007 safe_allocate( wf_psi_conj(1:gr%np_part, 1:st%d%dim))
2008 safe_allocate(gwf_psi(1:gr%np, 1:gr%der%dim, 1:st%d%dim))
2009 safe_allocate(abs_wf_psi(1:gr%np, 1:st%d%dim))
2010 safe_allocate(abs_gwf_psi(1:gr%np, 1:st%d%dim))
2011 safe_allocate(psi_gpsi(1:gr%np, 1:st%d%dim))
2012 if (present(density_laplacian)) then
2013 safe_allocate(lwf_psi(1:gr%np, 1:st%d%dim))
2014 end if
2015
2016 nullify(tau)
2017 if (present(kinetic_energy_density)) tau => kinetic_energy_density
2018
2019 nullify(jp)
2020 if (present(paramagnetic_current)) jp => paramagnetic_current
2021
2022 ! for the gauge-invariant kinetic energy density we need the
2023 ! current and the kinetic energy density
2024 if (present(gi_kinetic_energy_density)) then
2025 if (.not. present(paramagnetic_current) .and. states_are_complex(st)) then
2026 safe_allocate(jp(1:gr%np, 1:gr%der%dim, 1:st%d%nspin))
2027 end if
2028 if (.not. present(kinetic_energy_density)) then
2029 safe_allocate(tau(1:gr%np, 1:st%d%nspin))
2030 end if
2031 end if
2033 if (associated(tau)) tau = m_zero
2034 if (associated(jp)) jp = m_zero
2035 if (present(density_gradient)) density_gradient(:,:,:) = m_zero
2036 if (present(density_laplacian)) density_laplacian(:,:) = m_zero
2037 if (present(gi_kinetic_energy_density)) gi_kinetic_energy_density = m_zero
2038
2039 do ik = st%d%kpt%start, st%d%kpt%end
2040
2041 kpoint(1:gr%der%dim) = kpoints%get_point(st%d%get_kpoint_index(ik))
2042 is = st%d%get_spin_index(ik)
2043
2044 do ist = st%st_start, st_end_
2045 ww = st%kweights(ik)*st%occ(ist, ik)
2046 if (abs(ww) <= m_epsilon) cycle
2047
2048 ! all calculations will be done with complex wavefunctions
2049 call states_elec_get_state(st, gr, ist, ik, wf_psi)
2050
2051 do st_dim = 1, st%d%dim
2052 call boundaries_set(gr%der%boundaries, gr, wf_psi(:, st_dim))
2053 end do
2054
2055 ! calculate gradient of the wavefunction
2056 do st_dim = 1, st%d%dim
2057 call zderivatives_grad(gr%der, wf_psi(:,st_dim), gwf_psi(:,:,st_dim), set_bc = .false.)
2058 end do
2059
2060 ! calculate the Laplacian of the wavefunction
2061 if (present(density_laplacian)) then
2062 do st_dim = 1, st%d%dim
2063 call zderivatives_lapl(gr%der, wf_psi(:,st_dim), lwf_psi(:,st_dim), ghost_update = .false., set_bc = .false.)
2064 end do
2065 end if
2066
2067 ! We precompute some quantites, to avoid to compute it many times
2068 wf_psi_conj(1:gr%np, 1:st%d%dim) = conjg(wf_psi(1:gr%np,1:st%d%dim))
2069 !$omp parallel do collapse(2)
2070 do st_dim = 1, st%d%dim
2071 do ii = 1, gr%np
2072 abs_wf_psi(ii, st_dim) = real(wf_psi_conj(ii, st_dim) * wf_psi(ii, st_dim), real64)
2073 end do
2074 end do
2075 !$omp end parallel do
2076
2077 if (present(density_laplacian)) then
2078 !$omp parallel do
2079 do ii = 1, gr%np
2080 density_laplacian(ii, is) = density_laplacian(ii, is) + &
2081 ww * m_two*real(wf_psi_conj(ii, 1) * lwf_psi(ii, 1), real64)
2082 end do
2083 !$omp end parallel do
2084 if (st%d%ispin == spinors) then
2085 !$omp parallel do
2086 do ii = 1, gr%np
2087 density_laplacian(ii, 2) = density_laplacian(ii, 2) + &
2088 ww * m_two*real(wf_psi_conj(ii, 2) * lwf_psi(ii, 2), real64)
2089 end do
2090 !$omp end parallel do
2091 !$omp parallel do private(c_tmp)
2092 do ii = 1, gr%np
2093 c_tmp = ww*(lwf_psi(ii, 1) * wf_psi_conj(ii, 2) + wf_psi(ii, 1) * conjg(lwf_psi(ii, 2)))
2094 density_laplacian(ii, 3) = density_laplacian(ii, 3) + real(c_tmp, real64)
2095 density_laplacian(ii, 4) = density_laplacian(ii, 4) + aimag(c_tmp)
2096 end do
2097 end if
2098 end if
2099
2100 if (associated(tau)) then
2101 call lalg_axpy(gr%np, ww * sum(kpoint(1:gr%der%dim)**2), abs_wf_psi(:, 1), tau(:, is))
2102 if (st%d%ispin == spinors) then
2103 call lalg_axpy(gr%np, ww * sum(kpoint(1:gr%der%dim)**2), abs_wf_psi(:, 2), tau(:, 2))
2104
2105 !$omp parallel do private(c_tmp)
2106 do ii = 1, gr%np
2107 c_tmp = ww * sum(kpoint(1:gr%der%dim)**2) * wf_psi(ii, 1) * wf_psi_conj(ii, 2)
2108 tau(ii, 3) = tau(ii, 3) + real(c_tmp, real64)
2109 tau(ii, 4) = tau(ii, 4) + aimag(c_tmp)
2110 end do
2111 end if
2112 end if
2113
2114 do i_dim = 1, gr%der%dim
2115
2116 ! We precompute some quantites, to avoid to compute them many times
2117 !$omp parallel private(st_dim, ii)
2118 do st_dim = 1, st%d%dim
2119 !$omp do
2120 do ii = 1, gr%np
2121 psi_gpsi(ii, st_dim) = wf_psi_conj(ii, st_dim) * gwf_psi(ii, i_dim, st_dim)
2122 end do
2123 end do
2124 do st_dim = 1, st%d%dim
2125 !$omp do
2126 do ii = 1, gr%np
2127 abs_gwf_psi(ii, st_dim) = real(conjg(gwf_psi(ii, i_dim, st_dim)) &
2128 * gwf_psi(ii, i_dim, st_dim), real64)
2129 end do
2130 end do
2131 !$omp end parallel
2132
2133 if (present(density_gradient)) then
2134 !$omp parallel do
2135 do ii = 1, gr%np
2136 density_gradient(ii, i_dim, is) = density_gradient(ii, i_dim, is) &
2137 + ww * m_two * real(psi_gpsi(ii, 1), real64)
2138 end do
2139 !$omp end parallel do
2140 if (st%d%ispin == spinors) then
2141 !$omp parallel do
2142 do ii = 1, gr%np
2143 density_gradient(ii, i_dim, 2) = density_gradient(ii, i_dim, 2) &
2144 + ww * m_two*real(psi_gpsi(ii, 2), real64)
2145 end do
2146 !$omp end parallel do
2147 !$omp parallel do private(c_tmp)
2148 do ii = 1, gr%np
2149 c_tmp = ww * (gwf_psi(ii, i_dim, 1) * wf_psi_conj(ii, 2) + wf_psi(ii, 1) * conjg(gwf_psi(ii, i_dim, 2)))
2150 density_gradient(ii, i_dim, 3) = density_gradient(ii, i_dim, 3) + real(c_tmp, real64)
2151 density_gradient(ii, i_dim, 4) = density_gradient(ii, i_dim, 4) + aimag(c_tmp)
2152 end do
2153 end if
2154 end if
2155
2156 if (present(density_laplacian)) then
2157 call lalg_axpy(gr%np, ww*m_two, abs_gwf_psi(:,1), density_laplacian(:,is))
2158 if (st%d%ispin == spinors) then
2159 call lalg_axpy(gr%np, ww*m_two, abs_gwf_psi(:,2), density_laplacian(:,2))
2160 !$omp parallel do private(c_tmp)
2161 do ii = 1, gr%np
2162 c_tmp = m_two * ww * gwf_psi(ii, i_dim, 1) * conjg(gwf_psi(ii, i_dim, 2))
2163 density_laplacian(ii, 3) = density_laplacian(ii, 3) + real(c_tmp, real64)
2164 density_laplacian(ii, 4) = density_laplacian(ii, 4) + aimag(c_tmp)
2165 end do
2166 end if
2167 end if
2168
2169 ! the expression for the paramagnetic current with spinors is
2170 ! j = ( jp(1) jp(3) + i jp(4) )
2171 ! (-jp(3) + i jp(4) jp(2) )
2172 if (associated(jp)) then
2173 if (.not.(states_are_real(st))) then
2174 !$omp parallel do
2175 do ii = 1, gr%np
2176 jp(ii, i_dim, is) = jp(ii, i_dim, is) + &
2177 ww*(aimag(psi_gpsi(ii, 1)) - abs_wf_psi(ii, 1)*kpoint(i_dim))
2178 end do
2179 !$omp end parallel do
2180 if (st%d%ispin == spinors) then
2181 !$omp parallel do
2182 do ii = 1, gr%np
2183 jp(ii, i_dim, 2) = jp(ii, i_dim, 2) + &
2184 ww*( aimag(psi_gpsi(ii, 2)) - abs_wf_psi(ii, 2)*kpoint(i_dim))
2185 end do
2186 !$omp end parallel do
2187 !$omp parallel do private(c_tmp)
2188 do ii = 1, gr%np
2189 c_tmp = -ww*m_half*m_zi*(gwf_psi(ii, i_dim, 1)*wf_psi_conj(ii, 2) - wf_psi(ii, 1)*conjg(gwf_psi(ii, i_dim, 2)) &
2190 - m_two * m_zi*wf_psi(ii, 1)*wf_psi_conj(ii, 2)*kpoint(i_dim))
2191 jp(ii, i_dim, 3) = jp(ii, i_dim, 3) + real(c_tmp, real64)
2192 jp(ii, i_dim, 4) = jp(ii, i_dim, 4) + aimag(c_tmp)
2193 end do
2194 end if
2195 end if
2196 end if
2197
2198 ! the expression for the paramagnetic current with spinors is
2199 ! t = ( tau(1) tau(3) + i tau(4) )
2200 ! ( tau(3) - i tau(4) tau(2) )
2201 if (associated(tau)) then
2202 !$omp parallel do
2203 do ii = 1, gr%np
2204 tau(ii, is) = tau(ii, is) + ww*(abs_gwf_psi(ii,1) &
2205 - m_two*aimag(psi_gpsi(ii, 1))*kpoint(i_dim))
2206 end do
2207 !$omp end parallel do
2208 if (st%d%ispin == spinors) then
2209 !$omp parallel do
2210 do ii = 1, gr%np
2211 tau(ii, 2) = tau(ii, 2) + ww*(abs_gwf_psi(ii, 2) &
2212 - m_two*aimag(psi_gpsi(ii, 2))*kpoint(i_dim))
2213 end do
2214 !$omp end parallel do
2215 !$omp parallel do private(c_tmp)
2216 do ii = 1, gr%np
2217 c_tmp = ww * ( gwf_psi(ii, i_dim, 1)*conjg(gwf_psi(ii, i_dim, 2)) &
2218 + m_zi * (gwf_psi(ii,i_dim,1)*wf_psi_conj(ii, 2) &
2219 - wf_psi(ii, 1)*conjg(gwf_psi(ii,i_dim,2)))*kpoint(i_dim))
2220 tau(ii, 3) = tau(ii, 3) + real(c_tmp, real64)
2221 tau(ii, 4) = tau(ii, 4) + aimag(c_tmp)
2222 end do
2223 end if
2224 end if
2225
2226 end do
2227
2228 end do
2229 end do
2230
2231 safe_deallocate_a(wf_psi_conj)
2232 safe_deallocate_a(abs_wf_psi)
2233 safe_deallocate_a(abs_gwf_psi)
2234 safe_deallocate_a(psi_gpsi)
2235
2236 if (.not. present(gi_kinetic_energy_density)) then
2237 if (.not. present(paramagnetic_current)) then
2238 safe_deallocate_p(jp)
2239 end if
2240 if (.not. present(kinetic_energy_density)) then
2241 safe_deallocate_p(tau)
2242 end if
2243 end if
2244
2245 if (st%parallel_in_states .or. st%d%kpt%parallel) call reduce_all(st%st_kpt_mpi_grp)
2246
2247 ! We have to symmetrize everything as they are calculated from the
2248 ! wavefunctions.
2249 ! This must be done before compute the gauge-invariant kinetic energy density
2250 if (st%symmetrize_density) then
2251 do is = 1, st%d%nspin
2252 if (associated(tau)) then
2253 call dgrid_symmetrize_scalar_field(gr, tau(:, is), suppress_warning = .true.)
2254 end if
2255
2256 if (present(density_laplacian)) then
2257 call dgrid_symmetrize_scalar_field(gr, density_laplacian(:, is), suppress_warning = .true.)
2258 end if
2259
2260 if (associated(jp)) then
2261 call dgrid_symmetrize_vector_field(gr, jp(:, :, is), suppress_warning = .true.)
2262 end if
2263
2264 if (present(density_gradient)) then
2265 call dgrid_symmetrize_vector_field(gr, density_gradient(:, :, is), suppress_warning = .true.)
2266 end if
2267 end do
2268 end if
2269
2270
2271 if (allocated(st%rho_core) .and. nlcc .and. (present(density_laplacian) .or. present(density_gradient))) then
2272 do ii = 1, gr%np
2273 wf_psi(ii, 1) = st%rho_core(ii)/st%d%spin_channels
2274 end do
2275
2276 call boundaries_set(gr%der%boundaries, gr, wf_psi(:, 1))
2277
2278 if (present(density_gradient)) then
2279 ! calculate gradient of the NLCC
2280 call zderivatives_grad(gr%der, wf_psi(:,1), gwf_psi(:,:,1), set_bc = .false.)
2281 do is = 1, st%d%spin_channels
2282 !$omp parallel do collapse(2)
2283 do i_dim = 1, gr%der%dim
2284 do ii = 1, gr%np
2285 density_gradient(ii, i_dim, is) = density_gradient(ii, i_dim, is) + &
2286 real(gwf_psi(ii, i_dim, 1), real64)
2287 end do
2288 end do
2289 !$omp end parallel do
2290 end do
2291 end if
2292
2293 ! calculate the Laplacian of the wavefunction
2294 if (present(density_laplacian)) then
2295 call zderivatives_lapl(gr%der, wf_psi(:,1), lwf_psi(:,1), set_bc = .false.)
2296
2297 !$omp parallel private(is, ii)
2298 do is = 1, st%d%spin_channels
2299 !$omp do
2300 do ii = 1, gr%np
2301 density_laplacian(ii, is) = density_laplacian(ii, is) + real(lwf_psi(ii, 1))
2302 end do
2303 end do
2304 !$omp end parallel
2305 end if
2306 end if
2307
2308 !If we freeze some of the orbitals, we need to had the contributions here
2309 !Only in the case we are not computing it
2310 if (allocated(st%frozen_tau) .and. .not. present(st_end) .and. associated(tau)) then
2311 call lalg_axpy(gr%np, st%d%nspin, m_one, st%frozen_tau, tau)
2312 end if
2313 if (allocated(st%frozen_gdens) .and. .not. present(st_end) .and. present(density_gradient)) then
2314 do is = 1, st%d%nspin
2315 call lalg_axpy(gr%np, gr%der%dim, m_one, st%frozen_gdens(:,:,is), density_gradient(:,:,is))
2316 end do
2317 end if
2318 if (allocated(st%frozen_ldens) .and. .not. present(st_end) .and. present(density_laplacian)) then
2319 call lalg_axpy(gr%np, st%d%nspin, m_one, st%frozen_ldens, density_laplacian)
2320 end if
2321
2322 safe_deallocate_a(wf_psi)
2323 safe_deallocate_a(gwf_psi)
2324 safe_deallocate_a(lwf_psi)
2325
2326
2327 !We compute the gauge-invariant kinetic energy density
2328 if (present(gi_kinetic_energy_density)) then
2329 do is = 1, st%d%nspin
2330 assert(associated(tau))
2331 gi_kinetic_energy_density(1:gr%np, is) = tau(1:gr%np, is)
2332 end do
2333 if (states_are_complex(st)) then
2334 assert(associated(jp))
2335 if (st%d%ispin /= spinors) then
2336 do is = 1, st%d%nspin
2337 !$omp parallel do
2338 do ii = 1, gr%np
2339 if (st%rho(ii, is) < 1.0e-7_real64) cycle
2340 gi_kinetic_energy_density(ii, is) = &
2341 gi_kinetic_energy_density(ii, is) - sum(jp(ii,1:gr%der%dim, is)**2)/st%rho(ii, is)
2342 end do
2343 end do
2344 else ! Note that this is only the U(1) part of the gauge-invariant KED
2345 !$omp parallel do
2346 do ii = 1, gr%np
2347 gi_kinetic_energy_density(ii, 1) = gi_kinetic_energy_density(ii, 1) &
2348 - sum(jp(ii,1:gr%der%dim, 1)**2)/(safe_tol(st%rho(ii, 1),m_epsilon))
2349 gi_kinetic_energy_density(ii, 2) = gi_kinetic_energy_density(ii, 2) &
2350 - sum(jp(ii,1:gr%der%dim, 2)**2)/(safe_tol(st%rho(ii, 2),m_epsilon))
2351 gi_kinetic_energy_density(ii, 3) = &
2352 gi_kinetic_energy_density(ii, 3) - sum(jp(ii,1:gr%der%dim, 3)**2 + jp(ii,1:gr%der%dim, 4)**2) &
2353 /(safe_tol((st%rho(ii, 3)**2 + st%rho(ii, 4)**2), m_epsilon))*st%rho(ii, 3)
2354 gi_kinetic_energy_density(ii, 4) = &
2355 gi_kinetic_energy_density(ii, 4) + sum(jp(ii,1:gr%der%dim, 3)**2 + jp(ii,1:gr%der%dim, 4)**2) &
2356 /(safe_tol((st%rho(ii, 3)**2 + st%rho(ii, 4)**2), m_epsilon))*st%rho(ii, 4)
2357 end do
2358 end if
2359 end if
2360 end if
2361
2362 if (.not. present(kinetic_energy_density)) then
2363 safe_deallocate_p(tau)
2364 end if
2365 if (.not. present(paramagnetic_current)) then
2366 safe_deallocate_p(jp)
2367 end if
2368
2369
2371
2372 call profiling_out("STATES_CALC_QUANTITIES")
2373
2374 contains
2375
2376 subroutine reduce_all(grp)
2377 type(mpi_grp_t), intent(in) :: grp
2378
2380
2381 if (associated(tau)) call comm_allreduce(grp, tau, dim = (/gr%np, st%d%nspin/))
2382
2383 if (present(density_laplacian)) call comm_allreduce(grp, density_laplacian, dim = (/gr%np, st%d%nspin/))
2384
2385 do is = 1, st%d%nspin
2386 if (associated(jp)) call comm_allreduce(grp, jp(:, :, is), dim = (/gr%np, gr%der%dim/))
2387
2388 if (present(density_gradient)) then
2389 call comm_allreduce(grp, density_gradient(:, :, is), dim = (/gr%np, gr%der%dim/))
2390 end if
2391 end do
2392
2394 end subroutine reduce_all
2395
2396 end subroutine states_elec_calc_quantities
2397
2398
2399 ! ---------------------------------------------------------
2401 !
2402 function state_spin(mesh, f1) result(spin)
2403 type(mesh_t), intent(in) :: mesh
2404 complex(real64), contiguous, intent(in) :: f1(:, :)
2405 real(real64) :: spin(1:3)
2406
2407 complex(real64) :: z
2408
2409 push_sub(state_spin)
2410
2411 z = zmf_dotp(mesh, f1(:, 1) , f1(:, 2))
2412
2413 spin(1) = m_two*real(z, real64)
2414 spin(2) = m_two*aimag(z)
2415 spin(3) = zmf_nrm2(mesh, f1(:, 1))**2 - zmf_nrm2(mesh, f1(:, 2))**2
2416 spin = m_half*spin ! spin is half the sigma matrix.
2417
2418 pop_sub(state_spin)
2419 end function state_spin
2420
2421 ! ---------------------------------------------------------
2423 !
2424 logical function state_is_local(st, ist)
2425 type(states_elec_t), intent(in) :: st
2426 integer, intent(in) :: ist
2427
2428 push_sub(state_is_local)
2429
2430 state_is_local = ist >= st%st_start.and.ist <= st%st_end
2431
2432 pop_sub(state_is_local)
2433 end function state_is_local
2434
2435 ! ---------------------------------------------------------
2437 !
2438 logical function state_kpt_is_local(st, ist, ik)
2439 type(states_elec_t), intent(in) :: st
2440 integer, intent(in) :: ist
2441 integer, intent(in) :: ik
2442
2443 push_sub(state_kpt_is_local)
2444
2445 state_kpt_is_local = ist >= st%st_start .and. ist <= st%st_end .and. &
2446 ik >= st%d%kpt%start .and. ik <= st%d%kpt%end
2447
2448 pop_sub(state_kpt_is_local)
2449 end function state_kpt_is_local
2450
2451
2452 ! ---------------------------------------------------------
2454 real(real64) function states_elec_wfns_memory(st, mesh) result(memory)
2455 type(states_elec_t), intent(in) :: st
2456 class(mesh_t), intent(in) :: mesh
2457
2458 push_sub(states_elec_wfns_memory)
2459 memory = m_zero
2460
2461 ! orbitals
2462 memory = memory + real(storage_size(0.0_real64)/8, real64) * &
2463 real(mesh%np_part_global, real64) *st%d%dim * real(st%nst, real64) *st%d%kpt%nglobal()
2464
2466 end function states_elec_wfns_memory
2467
2468 ! ---------------------------------------------------------
2470 !
2471 subroutine states_elec_pack(st, copy)
2472 class(states_elec_t), intent(inout) :: st
2473 logical, optional, intent(in) :: copy
2474
2475 integer :: iqn, ib
2476 integer(int64) :: max_mem, mem
2477
2478 push_sub(states_elec_pack)
2479
2480 ! nothing to do, already packed
2481 if (st%packed) then
2482 pop_sub(states_elec_pack)
2483 return
2484 end if
2485
2486 st%packed = .true.
2487
2488 if (accel_is_enabled()) then
2489 max_mem = accel_global_memory_size()
2490
2491 if (st%gpu_states_mem > m_one) then
2492 max_mem = int(st%gpu_states_mem, int64)*(1024_8)**2
2493 else if (st%gpu_states_mem < 0.0_real64) then
2494 max_mem = max_mem + int(st%gpu_states_mem, int64)*(1024_8)**2
2495 else
2496 max_mem = int(st%gpu_states_mem*real(max_mem, real64) , int64)
2497 end if
2498 else
2499 max_mem = huge(max_mem)
2500 end if
2501
2502 mem = 0
2503 qnloop: do iqn = st%d%kpt%start, st%d%kpt%end
2504 do ib = st%group%block_start, st%group%block_end
2505
2506 mem = mem + st%group%psib(ib, iqn)%pack_total_size()
2507
2508 if (mem > max_mem) then
2509 call messages_write('Not enough device memory to store all states simultaneously.', new_line = .true.)
2510 call messages_write('Only ')
2511 call messages_write(ib - st%group%block_start)
2512 call messages_write(' of ')
2513 call messages_write(st%group%block_end - st%group%block_start + 1)
2514 call messages_write(' blocks will be stored in device memory.', new_line = .true.)
2515 call messages_warning()
2516 exit qnloop
2517 end if
2518
2519 call st%group%psib(ib, iqn)%do_pack(copy)
2520 end do
2521 end do qnloop
2522
2523 pop_sub(states_elec_pack)
2524 end subroutine states_elec_pack
2525
2526 ! ------------------------------------------------------------
2528 !
2529 subroutine states_elec_unpack(st, copy)
2530 class(states_elec_t), intent(inout) :: st
2531 logical, optional, intent(in) :: copy
2532
2533 integer :: iqn, ib
2534
2535 push_sub(states_elec_unpack)
2536
2537 if (st%packed) then
2538 st%packed = .false.
2539
2540 do iqn = st%d%kpt%start, st%d%kpt%end
2541 do ib = st%group%block_start, st%group%block_end
2542 if (st%group%psib(ib, iqn)%is_packed()) call st%group%psib(ib, iqn)%do_unpack(copy)
2543 end do
2544 end do
2545 end if
2546
2547 pop_sub(states_elec_unpack)
2548 end subroutine states_elec_unpack
2549
2550 ! -----------------------------------------------------------
2552 !
2553 subroutine states_elec_write_info(st, namespace)
2554 class(states_elec_t), intent(in) :: st
2555 type(namespace_t), intent(in) :: namespace
2556
2557 push_sub(states_elec_write_info)
2558
2559 call messages_print_with_emphasis(msg="States", namespace=namespace)
2560
2561 write(message(1), '(a,f12.3)') 'Total electronic charge = ', st%qtot
2562 write(message(2), '(a,i8)') 'Number of states = ', st%nst
2563 write(message(3), '(a,i8)') 'States block-size = ', st%block_size
2564 call messages_info(3, namespace=namespace)
2565
2566 call messages_print_with_emphasis(namespace=namespace)
2567
2568 pop_sub(states_elec_write_info)
2569 end subroutine states_elec_write_info
2570
2572 subroutine states_elec_set_zero(st)
2573 class(states_elec_t), intent(inout) :: st
2574
2575 integer :: iqn, ib
2576
2577 push_sub(states_elec_set_zero)
2578
2579 do iqn = st%d%kpt%start, st%d%kpt%end
2580 do ib = st%group%block_start, st%group%block_end
2581 call batch_set_zero(st%group%psib(ib, iqn))
2582 end do
2583 end do
2584
2585 pop_sub(states_elec_set_zero)
2586 end subroutine states_elec_set_zero
2587
2588 ! ------------------------------------------------------------
2590 !
2591 integer pure function states_elec_block_min(st, ib) result(range)
2592 type(states_elec_t), intent(in) :: st
2593 integer, intent(in) :: ib
2594
2595 range = st%group%block_range(ib, 1)
2596 end function states_elec_block_min
2597
2598 ! ------------------------------------------------------------
2600 !
2601 integer pure function states_elec_block_max(st, ib) result(range)
2602 type(states_elec_t), intent(in) :: st
2603 integer, intent(in) :: ib
2604
2605 range = st%group%block_range(ib, 2)
2606 end function states_elec_block_max
2607
2608 ! ------------------------------------------------------------
2610 !
2611 integer pure function states_elec_block_size(st, ib) result(size)
2612 type(states_elec_t), intent(in) :: st
2613 integer, intent(in) :: ib
2614
2615 size = st%group%block_size(ib)
2616 end function states_elec_block_size
2617
2618 ! ------------------------------------------------------------
2620 !
2621 logical pure function states_elec_all_states_gpu_packed(st) result(all_packed)
2622 type(states_elec_t), intent(in) :: st
2623
2624 integer :: ib, ik
2625
2626 all_packed = .true.
2627 do ik = st%d%kpt%start, st%d%kpt%end
2628 do ib = st%group%block_start, st%group%block_end
2629 if (st%group%psib(ib, ik)%status() /= batch_device_packed) then
2630 all_packed = .false.
2631 return
2632 end if
2633 end do
2634 end do
2636
2652 !
2653 subroutine occupied_states(st, namespace, ik, n_filled, n_partially_filled, n_half_filled, &
2654 filled, partially_filled, half_filled)
2655 type(states_elec_t), intent(in) :: st
2656 type(namespace_t), intent(in) :: namespace
2657 integer, intent(in) :: ik
2658 integer, intent(out) :: n_filled, n_partially_filled, n_half_filled
2659 integer, optional, intent(out) :: filled(:), partially_filled(:), half_filled(:)
2660
2661 integer :: ist
2662
2663 push_sub(occupied_states)
2664
2665 if (present(filled)) filled(:) = 0
2666 if (present(partially_filled)) partially_filled(:) = 0
2667 if (present(half_filled)) half_filled(:) = 0
2668 n_filled = 0
2669 n_partially_filled = 0
2670 n_half_filled = 0
2672 select case (st%d%ispin)
2673 case (unpolarized)
2674 do ist = 1, st%nst
2675 if (abs(st%occ(ist, ik) - m_two) < m_min_occ) then
2676 n_filled = n_filled + 1
2677 if (present(filled)) filled(n_filled) = ist
2678 else if (abs(st%occ(ist, ik) - m_one) < m_min_occ) then
2679 n_half_filled = n_half_filled + 1
2680 if (present(half_filled)) half_filled(n_half_filled) = ist
2681 else if (st%occ(ist, ik) > m_min_occ) then
2682 n_partially_filled = n_partially_filled + 1
2683 if (present(partially_filled)) partially_filled(n_partially_filled) = ist
2684 else if (abs(st%occ(ist, ik)) > m_min_occ) then
2685 write(message(1),*) 'Internal error in occupied_states: Illegal occupation value ', st%occ(ist, ik)
2686 call messages_fatal(1, namespace=namespace)
2687 end if
2688 end do
2689 case (spin_polarized, spinors)
2690 do ist = 1, st%nst
2691 if (abs(st%occ(ist, ik)-m_one) < m_min_occ) then
2692 n_filled = n_filled + 1
2693 if (present(filled)) filled(n_filled) = ist
2694 else if (st%occ(ist, ik) > m_min_occ) then
2695 n_partially_filled = n_partially_filled + 1
2696 if (present(partially_filled)) partially_filled(n_partially_filled) = ist
2697 else if (abs(st%occ(ist, ik)) > m_min_occ) then
2698 write(message(1),*) 'Internal error in occupied_states: Illegal occupation value ', st%occ(ist, ik)
2699 call messages_fatal(1, namespace=namespace)
2700 end if
2701 end do
2702 end select
2703
2704 pop_sub(occupied_states)
2705 end subroutine occupied_states
2706
2707
2709 subroutine kpoints_distribute(this, mc)
2710 type(states_elec_t), intent(inout) :: this
2711 type(multicomm_t), intent(in) :: mc
2712
2714 call distributed_init(this%d%kpt, this%nik, mc%group_comm(p_strategy_kpoints), "k-points")
2715
2716 pop_sub(kpoints_distribute)
2717 end subroutine kpoints_distribute
2718
2719
2720 ! TODO(Alex) Issue #824. Consider converting this to a function to returns `st_kpt_task`
2721 ! as this is only called in a couple of places, or package with the `st_kpt_mpi_grp` when split
2722 ! from st instance
2725 type(states_elec_t), intent(inout) :: st
2726
2728
2729 if (.not. allocated(st%st_kpt_task)) then
2730 safe_allocate(st%st_kpt_task(0:st%st_kpt_mpi_grp%size-1, 1:4))
2731 end if
2732
2733 st%st_kpt_task(0:st%st_kpt_mpi_grp%size-1, :) = 0
2734 st%st_kpt_task(st%st_kpt_mpi_grp%rank, :) = [st%st_start, st%st_end, st%d%kpt%start, st%d%kpt%end]
2735
2736 if (st%parallel_in_states .or. st%d%kpt%parallel) then
2737 call comm_allreduce(st%st_kpt_mpi_grp, st%st_kpt_task)
2738 end if
2739
2742
2743 ! ---------------------------------------------------------
2745 !
2746 subroutine states_elec_choose_kpoints(st, kpoints, namespace)
2747 type(states_elec_t), target, intent(inout) :: st
2748 type(kpoints_t), intent(in) :: kpoints
2749 type(namespace_t), intent(in) :: namespace
2750
2751 integer :: ik, iq
2752 type(states_elec_dim_t), pointer :: dd
2753
2754
2756
2757 dd => st%d
2758
2759 st%nik = kpoints_number(kpoints)
2760
2761 if (dd%ispin == spin_polarized) st%nik = 2*st%nik
2762
2763 safe_allocate(st%kweights(1:st%nik))
2764
2765 do iq = 1, st%nik
2766 ik = dd%get_kpoint_index(iq)
2767 st%kweights(iq) = kpoints%get_weight(ik)
2768 end do
2770 if (debug%info) call print_kpoints_debug
2772
2773 contains
2774 subroutine print_kpoints_debug
2775 integer :: iunit
2776
2778
2779 call io_mkdir('debug/', namespace)
2780 iunit = io_open('debug/kpoints', namespace, action = 'write')
2781 call kpoints%write_info(iunit=iunit, absolute_coordinates = .true.)
2782 call io_close(iunit)
2783
2785 end subroutine print_kpoints_debug
2786
2787 end subroutine states_elec_choose_kpoints
2788
2793 !
2794 function states_elec_calculate_dipole(this, gr) result(dipole)
2795 class(states_elec_t), intent(in) :: this
2796 class(mesh_t), intent(in) :: gr
2797 real(real64) :: dipole(1:gr%box%dim)
2798
2799 integer :: ispin
2800 real(real64) :: e_dip(1:gr%box%dim, this%d%spin_channels)
2801
2803
2804 do ispin = 1, this%d%spin_channels
2805 call dmf_dipole(gr, this%rho(:, ispin), e_dip(:, ispin))
2806 end do
2807
2808 dipole(:) = sum(e_dip(:, 1:this%d%spin_channels), 2) ! dipole moment <mu_el> = \sum_i -e <x_i>
2809
2811 end function states_elec_calculate_dipole
2812
2813
2814#include "undef.F90"
2815#include "real.F90"
2816#include "states_elec_inc.F90"
2817
2818#include "undef.F90"
2819#include "complex.F90"
2820#include "states_elec_inc.F90"
2821#include "undef.F90"
2822
2823end module states_elec_oct_m
2824
2825
2826!! Local Variables:
2827!! mode: f90
2828!! coding: utf-8
2829!! End:
initialize a batch with existing memory
Definition: batch.F90:278
constant times a vector plus a vector
Definition: lalg_basic.F90:171
scales a vector by a constant
Definition: lalg_basic.F90:147
Prints out to iunit a message in the form: ["InputVariable" = value] where "InputVariable" is given b...
Definition: messages.F90:158
subroutine, public accel_free_buffer(this, async)
Definition: accel.F90:967
pure logical function, public accel_is_enabled()
Definition: accel.F90:391
type(accel_t), public accel
Definition: accel.F90:225
This module implements batches of mesh functions.
Definition: batch.F90:112
This module implements common operations on batches of mesh functions.
Definition: batch_ops.F90:95
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)
subroutine, public blacs_proc_grid_copy(cin, cout)
Module implementing boundary conditions in Octopus.
Definition: boundaries.F90:101
This module handles the calculation mode.
type(calc_mode_par_t), public calc_mode_par
Singleton instance of parallel calculation mode.
integer, parameter, public p_strategy_states
parallelization in states
This module calculates the derivatives (gradients, Laplacians, etc.) of a function.
subroutine, public zderivatives_grad(der, ff, op_ff, ghost_update, set_bc, to_cartesian)
apply the gradient to a mesh function
subroutine, public zderivatives_lapl(der, ff, op_ff, ghost_update, set_bc, factor)
apply the Laplacian to a mesh function
subroutine, public distributed_end(this)
subroutine, public distributed_init(this, total, comm, tag, scalapack_compat)
Distribute N instances across M processes of communicator comm
subroutine, public distributed_copy(in, out)
Create a copy of a distributed instance.
subroutine, public distributed_init_serial(this, total)
Serial initialization of a distributed instance. The calling process is assigned all total instances,...
integer, parameter, public unpolarized
Parameters...
integer, parameter, public spinors
integer, parameter, public spin_polarized
real(real64), parameter, public m_two
Definition: global.F90:175
real(real64), parameter, public m_zero
Definition: global.F90:173
real(real64), parameter, public m_fourth
Definition: global.F90:182
complex(real64), parameter, public m_zi
Definition: global.F90:187
real(real64), parameter, public m_epsilon
Definition: global.F90:189
type(conf_t), public conf
Global instance of Octopus configuration.
Definition: global.F90:163
real(real64), parameter, public m_half
Definition: global.F90:179
real(real64), parameter, public m_one
Definition: global.F90:174
This module implements the underlying real-space grid.
Definition: grid.F90:96
subroutine, public dgrid_symmetrize_vector_field(gr, field, suppress_warning)
Definition: grid.F90:685
subroutine, public dgrid_symmetrize_scalar_field(gr, field, suppress_warning)
Definition: grid.F90:659
Definition: io.F90:93
logical pure function, public kpoints_point_is_gamma(this, ik)
Definition: kpoints.F90:1712
System information (time, memory, sysname)
Definition: loct.F90:94
This module is intended to contain "only mathematical" functions and procedures.
Definition: math.F90:94
integer pure function, public pad_pow2(size)
create array size, which is padded to powers of 2
Definition: math.F90:956
This module defines functions over batches of mesh functions.
Definition: mesh_batch.F90:95
subroutine, public zmesh_batch_exchange_points(mesh, aa, forward_map, backward_map)
This functions exchanges points of a mesh according to a certain map. Two possible maps can be given....
subroutine, public dmesh_batch_exchange_points(mesh, aa, forward_map, backward_map)
This functions exchanges points of a mesh according to a certain map. Two possible maps can be given....
This module defines various routines, operating on mesh functions.
subroutine, public zmf_random(mesh, ff, pre_shift, post_shift, seed, normalized)
This subroutine fills a function with random values.
subroutine, public dmf_random(mesh, ff, pre_shift, post_shift, seed, normalized)
This subroutine fills a function with random values.
subroutine, public zmf_normalize(mesh, dim, psi, norm)
Normalize a mesh function psi.
This module defines the meshes, which are used in Octopus.
Definition: mesh.F90:97
subroutine, public messages_not_implemented(feature, namespace)
Definition: messages.F90:1048
subroutine, public messages_warning(no_lines, all_nodes, namespace)
Definition: messages.F90:501
subroutine, public messages_obsolete_variable(namespace, name, rep)
Definition: messages.F90:980
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
Definition: messages.F90:138
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
Definition: messages.F90:386
subroutine, public messages_input_error(namespace, var, details, row, column)
Definition: messages.F90:671
subroutine, public messages_experimental(name, namespace)
Definition: messages.F90:1020
subroutine, public messages_info(no_lines, iunit, debug_only, stress, all_nodes, namespace)
Definition: messages.F90:570
general module for modelmb particles
subroutine, public modelmb_particles_end(this)
subroutine, public modelmb_particles_init(this, namespace, space, nst)
==============================================================
subroutine, public modelmb_particles_copy(modelmb_out, modelmb_in)
subroutine mpi_grp_copy(mpi_grp_out, mpi_grp_in)
MPI_THREAD_FUNNELED allows for calls to MPI from an OMP region if the thread is the team master.
Definition: mpi.F90:428
type(mpi_comm), parameter, public mpi_comm_undefined
used to indicate a communicator has not been initialized
Definition: mpi.F90:115
subroutine mpi_grp_init(grp, comm)
Initialize MPI group instance.
Definition: mpi.F90:386
This module handles the communicators for the various parallelization strategies.
Definition: multicomm.F90:124
logical pure function, public multicomm_strategy_is_parallel(mc, level)
Definition: multicomm.F90:705
subroutine, public multicomm_all_pairs_copy(apout, apin)
Definition: multicomm.F90:228
logical pure function, public multicomm_have_slaves(this)
Definition: multicomm.F90:831
logical function, public parse_is_defined(namespace, name)
Definition: parser.F90:440
integer function, public parse_block(namespace, name, blk, check_varinfo_)
Definition: parser.F90:600
/* To use the profiling module, call profiling_in and profiling_out with the label of the region as a...
Definition: profiling.F90:122
subroutine, public profiling_out(label)
Increment out counter and sum up difference between entry and exit time.
Definition: profiling.F90:672
subroutine, public profiling_in(label, exclude)
Increment in counter and save entry time.
Definition: profiling.F90:604
subroutine, public smear_find_fermi_energy(this, namespace, eigenvalues, occupations, qtot, nik, nst, kweights)
Definition: smear.F90:357
subroutine, public smear_fill_occupations(this, eigenvalues, occupations, kweights, nik, nst)
Definition: smear.F90:652
subroutine, public smear_copy(to, from)
Definition: smear.F90:326
integer, parameter, public smear_fixed_occ
Definition: smear.F90:153
subroutine, public smear_init(this, namespace, ispin, fixed_occ, integral_occs, kpoints)
Definition: smear.F90:171
logical pure function, public smear_is_semiconducting(this)
Definition: smear.F90:1021
subroutine, public states_set_complex(st)
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_dim_copy(dout, din)
subroutine, public states_elec_dim_end(dim)
This module handles groups of electronic batches and their parallel distribution.
subroutine, public states_elec_group_copy(d, group_in, group_out, copy_data, special, dest_type)
make a copy of a group
subroutine, public states_elec_group_end(this, d)
finalize the local blocks of wave functions and release local arrays
real(real64) function, public states_elec_wfns_memory(st, mesh)
return the memory usage of a states_elec_t object
integer pure function, public states_elec_block_max(st, ib)
return index of last state in block ib
subroutine zstates_elec_generate_random_vector(mesh, st, vector, normalized, reset_seed)
Generate a random vector.
subroutine, public states_elec_null(st)
subroutine, public states_elec_distribute_nodes(st, namespace, mc)
Distribute states over the processes for states parallelization.
subroutine, public states_elec_fermi(st, namespace, mesh, compute_spin)
calculate the Fermi level for the states in this object
logical function, public state_kpt_is_local(st, ist, ik)
check whether a given state (ist, ik) is on the local node
subroutine, public states_elec_calc_quantities(gr, st, kpoints, nlcc, kinetic_energy_density, paramagnetic_current, density_gradient, density_laplacian, gi_kinetic_energy_density, st_end)
calculated selected quantities
real(real64) function, dimension(1:gr%box%dim) states_elec_calculate_dipole(this, gr)
calculate the expectation value of the dipole moment of electrons
subroutine, public states_elec_densities_init(st, gr)
subroutine, public states_elec_end(st)
finalize the states_elec_t object
subroutine zstates_elec_get_state1(st, mesh, idim, ist, iqn, psi)
Write one component (dim) of a wave function into a state_elec_t object.
subroutine, public states_elec_deallocate_wfns(st)
Deallocates the KS wavefunctions defined within a states_elec_t structure.
subroutine, public states_elec_allocate_wfns(st, mesh, wfs_type, skip, packed)
Allocates the KS wavefunctions defined within a states_elec_t structure.
subroutine zstates_elec_get_points1(st, start_point, end_point, iqn, psi)
Returns the value of all the states for given k-point in the range of points [start_point:end_point].
subroutine states_elec_read_initial_occs(st, namespace, excess_charge, kpoints)
Reads from the input file the initial occupations, if the block "Occupations" is present....
subroutine zstates_elec_set_state1(st, mesh, idim, ist, iqn, psi)
get one dimension of local wave function for given k-point and states index from a states_elec_t obje...
real(real64) function, public states_elec_eigenvalues_sum(st, alt_eig)
function to calculate the eigenvalues sum using occupations as weights
integer, parameter, public par_independent
Method used to generate random states.
subroutine, public states_elec_copy(stout, stin, exclude_wfns, exclude_eigenval, special, dest_type, copy_data)
make a (selective) copy of a states_elec_t object
subroutine dstates_elec_generate_random_vector(mesh, st, vector, normalized, reset_seed)
Generate a random vector.
subroutine, public occupied_states(st, namespace, ik, n_filled, n_partially_filled, n_half_filled, filled, partially_filled, half_filled)
return information about occupied orbitals in many-body state
subroutine dstates_elec_get_state2(st, mesh, ist, iqn, psi)
Write a wave function into a state_elec_t object.
subroutine zstates_elec_set_state2(st, mesh, ist, iqn, psi)
get local wave function for given k-point and states index from a states_elec_t object
subroutine zstates_elec_get_state2(st, mesh, ist, iqn, psi)
Write a wave function into a state_elec_t object.
subroutine dstates_elec_get_points1(st, start_point, end_point, iqn, psi)
Returns the value of all the states for given k-point in the range of points [start_point:end_point].
integer pure function, public states_elec_block_size(st, ib)
return number of states in block ib
subroutine, public kpoints_distribute(this, mc)
distribute k-points over the nodes in the corresponding communicator
integer, parameter, public par_dependent
subroutine states_elec_pack(st, copy)
pack the batches in this states object
subroutine, public states_elec_choose_kpoints(st, kpoints, namespace)
double up k-points for SPIN_POLARIZED calculations
subroutine zstates_elec_get_state3(st, mesh, iqn, psi)
get local wave functions for given k-point from a states_elec_t object
logical function, public state_is_local(st, ist)
check whether a given state (ist) is on the local node
subroutine dstates_elec_set_state1(st, mesh, idim, ist, iqn, psi)
get one dimension of local wave function for given k-point and states index from a states_elec_t obje...
subroutine, public states_elec_exec_init(st, namespace, mc)
Further initializations.
subroutine dstates_elec_set_state4(st, mesh, psi)
set all local wave functions in a states_elec_t object
subroutine dstates_elec_set_state3(st, mesh, iqn, psi)
set local wave functions for given k-point in a states_elec_t object
subroutine states_elec_write_info(st, namespace)
write information about the states object
subroutine states_elec_init_block(st, mesh, verbose, skip, packed)
Initializes the data components in st that describe how the states are distributed in blocks:
real(real64) function, dimension(1:3) state_spin(mesh, f1)
calculate the spin vector for a spinor wave function f1
logical pure function, public states_elec_all_states_gpu_packed(st)
return boolean indicating whether all states are packed on the GPU
subroutine states_elec_kpoints_distribution(st)
Assign the start and end indices for states and kpoints, for "st_kpt_mpi_grp" communicator.
subroutine zstates_elec_get_state4(st, mesh, psi)
get all local wave functions from a states_elec_t object
subroutine, public states_elec_init(st, namespace, space, valence_charge, kpoints, calc_mode_id)
Initialize a new states_elec_t object.
subroutine, public states_elec_generate_random(st, mesh, kpoints, ist_start_, ist_end_, ikpt_start_, ikpt_end_, normalized)
randomize states
subroutine dstates_elec_get_state1(st, mesh, idim, ist, iqn, psi)
Write one component (dim) of a wave function into a state_elec_t object.
subroutine dstates_elec_set_state2(st, mesh, ist, iqn, psi)
get local wave function for given k-point and states index from a states_elec_t object
subroutine zstates_elec_set_state4(st, mesh, psi)
set all local wave functions in a states_elec_t object
subroutine states_elec_read_initial_spins(st, namespace)
Reads, if present, the "InitialSpins" block.
subroutine dstates_elec_get_state3(st, mesh, iqn, psi)
get local wave functions for given k-point from a states_elec_t object
subroutine dstates_elec_get_points2(st, start_point, end_point, psi)
Returns the value of all the states in the range of points [start_point:end_point].
integer pure function, public states_elec_block_min(st, ib)
return index of first state in block ib
subroutine states_elec_unpack(st, copy)
unpack the batches in this states object
subroutine, public states_elec_look(restart, nik, dim, nst, ierr)
Reads the 'states' file in the restart directory, and finds out the nik, dim, and nst contained in it...
subroutine dstates_elec_get_state4(st, mesh, psi)
get all local wave functions from a states_elec_t object
subroutine, public states_elec_allocate_current(st, space, mesh)
subroutine, public states_elec_set_zero(st)
Explicitly set all wave functions in the states to zero.
subroutine zstates_elec_set_state3(st, mesh, iqn, psi)
set local wave functions for given k-point in a states_elec_t object
subroutine zstates_elec_get_points2(st, start_point, end_point, psi)
Returns the value of all the states in the range of points [start_point:end_point].
type(type_t), parameter, public type_cmplx
Definition: types.F90:114
type(type_t), parameter, public type_float
Definition: types.F90:113
brief This module defines the class unit_t which is used by the unit_systems_oct_m module.
Definition: unit.F90:111
This module defines the unit system, used for input and output.
type(unit_t), public unit_megabytes
For large amounts of data (natural code units are bytes)
subroutine, public zwfs_elec_init(this, dim, st_start, st_end, np, ik, special, packed)
initialize an empty wfs_elec_t object
Definition: wfs_elec.F90:545
subroutine, public dwfs_elec_init(this, dim, st_start, st_end, np, ik, special, packed)
initialize an empty wfs_elec_t object
Definition: wfs_elec.F90:401
subroutine reduce_all(grp)
subroutine print_kpoints_debug
Class defining batches of mesh functions.
Definition: batch.F90:142
Distribution of N instances over mpi_grpsize processes, for the local rank mpi_grprank....
Extension of space that contains the knowledge of the spin dimension.
Description of the grid, containing information on derivatives, stencil, and symmetries.
Definition: grid.F90:148
Describes mesh distribution to nodes.
Definition: mesh.F90:165
==============================================================
This is defined even when running serial.
Definition: mpi.F90:121
An all-pairs communication schedule for a given group.
Definition: multicomm.F90:217
Stores all communicators and groups.
Definition: multicomm.F90:185
abstract class for states
The states_elec_t class contains all electronic wave functions.
int true(void)