A lot of renaming

config/ifort_h5.cfg

@@ -1,65 +0,0 @@
-# Common flags
-##############
-#
-# -mkl=[parallel|sequential] : Use the MKL library
-# --ninja                    : Allow the utilisation of ninja. It is mandatory !
-# --align=32                 : Align all provided arrays on a 32-byte boundary
-#
-
-[COMMON]
-FC           : ifort 
-LAPACK_LIB   : -mkl=parallel
-IRPF90       : irpf90
-IRPF90_FLAGS : --ninja --align=32 
-LIB          : -lhdf5 -lz -lrt  
-
-# Global options
-################
-#
-# 1 : Activate
-# 0 : Deactivate
-# 
-[OPTION]
-MODE    : OPT        ; [ OPT | PROFILE | DEBUG ] : Chooses the section below
-CACHE   : 1          ; Enable cache_compile.py
-OPENMP  : 1          ; Append OpenMP flags
-
-# Optimization flags
-####################
-#
-# -xHost                     : Compile a binary optimized for the current architecture
-# -O2                        : O3 not better than O2.
-# -ip                        : Inter-procedural optimizations
-# -ftz                       : Flushes denormal results to zero
-#
-[OPT]
-FC       : -traceback
-FCFLAGS  : -xAVX  -O2 -ip -ftz -g
-
-# Profiling flags
-#################
-#
-[PROFILE]
-FC       : -p -g
-FCFLAGS  : -xSSE4.2 -O2 -ip -ftz
-
-# Debugging flags
-#################
-#
-# -traceback   : Activate backtrace on runtime
-# -fpe0        : All floating point exaceptions
-# -C           : Checks uninitialized variables,  array subscripts, etc...
-# -g           : Extra debugging information
-# -xSSE2       : Valgrind needs a very simple x86 executable
-#
-[DEBUG]
-FC      : -g -traceback
-FCFLAGS : -xSSE2 -C -fpe0 
-
-# OpenMP flags
-#################
-#
-[OPENMP]
-FC           : -qopenmp
-IRPF90_FLAGS : --openmp
-

configure

@@ -21,10 +21,10 @@ Options:
 
 Example:
   ./configure -c config/gfortran.cfg
-  ./configure -c config/gfortran.cfg -i all
 
 Note:
-  - Using different configuration files for installing dependencies and compiling QPs can improve the user experience.
+  - Using different configuration files for installing dependencies and
+    compiling QP can improve the user experience.
 
 EOF
     exit

data/module_gitignore

@@ -7,8 +7,8 @@ tags
 Makefile
 ao_basis
 ao_one_e_integrals
-ao_two_e_erf_integrals
+ao_two_e_erf_ints
-ao_two_e_integrals
+ao_two_e_ints
 aux_quantities
 becke_numerical_grid
 bitmask
@@ -37,8 +37,8 @@ kohn_sham_rs
 mo_basis
 mo_guess
 mo_one_e_integrals
-mo_two_e_erf_integrals
+mo_two_e_erf_ints
-mo_two_e_integrals
+mo_two_e_ints
 mpi
 mrpt_utils
 nuclei

docs/source/users_guide/qp_name.rst

@@ -0,0 +1,35 @@
+.. _qp_name:
+
+qp_name
+=======
+
+.. program:: qp_name
+
+Displays the names of all the files in which the provider/subroutine/function
+given as argument is used. With the `-r` flag, the name can be changed in the
+whole quantum package.
+
+Usage
+-----
+
+.. code:: bash
+
+   qp_name <name> [-r <new_name> | --rename=<new_name>]
+
+
+.. option:: -h
+
+   Prints the help message.
+
+
+.. option:: -r <new_name> --rename=<new_name>
+
+   Renames the provider/subroutine/function and all its occurences.
+
+
+.. note::
+
+    It is safe to create a commit before renaming a provider, and then to
+    check what has changed using git diff.
+
+

scripts/ezfio_interface/ezfio_generate_provider.py

@@ -29,7 +29,7 @@ def gen_ezfio_provider_disk_access(name_ref, name):
      read_{name} = .False.
      write_{name} = .False.
    else
-     print *, '{name_ref} has a wrong type'
+     print *, '{name_ref} has a bad type'
      stop 1
    endif
 

scripts/qp_name

@@ -0,0 +1,98 @@
+#!/usr/bin/env python2
+
+"""
+Displays the names of all the files in which the provider/subroutine/function
+given as argument is used. With the -r flag, the name can be changed in the
+whole quantum package.
+
+Usage:
+    qp_name <name> [-r <new_name> | --rename=<new_name>]
+
+Options:
+    -h                                  Prints the help message
+    -r <new_name> --rename=<new_name>   Renames the provider /
+                                        subroutine / function and all
+                                        its occurences
+
+Note:
+    It is safe to create a commit before renaming a provider, and then to
+    check what has changed using git diff.
+
+"""
+
+
+import re
+import sys
+import os
+
+
+try:
+    from docopt import docopt
+    from qp_path import QP_SRC, QP_ROOT, QP_PLUGINS
+except ImportError:
+    print "source .quantum_package.rc"
+    raise
+
+
+def main(arguments):
+
+    # Check that name exist in */IRPF90_man
+    print "Checking that name exists..."
+    all_modules = os.listdir(QP_SRC)
+
+    f = arguments["<name>"]+".l"
+    found = False
+    for mod in all_modules:
+        if os.path.isdir( os.path.join(QP_SRC,mod,"IRPF90_man") ):
+            for filename in os.listdir( os.path.join(QP_SRC,mod,"IRPF90_man") ):
+                if filename == f:
+                    found = True
+                    break
+        if found: break
+    
+    if not found:
+        print "Error:"
+        print "The variable/subroutine/function \""+arguments["<name>"] \
+        + "\" was not found in the sources."
+        print "Did you compile the code at the root?"
+        print "Continue? [y/N]  ", 
+        cont = sys.stdin.read(1).strip() in [ "y", "Y" ]
+        if not cont:
+            print "Aborted"
+            sys.exit(1)
+
+    # Now search in all the files 
+    print "Replacing..."
+    name = re.compile(r"\b"+arguments["<name>"]+r"\b", re.IGNORECASE)
+
+    for mod in all_modules:
+        dirname = os.path.join(QP_SRC,mod)
+        if not os.path.isdir(dirname):
+            continue
+
+        for filename in os.listdir(dirname):
+            if "." not in filename:
+                continue
+            filename = os.path.join(dirname,filename)
+            if not os.path.isfile(filename):
+                continue
+            with open(filename, "r") as f:
+                f_in = f.read()
+            if name.search(f_in):
+                print filename
+                if arguments["--rename"]:
+                    f_new = name.sub(arguments["--rename"], f_in)
+                    with open(filename, "w") as f:
+                        f.write(f_new)
+
+    print "Done"
+    
+
+
+
+
+if __name__ == '__main__':
+  arguments = docopt(__doc__)
+  main(arguments)
+
+

src/ao_one_e_integrals/ao_mono_ints.irp.f

@@ -1,29 +0,0 @@
- BEGIN_PROVIDER [ double precision, ao_mono_elec_integral,(ao_num,ao_num)]
-&BEGIN_PROVIDER [ double precision, ao_mono_elec_integral_diag,(ao_num)]
-  implicit none
-  integer :: i,j,n,l
-  BEGIN_DOC
- ! Array of the one-electron Hamiltonian on the |AO| basis.
-  END_DOC
-  
-  IF (read_ao_one_integrals) THEN
-     call ezfio_get_ao_one_e_integrals_integral_combined(ao_mono_elec_integral)
-  ELSE
-        ao_mono_elec_integral = ao_nucl_elec_integral + ao_kinetic_integral
-
-        IF (DO_PSEUDO) THEN
-              ao_mono_elec_integral  += ao_pseudo_integral
-        ENDIF
-  ENDIF
-
-  DO j = 1, ao_num
-    ao_mono_elec_integral_diag(j) = ao_mono_elec_integral(j,j)
-  ENDDO
-
-  IF (write_ao_one_integrals) THEN
-       call ezfio_set_ao_one_e_integrals_integral_combined(ao_mono_elec_integral)
-       print *,  'AO integrals combined written to disk'
-  ENDIF
- 
- END_PROVIDER
-

src/ao_one_e_ints/EZFIO.cfg

@@ -1,63 +1,64 @@
-[integral_nuclear]
+[ao_integrals_e_n]
 type: double precision
 doc: Nucleus-electron integrals in |AO| basis set
 size: (ao_basis.ao_num,ao_basis.ao_num)
 interface: ezfio
 
-[io_ao_one_integrals_nuclear]
+[io_ao_integrals_e_n]
 type: Disk_access
-doc: Read/Write |AO| one-electron nuclear integrals from/to disk [ Write | Read | None ]
+doc: Read/Write |AO| nucleus-electron attraction integrals from/to disk [ Write | Read | None ]
 interface: ezfio,provider,ocaml
 default: None
 
 
-[integral_kinetic]
+[ao_integrals_kinetic]
 type: double precision
 doc: Kinetic energy integrals in |AO| basis set
 size: (ao_basis.ao_num,ao_basis.ao_num)
 interface: ezfio
 
-[io_ao_one_integrals_kinetic]
+[io_ao_integrals_kinetic]
 type: Disk_access
-doc: Read/Write |AO| one-electron kinetic integrals from/to disk [ Write | Read | None ]
+doc: Read/Write |AO| kinetic integrals from/to disk [ Write | Read | None ]
 interface: ezfio,provider,ocaml
 default: None
 
 
-[integral_pseudo]
+[ao_integrals_pseudo]
 type: double precision
 doc: Pseudopotential integrals in |AO| basis set
 size: (ao_basis.ao_num,ao_basis.ao_num)
 interface: ezfio
 
-[io_ao_one_integrals_pseudo]
+[io_ao_integrals_pseudo]
 type: Disk_access
-doc: Read/Write |AO| one-electron pseudo integrals from/to disk [ Write | Read | None ]
+doc: Read/Write |AO| pseudopotential integrals from/to disk [ Write | Read | None ]
 interface: ezfio,provider,ocaml
 default: None
 
 
-[integral_overlap]
+[ao_integrals_overlap]
 type: double precision
 doc: Overlap integrals in |AO| basis set
 size: (ao_basis.ao_num,ao_basis.ao_num)
 interface: ezfio
 
-[io_ao_one_integrals_overlap]
+[io_ao_integrals_overlap]
 type: Disk_access
-doc: Read/Write |AO| one-electron overlap integrals from/to disk [ Write | Read | None ]
+doc: Read/Write |AO| overlap integrals from/to disk [ Write | Read | None ]
 interface: ezfio,provider,ocaml
 default: None
 
 
-[integral_combined]
+[ao_one_e_integrals]
 type: double precision
-doc: Combined integrals in |MO| basis set
+doc: Combined integrals in |AO| basis set
 size: (ao_basis.ao_num,ao_basis.ao_num) 
 interface: ezfio
 
-[disk_access_ao_one_integrals]
+[io_ao_one_e_integrals]
 type: Disk_access
 doc: Read/Write |AO| one-electron integrals from/to disk [ Write | Read | None ]
 interface: ezfio,provider,ocaml
 default: None
+

src/ao_one_e_ints/README.rst

