38 #include "../base/base_uses.f90"
44 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'generic_shg_integrals'
67 SUBROUTINE ab_sint_shg(la_max, npgfa, zeta, lb_max, npgfb, zetb, omega, rab, v, calculate_forces)
69 INTEGER,
INTENT(IN) :: la_max, npgfa
70 REAL(KIND=
dp),
DIMENSION(:),
INTENT(IN) :: zeta
71 INTEGER,
INTENT(IN) :: lb_max, npgfb
72 REAL(KIND=
dp),
DIMENSION(:),
INTENT(IN) :: zetb
73 REAL(KIND=
dp),
INTENT(IN) :: omega
74 REAL(KIND=
dp),
DIMENSION(3),
INTENT(IN) :: rab
75 REAL(KIND=
dp),
DIMENSION(:, :, :),
INTENT(INOUT) :: v
76 LOGICAL,
INTENT(IN) :: calculate_forces
78 END SUBROUTINE ab_sint_shg
99 omega, calculate_forces)
101 INTEGER,
INTENT(IN) :: r12_operator
102 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(INOUT) :: vab
103 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(INOUT), &
105 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
106 TYPE(gto_basis_set_type),
POINTER :: fba, fbb
107 REAL(kind=
dp),
DIMENSION(:, :, :),
POINTER :: scona_shg, sconb_shg
108 REAL(kind=
dp),
INTENT(IN),
OPTIONAL :: omega
109 LOGICAL,
INTENT(IN) :: calculate_forces
111 INTEGER :: la_max, lb_max
112 REAL(kind=
dp) :: my_omega
113 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: waux_mat
114 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :, :) :: dwaux_mat
116 PROCEDURE(ab_sint_shg),
POINTER :: s_operator_ab
118 NULLIFY (s_operator_ab)
120 la_max = maxval(fba%lmax)
121 lb_max = maxval(fbb%lmax)
123 CALL precalc_angular_shg_part(la_max, lb_max, rab, waux_mat, dwaux_mat, calculate_forces)
126 SELECT CASE (r12_operator)
131 IF (
PRESENT(omega)) my_omega = omega
134 IF (
PRESENT(omega)) my_omega = omega
137 IF (
PRESENT(omega)) my_omega = omega
140 IF (
PRESENT(omega)) my_omega = omega
142 cpabort(
"Operator not available")
145 CALL int_operator_ab_shg_low(s_operator_ab, vab, dvab, rab, fba, fbb, scona_shg, sconb_shg, &
146 my_omega, waux_mat, dwaux_mat, calculate_forces)
148 DEALLOCATE (waux_mat, dwaux_mat)
166 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :), &
168 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :), &
169 INTENT(INOUT) :: dvab
170 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
171 TYPE(gto_basis_set_type),
POINTER :: fba, fbb
172 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: scona_shg, sconb_shg
173 LOGICAL,
INTENT(IN) :: calculate_forces
175 INTEGER :: la_max, lb_max
176 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: waux_mat
177 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :, :) :: dwaux_mat
179 la_max = maxval(fba%lmax)
180 lb_max = maxval(fbb%lmax)
182 CALL precalc_angular_shg_part(la_max, lb_max, rab, waux_mat, dwaux_mat, calculate_forces)
185 waux_mat, dwaux_mat, .true., calculate_forces, contraction_high=.true.)
187 DEALLOCATE (waux_mat, dwaux_mat)
206 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(INOUT) :: vab
207 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(INOUT) :: dvab
208 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
209 TYPE(gto_basis_set_type),
POINTER :: fba, fbb
210 REAL(kind=
dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: scon_ra2m
211 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: sconb_shg
212 INTEGER,
INTENT(IN) :: m
213 LOGICAL,
INTENT(IN) :: calculate_forces
215 INTEGER :: la_max, lb_max
216 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: waux_mat
217 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :, :) :: dwaux_mat
219 la_max = maxval(fba%lmax)
220 lb_max = maxval(fbb%lmax)
222 CALL precalc_angular_shg_part(la_max, lb_max, rab, waux_mat, dwaux_mat, calculate_forces)
224 m, waux_mat, dwaux_mat, calculate_forces)
226 DEALLOCATE (waux_mat, dwaux_mat)
248 scona_mix, oba_index, fba_index, &
249 cg_coeff, cg_none0_list, ncg_none0, &
252 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :), &
253 INTENT(INOUT) :: saba
254 REAL(kind=
dp),
ALLOCATABLE, &
255 DIMENSION(:, :, :, :),
INTENT(INOUT) :: dsaba
256 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
257 TYPE(gto_basis_set_type),
POINTER :: oba, obb, fba
258 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: scon_obb
259 REAL(kind=
dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: scona_mix
260 INTEGER,
DIMENSION(:, :, :),
INTENT(IN) :: oba_index, fba_index
261 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: cg_coeff
262 INTEGER,
DIMENSION(:, :, :),
INTENT(IN) :: cg_none0_list
263 INTEGER,
DIMENSION(:, :),
INTENT(IN) :: ncg_none0
264 LOGICAL,
INTENT(IN) :: calculate_forces
266 INTEGER :: laa_max, lb_max
267 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: waux_mat
268 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :, :) :: dwaux_mat
270 laa_max = maxval(oba%lmax) + maxval(fba%lmax)
271 lb_max = maxval(obb%lmax)
274 IF (calculate_forces) dsaba = 0.0_dp
275 CALL precalc_angular_shg_part(laa_max, lb_max, rab, waux_mat, dwaux_mat, &
278 scon_obb, scona_mix, oba_index, fba_index, &
279 cg_coeff, cg_none0_list, ncg_none0, &
280 waux_mat, dwaux_mat, .true., calculate_forces)
282 DEALLOCATE (waux_mat, dwaux_mat)
304 sconb_mix, obb_index, fbb_index, &
305 cg_coeff, cg_none0_list, ncg_none0, &
308 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :), &
309 INTENT(INOUT) :: sabb
310 REAL(kind=
dp),
ALLOCATABLE, &
311 DIMENSION(:, :, :, :),
INTENT(INOUT) :: dsabb
312 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
313 TYPE(gto_basis_set_type),
POINTER :: oba, obb, fbb
314 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: scon_oba
315 REAL(kind=
dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: sconb_mix
316 INTEGER,
DIMENSION(:, :, :),
INTENT(IN) :: obb_index, fbb_index
317 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: cg_coeff
318 INTEGER,
DIMENSION(:, :, :),
INTENT(IN) :: cg_none0_list
319 INTEGER,
DIMENSION(:, :),
INTENT(IN) :: ncg_none0
320 LOGICAL,
INTENT(IN) :: calculate_forces
322 INTEGER :: la_max, lbb_max
323 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: waux_mat
324 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :, :) :: dwaux_mat
326 la_max = maxval(oba%lmax)
327 lbb_max = maxval(obb%lmax) + maxval(fbb%lmax)
330 IF (calculate_forces) dsabb = 0.0_dp
331 CALL precalc_angular_shg_part(lbb_max, la_max, rab, waux_mat, dwaux_mat, &
334 scon_oba, sconb_mix, obb_index, fbb_index, &
335 cg_coeff, cg_none0_list, ncg_none0, &
336 waux_mat, dwaux_mat, .true., calculate_forces)
338 DEALLOCATE (waux_mat, dwaux_mat)
351 SUBROUTINE precalc_angular_shg_part(la_max, lb_max, rab, Waux_mat, dWaux_mat, calculate_forces)
353 INTEGER,
INTENT(IN) :: la_max, lb_max
354 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
355 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :), &
356 INTENT(OUT) :: waux_mat
357 REAL(kind=
dp),
ALLOCATABLE, &
358 DIMENSION(:, :, :, :),
INTENT(OUT) :: dwaux_mat
359 LOGICAL,
INTENT(IN) :: calculate_forces
361 INTEGER :: lmax, mdim(3)
362 INTEGER,
DIMENSION(:),
POINTER :: la_max_all
363 REAL(kind=
dp) :: rab2
364 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: rc, rs
367 rab2 = rab(1)*rab(1) + rab(2)*rab(2) + rab(3)*rab(3)
368 lmax = max(la_max, lb_max)
370 ALLOCATE (la_max_all(0:lb_max))
371 ALLOCATE (rc(0:lmax, -2*lmax:2*lmax), rs(0:lmax, -2*lmax:2*lmax))
374 mdim(1) = min(la_max, lb_max) + 1
375 mdim(2) =
nsoset(la_max) + 1
376 mdim(3) =
nsoset(lb_max) + 1
377 ALLOCATE (waux_mat(mdim(1), mdim(2), mdim(3)))
378 ALLOCATE (dwaux_mat(3, mdim(1), mdim(2), mdim(3)))
380 la_max_all(0:lb_max) = la_max
383 CALL get_w_matrix(la_max_all, lb_max, lmax, rc, rs, waux_mat)
384 IF (calculate_forces)
THEN
388 DEALLOCATE (rc, rs, la_max_all)
390 END SUBROUTINE precalc_angular_shg_part
409 SUBROUTINE int_operator_ab_shg_low(s_operator_ab, vab, dvab, rab, fba, fbb, scona_shg, sconb_shg, &
410 omega, Waux_mat, dWaux_mat, calculate_forces)
412 PROCEDURE(ab_sint_shg),
POINTER :: s_operator_ab
413 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(INOUT) :: vab
414 REAL(kind=
dp),
DIMENSION(:, :, :),
OPTIONAL,
INTENT(INOUT) :: dvab
415 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
416 TYPE(gto_basis_set_type),
POINTER :: fba, fbb
417 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(INOUT) :: scona_shg, sconb_shg
418 REAL(kind=
dp),
INTENT(IN) :: omega
419 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: waux_mat
420 REAL(kind=
dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: dwaux_mat
421 LOGICAL,
INTENT(IN) :: calculate_forces
423 INTEGER :: iset, jset, la_max_set, lb_max_set, ndev, nds, nds_max, npgfa_set, &
424 npgfb_set, nseta, nsetb, nsgfa_set, nsgfb_set, nshella_set, nshellb_set
425 INTEGER,
DIMENSION(:),
POINTER :: la_max, lb_max, npgfa, npgfb, nsgfa, &
426 nsgfb, nshella, nshellb
427 INTEGER,
DIMENSION(:, :),
POINTER :: first_sgfa, first_sgfb, la, lb
429 REAL(kind=
dp),
DIMENSION(:),
POINTER :: set_radius_a, set_radius_b
430 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: zeta, zetb
431 REAL(kind=
dp),
DIMENSION(:, :, :),
ALLOCATABLE :: swork, swork_cont
433 NULLIFY (la_max, lb_max, npgfa, npgfb, first_sgfa, first_sgfb, set_radius_a, &
434 set_radius_b, zeta, zetb)
437 first_sgfa => fba%first_sgf
441 nsgfa => fba%nsgf_set
443 set_radius_a => fba%set_radius
445 nshella => fba%nshell
447 first_sgfb => fbb%first_sgf
451 nsgfb => fbb%nsgf_set
453 set_radius_b => fbb%set_radius
455 nshellb => fbb%nshell
457 dab = sqrt(sum(rab**2))
459 la_max_set = maxval(la_max)
460 lb_max_set = maxval(lb_max)
463 npgfa_set = maxval(npgfa)
464 npgfb_set = maxval(npgfb)
465 nshella_set = maxval(nshella)
466 nshellb_set = maxval(nshellb)
467 nsgfa_set = maxval(nsgfa)
468 nsgfb_set = maxval(nsgfb)
470 IF (calculate_forces) ndev = 1
471 nds_max = la_max_set + lb_max_set + ndev + 1
472 ALLOCATE (swork(npgfa_set, npgfb_set, nds_max))
473 ALLOCATE (swork_cont(nds_max, nshella_set, nshellb_set))
476 IF (calculate_forces) dvab = 0.0_dp
482 nds = la_max(iset) + lb_max(jset) + ndev + 1
483 swork(1:npgfa(iset), 1:npgfb(jset), 1:nds) = 0.0_dp
484 CALL s_operator_ab(la_max(iset), npgfa(iset), zeta(:, iset), &
485 lb_max(jset), npgfb(jset), zetb(:, jset), &
486 omega, rab, swork, calculate_forces)
488 scona_shg(1:npgfa(iset), 1:nshella(iset), iset), &
489 npgfb(jset), nshellb(jset), &
490 sconb_shg(1:npgfb(jset), 1:nshellb(jset), jset), &
491 nds, swork(1:npgfa(iset), 1:npgfb(jset), 1:nds), &
492 swork_cont(1:nds, 1:nshella(iset), 1:nshellb(jset)))
494 lb(:, jset), first_sgfb(:, jset), nshellb(jset), &
495 swork_cont, waux_mat, vab)
496 IF (calculate_forces)
THEN
499 lb(:, jset), first_sgfb(:, jset), nshellb(jset), &
500 -rab, swork_cont, waux_mat, dwaux_mat, dvab)
505 DEALLOCATE (swork, swork_cont)
507 END SUBROUTINE int_operator_ab_shg_low
525 calculate_ints, calculate_forces, contraction_high)
527 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :), &
529 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :), &
530 INTENT(INOUT) :: dsab
531 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
532 TYPE(gto_basis_set_type),
POINTER :: fba, fbb
533 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: scona_shg, sconb_shg, waux_mat
534 REAL(kind=
dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: dwaux_mat
535 LOGICAL,
INTENT(IN) :: calculate_ints, calculate_forces
536 LOGICAL,
INTENT(IN),
OPTIONAL :: contraction_high
538 INTEGER :: iset, jset, la_max_set, lb_max_set, &
539 ndev, nds, nds_max, npgfa_set, &
540 npgfb_set, nseta, nsetb, nshella_set, &
542 INTEGER,
DIMENSION(:),
POINTER :: la_max, lb_max, npgfa, npgfb, nshella, &
544 INTEGER,
DIMENSION(:, :),
POINTER :: first_sgfa, first_sgfb, la, lb
545 LOGICAL :: my_contraction_high
547 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: swork, swork_cont
548 REAL(kind=
dp),
DIMENSION(:),
POINTER :: set_radius_a, set_radius_b
549 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: zeta, zetb
551 NULLIFY (la_max, lb_max, npgfa, npgfb, first_sgfa, first_sgfb, set_radius_a, &
552 set_radius_b, zeta, zetb)
555 first_sgfa => fba%first_sgf
560 set_radius_a => fba%set_radius
562 nshella => fba%nshell
564 first_sgfb => fbb%first_sgf
569 set_radius_b => fbb%set_radius
571 nshellb => fbb%nshell
573 dab = sqrt(sum(rab**2))
575 la_max_set = maxval(la_max)
576 lb_max_set = maxval(lb_max)
579 npgfa_set = maxval(npgfa)
580 npgfb_set = maxval(npgfb)
581 nshella_set = maxval(nshella)
582 nshellb_set = maxval(nshellb)
584 IF (calculate_forces) ndev = 1
585 nds_max = la_max_set + lb_max_set + ndev + 1
586 ALLOCATE (swork(npgfa_set, npgfb_set, nds_max))
587 ALLOCATE (swork_cont(nds_max, nshella_set, nshellb_set))
589 IF (calculate_ints) sab = 0.0_dp
590 IF (calculate_forces) dsab = 0.0_dp
592 my_contraction_high = .true.
593 IF (
PRESENT(contraction_high)) my_contraction_high = contraction_high
599 IF (set_radius_a(iset) + set_radius_b(jset) < dab) cycle
601 nds = la_max(iset) + lb_max(jset) + ndev + 1
602 swork(1:npgfa(iset), 1:npgfb(jset), 1:nds) = 0.0_dp
603 CALL s_overlap_ab(la_max(iset), npgfa(iset), zeta(:, iset), &
604 lb_max(jset), npgfb(jset), zetb(:, jset), &
605 rab, swork, calculate_forces)
606 IF (my_contraction_high)
THEN
608 scona_shg(1:npgfa(iset), 1:nshella(iset), iset), &
609 npgfb(jset), nshellb(jset), &
610 sconb_shg(1:npgfb(jset), 1:nshellb(jset), jset), &
611 nds, swork(1:npgfa(iset), 1:npgfb(jset), 1:nds), &
612 swork_cont(1:nds, 1:nshella(iset), 1:nshellb(jset)))
615 scona_shg(:, :, iset), &
616 lb(:, jset), npgfb(jset), nshellb(jset), &
617 sconb_shg(:, :, jset), &
618 swork, swork_cont, calculate_forces)
620 IF (calculate_ints)
THEN
622 lb(:, jset), first_sgfb(:, jset), nshellb(jset), &
623 swork_cont, waux_mat, sab)
625 IF (calculate_forces)
THEN
628 lb(:, jset), first_sgfb(:, jset), nshellb(jset), &
629 -rab, swork_cont, waux_mat, dwaux_mat, dsab)
634 DEALLOCATE (swork, swork_cont)
652 SUBROUTINE int_ra2m_ab_shg_low(vab, dvab, rab, fba, fbb, sconb_shg, scon_ra2m, m, Waux_mat, dWaux_mat, &
655 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(INOUT) :: vab
656 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(INOUT) :: dvab
657 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
658 TYPE(gto_basis_set_type),
POINTER :: fba, fbb
659 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: sconb_shg
660 REAL(kind=
dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: scon_ra2m
661 INTEGER,
INTENT(IN) :: m
662 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: waux_mat
663 REAL(kind=
dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: dwaux_mat
664 LOGICAL,
INTENT(IN) :: calculate_forces
666 INTEGER :: iset, jset, la_max_set, lb_max_set, &
667 ndev, nds, nds_max, npgfa_set, &
668 npgfb_set, nseta, nsetb, nshella_set, &
670 INTEGER,
DIMENSION(:),
POINTER :: la_max, lb_max, npgfa, npgfb, nsgfa, &
671 nsgfb, nshella, nshellb
672 INTEGER,
DIMENSION(:, :),
POINTER :: first_sgfa, first_sgfb, la, lb
674 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: swork_cont
675 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :, :) :: swork
676 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: zeta, zetb
678 NULLIFY (la_max, lb_max, npgfa, npgfb, first_sgfa, first_sgfb, zeta, zetb)
681 first_sgfa => fba%first_sgf
685 nsgfa => fba%nsgf_set
688 nshella => fba%nshell
690 first_sgfb => fbb%first_sgf
694 nsgfb => fbb%nsgf_set
697 nshellb => fbb%nshell
699 dab = sqrt(sum(rab**2))
701 la_max_set = maxval(la_max)
702 lb_max_set = maxval(lb_max)
705 npgfa_set = maxval(npgfa)
706 npgfb_set = maxval(npgfb)
707 nshella_set = maxval(nshella)
708 nshellb_set = maxval(nshellb)
710 IF (calculate_forces) ndev = 1
711 nds_max = la_max_set + lb_max_set + ndev + 1
712 ALLOCATE (swork(npgfa_set, npgfb_set, 1:m + 1, nds_max))
713 ALLOCATE (swork_cont(nds_max, nshella_set, nshellb_set))
716 IF (calculate_forces) dvab = 0.0_dp
722 nds = la_max(iset) + lb_max(jset) + ndev + 1
723 swork(1:npgfa(iset), 1:npgfb(jset), 1:m + 1, 1:nds) = 0.0_dp
724 CALL s_ra2m_ab(la_max(iset), npgfa(iset), zeta(:, iset), &
725 lb_max(jset), npgfb(jset), zetb(:, jset), &
726 m, rab, swork, calculate_forces)
728 scon_ra2m(1:npgfa(iset), 1:m + 1, 1:nshella(iset), iset), &
729 npgfb(jset), nshellb(jset), &
730 sconb_shg(1:npgfb(jset), 1:nshellb(jset), jset), &
731 swork(1:npgfa(iset), 1:npgfb(jset), 1:m + 1, 1:nds), &
732 swork_cont(1:nds, 1:nshella(iset), 1:nshellb(jset)), &
735 lb(:, jset), first_sgfb(:, jset), nshellb(jset), &
736 swork_cont, waux_mat, vab)
737 IF (calculate_forces)
THEN
740 lb(:, jset), first_sgfb(:, jset), nshellb(jset), &
741 -rab, swork_cont, waux_mat, dwaux_mat, dvab)
746 DEALLOCATE (swork, swork_cont)
770 obb_index, fbb_index, cg_coeff, cg_none0_list, &
771 ncg_none0, Waux_mat, dWaux_mat, calculate_ints, calculate_forces)
773 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :), &
774 INTENT(INOUT) :: abbint
775 REAL(kind=
dp),
ALLOCATABLE, &
776 DIMENSION(:, :, :, :),
INTENT(INOUT) :: dabbint
777 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
778 TYPE(gto_basis_set_type),
POINTER :: oba, obb, fbb
779 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: scon_oba
780 REAL(kind=
dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: sconb_mix
781 INTEGER,
DIMENSION(:, :, :),
INTENT(IN) :: obb_index, fbb_index
782 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: cg_coeff
783 INTEGER,
DIMENSION(:, :, :),
INTENT(IN) :: cg_none0_list
784 INTEGER,
DIMENSION(:, :),
INTENT(IN) :: ncg_none0
785 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: waux_mat
786 REAL(kind=
dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: dwaux_mat
787 LOGICAL,
INTENT(IN) :: calculate_ints, calculate_forces
789 INTEGER :: iset, jset, kset, la_max_set, lb_max_set, lbb_max, lbb_max_set, lcb_max_set, na, &
790 nb, ncb, ndev, nds, nds_max, nl, nl_set, npgfa_set, npgfb_set, npgfcb_set, nseta, nsetb, &
791 nsetcb, nshella_set, nshellb_set, nshellcb_set, sgfa, sgfb, sgfcb
792 INTEGER,
DIMENSION(:),
POINTER :: la_max, lb_max, lcb_max, npgfa, npgfb, &
793 npgfcb, nsgfa, nsgfb, nsgfcb, nshella, &
795 INTEGER,
DIMENSION(:, :),
POINTER :: first_sgfa, first_sgfb, first_sgfcb, la, &
797 REAL(kind=
dp) :: dab, rab2
798 REAL(kind=
dp),
ALLOCATABLE, &
799 DIMENSION(:, :, :, :, :) :: swork, swork_cont
800 REAL(kind=
dp),
DIMENSION(:),
POINTER :: set_radius_a, set_radius_b, set_radius_cb
801 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: zeta, zetb, zetcb
803 NULLIFY (la_max, lb_max, lcb_max, npgfa, npgfb, npgfcb)
804 NULLIFY (first_sgfa, first_sgfb, first_sgfcb, set_radius_a, set_radius_b, &
805 set_radius_cb, zeta, zetb, zetcb)
808 first_sgfa => oba%first_sgf
811 nsgfa => oba%nsgf_set
813 nshella => oba%nshell
815 set_radius_a => oba%set_radius
818 first_sgfb => obb%first_sgf
821 nsgfb => obb%nsgf_set
823 nshellb => obb%nshell
825 set_radius_b => obb%set_radius
829 first_sgfcb => fbb%first_sgf
832 nsgfcb => fbb%nsgf_set
834 nshellcb => fbb%nshell
836 set_radius_cb => fbb%set_radius
839 dab = sqrt(sum(rab**2))
840 rab2 = rab(1)*rab(1) + rab(2)*rab(2) + rab(3)*rab(3)
842 la_max_set = maxval(la_max)
843 lb_max_set = maxval(lb_max)
844 lcb_max_set = maxval(lcb_max)
845 npgfa_set = maxval(npgfa)
846 npgfb_set = maxval(npgfb)
847 npgfcb_set = maxval(npgfcb)
848 nshella_set = maxval(nshella)
849 nshellb_set = maxval(nshellb)
850 nshellcb_set = maxval(nshellcb)
853 IF (calculate_forces) ndev = 1
855 lbb_max_set = lb_max_set + lcb_max_set
858 nds_max = la_max_set + lbb_max_set + ndev + 1
859 nl_set = int((lbb_max_set)/2)
860 ALLOCATE (swork(npgfa_set, npgfb_set, npgfcb_set, nl_set + 1, nds_max))
861 ALLOCATE (swork_cont(nds_max, 0:nl_set, nshella_set, nshellb_set, nshellcb_set))
867 IF (set_radius_a(iset) + set_radius_b(jset) < dab) cycle
871 IF (set_radius_a(iset) + set_radius_cb(kset) < dab) cycle
873 lbb_max = lb_max(jset) + lcb_max(kset)
874 nds = la_max(iset) + lbb_max + ndev + 1
875 nl = int((lbb_max)/2) + 1
876 swork(1:npgfa(iset), 1:npgfb(jset), 1:npgfcb(kset), 1:nl, 1:nds) = 0.0_dp
877 CALL s_overlap_abb(la_max(iset), npgfa(iset), zeta(:, iset), &
878 lb_max(jset), npgfb(jset), zetb(:, jset), &
879 lcb_max(kset), npgfcb(kset), zetcb(:, kset), &
880 rab, swork, calculate_forces)
883 scon_oba(1:npgfa(iset), 1:nshella(iset), iset), &
884 lb(:, jset), npgfb(jset), nshellb(jset), &
885 lcb(:, kset), npgfcb(kset), nshellcb(kset), &
886 obb_index(:, :, jset), fbb_index(:, :, kset), sconb_mix, nl, nds, &
887 swork(1:npgfa(iset), 1:npgfb(jset), 1:npgfcb(kset), 1:nl, 1:nds), &
888 swork_cont, calculate_forces)
890 IF (calculate_ints)
THEN
892 lb(:, jset), first_sgfb(:, jset), nshellb(jset), &
893 lcb(:, kset), first_sgfcb(:, kset), nshellcb(kset), &
894 cg_coeff, cg_none0_list, &
895 ncg_none0, swork_cont, waux_mat, abbint)
897 IF (calculate_forces)
THEN
900 lb(:, jset), first_sgfb(:, jset), nshellb(jset), &
901 lcb(:, kset), first_sgfcb(:, kset), nshellcb(kset), &
902 cg_coeff, cg_none0_list, ncg_none0, -rab, swork_cont, &
903 waux_mat, dwaux_mat, dabbint)
906 sgfa = first_sgfa(1, iset)
907 na = sgfa + nsgfa(iset) - 1
908 sgfb = first_sgfb(1, jset)
909 nb = sgfb + nsgfb(jset) - 1
910 sgfcb = first_sgfcb(1, kset)
911 ncb = sgfcb + nsgfcb(kset) - 1
916 DEALLOCATE (swork_cont)
934 calculate_ints, calculate_forces)
936 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :), &
937 INTENT(INOUT) :: abbint
938 REAL(kind=
dp),
ALLOCATABLE, &
939 DIMENSION(:, :, :, :),
INTENT(INOUT) :: dabbint
940 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :), &
941 INTENT(INOUT) :: abaint
942 REAL(kind=
dp),
ALLOCATABLE, &
943 DIMENSION(:, :, :, :),
INTENT(INOUT) :: dabdaint
944 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
945 TYPE(gto_basis_set_type),
POINTER :: oba, fba
946 LOGICAL,
INTENT(IN) :: calculate_ints, calculate_forces
948 INTEGER :: i, iend, iset, isgfa, ishella, istart, jend, jset, jsgfa, jshella, jstart, kend, &
949 kset, ksgfa, kshella, kstart, lai, laj, lak, nseta, nsetca, nsgfa, nsgfca, sgfa_end, &
951 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: lai_set, laj_set, lak_set
952 INTEGER,
DIMENSION(:),
POINTER :: nsgfa_set, nsgfca_set, nshella, nshellca
953 INTEGER,
DIMENSION(:, :),
POINTER :: first_sgfa, first_sgfca, la, lca
955 REAL(kind=
dp),
DIMENSION(:),
POINTER :: set_radius_a, set_radius_ca
957 NULLIFY (nshellca, first_sgfa, first_sgfca, lca, set_radius_a, &
961 first_sgfa => oba%first_sgf
962 set_radius_a => oba%set_radius
965 nsgfa_set => oba%nsgf_set
966 nshella => oba%nshell
970 first_sgfca => fba%first_sgf
971 set_radius_ca => fba%set_radius
973 nshellca => fba%nshell
975 nsgfca_set => fba%nsgf_set
978 ALLOCATE (lai_set(nsgfa))
979 ALLOCATE (laj_set(nsgfa))
980 ALLOCATE (lak_set(nsgfca))
982 dab = sqrt(sum(rab**2))
985 DO ishella = 1, nshella(iset)
986 sgfa_start = first_sgfa(ishella, iset)
987 sgfa_end = sgfa_start + 2*la(ishella, iset)
988 lai_set(sgfa_start:sgfa_end) = la(ishella, iset)
990 istart = first_sgfa(1, iset)
991 iend = istart + nsgfa_set(iset) - 1
995 IF (set_radius_a(iset) + set_radius_a(jset) < dab) cycle
996 DO jshella = 1, nshella(jset)
997 sgfa_start = first_sgfa(jshella, jset)
998 sgfa_end = sgfa_start + 2*la(jshella, jset)
999 laj_set(sgfa_start:sgfa_end) = la(jshella, jset)
1001 jstart = first_sgfa(1, jset)
1002 jend = jstart + nsgfa_set(jset) - 1
1006 IF (set_radius_a(iset) + set_radius_ca(kset) < dab) cycle
1008 DO kshella = 1, nshellca(kset)
1009 sgfa_start = first_sgfca(kshella, kset)
1010 sgfa_end = sgfa_start + 2*lca(kshella, kset)
1011 lak_set(sgfa_start:sgfa_end) = lca(kshella, kset)
1013 kstart = first_sgfca(1, kset)
1014 kend = kstart + nsgfca_set(kset) - 1
1015 DO ksgfa = kstart, kend
1016 lak = lak_set(ksgfa)
1017 DO jsgfa = jstart, jend
1018 laj = laj_set(jsgfa)
1019 DO isgfa = istart, iend
1020 lai = lai_set(isgfa)
1021 IF (
modulo((lai + laj + lak), 2) /= 0)
THEN
1022 IF (calculate_ints)
THEN
1023 abbint(isgfa, jsgfa, ksgfa) = &
1024 -abaint(jsgfa, isgfa, ksgfa)
1026 IF (calculate_forces)
THEN
1028 dabbint(isgfa, jsgfa, ksgfa, i) = &
1029 -dabdaint(jsgfa, isgfa, ksgfa, i)
1033 IF (calculate_ints)
THEN
1034 abbint(isgfa, jsgfa, ksgfa) = &
1035 abaint(jsgfa, isgfa, ksgfa)
1037 IF (calculate_forces)
THEN
1039 dabbint(isgfa, jsgfa, ksgfa, i) = &
1040 dabdaint(jsgfa, isgfa, ksgfa, i)
1051 DEALLOCATE (lai_set, laj_set, lak_set)
1076 oba_index, fba_index, cg_coeff, cg_none0_list, &
1077 ncg_none0, Waux_mat, dWaux_mat, calculate_ints, calculate_forces)
1079 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :), &
1080 INTENT(INOUT) :: abaint
1081 REAL(kind=
dp),
ALLOCATABLE, &
1082 DIMENSION(:, :, :, :),
INTENT(INOUT) :: dabdaint
1083 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
1084 TYPE(gto_basis_set_type),
POINTER :: oba, obb, fba
1085 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: scon_obb
1086 REAL(kind=
dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: scona_mix
1087 INTEGER,
DIMENSION(:, :, :),
INTENT(IN) :: oba_index, fba_index
1088 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: cg_coeff
1089 INTEGER,
DIMENSION(:, :, :),
INTENT(IN) :: cg_none0_list
1090 INTEGER,
DIMENSION(:, :),
INTENT(IN) :: ncg_none0
1091 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: waux_mat
1092 REAL(kind=
dp),
DIMENSION(:, :, :, :),
INTENT(IN) :: dwaux_mat
1093 LOGICAL,
INTENT(IN) :: calculate_ints, calculate_forces
1095 INTEGER :: iset, jset, kset, la_max_set, laa_max, laa_max_set, lb_max_set, lca_max_set, na, &
1096 nb, nca, ndev, nds, nds_max, nl, nl_set, npgfa_set, npgfb_set, npgfca_set, nseta, nsetb, &
1097 nsetca, nshella_set, nshellb_set, nshellca_set, sgfa, sgfb, sgfca
1098 INTEGER,
DIMENSION(:),
POINTER :: la_max, lb_max, lca_max, npgfa, npgfb, &
1099 npgfca, nsgfa, nsgfb, nsgfca, nshella, &
1101 INTEGER,
DIMENSION(:, :),
POINTER :: first_sgfa, first_sgfb, first_sgfca, la, &
1103 REAL(kind=
dp) :: dab, rab2
1104 REAL(kind=
dp),
ALLOCATABLE, &
1105 DIMENSION(:, :, :, :, :) :: swork, swork_cont
1106 REAL(kind=
dp),
DIMENSION(:),
POINTER :: set_radius_a, set_radius_b, set_radius_ca
1107 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: zeta, zetb, zetca
1109 NULLIFY (la_max, lb_max, lca_max, npgfa, npgfb, npgfca)
1110 NULLIFY (first_sgfa, first_sgfb, first_sgfca, set_radius_a, set_radius_b, &
1111 set_radius_ca, zeta, zetb, zetca)
1114 first_sgfa => oba%first_sgf
1117 nsgfa => oba%nsgf_set
1119 nshella => oba%nshell
1121 set_radius_a => oba%set_radius
1124 first_sgfb => obb%first_sgf
1127 nsgfb => obb%nsgf_set
1129 nshellb => obb%nshell
1131 set_radius_b => obb%set_radius
1135 first_sgfca => fba%first_sgf
1138 nsgfca => fba%nsgf_set
1140 nshellca => fba%nshell
1142 set_radius_ca => fba%set_radius
1145 dab = sqrt(sum(rab**2))
1146 rab2 = rab(1)*rab(1) + rab(2)*rab(2) + rab(3)*rab(3)
1148 la_max_set = maxval(la_max)
1149 lb_max_set = maxval(lb_max)
1150 lca_max_set = maxval(lca_max)
1151 npgfa_set = maxval(npgfa)
1152 npgfb_set = maxval(npgfb)
1153 npgfca_set = maxval(npgfca)
1154 nshella_set = maxval(nshella)
1155 nshellb_set = maxval(nshellb)
1156 nshellca_set = maxval(nshellca)
1159 IF (calculate_forces) ndev = 1
1161 laa_max_set = la_max_set + lca_max_set
1164 nds_max = laa_max_set + lb_max_set + ndev + 1
1165 nl_set = int((laa_max_set)/2)
1166 ALLOCATE (swork(npgfb_set, npgfa_set, npgfca_set, nl_set + 1, nds_max))
1167 ALLOCATE (swork_cont(nds_max, 0:nl_set, nshella_set, nshellb_set, nshellca_set))
1173 IF (set_radius_a(iset) + set_radius_b(jset) < dab) cycle
1177 IF (set_radius_b(jset) + set_radius_ca(kset) < dab) cycle
1180 laa_max = la_max(iset) + lca_max(kset)
1181 nds = laa_max + lb_max(jset) + ndev + 1
1182 nl = int(laa_max/2) + 1
1183 swork(1:npgfb(jset), 1:npgfa(iset), 1:npgfca(kset), 1:nl, 1:nds) = 0.0_dp
1184 CALL s_overlap_abb(lb_max(jset), npgfb(jset), zetb(:, jset), &
1185 la_max(iset), npgfa(iset), zeta(:, iset), &
1186 lca_max(kset), npgfca(kset), zetca(:, kset), &
1187 rab, swork, calculate_forces)
1190 lb(:, jset), npgfb(jset), nshellb(jset), &
1191 scon_obb(1:npgfb(jset), 1:nshellb(jset), jset), &
1192 lca(:, kset), npgfca(kset), nshellca(kset), &
1193 oba_index(:, :, iset), fba_index(:, :, kset), scona_mix, nl, nds, &
1194 swork(1:npgfb(jset), 1:npgfa(iset), 1:npgfca(kset), 1:nl, 1:nds), &
1195 swork_cont, calculate_forces)
1196 IF (calculate_ints)
THEN
1198 lb(:, jset), first_sgfb(:, jset), nshellb(jset), &
1199 lca(:, kset), first_sgfca(:, kset), nshellca(kset), &
1200 cg_coeff, cg_none0_list, ncg_none0, &
1201 swork_cont, waux_mat, abaint)
1203 IF (calculate_forces)
THEN
1206 lb(:, jset), first_sgfb(:, jset), nshellb(jset), &
1207 lca(:, kset), first_sgfca(:, kset), nshellca(kset), &
1208 cg_coeff, cg_none0_list, ncg_none0, &
1209 -rab, swork_cont, waux_mat, dwaux_mat, dabdaint)
1212 sgfa = first_sgfa(1, iset)
1213 na = sgfa + nsgfa(iset) - 1
1214 sgfb = first_sgfb(1, jset)
1215 nb = sgfb + nsgfb(jset) - 1
1216 sgfca = first_sgfca(1, kset)
1217 nca = sgfca + nsgfca(kset) - 1
1223 DEALLOCATE (swork_cont)
1243 TYPE(gto_basis_set_type),
POINTER :: oba, obb, fba, fbb
1244 REAL(kind=
dp),
DIMENSION(3),
INTENT(IN) :: rab
1245 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :), &
1246 INTENT(OUT) :: waux_mat
1247 REAL(kind=
dp),
ALLOCATABLE, &
1248 DIMENSION(:, :, :, :),
INTENT(OUT) :: dwaux_mat
1249 LOGICAL,
INTENT(IN) :: calculate_forces
1251 INTEGER :: i, isize, j, k, la_max, laa_max, lb_max, &
1252 lbb_max, lca_max, lcb_max, li_max, &
1253 lj_max, lmax, mdim(3), size_int(4, 2), &
1255 INTEGER,
DIMENSION(:),
POINTER :: li_max_all
1256 REAL(kind=
dp) :: rab2
1257 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: rc, rs
1259 rab2 = rab(1)*rab(1) + rab(2)*rab(2) + rab(3)*rab(3)
1268 la_max = maxval(oba%lmax)
1269 lb_max = maxval(obb%lmax)
1270 lca_max = maxval(fba%lmax)
1271 lcb_max = maxval(fbb%lmax)
1273 laa_max = la_max + lca_max
1274 lbb_max = lb_max + lcb_max
1275 li_max = max(laa_max, lbb_max)
1276 lj_max = max(la_max, lb_max, lcb_max)
1279 ALLOCATE (li_max_all(0:lj_max))
1280 ALLOCATE (rc(0:lmax, -2*lmax:2*lmax), rs(0:lmax, -2*lmax:2*lmax))
1283 mdim(1) = li_max + lj_max + 1
1284 mdim(2) =
nsoset(li_max) + 1
1285 mdim(3) =
nsoset(lj_max) + 1
1286 ALLOCATE (waux_mat(mdim(1), mdim(2), mdim(3)))
1287 ALLOCATE (dwaux_mat(3, mdim(1), mdim(2), mdim(3)))
1294 size_int(1, :) = (/laa_max, lb_max/)
1295 size_int(2, :) = (/lbb_max, la_max/)
1296 size_int(3, :) = (/lca_max, lcb_max/)
1297 size_int(4, :) = (/la_max, lb_max/)
1301 i = size_int(isize, 1)
1302 j = size_int(isize, 2)
1304 IF (k < i) li_max_all(j) = i
1306 temp = li_max_all(lj_max)
1307 DO j = lj_max, 0, -1
1308 IF (li_max_all(j) < temp)
THEN
1309 li_max_all(j) = temp
1311 temp = li_max_all(j)
1317 CALL get_w_matrix(li_max_all, lj_max, lmax, rc, rs, waux_mat)
1318 IF (calculate_forces)
THEN
1322 DEALLOCATE (rc, rs, li_max_all)
static GRID_HOST_DEVICE int modulo(int a, int m)
Equivalent of Fortran's MODULO, which always return a positive number. https://gcc....
constants for the different operators of the 2c-integrals
integer, parameter, public operator_gauss
integer, parameter, public operator_verf
integer, parameter, public operator_vgauss
integer, parameter, public operator_verfc
integer, parameter, public operator_coulomb
Calculation of the integrals over solid harmonic Gaussian(SHG) functions. Routines for (a|O(r12)|b) a...
subroutine, public dev_overlap_shg_abb(la, first_sgfa, nshella, lb, first_sgfb, nshellb, lcb, first_sgfcb, nshellcb, cg_coeff, cg_none0_list, ncg_none0, rab, swork_cont, Waux_mat, dWaux_mat, dsabb)
calculates derivatives of [abb] SHG overlap integrals using precomputed angular-dependent part
subroutine, public get_w_matrix(lamax, lbmax, lmax, Rc, Rs, Waux_mat)
calculates the angular dependent-part of the SHG integrals, transformation matrix W,...
subroutine, public construct_int_shg_ab(la, first_sgfa, nshella, lb, first_sgfb, nshellb, swork_cont, Waux_mat, sab)
calculates [ab] SHG overlap integrals using precomputed angular- dependent part
subroutine, public construct_overlap_shg_aba(la, first_sgfa, nshella, lb, first_sgfb, nshellb, lca, first_sgfca, nshellca, cg_coeff, cg_none0_list, ncg_none0, swork_cont, Waux_mat, saba)
calculates [aba] SHG overlap integrals using precomputed angular- dependent part
subroutine, public construct_dev_shg_ab(la, first_sgfa, nshella, lb, first_sgfb, nshellb, rab, swork_cont, Waux_mat, dWaux_mat, dsab)
calculates derivatives of [ab] SHG overlap integrals using precomputed angular-dependent part
subroutine, public dev_overlap_shg_aba(la, first_sgfa, nshella, lb, first_sgfb, nshellb, lca, first_sgfca, nshellca, cg_coeff, cg_none0_list, ncg_none0, rab, swork_cont, Waux_mat, dWaux_mat, dsaba)
calculates derivatives of [aba] SHG overlap integrals using precomputed angular-dependent part
subroutine, public get_dw_matrix(lamax, lbmax, Waux_mat, dWaux_mat)
calculates derivatives of transformation matrix W,
subroutine, public get_real_scaled_solid_harmonic(Rlm_c, Rlm_s, l, r, r2)
computes the real scaled solid harmonics Rlm up to a given l
subroutine, public construct_overlap_shg_abb(la, first_sgfa, nshella, lb, first_sgfb, nshellb, lcb, first_sgfcb, nshellcb, cg_coeff, cg_none0_list, ncg_none0, swork_cont, Waux_mat, sabb)
calculates [abb] SHG overlap integrals using precomputed angular- dependent part
Calculation of contracted, spherical Gaussian integrals using the solid harmonic Gaussian (SHG) integ...
subroutine, public lri_precalc_angular_shg_part(oba, obb, fba, fbb, rab, Waux_mat, dWaux_mat, calculate_forces)
precalculates the angular part of the SHG integrals for the matrices (fa,fb), (a,b),...
subroutine, public int_overlap_aba_shg(saba, dsaba, rab, oba, obb, fba, scon_obb, scona_mix, oba_index, fba_index, cg_coeff, cg_none0_list, ncg_none0, calculate_forces)
calculate integrals (a,b,fa)
subroutine, public int_ra2m_ab_shg_low(vab, dvab, rab, fba, fbb, sconb_shg, scon_ra2m, m, Waux_mat, dWaux_mat, calculate_forces)
calculate integrals (a|ra^2m)|b); requires angular-dependent part as input
subroutine, public int_overlap_ab_shg(vab, dvab, rab, fba, fbb, scona_shg, sconb_shg, calculate_forces)
calculate overlap integrals (a,b)
subroutine, public int_overlap_ab_shg_low(sab, dsab, rab, fba, fbb, scona_shg, sconb_shg, Waux_mat, dWaux_mat, calculate_ints, calculate_forces, contraction_high)
calculate overlap integrals (a,b); requires angular-dependent part as input
subroutine, public get_abb_same_kind(abbint, dabbint, abaint, dabdaint, rab, oba, fba, calculate_ints, calculate_forces)
obtain integrals (a,b,fb) by symmetry relations from (a,b,fa) if basis sets at a and b are of the sam...
subroutine, public int_overlap_abb_shg_low(abbint, dabbint, rab, oba, obb, fbb, scon_oba, sconb_mix, obb_index, fbb_index, cg_coeff, cg_none0_list, ncg_none0, Waux_mat, dWaux_mat, calculate_ints, calculate_forces)
calculate integrals (a,b,fb); requires angular-dependent part as input
subroutine, public int_ra2m_ab_shg(vab, dvab, rab, fba, fbb, scon_ra2m, sconb_shg, m, calculate_forces)
Calcululates the two-center integrals of the type (a|(r-Ra)^(2m)|b) using the SHG scheme.
subroutine, public int_overlap_aba_shg_low(abaint, dabdaint, rab, oba, obb, fba, scon_obb, scona_mix, oba_index, fba_index, cg_coeff, cg_none0_list, ncg_none0, Waux_mat, dWaux_mat, calculate_ints, calculate_forces)
calculate integrals (a,b,fa); requires angular-dependent part as input
subroutine, public int_overlap_abb_shg(sabb, dsabb, rab, oba, obb, fbb, scon_oba, sconb_mix, obb_index, fbb_index, cg_coeff, cg_none0_list, ncg_none0, calculate_forces)
calculate integrals (a,b,fb)
subroutine, public int_operators_r12_ab_shg(r12_operator, vab, dvab, rab, fba, fbb, scona_shg, sconb_shg, omega, calculate_forces)
Calcululates the two-center integrals of the type (a|O(r12)|b) using the SHG scheme.
Defines the basic variable types.
integer, parameter, public dp
Provides Cartesian and spherical orbital pointers and indices.
integer, dimension(:), allocatable, public nsoset
Routines for calculating the s-integrals and their scalar derivatives with respect to rab2 over solid...
subroutine, public contract_s_overlap_aba(la, npgfa, nshella, lb, npgfb, nshellb, sconb_shg, lca, npgfca, nshellca, orba_index, ria_index, scona_mix, nl_max, nds_max, swork, swork_cont, calculate_forces)
Contraction and normalization of the (aba) overlap.
subroutine, public s_verf_ab(la_max, npgfa, zeta, lb_max, npgfb, zetb, omega, rab, v, calculate_forces)
calculates the uncontracted, not normalized [s|1/erf(omega*r12)/r12|s] two-center integral
subroutine, public s_gauss_ab(la_max, npgfa, zeta, lb_max, npgfb, zetb, omega, rab, v, calculate_forces)
calculates the uncontracted, not normalized [s|exp(-omega*r12**2)|s] two-center integral
subroutine, public s_overlap_abb(la_max, npgfa, zeta, lb_max, npgfb, zetb, lcb_max, npgfcb, zetcb, rab, s, calculate_forces)
calculates [s|ra^n|s] integrals for [aba] and the [s|rb^n|s] integrals for [abb]
subroutine, public s_vgauss_ab(la_max, npgfa, zeta, lb_max, npgfb, zetb, omega, rab, v, calculate_forces)
calculates the uncontracted, not normalized [s|exp(-omega*r12**2)/r12|s] two-center integral
subroutine, public contract_s_ra2m_ab(npgfa, nshella, scon_ra2m, npgfb, nshellb, sconb, swork, swork_cont, m, nds_max)
Contraction, normalization and combinatiorial combination of the [0a|(r-Ra)^(2m)|0b] integrals and th...
subroutine, public contract_sint_ab_chigh(npgfa, nshella, scona, npgfb, nshellb, sconb, nds, swork, swork_cont)
Contraction and normalization of the [s|O(r12)|s] integrals and their scalar derivatives; this routin...
subroutine, public s_coulomb_ab(la_max, npgfa, zeta, lb_max, npgfb, zetb, omega, rab, v, calculate_forces)
calculates the uncontracted, not normalized [s|1/r12|s] two-center coulomb integral
subroutine, public contract_s_overlap_abb(la, npgfa, nshella, scona_shg, lb, npgfb, nshellb, lcb, npgfcb, nshellcb, orbb_index, rib_index, sconb_mix, nl_max, nds_max, swork, swork_cont, calculate_forces)
Contraction and normalization of the (abb) overlap.
subroutine, public s_verfc_ab(la_max, npgfa, zeta, lb_max, npgfb, zetb, omega, rab, v, calculate_forces)
calculates the uncontracted, not normalized [s|1/erfc(omega*r12)/r12|s] two-center integral
subroutine, public contract_sint_ab_clow(la, npgfa, nshella, scona_shg, lb, npgfb, nshellb, sconb_shg, swork, swork_cont, calculate_forces)
Contraction and normalization of the [s|O(r12)|s] integrals and their scalar derivatives; this routin...
subroutine, public s_overlap_ab(la_max, npgfa, zeta, lb_max, npgfb, zetb, rab, s, calculate_forces)
calculates the uncontracted, not normalized [s|s] overlap
subroutine, public s_ra2m_ab(la_max, npgfa, zeta, lb_max, npgfb, zetb, m, rab, s, calculate_forces)
calculates the uncontracted, not normalized [0a|ra^(2m)|0b] two-center integral, where ra = r-Ra and ...