forte2._forte2.ints

Module Contents

class forte2._forte2.ints.Shell

class forte2._forte2.ints.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)

property size: int

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

property ncontr: int

The number of contractions in the shell.

property nprim: int

The number of primitive Gaussians in the shell.

property l: int

The angular momentum of the shell.

property coeff: list[float]

The coefficients of the primitives in the shell.

property exponents: list[float]

The exponents of the primitives in the shell.

property is_pure: bool

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

property center: list[float]

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

class forte2._forte2.ints.Basis

add(shell: Shell) → None

set_name(name: str) → None

serialize() → dict

Serialize the basis set to a dictionary.

property shell_first_and_size: 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.

property shell_offsets: 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.

property center_first_and_last: 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.

property center_first_and_last_shell: 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.

property size: int

Returns the number of basis functions in the basis set

property max_l: int

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

property name: str

Returns the name of the basis set

property max_nprim: int

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

property nprim: int

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

property max_nbasis: int

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

property nshells: int

Returns the number of shells in the basis set

forte2._forte2.ints.shell_label(l: int, idx: int) → str

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

forte2._forte2.ints.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.

forte2._forte2.ints.nuclear_repulsion(charges: collections.abc.Sequence[tuple[float, collections.abc.Sequence[float]]]) → float

forte2._forte2.ints.overlap(basis1: Basis, basis2: Basis) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None)]

forte2._forte2.ints.overlap(basis: Basis) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None)]

forte2._forte2.ints.kinetic(basis1: Basis, basis2: Basis) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None)]

forte2._forte2.ints.kinetic(basis: Basis) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None)]

forte2._forte2.ints.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)]

forte2._forte2.ints.nuclear(basis: Basis, charges: collections.abc.Sequence[tuple[float, collections.abc.Sequence[float]]]) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None)]

forte2._forte2.ints.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)]]

forte2._forte2.ints.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)]]

forte2._forte2.ints.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)]]

forte2._forte2.ints.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)]]

forte2._forte2.ints.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)]]

forte2._forte2.ints.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)]]

forte2._forte2.ints.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)]]

forte2._forte2.ints.opVop(basis: Basis, charges: collections.abc.Sequence[tuple[float, collections.abc.Sequence[float]]]) → list[Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None)]]

forte2._forte2.ints.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)]

forte2._forte2.ints.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)]

forte2._forte2.ints.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)]

forte2._forte2.ints.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)]

forte2._forte2.ints.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)]

forte2._forte2.ints.coulomb_4c(basis1: Basis, basis2: Basis, basis3: Basis, basis4: Basis) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None, None, None)]

forte2._forte2.ints.coulomb_4c(basis: Basis) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None, None, None)]

forte2._forte2.ints.coulomb_3c(basis1: Basis, basis2: Basis, basis3: Basis) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None, None)]

forte2._forte2.ints.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')]

forte2._forte2.ints.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

forte2._forte2.ints.coulomb_2c(basis1: Basis, basis2: Basis) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None)]

forte2._forte2.ints.coulomb_2c(basis: Basis) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None)]

forte2._forte2.ints.erf_coulomb_3c(basis1: Basis, basis2: Basis, basis3: Basis, omega: float) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None, None)]

forte2._forte2.ints.erf_coulomb_2c(basis1: Basis, basis2: Basis, omega: float) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None)]

forte2._forte2.ints.erfc_coulomb_3c(basis1: Basis, basis2: Basis, basis3: Basis, omega: float) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None, None)]

forte2._forte2.ints.erfc_coulomb_2c(basis1: Basis, basis2: Basis, omega: float) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None)]

forte2._forte2.ints.basis_at_points(basis: Basis, points: collections.abc.Sequence[collections.abc.Sequence[float]]) → Annotated[numpy.typing.NDArray[numpy.float64], dict(shape=None, None)]

forte2._forte2.ints.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).

forte2._forte2.ints.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)]

forte2._forte2.ints.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.

forte2._forte2.ints.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.

forte2._forte2.ints.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.

forte2._forte2.ints.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.

forte2._forte2.ints.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.

forte2._forte2.ints.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.

forte2._forte2.ints.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.

forte2._forte2.ints.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.

forte2._forte2.ints.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.

forte2._forte2.ints.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.

forte2._forte2.ints.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')]

forte2._forte2.ints.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.

forte2._forte2.ints.HAS_LIBCINT: bool = True

forte2._forte2.ints.libint2_max_am: int = 6