forte2._forte2.ints
===================

.. py:module:: forte2._forte2.ints








Module Contents
---------------

.. py:class:: Shell
              Shell(l: int, exponents: collections.abc.Sequence[float], coeffs: collections.abc.Sequence[float], center: collections.abc.Sequence[float], is_pure: bool = True, embed_normalization_into_coefficients: bool = True)

   .. py:property:: size
      :type: int


      
      The number of basis functions in the shell (e.g., for l = 2, size = 5).
















      ..
          !! processed by numpydoc !!


   .. py:property:: ncontr
      :type: int


      
      The number of contractions in the shell.
















      ..
          !! processed by numpydoc !!


   .. py:property:: nprim
      :type: int


      
      The number of primitive Gaussians in the shell.
















      ..
          !! processed by numpydoc !!


   .. py:property:: l
      :type: int


      
      The angular momentum of the shell.
















      ..
          !! processed by numpydoc !!


   .. py:property:: coeff
      :type: list[float]


      
      The coefficients of the primitives in the shell.
















      ..
          !! processed by numpydoc !!


   .. py:property:: exponents
      :type: list[float]


      
      The exponents of the primitives in the shell.
















      ..
          !! processed by numpydoc !!


   .. py:property:: is_pure
      :type: bool


      
      Is the shell pure? (i.e., we have 5d and 7f functions)
















      ..
          !! processed by numpydoc !!


   .. py:property:: center
      :type: list[float]


      
      The center of the shell (x, y, z) in bohr.
















      ..
          !! processed by numpydoc !!


.. py:class:: Basis

   .. py:method:: add(shell: Shell) -> None


   .. py:method:: set_name(name: str) -> None


   .. py:method:: serialize() -> dict

      
      Serialize the basis set to a dictionary.
















      ..
          !! processed by numpydoc !!


   .. py:property:: shell_first_and_size
      :type: list[tuple[int, int]]


      
      Returns a vector of pairs of the first index and size of each shell in the basis set. The first index is the index of the first basis function in the shell, and the size is the number of basis functions in the shell.
















      ..
          !! processed by numpydoc !!


   .. py:property:: shell_offsets
      :type: list[int]


      
      Returns a vector of the indices of the first basis function in each shell. The last element is the total number of basis functions in the basis set.
















      ..
          !! processed by numpydoc !!


   .. py:property:: center_first_and_last
      :type: list[tuple[int, int]]


      
      Returns a vector of pairs of the first and last index of the basis functions on a given center in the basis set.
















      ..
          !! processed by numpydoc !!


   .. py:property:: center_first_and_last_shell
      :type: list[tuple[int, int]]


      
      Returns a vector of pairs of the first and last index of the shells on a given center in the basis set.
















      ..
          !! processed by numpydoc !!


   .. py:property:: size
      :type: int


      
      Returns the number of basis functions in the basis set
















      ..
          !! processed by numpydoc !!


   .. py:property:: max_l
      :type: int


      
      Returns the maximum angular momentum of the shells in the basis set
















      ..
          !! processed by numpydoc !!


   .. py:property:: name
      :type: str


      
      Returns the name of the basis set
















      ..
          !! processed by numpydoc !!


   .. py:property:: max_nprim
      :type: int


      
      Returns the maximum number of primitive Gaussians in shells of the basis set
















      ..
          !! processed by numpydoc !!


   .. py:property:: nprim
      :type: int


      
      Returns the number of primitive Gaussians in shells of the basis set
















      ..
          !! processed by numpydoc !!


   .. py:property:: max_nbasis
      :type: int


      
      Returns the maximum number of basis functions in shells of the basis set
















      ..
          !! processed by numpydoc !!


   .. py:property:: nshells
      :type: int


      
      Returns the number of shells in the basis set
















      ..
          !! processed by numpydoc !!


.. py:function:: shell_label(l: int, idx: int) -> str

   
   Returns a label for a given angular momentum (l) and index (idx).
















   ..
       !! processed by numpydoc !!

.. py:function:: evaluate_shell(shell: Shell, point: collections.abc.Sequence[float]) -> list[float]

   
   Evaluate the shell at a given point. Returns a list of values for each basis function.
















   ..
       !! processed by numpydoc !!

.. py:function:: nuclear_repulsion(charges: collections.abc.Sequence[tuple[float, collections.abc.Sequence[float]]]) -> float

.. py:function:: overlap(basis1: Basis, basis2: Basis) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]
                 overlap(basis: Basis) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]