@@ -8,7 +8,7 @@ The most important providers for usual quantum-chemistry calculation are:
 
 * `ao_kinetic_integral` which are the kinetic operator integrals on the |AO| basis (see :file:`kin_ao_ints.irp.f`)
 * `ao_nucl_elec_integral` which are the nuclear-elctron operator integrals on the |AO| basis (see :file:`pot_ao_ints.irp.f`)
-* `ao_mono_elec_integral` which are the the h_core operator integrals on the |AO| basis (see :file:`ao_mono_ints.irp.f`)
+* `ao_one_e_integrals` which are the the h_core operator integrals on the |AO| basis (see :file:`ao_mono_ints.irp.f`)
 
 
 Note that you can find other interesting integrals related to the position operator in :file:`spread_dipole_ao.irp.f`. 

src/ao_one_e_ints/ao_one_e_ints.irp.f

@@ -0,0 +1,29 @@
+ BEGIN_PROVIDER [ double precision, ao_one_e_integrals,(ao_num,ao_num)]
+&BEGIN_PROVIDER [ double precision, ao_one_e_integrals_diag,(ao_num)]
+  implicit none
+  integer :: i,j,n,l
+  BEGIN_DOC
+ ! One-electron Hamiltonian in the |AO| basis.
+  END_DOC
+  
+  IF (read_ao_one_e_integrals) THEN
+     call ezfio_get_ao_one_e_ints_ao_one_e_integrals(ao_one_e_integrals)
+  ELSE
+        ao_one_e_integrals = ao_nucl_elec_integrals + ao_kinetic_integrals
+
+        IF (DO_PSEUDO) THEN
+              ao_one_e_integrals += ao_pseudo_integrals
+        ENDIF
+  ENDIF
+
+  DO j = 1, ao_num
+    ao_one_e_integrals_diag(j) = ao_one_e_integrals(j,j)
+  ENDDO
+
+  IF (write_ao_one_e_integrals) THEN
+       call ezfio_set_ao_one_e_ints_ao_one_e_integrals(ao_one_e_integrals)
+       print *,  'AO one-e integrals written to disk'
+  ENDIF
+ 
+END_PROVIDER
+

src/ao_one_e_ints/ao_overlap.irp.f

@@ -19,8 +19,8 @@
   ao_overlap_x = 0.d0
   ao_overlap_y = 0.d0
   ao_overlap_z = 0.d0
-  if (read_ao_one_integrals_overlap) then
+  if (read_ao_integrals_overlap) then
-     call ezfio_get_ao_one_e_integrals_integral_overlap(ao_overlap(1:ao_num, 1:ao_num))
+     call ezfio_get_ao_one_e_ints_ao_integrals_overlap(ao_overlap(1:ao_num, 1:ao_num))
      print *,  'AO overlap integrals read from disk'
   else
 
@@ -63,8 +63,8 @@
     enddo
     !$OMP END PARALLEL DO
   endif
-  if (write_ao_one_integrals_overlap) then
+  if (write_ao_integrals_overlap) then
-     call ezfio_set_ao_one_e_integrals_integral_overlap(ao_overlap(1:ao_num, 1:ao_num))
+     call ezfio_set_ao_one_e_ints_ao_integrals_overlap(ao_overlap(1:ao_num, 1:ao_num))
      print *,  'AO overlap integrals written to disk'
   endif
 

src/ao_one_e_ints/kin_ao_ints.irp.f

@@ -117,7 +117,7 @@
 
 END_PROVIDER
 
-BEGIN_PROVIDER [double precision, ao_kinetic_integral, (ao_num,ao_num)]
+BEGIN_PROVIDER [double precision, ao_kinetic_integrals, (ao_num,ao_num)]
   implicit none
   BEGIN_DOC
   ! Kinetic energy integrals in the |AO| basis.
@@ -126,22 +126,22 @@ BEGIN_PROVIDER [double precision, ao_kinetic_integral, (ao_num,ao_num)]
   END_DOC
   integer                        :: i,j,k,l
   
-  if (read_ao_one_integrals_kinetic) then
+  if (read_ao_integrals_kinetic) then
-    call ezfio_get_ao_one_e_integrals_integral_kinetic(ao_kinetic_integral)
+    call ezfio_get_ao_one_e_ints_ao_integrals_kinetic(ao_kinetic_integrals)
     print *,  'AO kinetic integrals read from disk'
   else
     !$OMP PARALLEL DO DEFAULT(NONE) &
     !$OMP  PRIVATE(i,j) &
-    !$OMP  SHARED(ao_num, ao_kinetic_integral,ao_deriv2_x,ao_deriv2_y,ao_deriv2_z)
+    !$OMP  SHARED(ao_num, ao_kinetic_integrals,ao_deriv2_x,ao_deriv2_y,ao_deriv2_z)
     do j = 1, ao_num
       do i = 1, ao_num
-      ao_kinetic_integral(i,j) = -0.5d0 * (ao_deriv2_x(i,j) + ao_deriv2_y(i,j) + ao_deriv2_z(i,j) )
+      ao_kinetic_integrals(i,j) = -0.5d0 * (ao_deriv2_x(i,j) + ao_deriv2_y(i,j) + ao_deriv2_z(i,j) )
       enddo
     enddo
     !$OMP END PARALLEL DO
   endif
-  if (write_ao_one_integrals_kinetic) then
+  if (write_ao_integrals_kinetic) then
-    call ezfio_set_ao_one_e_integrals_integral_kinetic(ao_kinetic_integral)
+    call ezfio_set_ao_one_e_ints_ao_integrals_kinetic(ao_kinetic_integrals)
     print *,  'AO kinetic integrals written to disk'
   endif
 END_PROVIDER

src/ao_one_e_ints/pot_ao_ints.irp.f

@@ -1,4 +1,4 @@
-BEGIN_PROVIDER [ double precision, ao_nucl_elec_integral, (ao_num,ao_num)]
+BEGIN_PROVIDER [ double precision, ao_nucl_elec_integrals, (ao_num,ao_num)]
   BEGIN_DOC
   !  Nucleus-electron interaction, in the |AO| basis set.
   !
@@ -12,12 +12,12 @@ BEGIN_PROVIDER [ double precision, ao_nucl_elec_integral, (ao_num,ao_num)]
   integer                        :: i,j,k,l,n_pt_in,m
   double precision               :: overlap_x,overlap_y,overlap_z,overlap,dx,NAI_pol_mult
   
-  if (read_ao_one_integrals_nuclear) then
+  if (read_ao_integrals_e_n) then
-    call ezfio_get_ao_one_e_integrals_integral_nuclear(ao_nucl_elec_integral)
+    call ezfio_get_ao_one_e_ints_ao_integrals_e_n(ao_nucl_elec_integrals)
     print *,  'AO N-e integrals read from disk'
   else
     
-    ao_nucl_elec_integral = 0.d0
+    ao_nucl_elec_integrals = 0.d0
     
     !        _
     ! /|  / |_)
@@ -29,7 +29,7 @@ BEGIN_PROVIDER [ double precision, ao_nucl_elec_integral, (ao_num,ao_num)]
         !$OMP PRIVATE (i,j,k,l,m,alpha,beta,A_center,B_center,C_center,power_A,power_B,&
         !$OMP          num_A,num_B,Z,c,n_pt_in)                      &
         !$OMP SHARED (ao_num,ao_prim_num,ao_expo_ordered_transp,ao_power,ao_nucl,nucl_coord,ao_coef_normalized_ordered_transp,&
-        !$OMP         n_pt_max_integrals,ao_nucl_elec_integral,nucl_num,nucl_charge)
+        !$OMP         n_pt_max_integrals,ao_nucl_elec_integrals,nucl_num,nucl_charge)
     
     n_pt_in = n_pt_max_integrals
     
@@ -65,7 +65,7 @@ BEGIN_PROVIDER [ double precision, ao_nucl_elec_integral, (ao_num,ao_num)]
                   power_A,power_B,alpha,beta,C_center,n_pt_in)
               
             enddo
-            ao_nucl_elec_integral(i,j) = ao_nucl_elec_integral(i,j)  &
+            ao_nucl_elec_integrals(i,j) = ao_nucl_elec_integrals(i,j)  &
                 + ao_coef_normalized_ordered_transp(l,j)             &
                 * ao_coef_normalized_ordered_transp(m,i) * c
           enddo
@@ -76,14 +76,14 @@ BEGIN_PROVIDER [ double precision, ao_nucl_elec_integral, (ao_num,ao_num)]
     !$OMP END DO
     !$OMP END PARALLEL
   endif
-  if (write_ao_one_integrals_nuclear) then
+  if (write_ao_integrals_e_n) then
-    call ezfio_set_ao_one_e_integrals_integral_nuclear(ao_nucl_elec_integral)
+    call ezfio_set_ao_one_e_ints_ao_integrals_e_n(ao_nucl_elec_integrals)
     print *,  'AO N-e integrals written to disk'
   endif
   
 END_PROVIDER
 
-BEGIN_PROVIDER [ double precision, ao_nucl_elec_integral_per_atom, (ao_num,ao_num,nucl_num)]
+BEGIN_PROVIDER [ double precision, ao_nucl_elec_integrals_per_atom, (ao_num,ao_num,nucl_num)]
   BEGIN_DOC
 ! Nucleus-electron interaction in the |AO| basis set, per atom A.
 !
