Molecular system

ElemCo.MSystemModule

Info about molecular system (geometry/basis).

Atom and FlexibleSystem from AtomsBase package are used for the atoms and the molecular system, respectively.

The molecular system is the core of the simulation. It contains all the information about the molecule, including the geometry and basis sets The molecular system is defined using the MSys function:

MSys(geometry, basis)

where geometry is a string containing the molecular geometry in the XYZ format, and basis is a dictionary containing the basis set information.

Geometry

The geometry of the molecule is defined using the geometry argument of the MSys function. The geometry is defined in the XYZ format. Here's an example of how you can define the geometry of a water molecule:

geometry="bohr
     O      0.000000000    0.000000000   -0.130186067
     H1     0.000000000    1.489124508    1.033245507
     H2     0.000000000   -1.489124508    1.033245507"

The first line of the geometry string contains the units of the coordinates. The supported units are bohr and angstrom. The coordinates of the atoms are specified in the following lines. Each line contains the atomic symbol and the coordinates of the atom. The coordinates are separated by spaces or tabs.

Basis set

The basis set is defined using the basis argument of the MSys function. The basis set is defined as a dictionary, where the keys are the names of the basis sets, and the values are the basis set definitions. Here's an example of how you can define the basis set for a water molecule:

basis = Dict("ao"=>"cc-pVDZ",
             "jkfit"=>"cc-pvtz-jkfit",
             "mp2fit"=>"cc-pvdz-rifit")

The basis set dictionary contains three keys: ao, jkfit, and mp2fit. The ao key contains the basis set for the AO integrals, the jkfit key contains the basis set for the density fitting integrals in the Hartree-Fock calculations, and the mp2fit key contains the fitting basis set for the correlated calculations.

Exported functions and types

ElemCo.MSystem.electron_distributionMethod
electron_distribution(elem::AbstractString, nsh4l::Vector{Int})

Distribute electrons among first atomic orbitals in nsh4l[1]s nsh4l[2]p nsh4l[3]d nsh4l[4]f... order considering the Hund's rule and electron configuration of the atom. Average occupations to account for the spin degeneracy and hybridization.

ElemCo.MSystem.electron_distributionMethod
electron_distribution(elnam::AbstractString, minbas::AbstractString)

Return the averaged number of electrons in the orbitals in the minimal basis set.

Number of orbitals in the minimal basis set has to be specified in minbas.jl.

ElemCo.MSystem.generate_basisFunction
generate_basis(ms::AbstractSystem, type = "ao")

Generate basis sets for integral calculations. type can be "ao", "mp2fit" or "jkfit".

ElemCo.MSystem.genxyzMethod
genxyz(ms::AbstractSystem; unit=u"angstrom")

Generate xyz string with elements without numbers.

ElemCo.MSystem.genxyzMethod
genxyz(ac::Atom; unit=u"angstrom")

Generate xyz string with element without numbers.

ElemCo.MSystem.parse_geometryMethod
parse_geometry(geometry::AbstractString, basis::Dict)

Parse geometry geometry and return FlexibleSystem object. The geometry can be in xyz format or in a file. The basis set can be defined for each element in the geometry.

Internal functions and types

ElemCo.MSystem.SubShellType

Occupation of the subshell with quantum numbers $n$ and $l$.

  • n::Int64: $n$-quantum number of the subshell.

  • l::Int64: $l$-quantum number of the subshell.

  • nel::Int64: Number of electrons in the subshell.

ElemCo.MSystem.basis_name_ABFunction
basis_name_AB(atoms, type="ao")

Return the name of the basis set. atoms can be a single atom ::Atom or a system ::AbstractSystem.

ElemCo.MSystem.genbasis4elementMethod
genbasis4element(basis::Dict,elem::AbstractString)

Set element specific basis from, e.g., Dict("ao"=>"cc-pVDZ; o=aug-cc-pVDZ","jkfit"=>"cc-pvdz-jkfit")

ElemCo.MSystem.guess_noccMethod
guess_nocc(ms::AbstractSystem)

Guess the number of alpha and beta occupied orbitals in the neutral system.

ElemCo.MSystem.ncoreorbsFunction
ncoreorbs(elem::AbstractString, coretype::Symbol=:large)

Guess the number of core orbitals in the element.

coretype:

  • :large - large core (w/o semi-core)
  • :small - small core (w/ semi-core)
  • :none - no core
ElemCo.MSystem.nshell4l_minbasMethod
nshell4l_minbas(nnum, basis::String)

Return the number of shells for each angular momentum in the minimal basis set.

ElemCo.MSystem.parse_electron_configurationMethod
parse_electron_configuration(e::AbstractString)

Parse the electron configuration string and return the number of electrons in each subshell. e.g. "[He] 2s^2 2p^6 3s^2 3p^6" -> [SubShell(1,0,2), SubShell(2,0,2), SubShell(2,1,6), SubShell(3,0,2), SubShell(3,1,6)]

ElemCo.MSystem.parse_xyz_geometryMethod
parse_xyz_geometry(xyz_lines::AbstractArray, basis::Dict)

Parse xyz geometry xyz_lines stored as a vector of strings. Return array of Atoms and an empty string in case of success.

Empty lines are skipped. The default units are bohr. If the line is bohr or angstrom: change the units. If the first line is a number: assume xyz format and skip the second line (in this case, the default units are angstroms). If parsing fails: return empty array and the line that failed.

ElemCo.MSystem.try2create_atomFunction
try2create_atom(line::AbstractString, basis::Dict, unit=u"bohr")

Create Atom from a line <Atom> x y z.

unit is the unit of the coordinates. Returns the center and a bool success variable. If the line has a different format: return dummy center and false.