.. py:function:: kinetic(basis1: Basis, basis2: Basis) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]
                 kinetic(basis: Basis) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]

.. py:function:: nuclear(basis1: Basis, basis2: Basis, charges: collections.abc.Sequence[tuple[float, collections.abc.Sequence[float]]]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]
                 nuclear(basis: Basis, charges: collections.abc.Sequence[tuple[float, collections.abc.Sequence[float]]]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]

.. py:function:: emultipole1(basis1: Basis, basis2: Basis, origin: collections.abc.Sequence[float] = [0.0, 0.0, 0.0]) -> list[Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]]
                 emultipole1(basis: Basis, origin: collections.abc.Sequence[float] = [0.0, 0.0, 0.0]) -> list[Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]]

.. py:function:: emultipole2(basis1: Basis, basis2: Basis, origin: collections.abc.Sequence[float] = [0.0, 0.0, 0.0]) -> list[Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]]
                 emultipole2(basis: Basis, origin: collections.abc.Sequence[float] = [0.0, 0.0, 0.0]) -> list[Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]]

.. py:function:: emultipole3(basis1: Basis, basis2: Basis, origin: collections.abc.Sequence[float] = [0.0, 0.0, 0.0]) -> list[Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]]
                 emultipole3(basis: Basis, origin: collections.abc.Sequence[float] = [0.0, 0.0, 0.0]) -> list[Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]]

.. py:function:: opVop(basis1: Basis, basis2: Basis, charges: collections.abc.Sequence[tuple[float, collections.abc.Sequence[float]]]) -> list[Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]]
                 opVop(basis: Basis, charges: collections.abc.Sequence[tuple[float, collections.abc.Sequence[float]]]) -> list[Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]]

.. py:function:: erf_nuclear(basis1: Basis, basis2: Basis, omega_charges: std::__1::tuple<double, std::__1::vector<std::__1::pair<double, std::__1::array<double, 3ul>>, std::__1::allocator<std::__1::pair<double, std::__1::array<double, 3ul>>>>>) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]

.. py:function:: erfc_nuclear(basis1: Basis, basis2: Basis, omega_charges: std::__1::tuple<double, std::__1::vector<std::__1::pair<double, std::__1::array<double, 3ul>>, std::__1::allocator<std::__1::pair<double, std::__1::array<double, 3ul>>>>>) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]

.. py:function:: overlap_deriv(basis1: Basis, basis2: Basis, dm: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))], charges: collections.abc.Sequence[tuple[float, collections.abc.Sequence[float]]]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]

.. py:function:: kinetic_deriv(basis1: Basis, basis2: Basis, dm: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))], charges: collections.abc.Sequence[tuple[float, collections.abc.Sequence[float]]]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]

.. py:function:: nuclear_deriv(basis1: Basis, basis2: Basis, dm: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))], charges: collections.abc.Sequence[tuple[float, collections.abc.Sequence[float]]]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]

.. py:function:: coulomb_4c(basis1: Basis, basis2: Basis, basis3: Basis, basis4: Basis) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None, None))]
                 coulomb_4c(basis: Basis) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None, None))]

.. py:function:: coulomb_3c(basis1: Basis, basis2: Basis, basis3: Basis) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None))]

.. py:function:: coulomb_3c_by_shell(basis1: Basis, basis2: Basis, basis3: Basis, shell_slices: collections.abc.Sequence[tuple[int, int]]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None), order='C')]
                 coulomb_3c_by_shell(basis1: Basis, basis2: Basis, basis3: Basis, shell_slices: collections.abc.Sequence[tuple[int, int]], buffer: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None), order='C')]) -> None

.. py:function:: coulomb_2c(basis1: Basis, basis2: Basis) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]
                 coulomb_2c(basis: Basis) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]

.. py:function:: erf_coulomb_3c(basis1: Basis, basis2: Basis, basis3: Basis, omega: float) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None))]

.. py:function:: erf_coulomb_2c(basis1: Basis, basis2: Basis, omega: float) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]

.. py:function:: erfc_coulomb_3c(basis1: Basis, basis2: Basis, basis3: Basis, omega: float) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None))]

.. py:function:: erfc_coulomb_2c(basis1: Basis, basis2: Basis, omega: float) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]

.. py:function:: basis_at_points(basis: Basis, points: collections.abc.Sequence[collections.abc.Sequence[float]]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]