@@ -97,14 +97,14 @@ BEGIN_PROVIDER [ double precision, ao_nucl_elec_integral_per_atom, (ao_num,ao_nu
   integer                        :: i,j,k,l,n_pt_in,m
   double precision               :: overlap_x,overlap_y,overlap_z,overlap,dx,NAI_pol_mult
   
-  ao_nucl_elec_integral_per_atom = 0.d0
+  ao_nucl_elec_integrals_per_atom = 0.d0
   
   !$OMP PARALLEL                                                    &
       !$OMP DEFAULT (NONE)                                          &
       !$OMP PRIVATE (i,j,k,l,m,alpha,beta,A_center,B_center,power_A,power_B,&
       !$OMP  num_A,num_B,c,n_pt_in,C_center)                        &
       !$OMP SHARED (ao_num,ao_prim_num,ao_expo_ordered_transp,ao_power,ao_nucl,nucl_coord,ao_coef_normalized_ordered_transp,&
-      !$OMP  n_pt_max_integrals,ao_nucl_elec_integral_per_atom,nucl_num)
+      !$OMP  n_pt_max_integrals,ao_nucl_elec_integrals_per_atom,nucl_num)
   n_pt_in = n_pt_max_integrals
   !$OMP DO SCHEDULE (dynamic)
   
@@ -140,7 +140,7 @@ BEGIN_PROVIDER [ double precision, ao_nucl_elec_integral_per_atom, (ao_num,ao_nu
                 * ao_coef_normalized_ordered_transp(m,i)
           enddo
         enddo
-        ao_nucl_elec_integral_per_atom(i,j,k) = -c
+        ao_nucl_elec_integrals_per_atom(i,j,k) = -c
       enddo
     enddo
   enddo

src/ao_one_e_ints/pot_ao_pseudo_ints.irp.f

@@ -1,33 +1,33 @@
-BEGIN_PROVIDER [ double precision, ao_pseudo_integral, (ao_num,ao_num)]
+BEGIN_PROVIDER [ double precision, ao_pseudo_integrals, (ao_num,ao_num)]
   implicit none
   BEGIN_DOC
   ! Pseudo-potential integrals in the |AO| basis set.
   END_DOC
   
-  if (read_ao_one_integrals_pseudo) then
+  if (read_ao_integrals_pseudo) then
-    call ezfio_get_ao_one_e_integrals_integral_pseudo(ao_pseudo_integral)
+    call ezfio_get_ao_one_e_ints_ao_integrals_pseudo(ao_pseudo_integrals)
     print *,  'AO pseudopotential integrals read from disk'
   else
     
-    ao_pseudo_integral = 0.d0
+    ao_pseudo_integrals = 0.d0
     if (do_pseudo) then
       if (pseudo_klocmax > 0) then
-        ao_pseudo_integral += ao_pseudo_integral_local
+        ao_pseudo_integrals += ao_pseudo_integrals_local
       endif
       if (pseudo_kmax > 0) then
-        ao_pseudo_integral += ao_pseudo_integral_non_local
+        ao_pseudo_integrals += ao_pseudo_integrals_non_local
       endif
     endif
   endif
   
-  if (write_ao_one_integrals_pseudo) then
+  if (write_ao_integrals_pseudo) then
-    call ezfio_set_ao_one_e_integrals_integral_pseudo(ao_pseudo_integral)
+    call ezfio_set_ao_one_e_ints_ao_integrals_pseudo(ao_pseudo_integrals)
     print *,  'AO pseudopotential integrals written to disk'
   endif
   
 END_PROVIDER
 
-BEGIN_PROVIDER [ double precision, ao_pseudo_integral_local, (ao_num,ao_num)]
+BEGIN_PROVIDER [ double precision, ao_pseudo_integrals_local, (ao_num,ao_num)]
   implicit none
   BEGIN_DOC
   ! Local pseudo-potential
@@ -44,7 +44,7 @@ BEGIN_PROVIDER [ double precision, ao_pseudo_integral_local, (ao_num,ao_num)]
   integer                        :: thread_num
   integer                        :: omp_get_thread_num
   
-  ao_pseudo_integral_local = 0.d0
+  ao_pseudo_integrals_local = 0.d0
   
   print*, 'Providing the nuclear electron pseudo integrals (local)'
   
@@ -59,7 +59,7 @@ BEGIN_PROVIDER [ double precision, ao_pseudo_integral_local, (ao_num,ao_num)]
       !$OMP          num_A,num_B,Z,c,n_pt_in,                        &
       !$OMP          wall_0,wall_2,thread_num)                       &
       !$OMP SHARED (ao_num,ao_prim_num,ao_expo_ordered_transp,ao_power,ao_nucl,nucl_coord,ao_coef_normalized_ordered_transp,&
-      !$OMP         ao_pseudo_integral_local,nucl_num,nucl_charge,   &
+      !$OMP         ao_pseudo_integrals_local,nucl_num,nucl_charge,   &
       !$OMP         pseudo_klocmax,pseudo_lmax,pseudo_kmax,pseudo_v_k_transp,pseudo_n_k_transp, pseudo_dz_k_transp,&
       !$OMP         wall_1)
   
@@ -105,7 +105,7 @@ BEGIN_PROVIDER [ double precision, ao_pseudo_integral_local, (ao_num,ao_num)]
                 A_center,power_A,alpha,B_center,power_B,beta,C_center)
 
           enddo
-          ao_pseudo_integral_local(i,j) = ao_pseudo_integral_local(i,j) +&
+          ao_pseudo_integrals_local(i,j) = ao_pseudo_integrals_local(i,j) +&
               ao_coef_normalized_ordered_transp(l,j)*ao_coef_normalized_ordered_transp(m,i)*c
         enddo
       enddo
@@ -127,7 +127,7 @@ BEGIN_PROVIDER [ double precision, ao_pseudo_integral_local, (ao_num,ao_num)]
  END_PROVIDER
 
 
- BEGIN_PROVIDER [ double precision, ao_pseudo_integral_non_local, (ao_num,ao_num)]
+ BEGIN_PROVIDER [ double precision, ao_pseudo_integrals_non_local, (ao_num,ao_num)]
   implicit none
   BEGIN_DOC
   ! Non-local pseudo-potential
@@ -144,7 +144,7 @@ BEGIN_PROVIDER [ double precision, ao_pseudo_integral_local, (ao_num,ao_num)]
   double precision               :: cpu_1, cpu_2, wall_1, wall_2, wall_0
   integer                        :: thread_num
   
-  ao_pseudo_integral_non_local = 0.d0
+  ao_pseudo_integrals_non_local = 0.d0
   
   print*, 'Providing the nuclear electron pseudo integrals (non-local)'
   
@@ -158,7 +158,7 @@ BEGIN_PROVIDER [ double precision, ao_pseudo_integral_local, (ao_num,ao_num)]
       !$OMP          num_A,num_B,Z,c,n_pt_in,                        &
       !$OMP          wall_0,wall_2,thread_num)                       &
       !$OMP SHARED (ao_num,ao_prim_num,ao_expo_ordered_transp,ao_power,ao_nucl,nucl_coord,ao_coef_normalized_ordered_transp,&
-      !$OMP         ao_pseudo_integral_non_local,nucl_num,nucl_charge,&
+      !$OMP         ao_pseudo_integrals_non_local,nucl_num,nucl_charge,&
       !$OMP         pseudo_klocmax,pseudo_lmax,pseudo_kmax,pseudo_n_kl_transp, pseudo_v_kl_transp, pseudo_dz_kl_transp,&
       !$OMP         wall_1)
   
@@ -204,7 +204,7 @@ BEGIN_PROVIDER [ double precision, ao_pseudo_integral_local, (ao_num,ao_num)]
                     pseudo_dz_kl_transp(1,0,k), &
                     A_center,power_A,alpha,B_center,power_B,beta,C_center)
           enddo
-          ao_pseudo_integral_non_local(i,j) = ao_pseudo_integral_non_local(i,j) +&
+          ao_pseudo_integrals_non_local(i,j) = ao_pseudo_integrals_non_local(i,j) +&
               ao_coef_normalized_ordered_transp(l,j)*ao_coef_normalized_ordered_transp(m,i)*c
         enddo
       enddo

src/ao_two_e_erf_integrals/NEED

@@ -1 +0,0 @@
-ao_two_e_integrals

src/ao_two_e_erf_ints/NEED

@@ -0,0 +1 @@
+ao_two_e_ints

src/ao_two_e_erf_ints/README.rst

@@ -1,12 +1,12 @@
 ======================
-ao_two_e_erf_integrals
+ao_two_e_erf_ints
 ======================
 
 Here, all two-electron integrals (:math:`erf(\mu r_{12})/r_{12}`) are computed.
 As they have 4 indices and many are zero, they are stored in a map, as defined
 in :file:`utils/map_module.f90`.
 
-The main parameter of this module is :option:`ao_two_e_erf_integrals mu_erf` which is the range-separation parameter. 
+The main parameter of this module is :option:`ao_two_e_erf_ints mu_erf` which is the range-separation parameter. 
 
 To fetch an |AO| integral, use the
 `get_ao_bielec_integral_erf(i,j,k,l,ao_integrals_erf_map)` function. 

src/ao_two_e_ints/EZFIO.cfg

@@ -1,4 +1,4 @@
-[disk_access_ao_integrals]
+[io_ao_two_e_integrals]
 type: Disk_access
 doc: Read/Write |AO| integrals from/to disk [ Write | Read | None ] 
 interface: ezfio,provider,ocaml

src/ao_two_e_ints/NEED

@@ -1,4 +1,4 @@
-ao_one_e_integrals
+ao_one_e_ints
 pseudo
 bitmask
 zmq

src/ao_two_e_ints/README.rst

@@ -1,5 +1,5 @@
 ==================
-ao_two_e_integrals
+ao_two_e_ints
 ==================
 
 Here, all two-electron integrals (:math:`1/r_{12}`) are computed.

src/ao_two_e_ints/two_e_integrals.irp.f

@@ -351,8 +351,8 @@ BEGIN_PROVIDER [ logical, ao_bielec_integrals_in_map ]
   integral = ao_bielec_integral(1,1,1,1)
   
   double precision               :: map_mb
