48 USE dftd4,
ONLY: d4_model, &
51 get_rational_damping, &
58 rational_damping_param, &
59 get_coordination_number, &
61 USE multicharge,
ONLY: get_charges
62 USE mctc_env,
ONLY: error_type
65#include "./base/base_uses.f90"
71 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'qs_dispersion_d4'
91 TYPE(qs_environment_type),
POINTER :: qs_env
92 TYPE(qs_dispersion_type),
INTENT(IN),
POINTER :: dispersion_env
93 REAL(KIND=
dp),
INTENT(INOUT) :: evdw
94 LOGICAL,
INTENT(IN) :: calculate_forces
95 INTEGER,
INTENT(IN) :: iw
96 REAL(KIND=
dp),
DIMENSION(:),
OPTIONAL :: atomic_energy
98 CHARACTER(LEN=*),
PARAMETER :: routineN =
'calculate_dispersion_d4_pairpot'
100 INTEGER :: atoma, cnfun, enshift, handle, i, iatom, &
101 ifull, ikind, mref, natom, natom_full, &
103 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: atom_map, atom_map_back, atom_of_kind, &
104 atomtype, kind_of, species, t_atomtype
105 INTEGER,
DIMENSION(3) :: periodic
106 LOGICAL :: debug, grad, ifloating, ighost, &
108 LOGICAL,
ALLOCATABLE,
DIMENSION(:) :: a_ghost, exclude_ghost
109 LOGICAL,
DIMENSION(3) :: lperiod
110 REAL(KIND=
dp) :: ed2, ed3, ev1, ev2, ev3, ev4, pd2, pd3, &
111 ta, tb, tc, td, te, ts
112 REAL(KIND=
dp),
ALLOCATABLE,
DIMENSION(:) :: cn, cn_red, cnd, dedcn, dedq, edcn, edq, &
113 enerd2, enerd3, energies, energies3, &
115 REAL(KIND=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: ga, gradient, t_xyz, tvec, xyz
116 REAL(KIND=
dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: gdeb, gwdcn, gwdq, gwvec
117 REAL(KIND=
dp),
DIMENSION(3, 3) :: sigma, stress
118 REAL(KIND=
dp),
DIMENSION(3, 3, 4) :: sdeb
119 TYPE(atomic_kind_type),
DIMENSION(:),
POINTER :: atomic_kind_set
120 TYPE(cell_type),
POINTER :: cell
121 TYPE(dcnum_type),
ALLOCATABLE,
DIMENSION(:) :: dcnum
122 TYPE(dft_control_type),
POINTER :: dft_control
123 TYPE(mp_para_env_type),
POINTER :: para_env
124 TYPE(particle_type),
DIMENSION(:),
POINTER :: particle_set
125 TYPE(qs_force_type),
DIMENSION(:),
POINTER :: force
126 TYPE(qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
127 TYPE(virial_type),
POINTER :: virial
129 CLASS(damping_param),
ALLOCATABLE :: param
130 TYPE(d4_model) :: disp
131 TYPE(structure_type) :: mol
132 TYPE(realspace_cutoff) :: cutoff
133 TYPE(work_partition) :: partition
135 TYPE(error_type),
ALLOCATABLE :: error
137 CALL timeset(routinen, handle)
139 debug = dispersion_env%d4_debug
141 CALL get_qs_env(qs_env=qs_env, particle_set=particle_set, atomic_kind_set=atomic_kind_set, &
142 cell=cell, dft_control=dft_control, force=force, virial=virial, para_env=para_env)
146 natom_full =
SIZE(particle_set)
148 ALLOCATE (t_xyz(3, natom_full), t_atomtype(natom_full), a_ghost(natom_full))
149 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set)
150 DO iatom = 1, natom_full
151 t_xyz(:, iatom) = particle_set(iatom)%r(:)
152 ikind = kind_of(iatom)
153 CALL get_qs_kind(qs_kind_set(ikind), zatom=t_atomtype(iatom), ghost=ighost, floating=ifloating)
154 a_ghost(iatom) = ighost .OR. ifloating
155 IF (a_ghost(iatom)) nghost = nghost + 1
158 natom = natom_full - nghost
160 ALLOCATE (atom_map(natom_full), atom_map_back(natom))
163 ALLOCATE (xyz(3, natom), atomtype(natom))
165 IF (.NOT. a_ghost(i))
THEN
168 atom_map_back(iatom) = i
169 xyz(:, iatom) = t_xyz(:, i)
170 atomtype(iatom) = t_atomtype(i)
173 DEALLOCATE (a_ghost, t_xyz, t_atomtype)
176 CALL get_cell(cell=cell, periodic=periodic)
177 lperiod(1) = periodic(1) == 1
178 lperiod(2) = periodic(2) == 1
179 lperiod(3) = periodic(3) == 1
186 CALL new(mol, atomtype, xyz, charge=real(dft_control%charge,
dp), lattice=cell%hmat, periodic=lperiod)
187 CALL new_d4_model(error, disp, mol)
188 IF (
ALLOCATED(error))
THEN
189 cpabort(error%message)
196 ALLOCATE (species(natom_full))
199 species(atom_map_back(i)) = mol%id(i)
203 ALLOCATE (exclude_ghost(
SIZE(qs_kind_set)))
204 exclude_ghost = .false.
205 DO i = 1,
SIZE(qs_kind_set)
206 CALL get_qs_kind(qs_kind_set(i), ghost=ighost, floating=ifloating)
207 exclude_ghost(i) = ighost .OR. ifloating
210 IF (dispersion_env%ref_functional ==
"none")
THEN
211 CALL get_rational_damping(
"pbe", param, s9=0.0_dp)
212 IF (.NOT.
ALLOCATED(param))
THEN
213 cpabort(
"D4: Failed to get rational damping parameters for default functional")
216 TYPE is (rational_damping_param)
217 param%s6 = dispersion_env%s6
218 param%s8 = dispersion_env%s8
219 param%a1 = dispersion_env%a1
220 param%a2 = dispersion_env%a2
221 param%alp = dispersion_env%alp
224 CALL get_rational_damping(dispersion_env%ref_functional, param, s9=dispersion_env%s9)
225 IF (.NOT.
ALLOCATED(param))
THEN
226 cpabort(
"D4: Unknown reference functional '"//trim(dispersion_env%ref_functional)//
"'")
229 TYPE is (rational_damping_param)
230 dispersion_env%s6 = param%s6
231 dispersion_env%s8 = param%s8
232 dispersion_env%a1 = param%a1
233 dispersion_env%a2 = param%a2
234 dispersion_env%alp = param%alp
239 cutoff%cn = dispersion_env%rc_cn
241 cutoff%disp2 = dispersion_env%rc_d4*2._dp
243 cutoff%disp3 = dispersion_env%rc_disp*2._dp
244 IF (cutoff%disp3 > cutoff%disp2)
THEN
245 cpabort(
"D4: Three-body cutoff should be smaller than two-body cutoff")
247 cutoff%width2 = dispersion_env%d4_cutoff_width
248 cutoff%width3 = dispersion_env%d4_3b_cutoff_width
249 IF (cutoff%width2 < 0.0_dp .OR. cutoff%width2 >= cutoff%disp2)
THEN
250 cpabort(
"D4: Two-body cutoff width must be non-negative and smaller than the cutoff")
252 IF (cutoff%width3 < 0.0_dp .OR. cutoff%width3 >= cutoff%disp3)
THEN
253 cpabort(
"D4: Three-body cutoff width must be non-negative and smaller than the cutoff")
256 IF (calculate_forces)
THEN
258 use_virial = virial%pv_availability .AND. (.NOT. virial%pv_numer)
264 IF (dispersion_env%d4_reference_code .OR. debug)
THEN
265 CALL new_work_partition(error, partition, para_env%mepos, para_env%num_pe)
266 IF (
ALLOCATED(error)) cpabort(error%message)
269 IF (dispersion_env%d4_reference_code)
THEN
272 IF (.NOT. dispersion_env%doabc)
THEN
273 cpwarn(
"Using D4_REFERENCE_CODE enforces calculation of C9 term.")
276 ALLOCATE (gradient(3, natom))
277 CALL get_dispersion(mol, disp, param, cutoff, evdw, gradient, stress, &
278 partition=partition, error=error)
279 IF (
ALLOCATED(error)) cpabort(error%message)
280 IF (calculate_forces)
THEN
282 virial%pv_virial = virial%pv_virial - stress
285 ifull = atom_map_back(iatom)
286 ikind = kind_of(ifull)
287 atoma = atom_of_kind(ifull)
288 force(ikind)%dispersion(:, atoma) = &
289 force(ikind)%dispersion(:, atoma) + gradient(:, iatom)
292 DEALLOCATE (gradient)
294 CALL get_dispersion(mol, disp, param, cutoff, evdw, partition=partition, error=error)
295 IF (
ALLOCATED(error)) cpabort(error%message)
298 IF (dispersion_env%ext_charges) dispersion_env%dcharges = 0.0_dp
299 IF (
PRESENT(atomic_energy))
THEN
300 cpwarn(
"Atomic energies not available for D4 reference code")
301 atomic_energy = 0.0_dp
307 WRITE (iw,
'(/,T2,A)')
'!-----------------------------------------------------------------------------!'
308 WRITE (iw, fmt=
"(T32,A)")
"DEBUG D4 DISPERSION"
309 WRITE (iw,
'(T2,A)')
'!-----------------------------------------------------------------------------!'
310 WRITE (iw,
'(A,T71,A10)')
" DEBUG D4| Reference functional ", trim(dispersion_env%ref_functional)
311 WRITE (iw,
'(A,T71,F10.4)')
" DEBUG D4| Scaling parameter (s6) ", dispersion_env%s6
312 WRITE (iw,
'(A,T71,F10.4)')
" DEBUG D4| Scaling parameter (s8) ", dispersion_env%s8
313 WRITE (iw,
'(A,T71,F10.4)')
" DEBUG D4| BJ Damping parameter (a1) ", dispersion_env%a1
314 WRITE (iw,
'(A,T71,F10.4)')
" DEBUG D4| BJ Damping parameter (a2) ", dispersion_env%a2
315 WRITE (iw,
'(A,T71,E10.4)')
" DEBUG D4| Cutoff value coordination numbers ", dispersion_env%eps_cn
316 WRITE (iw,
'(A,T71,F10.4)')
" DEBUG D4| Cutoff radius coordination numbers ", dispersion_env%rc_cn
317 WRITE (iw,
'(A,T71,I10)')
" DEBUG D4| Coordination number function type ", dispersion_env%cnfun
318 WRITE (iw,
'(A,T71,F10.4)')
" DEBUG D4| Cutoff radius 2-body terms [bohr]", 2._dp*dispersion_env%rc_d4
319 WRITE (iw,
'(A,T71,F10.4)')
" DEBUG D4| Cutoff radius 3-body terms [bohr]", 2._dp*dispersion_env%rc_disp
325 CALL refd4_debug(param, disp, mol, cutoff, partition, grad, dispersion_env%doabc, &
326 enerd2, enerd3, cnd, qd, edcn, edq, gdeb, sdeb)
328 CALL para_env%sum(enerd2)
329 IF (dispersion_env%doabc)
CALL para_env%sum(enerd3)
331 CALL para_env%sum(edcn)
332 CALL para_env%sum(edq)
333 CALL para_env%sum(gdeb)
334 CALL para_env%sum(sdeb)
338 CALL para_env%max(td)
344 mref = maxval(disp%ref)
346 cnfun = dispersion_env%cnfun
351 ALLOCATE (cn_red(natom))
353 cn_red(i) = cn(atom_map_back(i))
355 IF (debug .AND. iw > 0)
THEN
356 WRITE (iw,
'(A,T71,F10.6)')
" DEBUG D4| CN differences (max)", maxval(abs(cn_red - cnd))
357 WRITE (iw,
'(A,T71,F10.6)')
" DEBUG D4| CN differences (ave)", sum(abs(cn_red - cnd))/natom
364 IF (dispersion_env%ext_charges)
THEN
365 ALLOCATE (q_red(natom))
366 q_red(1:natom) = dispersion_env%charges(1:natom)
369 ALLOCATE (q_red(natom_full))
370 CALL eeq_charges(qs_env, q_red, dispersion_env%eeq_sparam, 2, enshift, &
371 exclude=exclude_ghost, cn_max=8.0_dp)
374 REAL(KIND=
dp),
ALLOCATABLE :: q_tmp(:)
375 ALLOCATE (q_tmp(natom))
377 q_tmp(i) = q_red(atom_map_back(i))
380 CALL move_alloc(q_tmp, q_red)
383 IF (debug .AND. iw > 0)
THEN
384 WRITE (iw,
'(A,T71,F10.6)')
" DEBUG D4| Charge differences (max)", maxval(abs(q_red - qd))
385 WRITE (iw,
'(A,T71,F10.6)')
" DEBUG D4| Charge differences (ave)", sum(abs(q_red - qd))/natom
388 ALLOCATE (gwvec(mref, natom, ncoup))
389 IF (grad)
ALLOCATE (gwdcn(mref, natom, ncoup), gwdq(mref, natom, ncoup))
390 CALL disp%weight_references(mol, cn_red, q_red, gwvec, gwdcn, gwdq)
393 ALLOCATE (energies(natom_full))
396 ALLOCATE (gradient(3, natom_full), ga(3, natom_full))
397 ALLOCATE (dedcn(natom_full), dedq(natom_full))
398 dedcn(:) = 0.0_dp; dedq(:) = 0.0_dp
402 CALL dispersion_2b(dispersion_env, cutoff%disp2, cutoff%width2, disp%r4r2, &
403 gwvec, gwdcn, gwdq, disp%c6, disp%ref, &
404 energies, dedcn, dedq, grad, ga, sigma, &
407 gradient(1:3, 1:natom_full) = ga(1:3, 1:natom_full)
410 CALL para_env%sum(ga)
411 CALL para_env%sum(sigma)
413 CALL gerror(ga, gdeb(:, :, 1), ev1, ev2, ev3, ev4)
414 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| RMS error Gradient [2B]", ev1, ev2,
" %"
415 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| MAV error Gradient [2B]", ev3, ev4,
" %"
417 CALL serror(sigma, sdeb(:, :, 1), ev1, ev2)
418 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| MAV error Stress [2B]", ev1, ev2,
" %"
426 IF (dispersion_env%ext_charges)
THEN
427 dispersion_env%dcharges = dedq
429 CALL para_env%sum(dedq)
432 REAL(KIND=
dp),
ALLOCATABLE :: q_full(:)
433 ALLOCATE (q_full(natom_full))
436 q_full(atom_map_back(i)) = q_red(i)
440 CALL eeq_forces(qs_env, q_full, dedq, ga, sigma, dispersion_env%eeq_sparam, &
441 2, enshift, response_only=.true., exclude=exclude_ghost, &
445 gradient(1:3, 1:natom_full) = gradient(1:3, 1:natom_full) + ga(1:3, 1:natom_full)
446 stress = stress + sigma
448 CALL para_env%sum(ga)
449 CALL para_env%sum(sigma)
451 CALL verror(dedq, edq, ev1, ev2)
452 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| MAV error Derivative dEdq", ev1, ev2,
" %"
453 CALL gerror(ga, gdeb(:, :, 2), ev1, ev2, ev3, ev4)
454 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| RMS error Gradient [dEdq]", ev1, ev2,
" %"
455 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| MAV error Gradient [dEdq]", ev3, ev4,
" %"
457 CALL serror(sigma, sdeb(:, :, 2), ev1, ev2)
458 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| MAV error Stress [dEdq]", ev1, ev2,
" %"
465 IF (dispersion_env%doabc)
THEN
466 ALLOCATE (energies3(natom_full))
467 energies3(:) = 0.0_dp
470 CALL disp%weight_references(mol, cn_red, q_red, gwvec, gwdcn, gwdq)
477 CALL get_lattice_points(mol%periodic, mol%lattice, cutoff%disp3, tvec)
478 CALL dispersion_3b(qs_env, dispersion_env, tvec, cutoff%disp3, disp%r4r2, &
479 gwvec, gwdcn, gwdq, disp%c6, disp%ref, &
480 energies3, dedcn, dedq, grad, ga, sigma, &
483 gradient(1:3, 1:natom_full) = gradient(1:3, 1:natom_full) + ga(1:3, 1:natom_full)
484 stress = stress + sigma
486 CALL para_env%sum(ga)
487 CALL para_env%sum(sigma)
489 CALL gerror(ga, gdeb(:, :, 3), ev1, ev2, ev3, ev4)
490 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| RMS error Gradient [3B]", ev1, ev2,
" %"
491 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| MAV error Gradient [3B]", ev3, ev4,
" %"
493 CALL serror(sigma, sdeb(:, :, 3), ev1, ev2)
494 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| MAV error Stress [3B]", ev1, ev2,
" %"
502 CALL para_env%sum(dedcn)
505 CALL dedcn_force(qs_env, dedcn, dcnum, ga, sigma)
506 gradient(1:3, 1:natom_full) = gradient(1:3, 1:natom_full) + ga(1:3, 1:natom_full)
507 stress = stress + sigma
509 CALL para_env%sum(ga)
510 CALL para_env%sum(sigma)
512 CALL verror(dedcn, edcn, ev1, ev2)
513 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| MAV error Derivative dEdcn", ev1, ev2,
" %"
514 CALL gerror(ga, gdeb(:, :, 4), ev1, ev2, ev3, ev4)
515 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| RMS error Gradient [dEdcn]", ev1, ev2,
" %"
516 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| MAV error Gradient [dEdcn]", ev3, ev4,
" %"
518 CALL serror(sigma, sdeb(:, :, 4), ev1, ev2)
519 WRITE (iw,
'(A,T51,F14.10,T69,F10.4,A)')
" DEBUG D4| MAV error Stress [dEdcn]", ev1, ev2,
" %"
524 DEALLOCATE (q_red, cn_red)
525 CALL cnumber_release(cn, dcnum, grad)
530 CALL para_env%max(tc)
532 CALL para_env%sum(ta)
536 pd2 = abs(ed2)/abs(tb)*100._dp
537 WRITE (iw,
'(A,T51,F14.8,T69,F10.4,A)')
" DEBUG D4| Energy error 2-body", ed2, pd2,
" %"
539 IF (dispersion_env%doabc)
THEN
541 CALL para_env%sum(ta)
545 pd3 = abs(ed3)/abs(tb)*100._dp
546 WRITE (iw,
'(A,T51,F14.8,T69,F10.4,A)')
" DEBUG D4| Energy error 3-body", ed3, pd3,
" %"
550 WRITE (iw,
'(A,T67,F14.4)')
" DEBUG D4| Time for reference code [s]", td
551 WRITE (iw,
'(A,T67,F14.4)')
" DEBUG D4| Time for production code [s]", tc
555 IF (dispersion_env%doabc)
THEN
556 energies(:) = energies(:) + energies3(:)
559 IF (
PRESENT(atomic_energy))
THEN
560 atomic_energy(1:natom_full) = energies(1:natom_full)
563 IF (use_virial .AND. calculate_forces)
THEN
564 virial%pv_virial = virial%pv_virial - stress
566 IF (calculate_forces)
THEN
567 DO iatom = 1, natom_full
568 IF (atom_map(iatom) == 0) cycle
569 ikind = kind_of(iatom)
570 atoma = atom_of_kind(iatom)
571 force(ikind)%dispersion(:, atoma) = &
572 force(ikind)%dispersion(:, atoma) + gradient(:, iatom)
576 DEALLOCATE (energies)
577 IF (dispersion_env%doabc)
DEALLOCATE (energies3)
579 DEALLOCATE (gradient, ga)
584 DEALLOCATE (xyz, atomtype, atom_map, atom_map_back, species, exclude_ghost)
586 CALL timestop(handle)
608 SUBROUTINE refd4_debug(param, disp, mol, cutoff, partition, grad, doabc, &
609 enerd2, enerd3, cnd, qd, dEdcn, dEdq, gradient, stress)
610 CLASS(damping_param) :: param
611 TYPE(d4_model) :: disp
612 TYPE(structure_type) :: mol
613 TYPE(realspace_cutoff) :: cutoff
614 TYPE(work_partition),
INTENT(IN) :: partition
615 TYPE(error_type),
ALLOCATABLE :: error
616 LOGICAL,
INTENT(IN) :: grad, doabc
617 REAL(KIND=dp),
ALLOCATABLE,
DIMENSION(:) :: enerd2, enerd3, cnd, qd, dedcn, dedq
618 REAL(KIND=dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: gradient
619 REAL(KIND=dp),
DIMENSION(3, 3, 4) :: stress
621 INTEGER :: mref, natom, i, ncoup
622 REAL(KIND=dp),
ALLOCATABLE,
DIMENSION(:) :: q, qq
623 REAL(KIND=dp),
ALLOCATABLE,
DIMENSION(:, :) :: lattr, c6, dc6dcn, dc6dq
624 REAL(KIND=dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: cndr, cndl, qdr, qdl, gwdcn, gwdq, gwvec
626 mref = maxval(disp%ref)
631 ALLOCATE (cnd(natom))
632 IF (grad)
ALLOCATE (cndr(3, natom, natom), cndl(3, 3, natom))
633 CALL get_lattice_points(mol%periodic, mol%lattice, cutoff%cn, lattr)
634 CALL get_coordination_number(mol, lattr, cutoff%cn, disp%rcov, disp%en, &
638 IF (grad)
ALLOCATE (qdr(3, natom, natom), qdl(3, 3, natom))
639 CALL get_charges(disp%mchrg, mol, error, qd, qdr, qdl)
640 IF (
ALLOCATED(error))
THEN
641 cpabort(error%message)
644 ALLOCATE (gwvec(mref, natom, ncoup))
645 IF (grad)
ALLOCATE (gwdcn(mref, natom, ncoup), gwdq(mref, natom, ncoup))
646 CALL disp%weight_references(mol, cnd, qd, gwvec, gwdcn, gwdq)
647 ALLOCATE (c6(natom, natom))
648 IF (grad)
ALLOCATE (dc6dcn(natom, natom), dc6dq(natom, natom))
649 CALL disp%get_atomic_c6(mol, gwvec, gwdcn, gwdq, c6, dc6dcn, dc6dq)
650 CALL get_lattice_points(mol%periodic, mol%lattice, cutoff%disp2, lattr)
653 ALLOCATE (gradient(3, natom, 4))
658 ALLOCATE (enerd2(natom))
661 ALLOCATE (dedcn(natom), dedq(natom))
662 dedcn(:) = 0.0_dp; dedq(:) = 0.0_dp
665 CALL param%get_dispersion2(mol, lattr, cutoff%disp2, cutoff%width2, disp%r4r2, c6, &
666 dc6dcn, dc6dq, enerd2, dedcn, dedq, gradient(:, :, 1), &
667 stress(:, :, 1), partition=partition)
669 gradient(i, :, 2) = matmul(qdr(i, :, :), dedq(:))
670 stress(i, :, 2) = matmul(qdl(i, :, :), dedq(:))
673 CALL param%get_dispersion2(mol, lattr, cutoff%disp2, cutoff%width2, disp%r4r2, c6, &
674 energy=enerd2, partition=partition)
678 ALLOCATE (q(natom), qq(natom))
679 q(:) = 0.0_dp; qq(:) = 0.0_dp
680 ALLOCATE (enerd3(natom))
682 CALL disp%weight_references(mol, cnd, q, gwvec, gwdcn, gwdq)
683 CALL disp%get_atomic_c6(mol, gwvec, gwdcn, gwdq, c6, dc6dcn, dc6dq)
684 CALL get_lattice_points(mol%periodic, mol%lattice, cutoff%disp3, lattr)
686 CALL param%get_dispersion3(mol, lattr, cutoff%disp3, cutoff%width3, disp%r4r2, c6, &
687 dc6dcn, dc6dq, enerd3, dedcn, qq, gradient(:, :, 3), &
688 stress(:, :, 3), partition=partition)
690 CALL param%get_dispersion3(mol, lattr, cutoff%disp3, cutoff%width3, disp%r4r2, c6, &
691 energy=enerd3, partition=partition)
696 gradient(i, :, 4) = matmul(cndr(i, :, :), dedcn(:))
697 stress(i, :, 4) = matmul(cndl(i, :, :), dedcn(:))
701 END SUBROUTINE refd4_debug
716 TYPE(qs_environment_type),
POINTER :: qs_env
717 TYPE(qs_dispersion_type),
INTENT(IN),
POINTER :: dispersion_env
718 REAL(kind=dp),
INTENT(INOUT) :: evdw
719 LOGICAL,
INTENT(IN) :: calculate_forces
720 INTEGER,
INTENT(IN) :: iw
721 REAL(kind=dp),
DIMENSION(:),
OPTIONAL :: atomic_energy
724 mark_used(dispersion_env)
726 mark_used(calculate_forces)
728 mark_used(atomic_energy)
730 cpabort(
"CP2K build without DFTD4")
744 SUBROUTINE d4_smooth_cutoff(r, cutoff, width, sw, dswdr)
745 REAL(kind=dp),
INTENT(IN) :: r, cutoff, width
746 REAL(kind=dp),
INTENT(OUT) :: sw, dswdr
748 REAL(kind=dp) :: effective_width, inner, x
750 IF (width <= 0.0_dp .OR. cutoff <= 0.0_dp)
THEN
754 effective_width = min(width, cutoff)
755 inner = cutoff - effective_width
759 ELSE IF (r >= cutoff)
THEN
763 x = (cutoff - r)/effective_width
764 sw = x**3*(10.0_dp + x*(-15.0_dp + 6.0_dp*x))
765 dswdr = -30.0_dp*x**2*(1.0_dp - x)**2/effective_width
769 END SUBROUTINE d4_smooth_cutoff
791 SUBROUTINE dispersion_2b(dispersion_env, cutoff, width, r4r2, &
792 gwvec, gwdcn, gwdq, c6ref, mrefs, &
793 energies, dEdcn, dEdq, &
794 calculate_forces, gradient, stress, &
796 TYPE(qs_dispersion_type),
POINTER :: dispersion_env
797 REAL(kind=dp),
INTENT(IN) :: cutoff, width
798 REAL(kind=dp),
DIMENSION(:),
INTENT(IN) :: r4r2
799 REAL(kind=dp),
DIMENSION(:, :, :),
INTENT(IN) :: gwvec, gwdcn, gwdq
800 REAL(kind=dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: c6ref
801 INTEGER,
DIMENSION(:),
INTENT(IN) :: mrefs
802 REAL(kind=dp),
DIMENSION(:),
INTENT(INOUT) :: energies, dedcn, dedq
803 LOGICAL,
INTENT(IN) :: calculate_forces
804 REAL(kind=dp),
DIMENSION(:, :),
INTENT(INOUT) :: gradient, stress
805 INTEGER,
DIMENSION(:),
INTENT(IN) :: atom_map, species
807 INTEGER :: ia, iatom, ik, ikind, ja, jatom, jk, &
809 REAL(kind=dp) :: a1, a2, c6ij, cutoff2, d6, d8, de, dr2, &
810 dswdr, edisp, edisp0,
fac, gdisp, &
811 gdisp0, r, r0ij, rrij, s6, s8, sw, t6, &
813 REAL(kind=dp),
DIMENSION(2) :: dcdcn, dcdq
814 REAL(kind=dp),
DIMENSION(3) :: dg, rij
815 REAL(kind=dp),
DIMENSION(3, 3) :: ds
816 TYPE(neighbor_list_iterator_p_type), &
817 DIMENSION(:),
POINTER :: nl_iterator
818 TYPE(neighbor_list_set_p_type),
DIMENSION(:), &
821 a1 = dispersion_env%a1
822 a2 = dispersion_env%a2
823 s6 = dispersion_env%s6
824 s8 = dispersion_env%s8
825 cutoff2 = cutoff*cutoff
827 sab_vdw => dispersion_env%sab_vdw
830 CALL neighbor_list_iterator_create(nl_iterator, sab_vdw, nthread=num_pe)
833 DO WHILE (neighbor_list_iterate(nl_iterator, mepos=mepos) == 0)
834 CALL get_iterator_info(nl_iterator, mepos=mepos, ikind=ikind, jkind=jkind, &
835 iatom=iatom, jatom=jatom, r=rij)
839 IF (ia == 0 .OR. ja == 0) cycle
845 IF (dr2 <= cutoff2 .AND. dr2 > 0.0000001_dp)
THEN
846 rrij = 3._dp*r4r2(ik)*r4r2(jk)
847 r0ij = a1*sqrt(rrij) + a2
848 IF (calculate_forces)
THEN
849 CALL get_c6derivs(c6ij, dcdcn, dcdq, ia, ja, ik, jk, &
850 gwvec, gwdcn, gwdq, c6ref, mrefs)
852 CALL get_c6value(c6ij, ia, ja, ik, jk, gwvec, c6ref, mrefs)
855 IF (iatom == jatom)
fac = 0.5_dp
857 CALL d4_smooth_cutoff(r, cutoff, width, sw, dswdr)
858 IF (sw <= 0.0_dp) cycle
859 t6 = 1.0_dp/(dr2**3 + r0ij**6)
860 t8 = 1.0_dp/(dr2**4 + r0ij**8)
862 edisp0 = s6*t6 + s8*rrij*t8
863 edisp = sw*edisp0*
fac
865 energies(iatom) = energies(iatom) + de*0.5_dp
866 energies(jatom) = energies(jatom) + de*0.5_dp
868 IF (calculate_forces)
THEN
869 d6 = -6.0_dp*dr2**2*t6**2
870 d8 = -8.0_dp*dr2**3*t8**2
871 gdisp0 = s6*d6 + s8*rrij*d8
872 gdisp = (sw*gdisp0 + dswdr*edisp0/r)*
fac
873 dg(:) = -c6ij*gdisp*rij(:)
874 gradient(:, iatom) = gradient(:, iatom) - dg
875 gradient(:, jatom) = gradient(:, jatom) + dg
876 ds(:, :) = spread(dg, 1, 3)*spread(rij, 2, 3)
877 stress(:, :) = stress(:, :) + ds(:, :)
878 dedcn(iatom) = dedcn(iatom) - dcdcn(1)*edisp
879 dedq(iatom) = dedq(iatom) - dcdq(1)*edisp
880 dedcn(jatom) = dedcn(jatom) - dcdcn(2)*edisp
881 dedq(jatom) = dedq(jatom) - dcdq(2)*edisp
886 CALL neighbor_list_iterator_release(nl_iterator)
888 END SUBROUTINE dispersion_2b
911 SUBROUTINE dispersion_3b(qs_env, dispersion_env, tvec, cutoff, r4r2, &
912 gwvec, gwdcn, gwdq, c6ref, mrefs, &
913 energies, dEdcn, dEdq, &
914 calculate_forces, gradient, stress, &
916 TYPE(qs_environment_type),
POINTER :: qs_env
917 TYPE(qs_dispersion_type),
POINTER :: dispersion_env
918 REAL(kind=dp),
DIMENSION(:, :),
INTENT(IN) :: tvec
919 REAL(kind=dp),
INTENT(IN) :: cutoff
920 REAL(kind=dp),
DIMENSION(:),
INTENT(IN) :: r4r2
921 REAL(kind=dp),
DIMENSION(:, :, :),
INTENT(IN) :: gwvec, gwdcn, gwdq
922 REAL(kind=dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: c6ref
923 INTEGER,
DIMENSION(:),
INTENT(IN) :: mrefs
924 REAL(kind=dp),
DIMENSION(:),
INTENT(INOUT) :: energies, dedcn, dedq
925 LOGICAL,
INTENT(IN) :: calculate_forces
926 REAL(kind=dp),
DIMENSION(:, :),
INTENT(INOUT) :: gradient, stress
927 INTEGER,
DIMENSION(:),
INTENT(IN) :: atom_map, species
929 INTEGER :: ia, iatom, ik, ikind, ja, jatom, jk, &
930 jkind, ka, katom, kk, ktr, mepos, &
932 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: kind_of
933 INTEGER,
DIMENSION(3) :: cell_b
934 REAL(kind=dp) :: a1, a2, alp, ang, c6ij, c6ik, c6jk, c9, &
935 cutoff2, dang, de, dfdmp,
fac, fdmp, &
936 r0, r0ij, r0ik, r0jk, r1, r2, r2ij, &
937 r2ik, r2jk, r3, r5, rr, s6, s8, s9
938 REAL(kind=dp),
ALLOCATABLE,
DIMENSION(:, :) :: rcpbc
939 REAL(kind=dp),
DIMENSION(2) :: dc6dcnij, dc6dcnik, dc6dcnjk, dc6dqij, &
941 REAL(kind=dp),
DIMENSION(3) :: dgij, dgik, dgjk, ra, rb, rb0, rij, vij, &
943 REAL(kind=dp),
DIMENSION(3, 3) :: ds
944 TYPE(atomic_kind_type),
DIMENSION(:),
POINTER :: atomic_kind_set
945 TYPE(cell_type),
POINTER :: cell
946 TYPE(neighbor_list_iterator_p_type), &
947 DIMENSION(:),
POINTER :: nl_iterator
948 TYPE(neighbor_list_set_p_type),
DIMENSION(:), &
950 TYPE(particle_type),
DIMENSION(:),
POINTER :: particle_set
952 CALL get_qs_env(qs_env=qs_env, natom=natom, cell=cell, &
953 atomic_kind_set=atomic_kind_set, particle_set=particle_set)
955 ALLOCATE (rcpbc(3, natom))
957 rcpbc(:, iatom) = pbc(particle_set(iatom)%r(:), cell)
959 CALL get_atomic_kind_set(atomic_kind_set, kind_of=kind_of)
961 a1 = dispersion_env%a1
962 a2 = dispersion_env%a2
963 s6 = dispersion_env%s6
964 s8 = dispersion_env%s8
965 s9 = dispersion_env%s9
966 alp = dispersion_env%alp
970 sab_vdw => dispersion_env%sab_vdw
973 CALL neighbor_list_iterator_create(nl_iterator, sab_vdw, nthread=num_pe)
976 DO WHILE (neighbor_list_iterate(nl_iterator, mepos=mepos) == 0)
977 CALL get_iterator_info(nl_iterator, mepos=mepos, ikind=ikind, jkind=jkind, iatom=iatom, jatom=jatom, r=rij)
982 IF (ia == 0 .OR. ja == 0) cycle
986 r2ij = sum(rij(:)**2)
987 IF (calculate_forces)
THEN
988 CALL get_c6derivs(c6ij, dc6dcnij, dc6dqij, ia, ja, ik, jk, &
989 gwvec, gwdcn, gwdq, c6ref, mrefs)
991 CALL get_c6value(c6ij, ia, ja, ik, jk, gwvec, c6ref, mrefs)
993 r0ij = a1*sqrt(3._dp*r4r2(jk)*r4r2(ik)) + a2
994 IF (r2ij <= cutoff2 .AND. r2ij > epsilon(1._dp))
THEN
995 CALL get_iterator_info(nl_iterator, cell=cell_b)
996 rb0(:) = matmul(cell%hmat, cell_b)
997 ra(:) = rcpbc(:, iatom)
998 rb(:) = rcpbc(:, jatom) + rb0
999 vij(:) = rb(:) - ra(:)
1001 DO katom = 1, min(iatom, jatom)
1002 ka = atom_map(katom)
1005 IF (calculate_forces)
THEN
1006 CALL get_c6derivs(c6ik, dc6dcnik, dc6dqik, ka, ia, kk, ik, &
1007 gwvec, gwdcn, gwdq, c6ref, mrefs)
1008 CALL get_c6derivs(c6jk, dc6dcnjk, dc6dqjk, ka, ja, kk, jk, &
1009 gwvec, gwdcn, gwdq, c6ref, mrefs)
1011 CALL get_c6value(c6ik, ka, ia, kk, ik, gwvec, c6ref, mrefs)
1012 CALL get_c6value(c6jk, ka, ja, kk, jk, gwvec, c6ref, mrefs)
1014 c9 = -s9*sqrt(abs(c6ij*c6ik*c6jk))
1015 r0ik = a1*sqrt(3._dp*r4r2(kk)*r4r2(ik)) + a2
1016 r0jk = a1*sqrt(3._dp*r4r2(kk)*r4r2(jk)) + a2
1018 fac = triple_scale(iatom, jatom, katom)
1019 DO ktr = 1,
SIZE(tvec, 2)
1020 vik(:) = rcpbc(:, katom) + tvec(:, ktr) - rcpbc(:, iatom)
1021 r2ik = vik(1)*vik(1) + vik(2)*vik(2) + vik(3)*vik(3)
1022 IF (r2ik > cutoff2 .OR. r2ik < epsilon(1.0_dp)) cycle
1023 vjk(:) = rcpbc(:, katom) + tvec(:, ktr) - rb(:)
1024 r2jk = vjk(1)*vjk(1) + vjk(2)*vjk(2) + vjk(3)*vjk(3)
1025 IF (r2jk > cutoff2 .OR. r2jk < epsilon(1.0_dp)) cycle
1031 fdmp = 1.0_dp/(1.0_dp + 6.0_dp*(r0/r1)**(alp/3.0_dp))
1032 ang = 0.375_dp*(r2ij + r2jk - r2ik)*(r2ij - r2jk + r2ik)* &
1033 (-r2ij + r2jk + r2ik)/r5 + 1.0_dp/r3
1037 energies(iatom) = energies(iatom) - de/3._dp
1038 energies(jatom) = energies(jatom) - de/3._dp
1039 energies(katom) = energies(katom) - de/3._dp
1041 IF (calculate_forces)
THEN
1043 dfdmp = -2.0_dp*alp*(r0/r1)**(alp/3.0_dp)*fdmp**2
1046 dang = -0.375_dp*(r2ij**3 + r2ij**2*(r2jk + r2ik) &
1047 + r2ij*(3.0_dp*r2jk**2 + 2.0_dp*r2jk*r2ik &
1049 - 5.0_dp*(r2jk - r2ik)**2*(r2jk + r2ik))/r5
1050 dgij(:) = c9*(-dang*fdmp + ang*dfdmp)/r2ij*vij
1053 dang = -0.375_dp*(r2ik**3 + r2ik**2*(r2jk + r2ij) &
1054 + r2ik*(3.0_dp*r2jk**2 + 2.0_dp*r2jk*r2ij &
1056 - 5.0_dp*(r2jk - r2ij)**2*(r2jk + r2ij))/r5
1057 dgik(:) = c9*(-dang*fdmp + ang*dfdmp)/r2ik*vik
1060 dang = -0.375_dp*(r2jk**3 + r2jk**2*(r2ik + r2ij) &
1061 + r2jk*(3.0_dp*r2ik**2 + 2.0_dp*r2ik*r2ij &
1063 - 5.0_dp*(r2ik - r2ij)**2*(r2ik + r2ij))/r5
1064 dgjk(:) = c9*(-dang*fdmp + ang*dfdmp)/r2jk*vjk
1066 gradient(:, iatom) = gradient(:, iatom) - dgij - dgik
1067 gradient(:, jatom) = gradient(:, jatom) + dgij - dgjk
1068 gradient(:, katom) = gradient(:, katom) + dgik + dgjk
1070 ds(:, :) = spread(dgij, 1, 3)*spread(vij, 2, 3) &
1071 + spread(dgik, 1, 3)*spread(vik, 2, 3) &
1072 + spread(dgjk, 1, 3)*spread(vjk, 2, 3)
1074 stress(:, :) = stress + ds*
fac
1076 dedcn(iatom) = dedcn(iatom) - de*0.5_dp &
1077 *(dc6dcnij(1)/c6ij + dc6dcnik(2)/c6ik)
1078 dedcn(jatom) = dedcn(jatom) - de*0.5_dp &
1079 *(dc6dcnij(2)/c6ij + dc6dcnjk(2)/c6jk)
1080 dedcn(katom) = dedcn(katom) - de*0.5_dp &
1081 *(dc6dcnik(1)/c6ik + dc6dcnjk(1)/c6jk)
1083 dedq(iatom) = dedq(iatom) - de*0.5_dp &
1084 *(dc6dqij(1)/c6ij + dc6dqik(2)/c6ik)
1085 dedq(jatom) = dedq(jatom) - de*0.5_dp &
1086 *(dc6dqij(2)/c6ij + dc6dqjk(2)/c6jk)
1087 dedq(katom) = dedq(katom) - de*0.5_dp &
1088 *(dc6dqik(1)/c6ik + dc6dqjk(1)/c6jk)
1097 CALL neighbor_list_iterator_release(nl_iterator)
1101 END SUBROUTINE dispersion_3b
1110 FUNCTION triple_scale(ii, jj, kk)
RESULT(triple)
1111 INTEGER,
INTENT(IN) :: ii, jj, kk
1112 REAL(kind=dp) :: triple
1117 triple = 1.0_dp/6.0_dp
1123 IF (ii /= kk .AND. jj /= kk)
THEN
1132 END FUNCTION triple_scale
1142 SUBROUTINE dedcn_force(qs_env, dEdcn, dcnum, gradient, stress)
1143 TYPE(qs_environment_type),
POINTER :: qs_env
1144 REAL(kind=dp),
DIMENSION(:),
INTENT(IN) :: dedcn
1145 TYPE(dcnum_type),
DIMENSION(:),
INTENT(IN) :: dcnum
1146 REAL(kind=dp),
DIMENSION(:, :),
INTENT(INOUT) :: gradient
1147 REAL(kind=dp),
DIMENSION(3, 3),
INTENT(INOUT) :: stress
1149 CHARACTER(len=*),
PARAMETER :: routinen =
'dEdcn_force'
1151 INTEGER :: handle, i, ia, iatom, ikind, katom, &
1153 LOGICAL :: use_virial
1154 REAL(kind=dp) :: drk
1155 REAL(kind=dp),
DIMENSION(3) :: fdik, rik
1156 TYPE(distribution_1d_type),
POINTER :: local_particles
1157 TYPE(virial_type),
POINTER :: virial
1159 CALL timeset(routinen, handle)
1161 CALL get_qs_env(qs_env, nkind=nkind, natom=natom, &
1162 local_particles=local_particles, &
1164 use_virial = virial%pv_availability .AND. (.NOT. virial%pv_numer)
1167 DO ia = 1, local_particles%n_el(ikind)
1168 iatom = local_particles%list(ikind)%array(ia)
1169 DO i = 1, dcnum(iatom)%neighbors
1170 katom = dcnum(iatom)%nlist(i)
1171 rik = dcnum(iatom)%rik(:, i)
1172 drk = sqrt(sum(rik(:)**2))
1173 fdik(:) = -(dedcn(iatom) + dedcn(katom))*dcnum(iatom)%dvals(i)*rik(:)/drk
1174 gradient(:, iatom) = gradient(:, iatom) + fdik(:)
1175 IF (use_virial)
THEN
1176 CALL virial_pair_force(stress, -0.5_dp, fdik, rik)
1182 CALL timestop(handle)
1184 END SUBROUTINE dedcn_force
1197 SUBROUTINE get_c6value(c6ij, ia, ja, ik, jk, gwvec, c6ref, mrefs)
1198 REAL(kind=dp),
INTENT(OUT) :: c6ij
1199 INTEGER,
INTENT(IN) :: ia, ja, ik, jk
1200 REAL(kind=dp),
DIMENSION(:, :, :),
INTENT(IN) :: gwvec
1201 REAL(kind=dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: c6ref
1202 INTEGER,
DIMENSION(:),
INTENT(IN) :: mrefs
1204 INTEGER :: iref, jref
1205 REAL(kind=dp) :: refc6
1208 DO jref = 1, mrefs(jk)
1209 DO iref = 1, mrefs(ik)
1210 refc6 = c6ref(iref, jref, ik, jk)
1211 c6ij = c6ij + gwvec(iref, ia, 1)*gwvec(jref, ja, 1)*refc6
1215 END SUBROUTINE get_c6value
1232 SUBROUTINE get_c6derivs(c6ij, dc6dcn, dc6dq, ia, ja, ik, jk, &
1233 gwvec, gwdcn, gwdq, c6ref, mrefs)
1234 REAL(kind=dp),
INTENT(OUT) :: c6ij
1235 REAL(kind=dp),
DIMENSION(2),
INTENT(OUT) :: dc6dcn, dc6dq
1236 INTEGER,
INTENT(IN) :: ia, ja, ik, jk
1237 REAL(kind=dp),
DIMENSION(:, :, :),
INTENT(IN) :: gwvec, gwdcn, gwdq
1238 REAL(kind=dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: c6ref
1239 INTEGER,
DIMENSION(:),
INTENT(IN) :: mrefs
1241 INTEGER :: iref, jref
1242 REAL(kind=dp) :: refc6
1247 DO jref = 1, mrefs(jk)
1248 DO iref = 1, mrefs(ik)
1249 refc6 = c6ref(iref, jref, ik, jk)
1250 c6ij = c6ij + gwvec(iref, ia, 1)*gwvec(jref, ja, 1)*refc6
1251 dc6dcn(1) = dc6dcn(1) + gwdcn(iref, ia, 1)*gwvec(jref, ja, 1)*refc6
1252 dc6dcn(2) = dc6dcn(2) + gwvec(iref, ia, 1)*gwdcn(jref, ja, 1)*refc6
1253 dc6dq(1) = dc6dq(1) + gwdq(iref, ia, 1)*gwvec(jref, ja, 1)*refc6
1254 dc6dq(2) = dc6dq(2) + gwvec(iref, ia, 1)*gwdq(jref, ja, 1)*refc6
1258 END SUBROUTINE get_c6derivs
1269 SUBROUTINE gerror(ga, gd, ev1, ev2, ev3, ev4)
1270 REAL(kind=dp),
DIMENSION(:, :) :: ga, gd
1271 REAL(kind=dp),
INTENT(OUT) :: ev1, ev2, ev3, ev4
1273 INTEGER :: na, np(2)
1276 ev1 = sqrt(sum((gd - ga)**2)/na)
1277 ev2 = ev1/sqrt(sum(gd**2)/na)*100._dp
1278 np = maxloc(abs(gd - ga))
1279 ev3 = abs(gd(np(1), np(2)) - ga(np(1), np(2)))
1280 ev4 = abs(gd(np(1), np(2)))
1281 IF (ev4 > 1.e-6_dp)
THEN
1282 ev4 = ev3/ev4*100._dp
1287 END SUBROUTINE gerror
1296 SUBROUTINE serror(sa, sd, ev1, ev2)
1297 REAL(kind=dp),
DIMENSION(3, 3) :: sa, sd
1298 REAL(kind=dp),
INTENT(OUT) :: ev1, ev2
1301 REAL(kind=dp) :: rel
1303 ev1 = maxval(abs(sd - sa))
1307 IF (abs(sd(i, j)) > 1.e-6_dp)
THEN
1308 rel = abs(sd(i, j) - sa(i, j))/abs(sd(i, j))*100._dp
1314 END SUBROUTINE serror
1323 SUBROUTINE verror(va, vd, ev1, ev2)
1324 REAL(kind=dp),
DIMENSION(:) :: va, vd
1325 REAL(kind=dp),
INTENT(OUT) :: ev1, ev2
1328 REAL(kind=dp) :: rel
1331 ev1 = maxval(abs(vd - va))
1334 IF (abs(vd(i)) > 1.e-8_dp)
THEN
1335 rel = abs(vd(i) - va(i))/abs(vd(i))*100._dp
1340 END SUBROUTINE verror
static GRID_HOST_DEVICE double fac(const int i)
Factorial function, e.g. fac(5) = 5! = 120.
Define the atomic kind types and their sub types.
subroutine, public get_atomic_kind_set(atomic_kind_set, atom_of_kind, kind_of, natom_of_kind, maxatom, natom, nshell, fist_potential_present, shell_present, shell_adiabatic, shell_check_distance, damping_present)
Get attributes of an atomic kind set.
subroutine, public get_atomic_kind(atomic_kind, fist_potential, element_symbol, name, mass, kind_number, natom, atom_list, rcov, rvdw, z, qeff, apol, cpol, mm_radius, shell, shell_active, damping)
Get attributes of an atomic kind.
Handles all functions related to the CELL.
subroutine, public get_cell(cell, alpha, beta, gamma, deth, orthorhombic, abc, periodic, h, h_inv, symmetry_id, tag)
Get informations about a simulation cell.
real(kind=dp) function, public plane_distance(h, k, l, cell)
Calculate the distance between two lattice planes as defined by a triple of Miller indices (hkl).
Defines control structures, which contain the parameters and the settings for the DFT-based calculati...
stores a lists of integer that are local to a processor. The idea is that these integers represent ob...
Calculation of charge equilibration method.
subroutine, public eeq_charges(qs_env, charges, eeq_sparam, eeq_model, enshift_type, exclude, cn_max)
...
subroutine, public eeq_forces(qs_env, charges, dcharges, gradient, stress, eeq_sparam, eeq_model, enshift_type, response_only, exclude, cn_max)
...
Defines the basic variable types.
integer, parameter, public dp
Machine interface based on Fortran 2003 and POSIX.
subroutine, public m_flush(lunit)
flushes units if the &GLOBAL flag is set accordingly
real(kind=dp) function, public m_walltime()
returns time from a real-time clock, protected against rolling early/easily
Interface to the message passing library MPI.
Define the data structure for the particle information.
Coordination number routines for dispersion pairpotentials.
subroutine, public cnumber_release(cnumbers, dcnum, derivatives)
...
subroutine, public cnumber_init(qs_env, cnumbers, dcnum, ftype, derivatives, disp_env)
...
Calculation of dispersion using pair potentials.
subroutine, public calculate_dispersion_d4_pairpot(qs_env, dispersion_env, evdw, calculate_forces, iw, atomic_energy)
...
Definition of disperson types for DFT calculations.
Set disperson types for DFT calculations.
integer function, public cellhash(cell, ncell)
...
subroutine, public get_qs_env(qs_env, atomic_kind_set, qs_kind_set, cell, super_cell, cell_ref, use_ref_cell, kpoints, dft_control, mos, sab_orb, sab_all, qmmm, qmmm_periodic, mimic, sac_ae, sac_ppl, sac_lri, sap_ppnl, sab_vdw, sab_scp, sap_oce, sab_lrc, sab_se, sab_xtbe, sab_tbe, sab_core, sab_xb, sab_xtb_pp, sab_xtb_nonbond, sab_almo, sab_kp, sab_kp_nosym, sab_cneo, particle_set, energy, force, matrix_h, matrix_h_im, matrix_ks, matrix_ks_im, matrix_vxc, run_rtp, rtp, matrix_h_kp, matrix_h_im_kp, matrix_ks_kp, matrix_ks_im_kp, matrix_vxc_kp, kinetic_kp, matrix_s_kp, matrix_w_kp, matrix_s_ri_aux_kp, matrix_s, matrix_s_ri_aux, matrix_w, matrix_p_mp2, matrix_p_mp2_admm, matrix_vhxc, rho, rho_xc, pw_env, ewald_env, ewald_pw, active_space, mpools, input, para_env, blacs_env, scf_control, rel_control, kinetic, qs_charges, vppl, xcint_weights, rho_core, rho_nlcc, rho_nlcc_g, ks_env, ks_qmmm_env, wf_history, scf_env, local_particles, local_molecules, distribution_2d, dbcsr_dist, molecule_kind_set, molecule_set, subsys, cp_subsys, oce, local_rho_set, rho_atom_set, task_list, task_list_soft, rho0_atom_set, rho0_mpole, rhoz_set, rhoz_cneo_set, ecoul_1c, rho0_s_rs, rho0_s_gs, rhoz_cneo_s_rs, rhoz_cneo_s_gs, do_kpoints, has_unit_metric, requires_mo_derivs, mo_derivs, mo_loc_history, nkind, natom, nelectron_total, nelectron_spin, efield, neighbor_list_id, linres_control, xas_env, virial, cp_ddapc_env, cp_ddapc_ewald, outer_scf_history, outer_scf_ihistory, x_data, et_coupling, dftb_potential, results, se_taper, se_store_int_env, se_nddo_mpole, se_nonbond_env, admm_env, lri_env, lri_density, exstate_env, ec_env, harris_env, dispersion_env, gcp_env, vee, rho_external, external_vxc, mask, mp2_env, bs_env, kg_env, wanniercentres, atprop, ls_scf_env, do_transport, transport_env, v_hartree_rspace, s_mstruct_changed, rho_changed, potential_changed, forces_up_to_date, mscfg_env, almo_scf_env, gradient_history, variable_history, embed_pot, spin_embed_pot, polar_env, mos_last_converged, eeq, rhs, do_rixs, tb_tblite)
Get the QUICKSTEP environment.
Define the quickstep kind type and their sub types.
subroutine, public get_qs_kind(qs_kind, basis_set, basis_type, ncgf, nsgf, all_potential, tnadd_potential, gth_potential, sgp_potential, upf_potential, cneo_potential, se_parameter, dftb_parameter, xtb_parameter, dftb3_param, zatom, zeff, elec_conf, mao, lmax_dftb, alpha_core_charge, ccore_charge, core_charge, core_charge_radius, paw_proj_set, paw_atom, hard_radius, hard0_radius, max_rad_local, covalent_radius, vdw_radius, gpw_type_forced, harmonics, max_iso_not0, max_s_harm, grid_atom, ngrid_ang, ngrid_rad, lmax_rho0, dft_plus_u_atom, l_of_dft_plus_u, n_of_dft_plus_u, u_minus_j, hund_j, u_of_dft_plus_u, j_of_dft_plus_u, alpha_of_dft_plus_u, beta_of_dft_plus_u, j0_of_dft_plus_u, occupation_of_dft_plus_u, dispersion, bs_occupation, magnetization, no_optimize, addel, laddel, naddel, orbitals, max_scf, eps_scf, smear, u_ramping, u_minus_j_target, eps_u_ramping, proj_shell_charge, lr_atom, do_mtlr, u_j_loop, ao_coef, init_u_ramping_each_scf, reltmat, ghost, monovalent, floating, name, element_symbol, pao_basis_size, pao_model_file, pao_potentials, pao_descriptors, nelec)
Get attributes of an atomic kind.
subroutine, public set_qs_kind(qs_kind, paw_atom, ghost, floating, hard_radius, hard0_radius, covalent_radius, vdw_radius, lmax_rho0, zeff, no_optimize, dispersion, u_minus_j, hund_j, reltmat, dftb_parameter, xtb_parameter, elec_conf, pao_basis_size)
Set the components of an atomic kind data set.
Define the neighbor list data types and the corresponding functionality.
subroutine, public neighbor_list_iterator_create(iterator_set, nl, search, nthread)
Neighbor list iterator functions.
subroutine, public neighbor_list_iterator_release(iterator_set)
...
integer function, public neighbor_list_iterate(iterator_set, mepos)
...
subroutine, public get_iterator_info(iterator_set, mepos, ikind, jkind, nkind, ilist, nlist, inode, nnode, iatom, jatom, r, cell)
...
pure subroutine, public virial_pair_force(pv_virial, f0, force, rab)
Computes the contribution to the stress tensor from two-body pair-wise forces.
Provides all information about an atomic kind.
Type defining parameters related to the simulation cell.
structure to store local (to a processor) ordered lists of integers.
stores all the informations relevant to an mpi environment
Provides all information about a quickstep kind.