FCIDump files

Read and write fcidump format integrals. Individual arrays of integrals can also be in *.npy format

FDump{N}

Molecular integrals

The 2-e integrals are stored in the physicists' notation: int2[pqrs] $= <pq|rs>=v_{pq}^{rs}$

N denotes the number of indices in the 2-e-integral tensors, for N=3 (usual) the last two indices are stored as a single uppertriangular index (r <= s)

• int2::Array{Float64}: 2-e⁻ integrals for restricted orbitals fcidump.

• int2aa::Array{Float64}: αα 2-e⁻ integrals for unrestricted orbitals fcidump.

• int2bb::Array{Float64}: ββ 2-e⁻ integrals for unrestricted orbitals fcidump.

• int2ab::Array{Float64, 4}: αβ 2-e⁻ integrals for unrestricted orbitals fcidump.

• int1::Matrix{Float64}: 1-e⁻ integrals for restricted orbitals fcidump.

• int1a::Matrix{Float64}: α 1-e⁻ integrals for unrestricted orbitals fcidump.

• int1b::Matrix{Float64}: β 1-e⁻ integrals for unrestricted orbitals fcidump.

• int0::Float64: core energy

• head::ElemCo.FciDumps.FDumpHeader: header of fcidump file, a dictionary of arrays.

• uhf::Bool: ⟨false⟩ a convinience variable, has to coincide with head["IUHF"][1] > 0.

fd_exists(fd::FDump)

Return true if the object is a non-empty FDump

headvar(fd::FDump, key::String)

Check header for key, return value if a list, or the element or nothing if not there.

headvar(head::FDumpHeader, key::String)

Check header for key, return value if a list, or the element or nothing if not there.

headvar(fd::FDump, key::String, ::Type{T}) where {T}

Check header for key, return the first element or nothing if not there.

headvar(head::FDumpHeader, key::String, ::Type{T}) where {T}

Check header for key of type T, return the first element or nothing if not there.

headvars(fd::FDump, key::String, ::Type{T}) where {T}

Check header for key, return a vector of values or nothing if not there.

headvars(head::FDumpHeader, key::String, ::Type{T}) where {T}

Check header for key of type T, return a vector of values or nothing if not there.

int1_npy_filename(fd::FDump, spincase::Symbol=:α)

Return filename for 1-e integrals in npy format. spincase can be :α or :β for UHF fcidump.

int2_npy_filename(fd::FDump, spincase::Symbol=:α)

Return filename for 2-e integrals in npy format. spincase can be :α, :β or :αβ for UHF fcidump.

integ1(fd::FDump, spincase::Symbol=:α)

Return 1-e⁻ integrals (for UHF fcidump: for spincase). spincase can be :α or :β.

integ2(fd::FDump, spincase::Symbol=:α)

Return 2-e⁻ integrals (for UHF fcidump: for spincase). spincase can be :α, :β or :αβ.

Use type-stable versions instead: integ2_ss for same-spin integrals and integ2_os for opposite-spin integrals.

integ2_os(fd::FDump)

Return αβ 2-e⁻ integrals for UHF fcidump

integ2_ss(fd::FDump, spincase::Symbol=:α)

Return 2-e⁻ integrals (for UHF fcidump: for spincase). spincase can be :α or :β.

modify_header!(fd::FDump, norb, nelec; ms2=-1, isym=-1, orbsym=[])

Modify header of FDump object

read_fcidump(fcidump::String)

Read ascii file (possibly with integrals in npy files) to TFDump object.

read_fcidump(fcidump::String, ::Val{N})

Read ascii file (possibly with integrals in npy files).

reorder_orbs_int2(int2::AbstractArray, orbs)

Reorder orbitals in 2-e integrals according to orbs.

orbscan be a subset of orbitals or a permutation of orbitals. Return int2[orbs[p],orbs[q],orbs[r],orbs[s]] or the triangular version.

transform_fcidump(fd::FDump, Tl::AbstractArray, Tr::AbstractArray)

Transform integrals to new basis using Tl and Tr transformation matrices. For UHF fcidump, Tl and Tr are arrays of matrices for α and β spin. If Tl and Tr are arrays of arrays, then the function transforms rhf fcidump to uhf fcidump.

write_fcidump(fd::FDump, fcidump::String, tol=1e-12)

Write fcidump file.

FDumpHeader

Header of fcidump file

is_triang(fd::FDump)

If true: an uppertriangular index for last two indices of 2e⁻ integrals is used.

mmap_integrals(fd::FDump, dir::AbstractString, key::AbstractString, ::Array{T,N})

Memory-map integral file (from head[key])

print_int_value(fdf, integ, i1, i2, i3, i4)

Print integral value to fdf file.

read_header(fdfile::IOStream)

Read header of fcidump file.

read_integrals!(fd::FDump, dir::AbstractString)

Read integrals from npy files.

read_integrals!(fd::FDump{N}, fdfile::IOStream)

Read integrals from fcidump file

set_int2!(int2::Array{Float64,3}, i1, i2, i3, i4, integ, simtra, ab)

Set 2-e integral in int2 array to integ considering permutational symmetries.

For not ab: particle symmetry is assumed. Integrals are stored in physicists' notation.

set_int2!(int2::Array{Float64,4}, i1, i2, i3, i4, integ, simtra, ab)

Set 2-e integral in int2 array to integ considering permutational symmetries.

For not ab: particle symmetry is assumed. Integrals are stored in physicists' notation.

set_zero!(fd::FDump, norb::Int=0)

Set all integrals to zero.

If norb is not provided, the integrals are set to zero with the same dimensions as before.

transform_int1(int1::AbstractArray, Tl::AbstractArray,  Tr::AbstractArray)

Transform 1-e integrals to new basis using Tl and Tr transformation matrices.

transform_int2(int2::Array{Float64,3}, Tl::AbstractArray, Tl2::AbstractArray, 
               Tr::AbstractArray, Tr2::AbstractArray)

Transform 2-e integrals to new basis using Tl/Tl2 and Tr/Tr2 transformation matrices.

$v_{pq}^{rs} = v_{p'q'}^{r's'}$* Tl[p',p] * Tl2[q',q] * Tr[r',r] * Tr2[s',s]

The last two indices are stored as a single uppertriangular index.

transform_int2_Q(int2::Array{Float64,3}, Tl::AbstractArray, Tl2::AbstractArray, 
               Tr::AbstractArray, Tr2::AbstractArray)

Transform 2-e integrals to new basis using Tl/Tl2 and Tr/Tr2 transformation matrices.

$v_{pq}^{rs} = v_{p'q'}^{r's'}$* Tl[p',p] * Tl2[q',q] * Tr[r',r] * Tr2[s',s]

The result is a full 4-index tensor.

write_header(fd::FDump, fdf)

Write header of fcidump file.

write_integrals(fd::FDump, fdf, tol)

Write integrals to fdf file.

write_integrals1(int1, fdf, tol, simtra)

Write 1-e integrals to fdf file.

write_integrals2(int2::Array{Float64,3}, fdf, tol, simtra)

Write 2-e integrals to fdf file.