-  PROVIDE read_ao_integrals disk_access_ao_integrals
+  PROVIDE read_ao_two_e_integrals io_ao_two_e_integrals
-  if (read_ao_integrals) then
+  if (read_ao_two_e_integrals) then
     print*,'Reading the AO integrals'
       call map_load_from_disk(trim(ezfio_filename)//'/work/ao_ints',ao_integrals_map)
       print*, 'AO integrals provided'
@@ -413,7 +413,7 @@ BEGIN_PROVIDER [ logical, ao_bielec_integrals_in_map ]
   
   ao_bielec_integrals_in_map = .True.
 
-  if (write_ao_integrals.and.mpi_master) then
+  if (write_ao_two_e_integrals.and.mpi_master) then
     call ezfio_set_work_empty(.False.)
     call map_save_to_disk(trim(ezfio_filename)//'/work/ao_ints',ao_integrals_map)
     call ezfio_set_ao_two_e_integrals_disk_access_ao_integrals('Read')

src/cis/20.cis.bats

@@ -9,7 +9,7 @@ function run() {
   ezfio set_file $1
   ezfio set determinants n_states  3
   ezfio set davidson threshold_davidson 1.e-12
-  echo "Write" > $1/mo_two_e_integrals/disk_access_mo_integrals
+  ezfio set mo_two_e_ints io_mo_two_e_integrals Write
   qp_set_frozen_core $1
   qp_run cis $1
   energy1="$(ezfio get cis energy | tr '[]' ' ' | cut -d ',' -f 1)"

src/determinants/NEED

@@ -1,3 +1,3 @@
 mo_basis
-mo_one_e_integrals
+mo_one_e_ints
-mo_two_e_integrals
+mo_two_e_ints

src/determinants/fock_diag.irp.f

@@ -33,8 +33,8 @@ subroutine build_fock_tmp(fock_diag_tmp,det_ref,Nint)
   ! Occupied MOs
   do ii=1,elec_alpha_num
     i = occ(ii,1)
-    fock_diag_tmp(1,i) = fock_diag_tmp(1,i) + mo_mono_elec_integral(i,i)
+    fock_diag_tmp(1,i) = fock_diag_tmp(1,i) + mo_mono_elec_integrals(i,i)
-    E0 = E0 + mo_mono_elec_integral(i,i)
+    E0 = E0 + mo_mono_elec_integrals(i,i)
     do jj=1,elec_alpha_num
       j = occ(jj,1)
       if (i==j) cycle
@@ -49,8 +49,8 @@ subroutine build_fock_tmp(fock_diag_tmp,det_ref,Nint)
   enddo
   do ii=1,elec_beta_num
     i = occ(ii,2)
-    fock_diag_tmp(2,i) = fock_diag_tmp(2,i) + mo_mono_elec_integral(i,i)
+    fock_diag_tmp(2,i) = fock_diag_tmp(2,i) + mo_mono_elec_integrals(i,i)
-    E0 = E0 + mo_mono_elec_integral(i,i)
+    E0 = E0 + mo_mono_elec_integrals(i,i)
     do jj=1,elec_beta_num
       j = occ(jj,2)
       if (i==j) cycle
@@ -66,7 +66,7 @@ subroutine build_fock_tmp(fock_diag_tmp,det_ref,Nint)
   ! Virtual MOs
   do i=1,mo_tot_num
     if (fock_diag_tmp(1,i) /= 0.d0) cycle
-    fock_diag_tmp(1,i) = fock_diag_tmp(1,i) + mo_mono_elec_integral(i,i)
+    fock_diag_tmp(1,i) = fock_diag_tmp(1,i) + mo_mono_elec_integrals(i,i)
     do jj=1,elec_alpha_num
       j = occ(jj,1)
       fock_diag_tmp(1,i) = fock_diag_tmp(1,i) + mo_bielec_integral_jj_anti(i,j)
@@ -78,7 +78,7 @@ subroutine build_fock_tmp(fock_diag_tmp,det_ref,Nint)
   enddo
   do i=1,mo_tot_num
     if (fock_diag_tmp(2,i) /= 0.d0) cycle
-    fock_diag_tmp(2,i) = fock_diag_tmp(2,i) + mo_mono_elec_integral(i,i)
+    fock_diag_tmp(2,i) = fock_diag_tmp(2,i) + mo_mono_elec_integrals(i,i)
     do jj=1,elec_beta_num
       j = occ(jj,2)
       fock_diag_tmp(2,i) = fock_diag_tmp(2,i) + mo_bielec_integral_jj_anti(i,j)

src/determinants/mo_energy_expval.irp.f

@@ -131,7 +131,7 @@ subroutine diag_H_mat_elem_au0_h_au0(det_in,Nint,hii)
   ! alpha - alpha
   do i = 1, elec_num_tab_local(1)
     iorb =  occ(i,1)
-    hii += mo_mono_elec_integral(iorb,iorb)
+    hii += mo_mono_elec_integrals(iorb,iorb)
     do j = i+1, elec_num_tab_local(1)
       jorb = occ(j,1)
       hii +=  mo_bielec_integral_jj_anti(jorb,iorb)
@@ -141,7 +141,7 @@ subroutine diag_H_mat_elem_au0_h_au0(det_in,Nint,hii)
   ! beta - beta
   do i = 1, elec_num_tab_local(2)
     iorb =  occ(i,2)
-    hii += mo_mono_elec_integral(iorb,iorb)
+    hii += mo_mono_elec_integrals(iorb,iorb)
     do j = i+1, elec_num_tab_local(2)
       jorb = occ(j,2)
       hii +=  mo_bielec_integral_jj_anti(jorb,iorb)

src/determinants/psi_energy_mono_elec.irp.f

@@ -5,13 +5,15 @@
   double precision :: tmp(mo_tot_num,mo_tot_num),mono_ints(mo_tot_num,mo_tot_num)
   BEGIN_DOC
 ! psi_energy_h_core = $\langle \Psi | h_{core} |\Psi \rangle$
-! computed using the `one_body_dm_mo_alpha` + `one_body_dm_mo_beta` and `mo_mono_elec_integral`
+!
+! computed using the :c:data:`one_body_dm_mo_alpha` +
+! :c:data:`one_body_dm_mo_beta` and :c:data:`mo_mono_elec_integrals`
   END_DOC
   psi_energy_h_core = 0.d0
   do i = 1, N_states
    do j = 1, mo_tot_num
     do k = 1, mo_tot_num
-     psi_energy_h_core(i) += mo_mono_elec_integral(k,j) * (one_body_dm_mo_alpha(k,j,i) + one_body_dm_mo_beta(k,j,i))
+     psi_energy_h_core(i) += mo_mono_elec_integrals(k,j) * (one_body_dm_mo_alpha(k,j,i) + one_body_dm_mo_beta(k,j,i))
     enddo
    enddo
   enddo

src/determinants/ref_bitmask.irp.f

@@ -23,15 +23,15 @@
   bi_elec_ref_bitmask_energy = 0.d0
   
   do i = 1, elec_beta_num
-    ref_bitmask_energy += mo_mono_elec_integral(occ(i,1),occ(i,1)) + mo_mono_elec_integral(occ(i,2),occ(i,2))
+    ref_bitmask_energy += mo_mono_elec_integrals(occ(i,1),occ(i,1)) + mo_mono_elec_integrals(occ(i,2),occ(i,2))
-    kinetic_ref_bitmask_energy += mo_kinetic_integral(occ(i,1),occ(i,1)) + mo_kinetic_integral(occ(i,2),occ(i,2))
+    kinetic_ref_bitmask_energy += mo_kinetic_integrals(occ(i,1),occ(i,1)) + mo_kinetic_integrals(occ(i,2),occ(i,2))
-    nucl_elec_ref_bitmask_energy += mo_nucl_elec_integral(occ(i,1),occ(i,1)) + mo_nucl_elec_integral(occ(i,2),occ(i,2))
+    nucl_elec_ref_bitmask_energy += mo_nucl_elec_integrals(occ(i,1),occ(i,1)) + mo_nucl_elec_integrals(occ(i,2),occ(i,2))
   enddo
 
   do i = elec_beta_num+1,elec_alpha_num
-    ref_bitmask_energy += mo_mono_elec_integral(occ(i,1),occ(i,1))
+    ref_bitmask_energy += mo_mono_elec_integrals(occ(i,1),occ(i,1))
-    kinetic_ref_bitmask_energy += mo_kinetic_integral(occ(i,1),occ(i,1)) 
+    kinetic_ref_bitmask_energy += mo_kinetic_integrals(occ(i,1),occ(i,1)) 
-    nucl_elec_ref_bitmask_energy += mo_nucl_elec_integral(occ(i,1),occ(i,1)) 
+    nucl_elec_ref_bitmask_energy += mo_nucl_elec_integrals(occ(i,1),occ(i,1)) 
   enddo
   
   do j= 1, elec_alpha_num

src/determinants/single_excitations.irp.f

@@ -52,8 +52,8 @@ BEGIN_PROVIDER [double precision, fock_operator_closed_shell_ref_bitmask, (mo_to
     k = occ(k0,1)
     accu += 2.d0 * array_coulomb(k) - array_exchange(k)
    enddo
-   fock_operator_closed_shell_ref_bitmask(i,j) = accu + mo_mono_elec_integral(i,j)
+   fock_operator_closed_shell_ref_bitmask(i,j) = accu + mo_mono_elec_integrals(i,j)
-   fock_operator_closed_shell_ref_bitmask(j,i) = accu + mo_mono_elec_integral(i,j)
+   fock_operator_closed_shell_ref_bitmask(j,i) = accu + mo_mono_elec_integrals(i,j)
   enddo
  enddo
 
@@ -69,8 +69,8 @@ BEGIN_PROVIDER [double precision, fock_operator_closed_shell_ref_bitmask, (mo_to
     k = occ(k0,1)
     accu += 2.d0 * array_coulomb(k) - array_exchange(k)
    enddo
-   fock_operator_closed_shell_ref_bitmask(i,j) = accu+ mo_mono_elec_integral(i,j)
+   fock_operator_closed_shell_ref_bitmask(i,j) = accu+ mo_mono_elec_integrals(i,j)
-   fock_operator_closed_shell_ref_bitmask(j,i) = accu+ mo_mono_elec_integral(i,j)
+   fock_operator_closed_shell_ref_bitmask(j,i) = accu+ mo_mono_elec_integrals(i,j)
   enddo
  enddo
 
@@ -86,8 +86,8 @@ BEGIN_PROVIDER [double precision, fock_operator_closed_shell_ref_bitmask, (mo_to
     k = occ(k0,1)
     accu += 2.d0 * array_coulomb(k) - array_exchange(k)
    enddo
-   fock_operator_closed_shell_ref_bitmask(i,j) = accu+ mo_mono_elec_integral(i,j)
+   fock_operator_closed_shell_ref_bitmask(i,j) = accu+ mo_mono_elec_integrals(i,j)
-   fock_operator_closed_shell_ref_bitmask(j,i) = accu+ mo_mono_elec_integral(i,j)
+   fock_operator_closed_shell_ref_bitmask(j,i) = accu+ mo_mono_elec_integrals(i,j)
   enddo
  enddo
  deallocate(array_coulomb,array_exchange)
@@ -122,33 +122,33 @@ subroutine get_mono_excitation_from_fock(det_1,det_2,h,p,spin,phase,hij)
  ! holes :: direct terms
  do i0 = 1, n_occ_ab_hole(1)
   i = occ_hole(i0,1)
-  hij -= big_array_coulomb_integrals(i,h,p) ! get_mo_bielec_integral_schwartz(h,i,p,i,mo_integrals_map)
+  hij -= big_array_coulomb_integrals(i,h,p)
  enddo
  do i0 = 1, n_occ_ab_hole(2)
   i = occ_hole(i0,2)
-  hij -= big_array_coulomb_integrals(i,h,p) !get_mo_bielec_integral_schwartz(h,i,p,i,mo_integrals_map)
+  hij -= big_array_coulomb_integrals(i,h,p)
  enddo
 
  ! holes :: exchange terms
  do i0 = 1, n_occ_ab_hole(spin)
   i = occ_hole(i0,spin)
-  hij += big_array_exchange_integrals(i,h,p) ! get_mo_bielec_integral_schwartz(h,i,i,p,mo_integrals_map)
+  hij += big_array_exchange_integrals(i,h,p)
  enddo
 
  ! particles :: direct terms
  do i0 = 1, n_occ_ab_partcl(1)
   i = occ_partcl(i0,1)
-  hij += big_array_coulomb_integrals(i,h,p)!get_mo_bielec_integral_schwartz(h,i,p,i,mo_integrals_map)
+  hij += big_array_coulomb_integrals(i,h,p)
  enddo
  do i0 = 1, n_occ_ab_partcl(2)
   i = occ_partcl(i0,2)
-  hij += big_array_coulomb_integrals(i,h,p) !get_mo_bielec_integral_schwartz(h,i,p,i,mo_integrals_map)
+  hij += big_array_coulomb_integrals(i,h,p)
  enddo
 
  ! particles :: exchange terms
  do i0 = 1, n_occ_ab_partcl(spin)
   i = occ_partcl(i0,spin)
-  hij -= big_array_exchange_integrals(i,h,p)!get_mo_bielec_integral_schwartz(h,i,i,p,mo_integrals_map)
+  hij -= big_array_exchange_integrals(i,h,p)
  enddo
  hij = hij * phase
 

src/determinants/slater_rules.irp.f

@@ -795,7 +795,7 @@ subroutine i_H_j_verbose(key_i,key_j,Nint,hij,hmono,hdouble,phase)
         enddo
         
       endif
-      hmono = mo_mono_elec_integral(m,p)
+      hmono = mo_mono_elec_integrals(m,p)
       hij = phase*(hdouble + hmono)
       
     case (0)
@@ -1745,7 +1745,7 @@ subroutine a_operator(iorb,ispin,key,hjj,Nint,na,nb)
   call bitstring_to_list_ab(key, occ, tmp, Nint)
   na = na-1
   
-  hjj = hjj - mo_mono_elec_integral(iorb,iorb)
+  hjj = hjj - mo_mono_elec_integrals(iorb,iorb)
   
   ! Same spin
   do i=1,na
@@ -1798,7 +1798,7 @@ subroutine ac_operator(iorb,ispin,key,hjj,Nint,na,nb)
 !    print *,  iorb, mo_tot_num
 !    stop -1
 !  endif
-  hjj = hjj + mo_mono_elec_integral(iorb,iorb)
+  hjj = hjj + mo_mono_elec_integrals(iorb,iorb)
   
   ! Same spin
   do i=1,na

src/determinants/slater_rules_wee_mono.irp.f

@@ -192,7 +192,7 @@ subroutine i_H_j_mono_spin_monoelec(key_i,key_j,Nint,spin,hij)
   integer :: m,p
   m = exc(1,1)
   p = exc(1,2)
-  hij = phase * mo_mono_elec_integral(m,p)
+  hij = phase * mo_mono_elec_integrals(m,p)
 end
 
 
@@ -225,7 +225,7 @@ double precision function diag_H_mat_elem_monoelec(det_in,Nint)
   call bitstring_to_list_ab(det_in, occ_particle, tmp, Nint)
   do ispin = 1,2 
    do i = 1, tmp(ispin)
-    diag_H_mat_elem_monoelec +=  mo_mono_elec_integral(occ_particle(i,ispin),occ_particle(i,ispin))
+    diag_H_mat_elem_monoelec +=  mo_mono_elec_integrals(occ_particle(i,ispin),occ_particle(i,ispin))
    enddo
   enddo
   
@@ -262,7 +262,7 @@ subroutine i_H_j_monoelec(key_i,key_j,Nint,hij)
      m = exc(1,1,2)
      p = exc(1,2,2)
    endif
-   hij = phase * mo_mono_elec_integral(m,p)
+   hij = phase * mo_mono_elec_integrals(m,p)
   endif
 
 end

src/dft_keywords/README.rst

@@ -8,6 +8,6 @@ This module contains the main keywords related to a DFT calculation or RS-DFT ca
 * :option:`dft_keywords correlation_functional`
 * :option:`dft_keywords HF_exchange`  : only relevent for the :c:func:`rs_ks_scf` program
 
-The keyword for the **range separation parameter**  :math:`\mu` is the :option:`ao_two_e_erf_integrals mu_erf` keyword. 
+The keyword for the **range separation parameter**  :math:`\mu` is the :option:`ao_two_e_erf_ints mu_erf` keyword. 
 
 The keyword for the type of density used in RS-DFT calculation with a multi-configurational wave function is the :option:`density_for_dft density_for_dft` keyword.

src/dft_utils_one_e/NEED

@@ -1,8 +1,8 @@
 density_for_dft 
 dft_utils_in_r
-mo_one_e_integrals
+mo_one_e_ints
-mo_two_e_integrals
+mo_two_e_ints
-ao_one_e_integrals
+ao_one_e_ints
-ao_two_e_integrals
+ao_two_e_ints
-mo_two_e_erf_integrals
+mo_two_e_erf_ints
-ao_two_e_erf_integrals
+ao_two_e_erf_ints

src/dft_utils_one_e/one_e_energy_dft.irp.f

@@ -12,8 +12,8 @@
  do istate = 1, N_states 
   do i = 1, mo_tot_num
    do j = 1, mo_tot_num
-    psi_dft_energy_kinetic(istate)      += ( one_body_dm_mo_alpha_for_dft(j,i,istate)+one_body_dm_mo_beta_for_dft(j,i,istate)) * mo_kinetic_integral(j,i) 
+    psi_dft_energy_kinetic(istate)      += ( one_body_dm_mo_alpha_for_dft(j,i,istate)+one_body_dm_mo_beta_for_dft(j,i,istate)) * mo_kinetic_integrals(j,i) 
-    psi_dft_energy_nuclear_elec(istate) += ( one_body_dm_mo_alpha_for_dft(j,i,istate)+one_body_dm_mo_beta_for_dft(j,i,istate)) * mo_nucl_elec_integral(j,i) 
+    psi_dft_energy_nuclear_elec(istate) += ( one_body_dm_mo_alpha_for_dft(j,i,istate)+one_body_dm_mo_beta_for_dft(j,i,istate)) * mo_nucl_elec_integrals(j,i) 
    enddo
   enddo
  enddo

src/dft_utils_one_e/sr_coulomb.irp.f

@@ -54,10 +54,10 @@ END_PROVIDER
  do istate = 1, N_states
   do i = 1, mo_tot_num
    do j = 1, mo_tot_num
-    effective_one_e_potential(i,j,istate) = short_range_Hartree_operator(i,j,istate) + mo_nucl_elec_integral(i,j) + mo_kinetic_integral(i,j)    & 
+    effective_one_e_potential(i,j,istate) = short_range_Hartree_operator(i,j,istate) + mo_nucl_elec_integrals(i,j) + mo_kinetic_integrals(i,j)    & 
                                    + 0.5d0 * (potential_x_alpha_mo(i,j,istate) + potential_c_alpha_mo(i,j,istate)                               &
                                    +          potential_x_beta_mo(i,j,istate)  + potential_c_beta_mo(i,j,istate)   )
-    effective_one_e_potential_without_kin(i,j,istate) = short_range_Hartree_operator(i,j,istate) + mo_nucl_elec_integral(i,j)                   & 
+    effective_one_e_potential_without_kin(i,j,istate) = short_range_Hartree_operator(i,j,istate) + mo_nucl_elec_integrals(i,j)                   & 
                                    + 0.5d0 * (potential_x_alpha_mo(i,j,istate) + potential_c_alpha_mo(i,j,istate)                               &
                                    +          potential_x_beta_mo(i,j,istate)  + potential_c_beta_mo(i,j,istate)   )
    enddo

src/dressing/dress_stoch_routines.irp.f

@@ -258,7 +258,7 @@ subroutine ZMQ_dress(E, dress, delta_out, delta_s2_out, relative_error)
     state_average_weight(dress_stoch_istate) = 1.d0
     TOUCH state_average_weight dress_stoch_istate
     
-    provide nproc mo_bielec_integrals_in_map mo_mono_elec_integral psi_selectors pt2_F pt2_N_teeth dress_M_m
+    provide nproc mo_bielec_integrals_in_map mo_mono_elec_integrals psi_selectors pt2_F pt2_N_teeth dress_M_m
     
     print *, '========== ================= ================= ================='
     print *, ' Samples        Energy         Stat. Error         Seconds      '

src/dummy/NEED

@@ -1,7 +1,7 @@
 ao_basis
-ao_one_e_integrals
+ao_one_e_ints
-ao_two_e_erf_integrals
+ao_two_e_erf_ints
-ao_two_e_integrals
+ao_two_e_ints
 aux_quantities
 becke_numerical_grid
 bitmask
@@ -27,9 +27,9 @@ kohn_sham
 kohn_sham_rs
 mo_basis
 mo_guess
-mo_one_e_integrals
+mo_one_e_ints
-mo_two_e_erf_integrals
+mo_two_e_erf_ints
-mo_two_e_integrals
+mo_two_e_ints
 mpi
 nuclei
 perturbation

src/ezfio_files/00.create.bats

@@ -19,7 +19,7 @@ function run {
   qp_edit -c $EZ
   ezfio set_file $EZ
   ezfio set scf_utils thresh_scf 1.e-12
-  echo "Write" > ${EZ}/ao_two_e_integrals/disk_access_ao_integrals
+  ezfio set ao_two_e_ints io_ao_two_e_integrals "Write" 
 }
 
 

src/ezfio_files/01.convert.bats

@@ -10,7 +10,7 @@ function run {
   qp_edit -c $EZ
   ezfio set_file $EZ
   ezfio set scf_utils thresh_scf 1.e-12
-  echo "Write" > ${EZ}/ao_two_e_integrals/disk_access_ao_integrals
+  echo "Write" > ${EZ}/ao_two_e_ints/io_ao_two_e_integrals
 }
 
 @test "HBO GAMESS" {

src/fci/pt2_stoch_routines.irp.f

@@ -128,7 +128,7 @@ subroutine ZMQ_pt2(E, pt2,relative_error, error, variance, norm)
       state_average_weight(pt2_stoch_istate) = 1.d0
       TOUCH state_average_weight pt2_stoch_istate
 
-      provide nproc pt2_F mo_bielec_integrals_in_map mo_mono_elec_integral pt2_w psi_selectors 
+      provide nproc pt2_F mo_bielec_integrals_in_map mo_mono_elec_integrals pt2_w psi_selectors 
       call new_parallel_job(zmq_to_qp_run_socket, zmq_socket_pull, 'pt2')
 
       integer, external              :: zmq_put_psi

src/hartree_fock/NEED

@@ -1 +1,3 @@
-scf_utils ao_one_e_integrals ao_two_e_integrals
+ao_one_e_ints
+ao_two_e_ints
+scf_utils

src/hartree_fock/fock_matrix_hf.irp.f

@@ -169,8 +169,8 @@ END_PROVIDER
  integer                        :: i,j
  do j=1,ao_num
    do i=1,ao_num
-     Fock_matrix_ao_alpha(i,j) = ao_mono_elec_integral(i,j) + ao_bi_elec_integral_alpha(i,j)
+     Fock_matrix_ao_alpha(i,j) = ao_one_e_integrals(i,j) + ao_bi_elec_integral_alpha(i,j)
-     Fock_matrix_ao_beta (i,j) = ao_mono_elec_integral(i,j) + ao_bi_elec_integral_beta (i,j)
+     Fock_matrix_ao_beta (i,j) = ao_one_e_integrals(i,j) + ao_bi_elec_integral_beta (i,j)
    enddo
  enddo
 

src/hartree_fock/hf_energy.irp.f

@@ -24,7 +24,7 @@ END_PROVIDER
    do i=1,ao_num
     HF_two_electron_energy += 0.5d0 * ( ao_bi_elec_integral_alpha(i,j) * SCF_density_matrix_ao_alpha(i,j) &
                                        +ao_bi_elec_integral_beta(i,j)  * SCF_density_matrix_ao_beta(i,j) )
-    HF_one_electron_energy += ao_mono_elec_integral(i,j) * (SCF_density_matrix_ao_alpha(i,j) + SCF_density_matrix_ao_beta (i,j) )
+    HF_one_electron_energy += ao_one_e_integrals(i,j) * (SCF_density_matrix_ao_alpha(i,j) + SCF_density_matrix_ao_beta (i,j) )
    enddo
  enddo
  HF_energy += HF_two_electron_energy + HF_one_electron_energy

src/hartree_fock/scf.irp.f

@@ -1,14 +1,13 @@
 program scf
   BEGIN_DOC
-! Produce `Hartree_Fock` MO orbital 
+! Produce `Hartree_Fock` |MOs| 
+!
 ! output: mo_basis.mo_tot_num mo_basis.mo_label mo_basis.ao_md5 mo_basis.mo_coef mo_basis.mo_occ
+!
 ! output: hartree_fock.energy
+!
 ! optional: mo_basis.mo_coef
   END_DOC
-  disk_access_mo_one_integrals = "None" 
-  touch disk_access_mo_one_integrals 
-  disk_access_ao_one_integrals = "None" 
-  touch disk_access_ao_one_integrals 
   call create_guess
   call orthonormalize_mos
   call run
@@ -27,7 +26,10 @@ subroutine create_guess
       mo_coef = ao_ortho_lowdin_coef
       TOUCH mo_coef
       mo_label = 'Guess'
-      call mo_as_eigvectors_of_mo_matrix(mo_mono_elec_integral,size(mo_mono_elec_integral,1),size(mo_mono_elec_integral,2),mo_label,1,.false.)
+      call mo_as_eigvectors_of_mo_matrix(mo_mono_elec_integrals,     &
+          size(mo_mono_elec_integrals,1),                            &
+          size(mo_mono_elec_integrals,2),                            &
+          mo_label,1,.false.)
       SOFT_TOUCH mo_coef mo_label
     else if (mo_guess_type == "Huckel") then
       call huckel_guess
@@ -47,15 +49,9 @@ subroutine run
   use bitmasks
   implicit none
 
-  double precision               :: SCF_energy_before,SCF_energy_after,diag_H_mat_elem
-  double precision               :: EHF
   integer                        :: i_it, i, j, k
    
-  EHF = SCF_energy 
+  mo_label = "Orthonormalized"
-
-  mo_label = "Canonical"
-
-! Choose SCF algorithm
 
   call Roothaan_Hall_SCF
   call ezfio_set_hartree_fock_energy(SCF_energy)

src/kohn_sham/fock_matrix_ks.irp.f

@@ -192,8 +192,8 @@ END_PROVIDER
  integer                        :: i,j
  do j=1,ao_num
    do i=1,ao_num
-     Fock_matrix_alpha_no_xc_ao(i,j) = ao_mono_elec_integral(i,j) + ao_bi_elec_integral_alpha(i,j)
+     Fock_matrix_alpha_no_xc_ao(i,j) = ao_one_e_integrals(i,j) + ao_bi_elec_integral_alpha(i,j)
-     Fock_matrix_beta_no_xc_ao(i,j) = ao_mono_elec_integral(i,j) + ao_bi_elec_integral_beta (i,j)
+     Fock_matrix_beta_no_xc_ao(i,j) = ao_one_e_integrals(i,j) + ao_bi_elec_integral_beta (i,j)
    enddo
  enddo
 

src/kohn_sham/ks_enery.irp.f

@@ -21,7 +21,7 @@
                             Fock_matrix_ao_beta(i,j) * SCF_density_matrix_ao_beta(i,j)
     two_electron_energy += 0.5d0 * ( ao_bi_elec_integral_alpha(i,j) * SCF_density_matrix_ao_alpha(i,j) &
                 +ao_bi_elec_integral_beta(i,j) * SCF_density_matrix_ao_beta(i,j) )
-    one_electron_energy += ao_mono_elec_integral(i,j) * (SCF_density_matrix_ao_alpha(i,j) + SCF_density_matrix_ao_beta (i,j) )
+    one_electron_energy += ao_one_e_integrals(i,j) * (SCF_density_matrix_ao_alpha(i,j) + SCF_density_matrix_ao_beta (i,j) )
     trace_potential_xc += ao_potential_alpha_xc(i,j) * SCF_density_matrix_ao_alpha(i,j) + ao_potential_beta_xc(i,j) *  SCF_density_matrix_ao_beta (i,j)
    enddo
  enddo

src/kohn_sham/ks_scf.irp.f

@@ -6,10 +6,10 @@ program srs_ks_cf
 ! optional: mo_basis.mo_coef
   END_DOC
 
-  disk_access_mo_one_integrals = "None" 
+  io_mo_one_e_integrals = "None" 
-  touch disk_access_mo_one_integrals
+  touch io_mo_one_e_integrals
-  disk_access_ao_one_integrals = "None"  
+  io_ao_one_e_integrals = "None"  
-  touch disk_access_ao_one_integrals
+  touch io_ao_one_e_integrals
   read_wf = .False.
   density_for_dft ="WFT"
   touch density_for_dft
@@ -64,7 +64,7 @@ subroutine create_guess
       mo_coef = ao_ortho_lowdin_coef
       TOUCH mo_coef
       mo_label = 'Guess'
-      call mo_as_eigvectors_of_mo_matrix(mo_mono_elec_integral,size(mo_mono_elec_integral,1),size(mo_mono_elec_integral,2),mo_label,.false.)
+      call mo_as_eigvectors_of_mo_matrix(mo_mono_elec_integrals,size(mo_mono_elec_integrals,1),size(mo_mono_elec_integrals,2),mo_label,.false.)
       SOFT_TOUCH mo_coef mo_label
     else if (mo_guess_type == "Huckel") then
       call huckel_guess

src/kohn_sham_rs/61.rsks.bats

@@ -10,7 +10,7 @@ function run() {
   ezfio set scf_utils thresh_scf 1.e-10
   echo "short_range_PBE" > $1/dft_keywords/exchange_functional 
   echo "short_range_PBE" > $1/dft_keywords/correlation_functional 
-  echo "0.5"             > $1/ao_two_e_erf_integrals/mu_erf
+  echo "0.5"             > $1/ao_two_e_erf_ints/mu_erf
   echo "1"               > $1/becke_numerical_grid/grid_type_sgn 
   qp_run rs_ks_scf $1
   energy="$(ezfio get kohn_sham_rs energy)"

src/kohn_sham_rs/README.rst

@@ -5,7 +5,7 @@ kohn_sham_rs
 
 The Range-separated Kohn-Sham module performs *Restricted* Kohn-Sham calculations (the
 spatial part of the |MOs| is common for alpha and beta spinorbitals) where the coulomb interaction is partially treated using exact exchange. 
-The splitting of the interaction between long- and short-range is determined by the range-separation parameter :option:`ao_two_e_erf_integrals mu_erf`. The long-range part of the interaction is explicitly treated with exact exchange, and the short-range part of the interaction is treated with appropriate DFT functionals. 
+The splitting of the interaction between long- and short-range is determined by the range-separation parameter :option:`ao_two_e_erf_ints mu_erf`. The long-range part of the interaction is explicitly treated with exact exchange, and the short-range part of the interaction is treated with appropriate DFT functionals. 
 
 The Range-separated Kohn-Sham in an SCF and therefore is based on the ``scf_utils`` structure. 
 It performs the following actions:

src/kohn_sham_rs/fock_matrix_rs_ks.irp.f

@@ -238,8 +238,8 @@ END_PROVIDER
  integer                        :: i,j
  do j=1,ao_num
    do i=1,ao_num
-     Fock_matrix_alpha_no_xc_ao(i,j) = ao_mono_elec_integral(i,j) + ao_bi_elec_integral_alpha(i,j) 
+     Fock_matrix_alpha_no_xc_ao(i,j) = ao_one_e_integrals(i,j) + ao_bi_elec_integral_alpha(i,j) 
-     Fock_matrix_beta_no_xc_ao(i,j) = ao_mono_elec_integral(i,j) + ao_bi_elec_integral_beta (i,j) 
+     Fock_matrix_beta_no_xc_ao(i,j) = ao_one_e_integrals(i,j) + ao_bi_elec_integral_beta (i,j) 
    enddo
  enddo
 

src/kohn_sham_rs/rs_ks_energy.irp.f

@@ -21,7 +21,7 @@
                             Fock_matrix_ao_beta(i,j) * SCF_density_matrix_ao_beta(i,j) 
     two_electron_energy += 0.5d0 * ( ao_bi_elec_integral_alpha(i,j) * SCF_density_matrix_ao_alpha(i,j) & 
                 +ao_bi_elec_integral_beta(i,j) * SCF_density_matrix_ao_beta(i,j) ) 
-    one_electron_energy += ao_mono_elec_integral(i,j) * (SCF_density_matrix_ao_alpha(i,j) + SCF_density_matrix_ao_beta (i,j) )
+    one_electron_energy += ao_one_e_integrals(i,j) * (SCF_density_matrix_ao_alpha(i,j) + SCF_density_matrix_ao_beta (i,j) )
     trace_potential_xc += ao_potential_alpha_xc(i,j) * SCF_density_matrix_ao_alpha(i,j) + ao_potential_beta_xc(i,j) *  SCF_density_matrix_ao_beta (i,j)
    enddo
  enddo

src/kohn_sham_rs/rs_ks_scf.irp.f

@@ -6,10 +6,10 @@ program rs_ks_scf
 ! optional: mo_basis.mo_coef
   END_DOC
 
-  disk_access_mo_one_integrals = "None"
+  io_mo_one_e_integrals = "None"
-  touch disk_access_mo_one_integrals
+  touch io_mo_one_e_integrals
-  disk_access_ao_one_integrals = "None"
+  io_ao_one_e_integrals = "None"
-  touch disk_access_ao_one_integrals
+  touch io_ao_one_e_integrals
 
   read_wf = .False.
   density_for_dft ="WFT"
@@ -66,7 +66,7 @@ subroutine create_guess
       mo_coef = ao_ortho_lowdin_coef
       TOUCH mo_coef
       mo_label = 'Guess'
-      call mo_as_eigvectors_of_mo_matrix(mo_mono_elec_integral,size(mo_mono_elec_integral,1),size(mo_mono_elec_integral,2),mo_label,.false.)
+      call mo_as_eigvectors_of_mo_matrix(mo_mono_elec_integrals,size(mo_mono_elec_integrals,1),size(mo_mono_elec_integrals,2),mo_label,.false.)
       SOFT_TOUCH mo_coef mo_label
     else if (mo_guess_type == "Huckel") then
       call huckel_guess

src/mo_basis/NEED

@@ -1,3 +1,3 @@
 ao_basis
-ao_one_e_integrals
+ao_one_e_ints
 electrons

src/mo_guess/NEED

@@ -1,2 +1,2 @@
 mo_basis
-mo_one_e_integrals
+mo_one_e_ints

src/mo_guess/h_core_guess_routine.irp.f

@@ -5,9 +5,9 @@ subroutine hcore_guess
   implicit none
   character*(64)                 :: label
   label = "Guess"
-  call mo_as_eigvectors_of_mo_matrix(mo_mono_elec_integral,          &
+  call mo_as_eigvectors_of_mo_matrix(mo_mono_elec_integrals,          &
-                                     size(mo_mono_elec_integral,1),  &
+                                     size(mo_mono_elec_integrals,1),  &
-                                     size(mo_mono_elec_integral,2),label,1,.false.)
+                                     size(mo_mono_elec_integrals,2),label,1,.false.)
   call save_mos
   SOFT_TOUCH mo_coef mo_label
 end

src/mo_guess/pot_mo_ortho_canonical_ints.irp.f

@@ -1,21 +1,21 @@
-BEGIN_PROVIDER [double precision, ao_ortho_canonical_nucl_elec_integral, (mo_tot_num,mo_tot_num)]
+BEGIN_PROVIDER [double precision, ao_ortho_canonical_nucl_elec_integrals, (mo_tot_num,mo_tot_num)]
  implicit none
  integer :: i1,j1,i,j
  double precision :: c_i1,c_j1
 
- ao_ortho_canonical_nucl_elec_integral = 0.d0
+ ao_ortho_canonical_nucl_elec_integrals = 0.d0
  !$OMP PARALLEL DO DEFAULT(none) &
  !$OMP PRIVATE(i,j,i1,j1,c_j1,c_i1) &
  !$OMP SHARED(mo_tot_num,ao_num,ao_ortho_canonical_coef, &
- !$OMP   ao_ortho_canonical_nucl_elec_integral, ao_nucl_elec_integral)
+ !$OMP   ao_ortho_canonical_nucl_elec_integrals, ao_nucl_elec_integrals)
  do i = 1, mo_tot_num
    do j = 1, mo_tot_num
     do i1 = 1,ao_num
      c_i1 = ao_ortho_canonical_coef(i1,i)
      do j1 = 1,ao_num
        c_j1 = c_i1*ao_ortho_canonical_coef(j1,j)
-       ao_ortho_canonical_nucl_elec_integral(j,i) = ao_ortho_canonical_nucl_elec_integral(j,i) + &
+       ao_ortho_canonical_nucl_elec_integrals(j,i) = ao_ortho_canonical_nucl_elec_integrals(j,i) + &
-                                           c_j1 * ao_nucl_elec_integral(j1,i1)
+                                           c_j1 * ao_nucl_elec_integrals(j1,i1)
      enddo
     enddo
    enddo

src/mo_guess/pot_mo_ortho_lowdin_ints.irp.f

@@ -1,21 +1,21 @@
-BEGIN_PROVIDER [double precision, ao_ortho_lowdin_nucl_elec_integral, (mo_tot_num,mo_tot_num)]
+BEGIN_PROVIDER [double precision, ao_ortho_lowdin_nucl_elec_integrals, (mo_tot_num,mo_tot_num)]
  implicit none
  integer :: i1,j1,i,j
  double precision :: c_i1,c_j1
 
- ao_ortho_lowdin_nucl_elec_integral = 0.d0
+ ao_ortho_lowdin_nucl_elec_integrals = 0.d0
  !$OMP PARALLEL DO DEFAULT(none) &
  !$OMP PRIVATE(i,j,i1,j1,c_j1,c_i1) &
  !$OMP SHARED(mo_tot_num,ao_num,ao_ortho_lowdin_coef, &
- !$OMP   ao_ortho_lowdin_nucl_elec_integral, ao_nucl_elec_integral)
+ !$OMP   ao_ortho_lowdin_nucl_elec_integrals, ao_nucl_elec_integrals)
  do i = 1, mo_tot_num
    do j = 1, mo_tot_num
     do i1 = 1,ao_num
      c_i1 = ao_ortho_lowdin_coef(i1,i)
      do j1 = 1,ao_num
        c_j1 = c_i1*ao_ortho_lowdin_coef(j1,j)
-       ao_ortho_lowdin_nucl_elec_integral(j,i) = ao_ortho_lowdin_nucl_elec_integral(j,i) + &
+       ao_ortho_lowdin_nucl_elec_integrals(j,i) = ao_ortho_lowdin_nucl_elec_integrals(j,i) + &
-                                           c_j1 * ao_nucl_elec_integral(j1,i1)
+                                           c_j1 * ao_nucl_elec_integrals(j1,i1)
      enddo
     enddo
    enddo

src/mo_one_e_integrals/.gitignore

@@ -1 +0,0 @@
-../../data/module_gitignore

src/mo_one_e_integrals/NEED

@@ -1,3 +0,0 @@
-ao_one_e_integrals
-mo_basis
-pseudo

src/mo_one_e_integrals/README.rst

@@ -1,13 +0,0 @@
-==================
-mo_one_e_integrals
-==================
-
-All the one-electron integrals in |MO| basis are defined here.
-
-The most important providers for usual quantum-chemistry calculation are:  
-
-* `mo_kinetic_integral` which are the kinetic operator integrals on the |AO| basis (see :file:`kin_mo_ints.irp.f`)
-* `mo_nucl_elec_integral` which are the nuclear-elctron operator integrals on the |AO| basis (see :file:`pot_mo_ints.irp.f`)
-* `mo_mono_elec_integral` which are the the h_core operator integrals on the |AO| basis (see :file:`mo_mono_ints.irp.f`)
-
-Note that you can find other interesting integrals related to the position operator in :file:`spread_dipole_mo.irp.f`. 

src/mo_one_e_integrals/kin_mo_ints.irp.f

@@ -1,24 +0,0 @@
-BEGIN_PROVIDER [double precision, mo_kinetic_integral, (mo_tot_num,mo_tot_num)]
-  implicit none
-  BEGIN_DOC
-  !  Kinetic energy integrals in the MO basis
-  END_DOC
-
-  if (read_mo_one_integrals_kinetic) then
-    call ezfio_get_mo_one_e_integrals_integral_kinetic(mo_kinetic_integral)
-    print *,  'MO kinetic integrals read from disk'
-  else
-    call ao_to_mo(                                                   &
-        ao_kinetic_integral,                                         &
-        size(ao_kinetic_integral,1),                                 &
-        mo_kinetic_integral,                                         &
-        size(mo_kinetic_integral,1)                                  &
-        )
-  endif
-  if (write_mo_one_integrals_kinetic) then
-    call ezfio_set_mo_one_e_integrals_integral_kinetic(mo_kinetic_integral)
-    print *,  'MO kinetic integrals written to disk'
-  endif
-
-END_PROVIDER
-

src/mo_one_e_integrals/mo_mono_ints.irp.f

@@ -1,26 +0,0 @@
-BEGIN_PROVIDER [ double precision, mo_mono_elec_integral,(mo_tot_num,mo_tot_num)]
-  implicit none
-  integer                        :: i,j,n,l
-  BEGIN_DOC
-  ! array of the mono electronic hamiltonian on the MOs basis :
-  ! sum of the kinetic and nuclear electronic potential (and pseudo potential if needed)
-  END_DOC
-  print*,'Providing the mono electronic integrals'
-
-  IF (read_mo_one_integrals) THEN
-        call ezfio_get_mo_one_e_integrals_integral_combined(mo_mono_elec_integral)
-  ELSE
-      mo_mono_elec_integral  = mo_nucl_elec_integral + mo_kinetic_integral
-
-      IF (DO_PSEUDO) THEN
-            mo_mono_elec_integral  += mo_pseudo_integral
-      ENDIF
-
-  ENDIF
-
-  IF (write_mo_one_integrals) THEN
-        call ezfio_set_mo_one_e_integrals_integral_combined(mo_mono_elec_integral)
-       print *,  'MO integrals combined written to disk'
-  ENDIF
-
-END_PROVIDER

src/mo_one_e_integrals/pot_mo_ints.irp.f

@@ -1,46 +0,0 @@
-BEGIN_PROVIDER [double precision, mo_nucl_elec_integral, (mo_tot_num,mo_tot_num)]
- implicit none
- BEGIN_DOC
-! Nucleus-electron interaction on the |MO| basis
- END_DOC
-
-  if (read_mo_one_integrals_nuclear) then
-     call ezfio_get_mo_one_e_integrals_integral_nuclear(mo_nucl_elec_integral)
-    print *,  'MO N-e integrals read from disk'
-  else
-    call ao_to_mo(                                                   &
-        ao_nucl_elec_integral,                                       &
-        size(ao_nucl_elec_integral,1),                               &
-        mo_nucl_elec_integral,                                       &
-        size(mo_nucl_elec_integral,1)                                &
-        )
-  endif
-  if (write_mo_one_integrals_nuclear) then
-     call ezfio_set_mo_one_e_integrals_integral_nuclear(mo_nucl_elec_integral)
-    print *,  'MO N-e integrals written to disk'
-  endif
-
-END_PROVIDER
-
-
-BEGIN_PROVIDER [double precision, mo_nucl_elec_integral_per_atom, (mo_tot_num,mo_tot_num,nucl_num)]
- implicit none
- BEGIN_DOC
-! mo_nucl_elec_integral_per_atom(i,j,k) =
-! $\langle \phi_i| -\frac{1}{|r-R_k|} | \phi_j \rangle$.
-! where R_k is the coordinate of the k-th nucleus.
- END_DOC
-
- integer :: k
- mo_nucl_elec_integral_per_atom = 0.d0
- do k = 1, nucl_num 
-   call ao_to_mo(                                                    &
-       ao_nucl_elec_integral_per_atom(1,1,k),                        &
-       size(ao_nucl_elec_integral_per_atom,1),                       &
-       mo_nucl_elec_integral_per_atom(1,1,k),                        &
-       size(mo_nucl_elec_integral_per_atom,1)                        &
-       )
- enddo
-
-END_PROVIDER
-

src/mo_one_e_integrals/pot_mo_pseudo_ints.irp.f

@@ -1,28 +0,0 @@
-BEGIN_PROVIDER [double precision, mo_pseudo_integral, (mo_tot_num,mo_tot_num)]
-  implicit none
-  BEGIN_DOC
-  ! interaction nuclear electron on the MO basis
-  END_DOC
-  
-  if (read_mo_one_integrals_pseudo) then
-    call ezfio_get_mo_one_e_integrals_integral_pseudo(mo_pseudo_integral)
-    print *,  'MO pseudopotential integrals read from disk'
-  else if (do_pseudo) then
-      call ao_to_mo(                                                   &
-        ao_pseudo_integral,                                         &
-        size(ao_pseudo_integral,1),                                 &
-        mo_pseudo_integral,                                         &
-        size(mo_pseudo_integral,1)                                  &
-        )
-  else
-      mo_pseudo_integral = 0.d0
-  endif
-
-  if (write_mo_one_integrals_pseudo) then
-    call ezfio_set_mo_one_e_integrals_integral_pseudo(mo_pseudo_integral)
-    print *,  'MO pseudopotential integrals written to disk'
-  endif
-
-END_PROVIDER
-
-

src/mo_one_e_ints/EZFIO.cfg

@@ -1,23 +1,23 @@
-[integral_nuclear]
+[mo_integrals_e_n]
 type: double precision
 doc: Nucleus-electron integrals in |MO| basis set
 size: (mo_basis.mo_tot_num,mo_basis.mo_tot_num)
 interface: ezfio
 
-[io_mo_one_integrals_nuclear]
+[io_mo_integrals_e_n]
 type: Disk_access
-doc: Read/Write |MO| one-electron nuclear integrals from/to disk [ Write | Read | None ]
+doc: Read/Write |MO| electron-nucleus attraction integrals from/to disk [ Write | Read | None ]
 interface: ezfio,provider,ocaml
 default: None
 
 
-[integral_kinetic]
+[mo_integrals_kinetic]
 type: double precision
 doc: Kinetic energy integrals in |MO| basis set
 size: (mo_basis.mo_tot_num,mo_basis.mo_tot_num)
 interface: ezfio
 
-[io_mo_one_integrals_kinetic]
+[io_mo_integrals_kinetic]
 type: Disk_access
 doc: Read/Write |MO| one-electron kinetic integrals from/to disk [ Write | Read | None ]
 interface: ezfio,provider,ocaml
@@ -25,39 +25,27 @@ default: None
 
 
 
-[integral_pseudo]
+[mo_integrals_pseudo]
 type: double precision
 doc: Pseudopotential integrals in |MO| basis set
 size: (mo_basis.mo_tot_num,mo_basis.mo_tot_num)
 interface: ezfio
 
-[io_mo_one_integrals_pseudo]
+[io_mo_integrals_pseudo]
 type: Disk_access
-doc: Read/Write |MO| one-electron pseudo integrals from/to disk [ Write | Read | None ]
+doc: Read/Write |MO| pseudopotential integrals from/to disk [ Write | Read | None ]
 interface: ezfio,provider,ocaml
 default: None
 
-[integral_overlap]
+[mo_one_e_integrals]
 type: double precision
-doc: Overlap integrals in |MO| basis set
+doc: One-electron integrals in |MO| basis set
 size: (mo_basis.mo_tot_num,mo_basis.mo_tot_num)
 interface: ezfio
 
-[io_mo_one_integrals_overlap]
+[io_mo_one_e_integrals]
-type: Disk_access
-doc: Read/Write |MO| one-electron overlap integrals from/to disk [ Write | Read | None ]
-interface: ezfio,provider,ocaml
-default: None
-
-
-[integral_combined]
-type: double precision
-doc: Combined integrals in |MO| basis set
-size: (mo_basis.mo_tot_num,mo_basis.mo_tot_num)
-interface: ezfio
-
-[disk_access_mo_one_integrals]
 type: Disk_access
 doc: Read/Write |MO| one-electron integrals from/to disk [ Write | Read | None ]
 interface: ezfio,provider,ocaml
 default: None
+

src/mo_one_e_ints/NEED

@@ -0,0 +1,3 @@
+ao_one_e_ints
+mo_basis
+pseudo

src/mo_one_e_ints/README.rst

@@ -0,0 +1,13 @@
+==================
+mo_one_e_integrals
+==================
+
+All the one-electron integrals in |MO| basis are defined here.
+
+The most important providers for usual quantum-chemistry calculation are:  
+
+* `mo_kinetic_integrals` which are the kinetic operator integrals on the |AO| basis (see :file:`kin_mo_ints.irp.f`)
+* `mo_nucl_elec_integrals` which are the nuclear-elctron operator integrals on the |AO| basis (see :file:`pot_mo_ints.irp.f`)
+* `mo_mono_elec_integrals` which are the the h_core operator integrals on the |AO| basis (see :file:`mo_mono_ints.irp.f`)
+
+Note that you can find other interesting integrals related to the position operator in :file:`spread_dipole_mo.irp.f`. 

src/mo_one_e_ints/kin_mo_ints.irp.f

@@ -0,0 +1,24 @@
+BEGIN_PROVIDER [double precision, mo_kinetic_integrals, (mo_tot_num,mo_tot_num)]
+  implicit none
+  BEGIN_DOC
+  !  Kinetic energy integrals in the MO basis
+  END_DOC
+
+  if (read_mo_integrals_kinetic) then
+    call ezfio_get_mo_one_e_ints_mo_integrals_kinetic(mo_kinetic_integrals)
+    print *,  'MO kinetic integrals read from disk'
+  else
+    call ao_to_mo(                                                   &
+        ao_kinetic_integrals,                                         &
+        size(ao_kinetic_integrals,1),                                 &
+        mo_kinetic_integrals,                                         &
+        size(mo_kinetic_integrals,1)                                  &
+        )
+  endif
+  if (write_mo_integrals_kinetic) then
+    call ezfio_set_mo_one_e_ints_mo_integrals_kinetic(mo_kinetic_integrals)
+    print *,  'MO kinetic integrals written to disk'
+  endif
+
+END_PROVIDER
+

src/mo_one_e_ints/mo_one_e_ints.irp.f

@@ -0,0 +1,26 @@
+BEGIN_PROVIDER [ double precision, mo_mono_elec_integrals,(mo_tot_num,mo_tot_num)]
+  implicit none
+  integer                        :: i,j,n,l
+  BEGIN_DOC
+  ! array of the mono electronic hamiltonian on the MOs basis :
+  ! sum of the kinetic and nuclear electronic potential (and pseudo potential if needed)
+  END_DOC
+  print*,'Providing the mono electronic integrals'
+
+  IF (read_mo_one_e_integrals) THEN
+        call ezfio_get_mo_one_e_ints_mo_one_e_integrals(mo_mono_elec_integrals)
+  ELSE
+      mo_mono_elec_integrals  = mo_nucl_elec_integrals + mo_kinetic_integrals
+
+      IF (DO_PSEUDO) THEN
+            mo_mono_elec_integrals  += mo_pseudo_integrals
+      ENDIF
+
+  ENDIF
+
+  IF (write_mo_one_e_integrals) THEN
+        call ezfio_set_mo_one_e_ints_mo_one_e_integrals(mo_mono_elec_integrals)
+       print *,  'MO one-e integrals written to disk'
+  ENDIF
+
+END_PROVIDER

src/mo_one_e_ints/mo_overlap.irp.f

@@ -1,16 +1,14 @@
 
-BEGIN_PROVIDER [ double precision, mo_overlap,(mo_tot_num,mo_tot_num)]
+BEGIN_PROVIDER [ double precision, mo_overlap,(mo_tot_num,mo_tot_num) ]
   implicit none
+  BEGIN_DOC
+! Provider to check that the MOs are indeed orthonormal.
+  END_DOC
   integer :: i,j,n,l
   double precision :: f
   integer :: lmax
 
 
-  if (read_mo_one_integrals_overlap) then
-    call ezfio_get_mo_one_e_integrals_integral_overlap(mo_kinetic_integral)
-    print *,  'MO kinetic overlap read from disk'
-  else
-
   lmax = (ao_num/4) * 4
   !$OMP PARALLEL DO SCHEDULE(STATIC) DEFAULT(NONE) &
   !$OMP  PRIVATE(i,j,n,l) &
@@ -36,12 +34,6 @@ BEGIN_PROVIDER [ double precision, mo_overlap,(mo_tot_num,mo_tot_num)]
    enddo
   enddo
   !$OMP END PARALLEL DO
- endif
-
-  if (write_mo_one_integrals_overlap) then
-    call ezfio_set_mo_one_e_integrals_integral_overlap(mo_kinetic_integral)
-    print *,  'MO kinetic integrals written to disk'
-  endif
 
 END_PROVIDER
 

src/mo_one_e_ints/pot_mo_ints.irp.f

@@ -0,0 +1,46 @@
+BEGIN_PROVIDER [double precision, mo_nucl_elec_integrals, (mo_tot_num,mo_tot_num)]
+ implicit none
+ BEGIN_DOC
+! Nucleus-electron interaction on the |MO| basis
+ END_DOC
+
+  if (read_mo_integrals_e_n) then
+     call ezfio_get_mo_one_e_ints_mo_integrals_e_n(mo_nucl_elec_integrals)
+    print *,  'MO N-e integrals read from disk'
+  else
+    call ao_to_mo(                                                   &
+        ao_nucl_elec_integrals,                                       &
+        size(ao_nucl_elec_integrals,1),                               &
+        mo_nucl_elec_integrals,                                       &
+        size(mo_nucl_elec_integrals,1)                                &
+        )
+  endif
+  if (write_mo_integrals_e_n) then
+     call ezfio_set_mo_one_e_ints_mo_integrals_e_n(mo_nucl_elec_integrals)
+    print *,  'MO N-e integrals written to disk'
+  endif
+
+END_PROVIDER
+
+
+BEGIN_PROVIDER [double precision, mo_nucl_elec_integrals_per_atom, (mo_tot_num,mo_tot_num,nucl_num)]
+ implicit none
+ BEGIN_DOC
+! mo_nucl_elec_integrals_per_atom(i,j,k) =
+! $\langle \phi_i| -\frac{1}{|r-R_k|} | \phi_j \rangle$.
+! where R_k is the coordinate of the k-th nucleus.
+ END_DOC
+
+ integer :: k
+ mo_nucl_elec_integrals_per_atom = 0.d0
+ do k = 1, nucl_num 
+   call ao_to_mo(                                                    &
+       ao_nucl_elec_integrals_per_atom(1,1,k),                        &
+       size(ao_nucl_elec_integrals_per_atom,1),                       &
+       mo_nucl_elec_integrals_per_atom(1,1,k),                        &
+       size(mo_nucl_elec_integrals_per_atom,1)                        &
+       )
+ enddo
+
+END_PROVIDER
+

src/mo_one_e_ints/pot_mo_pseudo_ints.irp.f

@@ -0,0 +1,28 @@
+BEGIN_PROVIDER [double precision, mo_pseudo_integrals, (mo_tot_num,mo_tot_num)]
+  implicit none
+  BEGIN_DOC
+  ! Pseudopotential integrals in |MO| basis
+  END_DOC
+  
+  if (read_mo_integrals_pseudo) then
+    call ezfio_get_mo_one_e_ints_mo_integrals_pseudo(mo_pseudo_integrals)
+    print *,  'MO pseudopotential integrals read from disk'
+  else if (do_pseudo) then
+      call ao_to_mo(                                                   &
+        ao_pseudo_integrals,                                         &
+        size(ao_pseudo_integrals,1),                                 &
+        mo_pseudo_integrals,                                         &
+        size(mo_pseudo_integrals,1)                                  &
+        )
+  else
+      mo_pseudo_integrals = 0.d0
+  endif
+
+  if (write_mo_integrals_pseudo) then
+    call ezfio_set_mo_one_e_ints_mo_integrals_pseudo(mo_pseudo_integrals)
+    print *,  'MO pseudopotential integrals written to disk'
+  endif
+
+END_PROVIDER
+
+

src/mo_two_e_erf_integrals/NEED

@@ -1,3 +0,0 @@
-ao_two_e_erf_integrals
-mo_two_e_integrals
-mo_basis

src/mo_two_e_erf_ints/NEED

@@ -0,0 +1,3 @@
+ao_two_e_erf_ints
+mo_two_e_ints
+mo_basis

src/mo_two_e_erf_ints/README.rst

@@ -1,12 +1,12 @@
 ======================
-mo_two_e_erf_integrals
+mo_two_e_erf_ints
 ======================
 
 Here, all two-electron integrals (:math:`erf({\mu}_{erf} * r_{12})/r_{12}`) are computed.
 As they have 4 indices and many are zero, they are stored in a map, as defined
 in :file:`Utils/map_module.f90`. 
 
-The range separation parameter :math:`{\mu}_{erf}` is the variable :option:`ao_two_e_erf_integrals mu_erf`. 
+The range separation parameter :math:`{\mu}_{erf}` is the variable :option:`ao_two_e_erf_ints mu_erf`. 
 
 To fetch an |MO| integral, use
 `get_mo_bielec_integral_erf(i,j,k,l,mo_integrals_map_erf)`

src/mo_two_e_erf_ints/core_quantities_erf.irp.f

@@ -7,7 +7,7 @@ BEGIN_PROVIDER [double precision, core_energy_erf]
  core_energy_erf = 0.d0
  do i = 1, n_core_orb
   j = list_core(i)
-  core_energy_erf += 2.d0 * mo_mono_elec_integral(j,j) + mo_two_e_int_erf_jj(j,j)
+  core_energy_erf += 2.d0 * mo_mono_elec_integrals(j,j) + mo_two_e_int_erf_jj(j,j)
   do k = i+1, n_core_orb
    l = list_core(k)
    core_energy_erf += 2.d0 * (2.d0 * mo_two_e_int_erf_jj(j,l) - mo_two_e_int_erf_jj_exchange(j,l))

src/mo_two_e_integrals/NEED

@@ -1,7 +0,0 @@
-ao_one_e_integrals
-mo_one_e_integrals
-ao_two_e_integrals
-pseudo
-bitmask
-zmq
-mo_basis