def kernel(s1, s2, s12, orbocc):
"""Make IAOs for a molecule or single k-point."""
s21 = s12.conj().T
# Minimal basis CD is not expected to fail
s2cd = scipy.linalg.cho_factor(s2)
ctild = scipy.linalg.cho_solve(s2cd, numpy.dot(s21, orbocc))
# Try Cholesky of computational basis first
try:
s1cd = scipy.linalg.cho_factor(s1)
p12 = scipy.linalg.cho_solve(s1cd, s12)
ctild = scipy.linalg.cho_solve(s1cd, numpy.dot(s12, ctild))
# For overcomplete basis sets, use eigendecomposition + canonical orthogonalization instead
except numpy.linalg.LinAlgError:
se, sv = numpy.linalg.eigh(s1)
logger.debug(
mol,
"Cholesky decomp. of overlap S failed; removing %d eigenvectors of S with eigenvalues below %.2e",
numpy.count_nonzero(se < lindep_threshold), lindep_threshold)
keep = (se >= lindep_threshold)
invS = numpy.einsum("ai,i,bi->ab", sv[:, keep], 1 / se[keep],
sv[:, keep])
p12 = numpy.dot(invS, s12)
ctild = numpy.dot(p12, ctild)
ctild = vec_lowdin(ctild, s1)
ccs1 = reduce(numpy.dot, (orbocc, orbocc.conj().T, s1))
ccs2 = reduce(numpy.dot, (ctild, ctild.conj().T, s1))
#a is the set of IAOs in the original basis
a = (p12 + reduce(numpy.dot, (ccs1, ccs2, p12)) * 2 -
numpy.dot(ccs1, p12) - numpy.dot(ccs2, p12))
return a
def make_iaos(s1, s2, s12, mo):
"""Make IAOs for a molecule or single k-point"""
s21 = s12.conj().T
# s2 is overlap in minimal reference basis and should never be singular:
s2cd = scipy.linalg.cho_factor(s2)
ctild = scipy.linalg.cho_solve(s2cd, numpy.dot(s21, mo))
try:
s1cd = scipy.linalg.cho_factor(s1)
p12 = scipy.linalg.cho_solve(s1cd, s12)
ctild = scipy.linalg.cho_solve(s1cd, numpy.dot(s12, ctild))
# s1 can be singular in large basis sets: Use canonical orthogonalization in this case:
except numpy.linalg.LinAlgError:
x = scf.addons.canonical_orth_(s1, lindep_threshold)
p12 = numpy.linalg.multi_dot((x, x.conj().T, s12))
ctild = numpy.dot(p12, ctild)
# If there are no occupied orbitals at this k-point, all but the first term will vanish:
if mo.shape[-1] == 0:
return p12
ctild = vec_lowdin(ctild, s1)
ccs1 = numpy.linalg.multi_dot((mo, mo.conj().T, s1))
ccs2 = numpy.linalg.multi_dot((ctild, ctild.conj().T, s1))
#a is the set of IAOs in the original basis
a = (p12 + 2 * numpy.linalg.multi_dot(
(ccs1, ccs2, p12)) - numpy.dot(ccs1, p12) - numpy.dot(ccs2, p12))
return a
def vvo(mol, orbocc, orbvirt, iaos=None, s=None, verbose=logger.NOTE):
'''Valence Virtual Orbitals ref. 10.1021/acs.jctc.7b00493
Valence virtual orbitals can be formed from the singular value
decomposition of the overlap between the canonical molecular orbitals
and an accurate underlying atomic basis set. This implementation uses
the intrinsic atomic orbital as this underlying set. VVOs can also be
formed from the null space of the overlap of the canonical molecular
orbitals and the underlying atomic basis sets (IAOs). This is not
implemented here.
Args:
mol : the molecule or cell object
orbocc : occupied molecular orbital coefficients
orbvirt : virtual molecular orbital coefficients
Kwargs:
iaos : 2D array
the array of IAOs
s : 2D array
the overlap array in the ao basis
Returns:
VVOs in the basis defined in mol object.
'''
log = logger.new_logger(mol, verbose)
if s is None:
if getattr(mol, 'pbc_intor', None): # whether mol object is a cell
if isinstance(orbocc, numpy.ndarray) and orbocc.ndim == 2:
s = mol.pbc_intor('int1e_ovlp', hermi=1)
else:
raise NotImplementedError('k-points crystal orbitals')
else:
s = mol.intor_symmetric('int1e_ovlp')
if iaos is None:
iaos = iao.iao(mol, orbocc)
nvvo = iaos.shape[1] - orbocc.shape[1]
# Symmetrically orthogonalization of the IAO orbitals as Knizia's
# implementation. The IAO returned by iao.iao function is not orthogonal.
iaos = orth.vec_lowdin(iaos, s)
#S = reduce(np.dot, (orbvirt.T, s, iaos))
S = numpy.einsum('ji,jk,kl->il', orbvirt, s, iaos, optimize=True)
U, sigma, Vh = scipy.linalg.svd(S)
U = U[:, 0:nvvo]
vvo = numpy.einsum('ik,ji->jk', U, orbvirt, optimize=True)
return vvo
def test_orth(self):
numpy.random.seed(10)
n = 100
a = numpy.random.random((n,n))
s = numpy.dot(a.T, a)
c = orth.lowdin(s)
self.assertTrue(numpy.allclose(reduce(numpy.dot, (c.T, s, c)),
numpy.eye(n)))
x1 = numpy.dot(a, c)
x2 = orth.vec_lowdin(a)
d = numpy.dot(x1.T,x2)
d[numpy.diag_indices(n)] = 0
self.assertAlmostEqual(numpy.linalg.norm(d), 0, 9)
self.assertAlmostEqual(numpy.linalg.norm(c), 36.56738258719514, 9)
self.assertAlmostEqual(abs(c).sum(), 2655.5580057303964, 7)
def test_orth(self):
numpy.random.seed(10)
n = 100
a = numpy.random.random((n, n))
s = numpy.dot(a.T, a)
c = orth.lowdin(s)
self.assertTrue(
numpy.allclose(reduce(numpy.dot, (c.T, s, c)), numpy.eye(n)))
x1 = numpy.dot(a, c)
x2 = orth.vec_lowdin(a)
d = numpy.dot(x1.T, x2)
d[numpy.diag_indices(n)] = 0
self.assertAlmostEqual(numpy.linalg.norm(d), 0, 9)
self.assertAlmostEqual(numpy.linalg.norm(c), 36.56738258719514, 9)
self.assertAlmostEqual(abs(c).sum(), 2655.5580057303964, 7)
def iao(mol, orbocc, minao=MINAO, kpts=None):
'''Intrinsic Atomic Orbitals. [Ref. JCTC, 9, 4834]
Args:
mol : the molecule or cell object
orbocc : 2D array
occupied orbitals
Returns:
non-orthogonal IAO orbitals. Orthogonalize them as C (C^T S C)^{-1/2},
eg using :func:`orth.lowdin`
>>> orbocc = mf.mo_coeff[:,mf.mo_occ>0]
>>> c = iao(mol, orbocc)
>>> numpy.dot(c, orth.lowdin(reduce(numpy.dot, (c.T,s,c))))
'''
if mol.has_ecp():
logger.warn(
mol,
'ECP/PP is used. MINAO is not a good reference AO basis in IAO.')
pmol = reference_mol(mol, minao)
# For PBC, we must use the pbc code for evaluating the integrals lest the
# pbc conditions be ignored.
# DO NOT import pbcgto early and check whether mol is a cell object.
# "from pyscf.pbc import gto as pbcgto and isinstance(mol, pbcgto.Cell)"
# The code should work even pbc module is not availabe.
if getattr(mol, 'pbc_intor', None): # cell object has pbc_intor method
from pyscf.pbc import gto as pbcgto
s1 = numpy.asarray(mol.pbc_intor('int1e_ovlp', hermi=1, kpts=kpts))
s2 = numpy.asarray(pmol.pbc_intor('int1e_ovlp', hermi=1, kpts=kpts))
s12 = numpy.asarray(
pbcgto.cell.intor_cross('int1e_ovlp', mol, pmol, kpts=kpts))
else:
#s1 is the one electron overlap integrals (coulomb integrals)
s1 = mol.intor_symmetric('int1e_ovlp')
#s2 is the same as s1 except in minao
s2 = pmol.intor_symmetric('int1e_ovlp')
#overlap integrals of the two molecules
s12 = gto.mole.intor_cross('int1e_ovlp', mol, pmol)
if len(s1.shape) == 2:
s21 = s12.conj().T
s1cd = scipy.linalg.cho_factor(s1)
s2cd = scipy.linalg.cho_factor(s2)
p12 = scipy.linalg.cho_solve(s1cd, s12)
ctild = scipy.linalg.cho_solve(s2cd, numpy.dot(s21, orbocc))
ctild = scipy.linalg.cho_solve(s1cd, numpy.dot(s12, ctild))
ctild = vec_lowdin(ctild, s1)
ccs1 = reduce(numpy.dot, (orbocc, orbocc.conj().T, s1))
ccs2 = reduce(numpy.dot, (ctild, ctild.conj().T, s1))
#a is the set of IAOs in the original basis
a = (p12 + reduce(numpy.dot, (ccs1, ccs2, p12)) * 2 -
numpy.dot(ccs1, p12) - numpy.dot(ccs2, p12))
else: # k point sampling
s21 = numpy.swapaxes(s12, -1, -2).conj()
nkpts = len(kpts)
a = numpy.zeros((nkpts, s1.shape[-1], s2.shape[-1]),
dtype=numpy.complex128)
for k in range(nkpts):
# ZHC NOTE check the case, at some kpts, there is no occupied MO.
s1cd_k = scipy.linalg.cho_factor(s1[k])
s2cd_k = scipy.linalg.cho_factor(s2[k])
p12_k = scipy.linalg.cho_solve(s1cd_k, s12[k])
ctild_k = scipy.linalg.cho_solve(s2cd_k,
numpy.dot(s21[k], orbocc[k]))
ctild_k = scipy.linalg.cho_solve(s1cd_k,
numpy.dot(s12[k], ctild_k))
ctild_k = vec_lowdin(ctild_k, s1[k])
ccs1_k = reduce(numpy.dot, (orbocc[k], orbocc[k].conj().T, s1[k]))
ccs2_k = reduce(numpy.dot, (ctild_k, ctild_k.conj().T, s1[k]))
#a is the set of IAOs in the original basis
a[k] = (p12_k + reduce(numpy.dot, (ccs1_k, ccs2_k, p12_k)) * 2 -
numpy.dot(ccs1_k, p12_k) - numpy.dot(ccs2_k, p12_k))
return a
def ibo_loc(mol, orbocc, iaos, s, exponent, grad_tol, max_iter,
minao=MINAO, verbose=logger.NOTE):
'''Intrinsic Bonding Orbitals. [Ref. JCTC, 9, 4834]
This implementation follows Knizia's implementation execept that the
resultant IBOs are symmetrically orthogonalized. Note the IBOs of this
implementation do not strictly maximize the IAO Mulliken charges.
IBOs can also be generated by another implementation (see function
pyscf.lo.ibo.PM). In that function, PySCF builtin Pipek-Mezey localization
module was used to maximize the IAO Mulliken charges.
Args:
mol : the molecule or cell object
orbocc : 2D array or a list of 2D array
occupied molecular orbitals or crystal orbitals for each k-point
Kwargs:
iaos : 2D array
the array of IAOs
exponent : integer
Localization power in PM scheme
grad_tol : float
convergence tolerance for norm of gradients
Returns:
IBOs in the big basis (the basis defined in mol object).
'''
log = logger.new_logger(mol, verbose)
assert(exponent in (2, 4))
# Symmetrically orthogonalization of the IAO orbitals as Knizia's
# implementation. The IAO returned by iao.iao function is not orthogonal.
iaos = orth.vec_lowdin(iaos, s)
#static variables
StartTime = logger.perf_counter()
L = 0 # initialize a value of the localization function for safety
#max_iter = 20000 #for some reason the convergence of solid is slower
#fGradConv = 1e-10 #this ought to be pumped up to about 1e-8 but for testing purposes it's fine
swapGradTolerance = 1e-12
#dynamic variables
Converged = False
# render Atoms list without ghost atoms
iao_mol = iao.reference_mol(mol, minao=minao)
Atoms = [iao_mol.atom_pure_symbol(i) for i in range(iao_mol.natm)]
#generates the parameters we need about the atomic structure
nAtoms = len(Atoms)
AtomOffsets = MakeAtomIbOffsets(Atoms)[0]
iAtSl = [slice(AtomOffsets[A],AtomOffsets[A+1]) for A in range(nAtoms)]
#converts the occupied MOs to the IAO basis
CIb = reduce(numpy.dot, (iaos.T, s , orbocc))
numOccOrbitals = CIb.shape[1]
log.debug(" {0:^5s} {1:^14s} {2:^11s} {3:^8s}"
.format("ITER.","LOC(Orbital)","GRADIENT", "TIME"))
for it in range(max_iter):
fGrad = 0.00
#calculate L for convergence checking
L = 0.
for A in range(nAtoms):
for i in range(numOccOrbitals):
CAi = CIb[iAtSl[A],i]
L += numpy.dot(CAi,CAi)**exponent
# loop over the occupied orbitals pairs i,j
for i in range(numOccOrbitals):
for j in range(i):
# I eperimented with exponentially falling off random noise
Aij = 0.0 #numpy.random.random() * numpy.exp(-1*it)
Bij = 0.0 #numpy.random.random() * numpy.exp(-1*it)
for k in range(nAtoms):
CIbA = CIb[iAtSl[k],:]
Cii = numpy.dot(CIbA[:,i], CIbA[:,i])
Cij = numpy.dot(CIbA[:,i], CIbA[:,j])
Cjj = numpy.dot(CIbA[:,j], CIbA[:,j])
#now I calculate Aij and Bij for the gradient search
if exponent == 2:
Aij += 4.*Cij**2 - (Cii - Cjj)**2
Bij += 4.*Cij*(Cii - Cjj)
else:
Bij += 4.*Cij*(Cii**3-Cjj**3)
Aij += -Cii**4 - Cjj**4 + 6*(Cii**2 + Cjj**2)*Cij**2 + Cii**3 * Cjj + Cii*Cjj**3
if (Aij**2 + Bij**2 < swapGradTolerance) and False:
continue
#this saves us from replacing already fine orbitals
else:
#THE BELOW IS TAKEN DIRECLTY FROMG KNIZIA's FREE CODE
# Calculate 2x2 rotation angle phi.
# This correspond to [2] (12)-(15), re-arranged and simplified.
phi = .25*numpy.arctan2(Bij,-Aij)
fGrad += Bij**2
# ^- Bij is the actual gradient. Aij is effectively
# the second derivative at phi=0.
# 2x2 rotation form; that's what PM suggest. it works
# fine, but I don't like the asymmetry.
cs = numpy.cos(phi)
ss = numpy.sin(phi)
Ci = 1. * CIb[:,i]
Cj = 1. * CIb[:,j]
CIb[:,i] = cs * Ci + ss * Cj
CIb[:,j] = -ss * Ci + cs * Cj
fGrad = fGrad**.5
log.debug(" {0:5d} {1:12.8f} {2:11.2e} {3:8.2f}"
.format(it+1, L**(1./exponent), fGrad, logger.perf_counter()-StartTime))
if fGrad < grad_tol:
Converged = True
break
Note = "IB/P%i/2x2, %i iter; Final gradient %.2e" % (exponent, it+1, fGrad)
if not Converged:
log.note("\nWARNING: Iterative localization failed to converge!"
"\n %s", Note)
else:
log.note(" Iterative localization: %s", Note)
log.debug(" Localized orbitals deviation from orthogonality: %8.2e",
numpy.linalg.norm(numpy.dot(CIb.T, CIb) - numpy.eye(numOccOrbitals)))
# Note CIb is not unitary matrix (although very close to unitary matrix)
# because the projection <IAO|OccOrb> does not give unitary matrix.
return numpy.dot(iaos, (orth.vec_lowdin(CIb)))
def atomic_pops(mol, mo_coeff, method='meta_lowdin', mf=None):
'''
Kwargs:
method : string
The atomic population projection scheme. It can be mulliken,
lowdin, meta_lowdin, iao, or becke
Returns:
A 3-index tensor [A,i,j] indicates the population of any orbital-pair
density |i><j| for each species (atom in this case). This tensor is
used to construct the population and gradients etc.
You can customize the PM localization wrt other population metric,
such as the charge of a site, the charge of a fragment (a group of
atoms) by overwriting this tensor. See also the example
pyscf/examples/loc_orb/40-hubbard_model_PM_localization.py for the PM
localization of site-based population for hubbard model.
'''
method = method.lower().replace('_', '-')
nmo = mo_coeff.shape[1]
proj = numpy.empty((mol.natm,nmo,nmo))
if getattr(mol, 'pbc_intor', None): # whether mol object is a cell
s = mol.pbc_intor('int1e_ovlp_sph', hermi=1)
else:
s = mol.intor_symmetric('int1e_ovlp')
if method == 'becke':
from pyscf.dft import gen_grid
if not (getattr(mf, 'grids', None) and getattr(mf, '_numint', None)):
# Call DFT to initialize grids and numint objects
mf = mol.RKS()
grids = mf.grids
ni = mf._numint
if not isinstance(grids, gen_grid.Grids):
raise NotImplementedError('PM becke scheme for PBC systems')
# The atom-wise Becke grids (without concatenated to a vector of grids)
coords, weights = grids.get_partition(mol, concat=False)
for i in range(mol.natm):
ao = ni.eval_ao(mol, coords[i], deriv=0)
aow = numpy.einsum('pi,p->pi', ao, weights[i])
charge_matrix = lib.dot(aow.conj().T, ao)
proj[i] = reduce(lib.dot, (mo_coeff.conj().T, charge_matrix, mo_coeff))
elif method == 'mulliken':
for i, (b0, b1, p0, p1) in enumerate(mol.offset_nr_by_atom()):
csc = reduce(numpy.dot, (mo_coeff[p0:p1].conj().T, s[p0:p1], mo_coeff))
proj[i] = (csc + csc.conj().T) * .5
elif method in ('lowdin', 'meta-lowdin'):
csc = reduce(lib.dot, (mo_coeff.conj().T, s, orth.orth_ao(mol, method, 'ANO', s=s)))
for i, (b0, b1, p0, p1) in enumerate(mol.offset_nr_by_atom()):
proj[i] = numpy.dot(csc[:,p0:p1], csc[:,p0:p1].conj().T)
elif method in ('iao', 'ibo'):
from pyscf.lo import iao
assert mf is not None
# FIXME: How to handle UHF/UKS object?
orb_occ = mf.mo_coeff[:,mf.mo_occ>0]
iao_coeff = iao.iao(mol, orb_occ)
#
# IAO is generally not orthogonalized. For simplicity, we take Lowdin
# orthogonalization here. Other orthogonalization can be used. Results
# should be very closed to the Lowdin-orth orbitals
#
# PM with Mulliken population of non-orth IAOs can be found in
# ibo.PipekMezey function
#
iao_coeff = orth.vec_lowdin(iao_coeff, s)
csc = reduce(lib.dot, (mo_coeff.conj().T, s, iao_coeff))
iao_mol = iao.reference_mol(mol)
for i, (b0, b1, p0, p1) in enumerate(iao_mol.offset_nr_by_atom()):
proj[i] = numpy.dot(csc[:,p0:p1], csc[:,p0:p1].conj().T)
else:
raise KeyError('method = %s' % method)
return proj
mol.symmetry = 1
mol.build()
mf = dft.RKS(mol)
mf.xc = 'HF*0.2 + .08*LDA + .72*B88, .81*LYP + .19*VWN5'
mf.kernel()
orbocc = mf.mo_coeff[:,0:mol.nelec[0]]
orbvirt = mf.mo_coeff[:,mol.nelec[0]:]
mocoeff = mf.mo_coeff
ovlpS = mol.intor_symmetric('int1e_ovlp')
# plot canonical mos
iaos = iao.iao(mol, orbocc)
iaos = orth.vec_lowdin(iaos, ovlpS)
for i in range(iaos.shape[1]):
tools.cubegen.orbital(mol, 'h2o_cmo_{:02d}.cube'.format(i+1), mocoeff[:,i])
# plot intrinsic atomic orbitals
for i in range(iaos.shape[1]):
tools.cubegen.orbital(mol, 'h2o_iao_{:02d}.cube'.format(i+1), iaos[:,i])
# plot intrinsic bonding orbitals
count = 0
ibos = lo.ibo.ibo(mol, orbocc, locmethod='IBO')
for i in range(ibos.shape[1]):
count += 1
tools.cubegen.orbital(mol, 'h2o_ibo_{:02d}.cube'.format(count), ibos[:,i])
# plot valence virtual orbitals and localized valence virtual orbitals
def ibo(mol, orbocc, iaos=None, exponent=4, grad_tol=1e-8, max_iter=200,
verbose=logger.NOTE):
'''Intrinsic Bonding Orbitals. [Ref. JCTC, 9, 4834]
This implementation follows Knizia's implementation execept that the
resultant IBOs are symmetrically orthogonalized. Note the IBOs of this
implementation do not strictly maximize the IAO Mulliken charges.
IBOs can also be generated by another implementation (see function
pyscf.lo.ibo.PM). In that function, PySCF builtin Pipek-Mezey localization
module was used to maximize the IAO Mulliken charges.
Args:
mol : the molecule or cell object
orbocc : 2D array or a list of 2D array
occupied molecular orbitals or crystal orbitals for each k-point
Kwargs:
iaos : 2D array
the array of IAOs
exponent : integer
Localization power in PM scheme
grad_tol : float
convergence tolerance for norm of gradients
Returns:
IBOs in the big basis (the basis defined in mol object).
'''
log = logger.new_logger(mol, verbose)
assert(exponent in (2, 4))
if getattr(mol, 'pbc_intor', None): # whether mol object is a cell
if isinstance(orbocc, numpy.ndarray) and orbocc.ndim == 2:
ovlpS = mol.pbc_intor('int1e_ovlp', hermi=1)
else:
raise NotImplementedError('k-points crystal orbitals')
else:
ovlpS = mol.intor_symmetric('int1e_ovlp')
if iaos is None:
iaos = iao.iao(mol, orbocc)
# Symmetrically orthogonalization of the IAO orbitals as Knizia's
# implementation. The IAO returned by iao.iao function is not orthogonal.
iaos = orth.vec_lowdin(iaos, ovlpS)
#static variables
StartTime = time()
L = 0 # initialize a value of the localization function for safety
#max_iter = 20000 #for some reason the convergence of solid is slower
#fGradConv = 1e-10 #this ought to be pumped up to about 1e-8 but for testing purposes it's fine
swapGradTolerance = 1e-12
#dynamic variables
Converged = False
Atoms = [mol.atom_symbol(i) for i in range(mol.natm)]
#generates the parameters we need about the atomic structure
nAtoms = len(Atoms)
AtomOffsets = MakeAtomIbOffsets(Atoms)[0]
iAtSl = [slice(AtomOffsets[A],AtomOffsets[A+1]) for A in range(nAtoms)]
#converts the occupied MOs to the IAO basis
CIb = reduce(numpy.dot, (iaos.T, ovlpS , orbocc))
numOccOrbitals = CIb.shape[1]
log.debug(" {0:^5s} {1:^14s} {2:^11s} {3:^8s}"
.format("ITER.","LOC(Orbital)","GRADIENT", "TIME"))
for it in range(max_iter):
fGrad = 0.00
#calculate L for convergence checking
L = 0.
for A in range(nAtoms):
for i in range(numOccOrbitals):
CAi = CIb[iAtSl[A],i]
L += numpy.dot(CAi,CAi)**exponent
# loop over the occupied orbitals pairs i,j
for i in range(numOccOrbitals):
for j in range(i):
# I eperimented with exponentially falling off random noise
Aij = 0.0 #numpy.random.random() * numpy.exp(-1*it)
Bij = 0.0 #numpy.random.random() * numpy.exp(-1*it)
for k in range(nAtoms):
CIbA = CIb[iAtSl[k],:]
Cii = numpy.dot(CIbA[:,i], CIbA[:,i])
Cij = numpy.dot(CIbA[:,i], CIbA[:,j])
Cjj = numpy.dot(CIbA[:,j], CIbA[:,j])
#now I calculate Aij and Bij for the gradient search
if exponent == 2:
Aij += 4.*Cij**2 - (Cii - Cjj)**2
Bij += 4.*Cij*(Cii - Cjj)
else:
Bij += 4.*Cij*(Cii**3-Cjj**3)
Aij += -Cii**4 - Cjj**4 + 6*(Cii**2 + Cjj**2)*Cij**2 + Cii**3 * Cjj + Cii*Cjj**3
if (Aij**2 + Bij**2 < swapGradTolerance) and False:
continue
#this saves us from replacing already fine orbitals
else:
#THE BELOW IS TAKEN DIRECLTY FROMG KNIZIA's FREE CODE
# Calculate 2x2 rotation angle phi.
# This correspond to [2] (12)-(15), re-arranged and simplified.
phi = .25*numpy.arctan2(Bij,-Aij)
fGrad += Bij**2
# ^- Bij is the actual gradient. Aij is effectively
# the second derivative at phi=0.
# 2x2 rotation form; that's what PM suggest. it works
# fine, but I don't like the asymmetry.
cs = numpy.cos(phi)
ss = numpy.sin(phi)
Ci = 1. * CIb[:,i]
Cj = 1. * CIb[:,j]
CIb[:,i] = cs * Ci + ss * Cj
CIb[:,j] = -ss * Ci + cs * Cj
fGrad = fGrad**.5
log.debug(" {0:5d} {1:12.8f} {2:11.2e} {3:8.2f}"
.format(it+1, L**(1./exponent), fGrad, time()-StartTime))
if fGrad < grad_tol:
Converged = True
break
Note = "IB/P%i/2x2, %i iter; Final gradient %.2e" % (exponent, it+1, fGrad)
if not Converged:
log.note("\nWARNING: Iterative localization failed to converge!"
"\n %s", Note)
else:
log.note(" Iterative localization: %s", Note)
log.debug(" Localized orbitals deviation from orthogonality: %8.2e",
numpy.linalg.norm(numpy.dot(CIb.T, CIb) - numpy.eye(numOccOrbitals)))
# Note CIb is not unitary matrix (although very close to unitary matrix)
# because the projection <IAO|OccOrb> does not give unitary matrix.
return numpy.dot(iaos, (orth.vec_lowdin(CIb)))