45#include "../base/base_uses.f90"
51 LOGICAL,
PRIVATE,
PARAMETER :: debug_this_module = .true.
52 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'helium_interactions'
77 INTEGER :: b, bead, i, j, n
78 INTEGER,
DIMENSION(:),
POINTER :: perm
80 REAL(kind=
dp) :: a, cell_size, en, interac, kin, pot, &
82 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: work2, work3
83 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: work
84 REAL(kind=
dp),
DIMENSION(3) :: r
85 REAL(kind=
dp),
DIMENSION(:, :, :),
POINTER :: pos
89 perm => helium%permutation
91 cell_size = 0.5_dp*helium%cell_size
92 nperiodic = .NOT. helium%periodic
99 ALLOCATE (work(3, helium%beads + 1), &
100 work2(helium%beads + 1), &
101 work3(
SIZE(helium%uoffdiag, 1) + 1))
105 work(:, bead) = pos(:, i, bead) - pos(:, j, bead)
107 work(:, b + 1) = pos(:, perm(i), 1) - pos(:, perm(j), 1)
111 IF (a < rmin) rmin = a
112 IF (a > rmax) rmax = a
113 IF ((a < cell_size) .OR. nperiodic)
THEN
119 DEALLOCATE (work, work2, work3)
125 IF (helium%solute_present)
THEN
126 CALL helium_solute_e(pint_env, helium, interac)
136 r(:) = pos(:, i, b) - pos(:, perm(i), 1)
138 kin = kin + r(1)*r(1) + r(2)*r(2) + r(3)*r(3)
140 r(:) = pos(:, i, bead - 1) - pos(:, i, bead)
142 kin = kin + r(1)*r(1) + r(2)*r(2) + r(3)*r(3)
145 kin = 1.5_dp*n/helium%tau - 0.5*kin/(b*helium%tau**2*helium%hb2m)
162 helium%energy_inst(
e_id_thermo) = (en + kin)/n + helium%e_corr
181 INTEGER :: iatom, ibead
182 INTEGER,
DIMENSION(:),
POINTER :: perm
183 REAL(kind=
dp),
DIMENSION(3) :: r
185 perm => helium%permutation
190 DO ibead = 1, helium%beads - 1
191 DO iatom = 1, helium%atoms
192 r(:) = helium%pos(:, iatom, ibead) - helium%pos(:, iatom, ibead + 1)
194 linkaction = linkaction + (r(1)*r(1) + r(2)*r(2) + r(3)*r(3))
197 DO iatom = 1, helium%atoms
199 r(:) = helium%pos(:, iatom, helium%beads) - helium%pos(:, perm(iatom), 1)
201 linkaction = linkaction + (r(1)*r(1) + r(2)*r(2) + r(3)*r(3))
203 linkaction = linkaction/(2.0_dp*helium%tau*helium%hb2m)
218 INTEGER :: iatom, ibead, jatom, opatom, patom
219 INTEGER,
DIMENSION(:),
POINTER :: perm
220 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: work3
221 REAL(kind=
dp),
DIMENSION(3) :: r, rp
223 ALLOCATE (work3(
SIZE(helium%uoffdiag, 1) + 1))
224 perm => helium%permutation
228 DO ibead = 1, helium%beads - 1
229 DO iatom = 1, helium%atoms - 1
230 DO jatom = iatom + 1, helium%atoms
231 r(:) = helium%pos(:, iatom, ibead) - helium%pos(:, jatom, ibead)
232 rp(:) = helium%pos(:, iatom, ibead + 1) - helium%pos(:, jatom, ibead + 1)
238 DO iatom = 1, helium%atoms - 1
239 DO jatom = iatom + 1, helium%atoms
240 r(:) = helium%pos(:, iatom, helium%beads) - helium%pos(:, jatom, helium%beads)
241 rp(:) = helium%pos(:, perm(iatom), 1) - helium%pos(:, perm(jatom), 1)
247 IF (.NOT. helium%worm_is_closed)
THEN
249 iatom = helium%worm_atom_idx
250 IF (helium%worm_bead_idx == 1)
THEN
252 patom = helium%iperm(iatom)
254 DO jatom = 1, helium%atoms
255 IF (jatom == helium%worm_atom_idx) cycle
256 opatom = helium%iperm(jatom)
258 r(:) = helium%pos(:, iatom, 1) - helium%pos(:, jatom, 1)
259 rp(:) = helium%pos(:, patom, helium%beads) - helium%pos(:, opatom, helium%beads)
263 r(:) = helium%worm_xtra_bead(:) - helium%pos(:, jatom, 1)
268 ibead = helium%worm_bead_idx
270 DO jatom = 1, helium%atoms
271 IF (jatom == helium%worm_atom_idx) cycle
273 r(:) = helium%pos(:, iatom, ibead) - helium%pos(:, jatom, ibead)
274 rp(:) = helium%pos(:, iatom, ibead - 1) - helium%pos(:, jatom, ibead - 1)
278 r(:) = helium%worm_xtra_bead(:) - helium%pos(:, jatom, ibead)
300 INTEGER :: iatom, ibead
306 IF (helium%solute_present)
THEN
307 DO ibead = 1, helium%beads
308 DO iatom = 1, helium%atoms
311 iatom, ibead, helium%pos(:, iatom, ibead), e)
312 interaction = interaction + e
316 IF (.NOT. helium%worm_is_closed)
THEN
319 helium%worm_atom_idx, helium%worm_bead_idx, &
320 helium%pos(:, helium%worm_atom_idx, helium%worm_bead_idx), e)
321 interaction = interaction - 0.5_dp*e
324 helium%worm_atom_idx, helium%worm_bead_idx, &
325 helium%worm_xtra_bead, e)
326 interaction = interaction + 0.5_dp*e
331 interaction = interaction*helium%tau
351 helium_slice_index, helium_r_opt, energy, force)
355 INTEGER,
INTENT(IN) :: helium_part_index, helium_slice_index
356 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN),
OPTIONAL :: helium_r_opt
357 REAL(kind=
dp),
INTENT(OUT) :: energy
358 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(INOUT), &
359 OPTIONAL,
POINTER :: force
361 INTEGER :: hbeads, hi, qi, stride
362 REAL(kind=
dp),
DIMENSION(3) :: helium_r
363 REAL(kind=
dp),
DIMENSION(:),
POINTER :: my_force
365 hbeads = helium%beads
367 hi = mod(helium_slice_index - 1 + hbeads + helium%relrot, hbeads) + 1
369 qi = ((hi - 1)*pint_env%p)/hbeads + 1
372 IF (
PRESENT(helium_r_opt))
THEN
373 helium_r(:) = helium_r_opt(:)
375 helium_r(:) = helium%pos(:, helium_part_index, helium_slice_index)
378 SELECT CASE (helium%solute_interaction)
381 IF (
PRESENT(force))
THEN
383 my_force => force(qi, :)
384 CALL helium_intpot_model_water( &
392 CALL helium_intpot_model_water( &
401 IF (
PRESENT(force))
THEN
403 my_force => force(qi, :)
404 CALL helium_intpot_nnp( &
412 CALL helium_intpot_nnp( &
422 IF (
PRESENT(force))
THEN
431 IF (
PRESENT(force))
THEN
432 IF (hbeads < pint_env%p)
THEN
433 stride = pint_env%p/hbeads
434 force = force*real(stride,
dp)
451 REAL(kind=
dp),
INTENT(OUT) :: energy
453 INTEGER :: ia, ib, jb, jc
454 REAL(kind=
dp) :: my_energy
455 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: force
458 force => helium%force_inst
465 DO ia = 1, helium%atoms
466 DO ib = 1, helium%beads
468 energy=my_energy, force=helium%rtmp_p_ndim_2d)
469 energy = energy + my_energy
470 DO jb = 1, pint_env%p
471 DO jc = 1, pint_env%ndim
472 force(jb, jc) = force(jb, jc) + helium%rtmp_p_ndim_2d(jb, jc)
487 SUBROUTINE helium_solute_e(pint_env, helium, energy)
491 REAL(kind=
dp),
INTENT(OUT) :: energy
494 REAL(kind=
dp) :: my_energy
498 DO ia = 1, helium%atoms
499 DO ib = 1, helium%beads
501 energy = energy + my_energy
505 END SUBROUTINE helium_solute_e
521 CHARACTER(len=*),
PARAMETER :: routinen =
'helium_intpot_scan'
523 INTEGER :: handle, ic, ix, iy, iz, k, nbin
525 REAL(kind=
dp) :: delr, my_en, ox, oy, oz
526 REAL(kind=
dp),
DIMENSION(3) :: pbc1, pbc2, pos
528 CALL timeset(routinen, handle)
531 IF (pint_env%logger%para_env%is_source())
THEN
534 helium_env(k)%helium%rho_inst(1, :, :, :) = 0.0_dp
535 nbin = helium_env(k)%helium%rho_nbin
536 delr = helium_env(k)%helium%rho_delr
537 helium_env(k)%helium%center(:) = 0.0_dp
538 ox = helium_env(k)%helium%center(1) - helium_env(k)%helium%rho_maxr/2.0_dp
539 oy = helium_env(k)%helium%center(2) - helium_env(k)%helium%rho_maxr/2.0_dp
540 oz = helium_env(k)%helium%center(3) - helium_env(k)%helium%rho_maxr/2.0_dp
547 pos(:) = (/ox + (ix - 0.5_dp)*delr, oy + (iy - 0.5_dp)*delr, oz + (iz - 0.5_dp)*delr/)
550 helium_env(k)%helium%pos(:, 1, 1) = pos(:)
554 pbc1(:) = pos(:) - helium_env(k)%helium%center
559 IF (abs(pbc1(ic) - pbc2(ic)) .GT. 10.0_dp*epsilon(0.0_dp))
THEN
566 helium_env(k)%helium%rho_inst(1, ix, iy, iz) = 0.0_dp
568 helium_env(k)%helium%rho_inst(1, ix, iy, iz) = my_en
576 CALL timestop(handle)
591 SUBROUTINE helium_intpot_model_water(solute_x, helium, helium_x, energy, force)
593 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: solute_x
595 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: helium_x
596 REAL(kind=
dp),
INTENT(OUT) :: energy
597 REAL(kind=
dp),
DIMENSION(:),
INTENT(INOUT), &
598 OPTIONAL,
POINTER :: force
601 REAL(kind=
dp) :: d, d2, dd, ep, eps, s1, s2, sig
602 REAL(kind=
dp),
DIMENSION(3) :: dr, solute_r
605 IF (
PRESENT(force))
THEN
612 DO i = 1,
SIZE(helium%solute_element)
613 IF (helium%solute_element(i) ==
"H ")
THEN
615 solute_r(1) = solute_x(3*ig + 1)
616 solute_r(2) = solute_x(3*ig + 2)
617 solute_r(3) = solute_x(3*ig + 3)
618 dr(:) = solute_r(:) - helium_x(:)
620 d2 = dr(1)*dr(1) + dr(2)*dr(2) + dr(3)*dr(3)
623 ep = 4.0_dp*eps*dd*(dd - 1.0_dp)
625 s2 = 24.0_dp*eps*dd*(2.0_dp*dd - 1.0_dp)/d2
626 IF (
PRESENT(force))
THEN
627 force(3*ig + 1) = force(3*ig + 1) + s2*dr(1)
628 force(3*ig + 2) = force(3*ig + 2) + s2*dr(2)
629 force(3*ig + 3) = force(3*ig + 3) + s2*dr(3)
638 DO i = 1,
SIZE(helium%solute_element)
639 IF (helium%solute_element(i) ==
"O ")
THEN
641 solute_r(1) = solute_x(3*ig + 1)
642 solute_r(2) = solute_x(3*ig + 2)
643 solute_r(3) = solute_x(3*ig + 3)
644 dr(:) = solute_r(:) - helium_x(:)
646 d2 = dr(1)*dr(1) + dr(2)*dr(2) + dr(3)*dr(3)
649 ep = 4.0_dp*eps*dd*(dd - 1.0_dp)
651 s2 = 24.0_dp*eps*dd*(2.0_dp*dd - 1.0_dp)/d2
652 IF (
PRESENT(force))
THEN
653 force(3*ig + 1) = force(3*ig + 1) + s2*dr(1)
654 force(3*ig + 2) = force(3*ig + 2) + s2*dr(2)
655 force(3*ig + 3) = force(3*ig + 3) + s2*dr(3)
661 END SUBROUTINE helium_intpot_model_water
675 SUBROUTINE helium_intpot_nnp(solute_x, helium, helium_x, energy, force)
677 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: solute_x
679 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: helium_x
680 REAL(kind=
dp),
INTENT(OUT) :: energy
681 REAL(kind=
dp),
DIMENSION(:),
INTENT(INOUT), &
682 OPTIONAL,
POINTER :: force
684 INTEGER :: i, i_com, ig, ind, ind_he, j, k, m
685 LOGICAL :: extrapolate
686 REAL(kind=
dp) :: rsqr, rvect(3), threshold
687 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: denergydsym
688 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: dsymdxyz
696 IF (
PRESENT(force))
THEN
697 helium%nnp%myforce(:, :, :) = 0.0_dp
700 extrapolate = .false.
705 DO i = 1, helium%nnp%n_ele
706 IF (helium%nnp%ele(i) ==
'He')
THEN
709 helium%nnp%coord(m, ig) = helium_x(m)
713 DO j = 1, helium%solute_atoms
714 IF (helium%nnp%ele(i) == helium%solute_element(j))
THEN
716 helium%nnp%coord(m, ig) = solute_x(3*(j - 1) + m)
724 IF (
ASSOCIATED(helium%nnp_sr_cut))
THEN
725 DO i = 1, helium%nnp%num_atoms
726 IF (i == ind_he) cycle
727 rvect(:) = helium%nnp%coord(:, i) - helium%nnp%coord(:, ind_he)
729 rsqr = rvect(1)*rvect(1) + rvect(2)*rvect(2) + rvect(3)*rvect(3)
730 IF (rsqr < helium%nnp_sr_cut(helium%nnp%ele_ind(i)))
THEN
731 energy = 0.3_dp + 1.0_dp/rsqr
732 IF (
PRESENT(force))
THEN
741 helium%nnp%output_expol = .false.
746 DO i = 1, helium%nnp%num_atoms
749 ind = helium%nnp%ele_ind(i)
752 helium%nnp%arc(ind)%layer(1)%node(:) = 0.0_dp
754 IF (
PRESENT(force))
THEN
755 helium%nnp%arc(ind)%layer(1)%node_grad(:) = 0.0_dp
756 ALLOCATE (dsymdxyz(3, helium%nnp%arc(ind)%n_nodes(1), helium%nnp%num_atoms))
757 ALLOCATE (denergydsym(helium%nnp%arc(ind)%n_nodes(1)))
758 dsymdxyz(:, :, :) = 0.0_dp
765 DO i_com = 1, helium%nnp%n_committee
767 CALL nnp_predict(helium%nnp%arc(ind), helium%nnp, i_com)
768 helium%nnp%atomic_energy(i, i_com) = helium%nnp%arc(ind)%layer(helium%nnp%n_layer)%node(1)
771 IF (
PRESENT(force))
THEN
773 denergydsym(:) = 0.0_dp
775 CALL nnp_gradients(helium%nnp%arc(ind), helium%nnp, i_com, denergydsym)
776 DO j = 1, helium%nnp%arc(ind)%n_nodes(1)
777 DO k = 1, helium%nnp%num_atoms
779 helium%nnp%myforce(m, k, i_com) = helium%nnp%myforce(m, k, i_com) &
780 - denergydsym(j)*dsymdxyz(m, j, k)
789 IF (
PRESENT(force))
THEN
790 DEALLOCATE (denergydsym)
791 DEALLOCATE (dsymdxyz)
797 helium%nnp%committee_energy(:) = sum(helium%nnp%atomic_energy, 1)
798 energy = sum(helium%nnp%committee_energy)/real(helium%nnp%n_committee,
dp)
799 helium%nnp%nnp_potential_energy = energy
801 IF (
PRESENT(force))
THEN
803 DO j = 1, helium%nnp%num_atoms
805 helium%nnp%committee_forces(k, j, :) = helium%nnp%myforce(k, j, :)
808 helium%nnp%nnp_forces(:, :) = sum(helium%nnp%committee_forces, dim=3)/real(helium%nnp%n_committee,
dp)
811 DO j = 1, helium%nnp%num_atoms
812 IF (j == ind_he) cycle
814 force(3*(helium%nnp%sort(ig) - 1) + k) = helium%nnp%nnp_forces(k, j)
826 END SUBROUTINE helium_intpot_nnp
835 REAL(kind=
dp),
INTENT(IN) :: r
838 REAL(kind=
dp) :: f, x, x2
841 IF (x < 1.241314_dp)
THEN
842 x2 = 1.241314_dp/x - 1.0_dp
848 vij = 10.8_dp/
kelvin*(544850.4_dp*exp(-13.353384_dp*x) - f* &
849 ((0.1781_dp*x2 + 0.4253785_dp)*x2 + 1.3732412_dp)*x2*x2*x2)
861 ELEMENTAL FUNCTION helium_d_vij(r)
RESULT(dvij)
863 REAL(kind=
dp),
INTENT(IN) :: r
864 REAL(kind=
dp) :: dvij
866 REAL(kind=
dp) :: f, fp, x, x2, y
871 IF (x < 1.241314_dp)
THEN
872 y = 1.241314_dp/x - 1.0_dp
874 fp = 2.0_dp*1.241314_dp*f*y* &
875 ((0.1781_dp*x2 + 0.4253785_dp)*x2 + 1.3732412_dp)*x2*x2*x2*x2
881 dvij =
angstrom*(10.8_dp/2.9673_dp)*( &
882 (-13.353384_dp*544850.4_dp)*exp(-13.353384_dp*x) - fp + &
883 f*(((10.0_dp*0.1781_dp)*x2 + (8.0_dp*0.4253785_dp))*x2 + (6.0_dp*1.3732412_dp))* &
885 END FUNCTION helium_d_vij
894 FUNCTION helium_atom_action(helium, n, i)
RESULT(res)
897 INTEGER,
INTENT(IN) :: n, i
901 REAL(kind=
dp) :: r(3), rp(3), s, t
902 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: work3
904 ALLOCATE (work3(
SIZE(helium%uoffdiag, 1) + 1))
907 IF (n < helium%beads)
THEN
909 r(c) = helium%pos(c, i, n) - helium%pos(c, i, n + 1)
912 t = r(1)*r(1) + r(2)*r(2) + r(3)*r(3)
915 r(c) = helium%pos(c, i, n) - helium%pos(c, j, n)
916 rp(c) = helium%pos(c, i, n + 1) - helium%pos(c, j, n + 1)
920 DO j = i + 1, helium%atoms
922 r(c) = helium%pos(c, i, n) - helium%pos(c, j, n)
923 rp(c) = helium%pos(c, i, n + 1) - helium%pos(c, j, n + 1)
929 r(c) = helium%pos(c, i, n) - helium%pos(c, helium%permutation(i), 1)
932 t = r(1)*r(1) + r(2)*r(2) + r(3)*r(3)
935 r(c) = helium%pos(c, i, n) - helium%pos(c, j, n)
936 rp(c) = helium%pos(c, helium%permutation(i), 1) - helium%pos(c, helium%permutation(j), 1)
940 DO j = i + 1, helium%atoms
942 r(c) = helium%pos(c, i, n) - helium%pos(c, j, n)
943 rp(c) = helium%pos(c, helium%permutation(i), 1) - helium%pos(c, helium%permutation(j), 1)
948 t = t/(2.0_dp*helium%tau*helium%hb2m)
953 END FUNCTION helium_atom_action
961 FUNCTION helium_link_action(helium, n)
RESULT(res)
964 INTEGER,
INTENT(IN) :: n
968 REAL(kind=
dp) :: r(3), rp(3), s, t
969 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: work3
971 ALLOCATE (work3(
SIZE(helium%uoffdiag, 1) + 1))
974 IF (n < helium%beads)
THEN
975 DO i = 1, helium%atoms
977 r(c) = helium%pos(c, i, n) - helium%pos(c, i, n + 1)
980 t = t + r(1)*r(1) + r(2)*r(2) + r(3)*r(3)
983 r(c) = helium%pos(c, i, n) - helium%pos(c, j, n)
984 rp(c) = helium%pos(c, i, n + 1) - helium%pos(c, j, n + 1)
990 DO i = 1, helium%atoms
992 r(c) = helium%pos(c, i, n) - helium%pos(c, helium%permutation(i), 1)
995 t = t + r(1)*r(1) + r(2)*r(2) + r(3)*r(3)
998 r(c) = helium%pos(c, i, n) - helium%pos(c, j, n)
999 rp(c) = helium%pos(c, helium%permutation(i), 1) - helium%pos(c, helium%permutation(j), 1)
1005 t = t/(2.0_dp*helium%tau*helium%hb2m)
1009 END FUNCTION helium_link_action
1016 FUNCTION helium_total_action(helium)
RESULT(res)
1019 REAL(kind=
dp) :: res
1025 DO i = 1, helium%beads
1026 s = s + helium_link_action(helium, i)
1030 END FUNCTION helium_total_action
1040 SUBROUTINE helium_delta_pos(helium, part, ref_bead, delta_bead, d)
1043 INTEGER,
INTENT(IN) :: part, ref_bead, delta_bead
1044 REAL(kind=
dp),
DIMENSION(3),
INTENT(OUT) :: d
1046 INTEGER :: b, bead, db, nbead, np, p
1047 REAL(kind=
dp),
DIMENSION(3) :: r
1052 IF (delta_bead > 0)
THEN
1062 np = helium%permutation(np)
1064 r(:) = helium%pos(:, p, bead) - helium%pos(:, np, nbead)
1071 ELSEIF (delta_bead < 0)
THEN
1081 np = helium%iperm(np)
1083 r(:) = helium%pos(:, p, bead) - helium%pos(:, np, nbead)
1091 END SUBROUTINE helium_delta_pos
various routines to log and control the output. The idea is that decisions about where to log should ...
type(cp_logger_type) function, pointer, public cp_get_default_logger()
returns the default logger
Independent helium subroutines shared with other modules.
subroutine, public helium_pbc(helium, r, enforce)
General PBC routine for helium.
real(kind=dp) function, public helium_eval_chain(helium, rchain, nchain, aij, vcoef, energy)
Calculate the pair-product action or energy by evaluating the power series expansion according to Eq....
real(kind=dp) function, public helium_eval_expansion(helium, r, rp, work, action)
Calculate the pair-product action or energy by evaluating the power series expansion according to Eq....
real(kind=dp) function, public helium_spline(spl, xx)
...
Methods that handle helium-solvent and helium-helium interactions.
subroutine, public helium_solute_e_f(pint_env, helium, energy)
Calculate total helium-solute interaction energy and forces.
real(kind=dp) function, public helium_total_pair_action(helium)
Computes the total pair action of the helium.
real(kind=dp) function, public helium_total_inter_action(pint_env, helium)
Computes the total interaction of the helium with the solute.
subroutine, public helium_intpot_scan(pint_env, helium_env)
Scan the helium-solute interaction energy within the periodic cell.
subroutine, public helium_bead_solute_e_f(pint_env, helium, helium_part_index, helium_slice_index, helium_r_opt, energy, force)
Calculate general helium-solute interaction energy (and forces) between one helium bead and the corre...
elemental real(kind=dp) function, public helium_vij(r)
Helium-helium pair interaction potential.
subroutine, public helium_calc_energy(helium, pint_env)
Calculate the helium energy (including helium-solute interaction)
real(kind=dp) function, public helium_total_link_action(helium)
Computes the total harmonic link action of the helium.
Methods dealing with Neural Network interaction potential.
subroutine, public helium_nnp_print(nnp, print_section, ind_he)
Print properties according to the requests in input file.
Data types representing superfluid helium.
integer, parameter, public e_id_potential
integer, parameter, public e_id_thermo
integer, parameter, public e_id_virial
integer, parameter, public e_id_interact
integer, parameter, public e_id_kinetic
integer, parameter, public e_id_total
Energy contributions - symbolic names for indexing energy arrays.
Defines the basic variable types.
integer, parameter, public dp
Functionality for atom centered symmetry functions for neural network potentials.
subroutine, public nnp_calc_acsf(nnp, i, dsymdxyz, stress)
Calculate atom centered symmetry functions for given atom i.
Data types for neural network potentials.
Methods dealing with core routines for artificial neural networks.
subroutine, public nnp_predict(arc, nnp, i_com)
Predict energy by evaluating neural network.
subroutine, public nnp_gradients(arc, nnp, i_com, denergydsym)
Calculate gradients of neural network.
Definition of physical constants:
real(kind=dp), parameter, public kelvin
real(kind=dp), parameter, public angstrom
routines for handling splines_types
type of a logger, at the moment it contains just a print level starting at which level it should be l...
data structure for array of solvent helium environments
data structure for solvent helium
Main data type collecting all relevant data for neural network potentials.
environment for a path integral run
Data-structure that holds all needed information about a specific spline interpolation.