.. py:function:: orbitals_at_points(basis: Basis, points: collections.abc.Sequence[collections.abc.Sequence[float]], C: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]

   
   Evaluate the orbitals on a set of points. Returns a 2D array of shape (npoints, norb).
















   ..
       !! processed by numpydoc !!

.. py:function:: orbitals_on_grid(basis: Basis, C: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))], min: collections.abc.Sequence[float], npoints: collections.abc.Sequence[int], axis: collections.abc.Sequence[collections.abc.Sequence[float]]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None))]

.. py:function:: cint_int1e_ovlp_sph(shell_slice: collections.abc.Sequence[int], atm: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], bas: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], env: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None), order='C')]

   
   Compute the overlap integral matrix using libcint in spherical harmonics.
















   ..
       !! processed by numpydoc !!

.. py:function:: cint_int1e_ovlp_spinor(shell_slice: collections.abc.Sequence[int], atm: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], bas: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], env: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]) -> Annotated[numpy.typing.NDArray[numpy.complex128], dict(shape=(None, None, None), order='C')]

   
   Compute the overlap integral matrix using libcint in spinor basis.
















   ..
       !! processed by numpydoc !!

.. py:function:: cint_int1e_kin_sph(shell_slice: collections.abc.Sequence[int], atm: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], bas: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], env: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None), order='C')]

   
   Compute the kinetic energy integral matrix using libcint in spherical harmonics.
















   ..
       !! processed by numpydoc !!

.. py:function:: cint_int1e_kin_spinor(shell_slice: collections.abc.Sequence[int], atm: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], bas: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], env: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]) -> Annotated[numpy.typing.NDArray[numpy.complex128], dict(shape=(None, None, None), order='C')]

   
   Compute the kinetic energy integral matrix using libcint in spinor basis.
















   ..
       !! processed by numpydoc !!

.. py:function:: cint_int1e_nuc_sph(shell_slice: collections.abc.Sequence[int], atm: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], bas: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], env: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None), order='C')]

   
   Compute the nuclear attraction integral matrix using libcint in spherical harmonics.
















   ..
       !! processed by numpydoc !!

.. py:function:: cint_int1e_nuc_spinor(shell_slice: collections.abc.Sequence[int], atm: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], bas: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], env: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]) -> Annotated[numpy.typing.NDArray[numpy.complex128], dict(shape=(None, None, None), order='C')]

   
   Compute the nuclear attraction integral matrix using libcint in spinor basis.
















   ..
       !! processed by numpydoc !!

.. py:function:: cint_int1e_spnucsp_sph(shell_slice: collections.abc.Sequence[int], atm: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], bas: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], env: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None), order='C')]

   
   Compute the small component of the nuclear attraction integral matrix using libcint in spherical harmonics.
















   ..
       !! processed by numpydoc !!

.. py:function:: cint_int1e_spnucsp_spinor(shell_slice: collections.abc.Sequence[int], atm: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], bas: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], env: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]) -> Annotated[numpy.typing.NDArray[numpy.complex128], dict(shape=(None, None, None), order='C')]

   
   Compute the small component of the nuclear attraction integral matrix using libcint in spinor basis.
















   ..
       !! processed by numpydoc !!

.. py:function:: cint_int1e_r_sph(shell_slice: collections.abc.Sequence[int], atm: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], bas: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], env: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None), order='C')]

   
   Compute the dipole integral matrix using libcint in spherical harmonics.
















   ..
       !! processed by numpydoc !!

.. py:function:: cint_int2c2e_sph(shell_slice: collections.abc.Sequence[int], atm: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], bas: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], env: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None), order='C')]

   
   Compute the two-center two-electron integral matrix using libcint in spherical harmonics.
















   ..
       !! processed by numpydoc !!

.. py:function:: cint_int3c2e_sph(shell_slice: collections.abc.Sequence[int], atm: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], bas: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], env: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None), order='C')]
                 cint_int3c2e_sph(shell_slice: collections.abc.Sequence[int], atm: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], bas: Annotated[numpy.typing.NDArray[numpy.int32], dict(shape=(None, None))], env: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, ))], ints: Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None), order='C')]) -> Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=(None, None, None), order='C')]

   
   Compute the three-center two-electron integral tensor using libcint in spherical harmonics, with a user-provided buffer for the result.
















   ..
       !! processed by numpydoc !!

.. py:data:: HAS_LIBCINT
   :type:  bool
   :value: True


.. py:data:: libint2_max_am
   :type:  int
   :value: 6