def simx(A,B,trans='N'):
"""\
C = simx(A,B,trans)
Perform the similarity transformation C = B'*A*B (trans='N') or
C = B*A*B' (trans='T').
"""
if trans.lower().startswith('t'):
return matrixmultiply(B,matrixmultiply(A,B.T))
return matrixmultiply(B.T,matrixmultiply(A,B))
def simx(A, B, trans='N'):
"""\
C = simx(A,B,trans)
Perform the similarity transformation C = B'*A*B (trans='N') or
C = B*A*B' (trans='T').
"""
if trans.lower().startswith('t'):
return matrixmultiply(B, matrixmultiply(A, B.T))
return matrixmultiply(B.T, matrixmultiply(A, B))
def setdens(self,D):
self._dens = 2*dot(self.bfs,matrixmultiply(D,self.bfs))
# This *if* statement is potentially slow. If it becomes
# a factor, pull it up to AtomicGrids and have two
# explicit cases here.
if self.do_grad_dens:
self._grad = 2*dot(self.bfs.T,matrixmultiply(D,self.bfgrads)) +\
2*dot(self.bfgrads.T,matrixmultiply(D,self.bfs))
self._gamma = dot(self._grad,self._grad)
return
def setdens(self, D):
self._dens = 2 * dot(self.bfs, matrixmultiply(D, self.bfs))
# This *if* statement is potentially slow. If it becomes
# a factor, pull it up to AtomicGrids and have two
# explicit cases here.
if self.do_grad_dens:
self._grad = 2*dot(self.bfs.T,matrixmultiply(D,self.bfgrads)) +\
2*dot(self.bfgrads.T,matrixmultiply(D,self.bfs))
self._gamma = dot(self._grad, self._grad)
return
def geigh(H,A,**kwargs):
"""\
Generalized eigenproblem using a symmetric matrix H.
Options:
have_xfrm False Need to form canonical transformation from S (default)
True A is the canonical transformation matrix
orthog 'Sym' Use Symmetric Orthogonalization (default)
'Can' Use Canonical Orthogonalization
'Chol' Use a Cholesky decomposition
'Cut' Use a symmetric orthogonalization with a cutoff
"""
have_xfrm = kwargs.get('have_xfrm')
orthog = kwargs.get('orthog',settings.OrthogMethod)
if not have_xfrm:
if orthog == 'Can':
X = CanOrth(A)
elif orthog == 'Chol':
X = CholOrth(A)
elif orthog == 'Cut':
X = SymOrthCutoff(A)
else:
X = SymOrth(A)
kwargs['have_xfrm'] = True
return geigh(H,X,**kwargs)
val,vec = eigh(simx(H,A))
vec = matrixmultiply(A,vec)
return val,vec
def geigh(H, A, **kwargs):
"""\
Generalized eigenproblem using a symmetric matrix H.
Options:
have_xfrm False Need to form canonical transformation from S (default)
True A is the canonical transformation matrix
orthog 'Sym' Use Symmetric Orthogonalization (default)
'Can' Use Canonical Orthogonalization
'Chol' Use a Cholesky decomposition
'Cut' Use a symmetric orthogonalization with a cutoff
"""
have_xfrm = kwargs.get('have_xfrm')
orthog = kwargs.get('orthog', settings.OrthogMethod)
if not have_xfrm:
if orthog == 'Can':
X = CanOrth(A)
elif orthog == 'Chol':
X = CholOrth(A)
elif orthog == 'Cut':
X = SymOrthCutoff(A)
else:
X = SymOrth(A)
kwargs['have_xfrm'] = True
return geigh(H, X, **kwargs)
val, vec = eigh(simx(H, A))
vec = matrixmultiply(A, vec)
return val, vec
def setdens(self,D):
self._dens = 2*dot(self.bfs,matrixmultiply(D,self.bfs))
# This *if* statement is potentially slow. If it becomes
# a factor, pull it up to AtomicGrids and have two
# explicit cases here.
if self.do_grad_dens:
#gx = 2*dot(self.bfs,matrixmultiply(D,self.bfgrads[:,0])) + \
# 2*dot(self.bfgrads[:,0],matrixmultiply(D,self.bfs))
#gy = 2*dot(self.bfs,matrixmultiply(D,self.bfgrads[:,1])) + \
# 2*dot(self.bfgrads[:,1],matrixmultiply(D,self.bfs))
#gz = 2*dot(self.bfs,matrixmultiply(D,self.bfgrads[:,2])) + \
# 2*dot(self.bfgrads[:,2],matrixmultiply(D,self.bfs))
#self._grad = array((gx,gy,gz))
self._grad = 2*dot(self.bfs.T,matrixmultiply(D,self.bfgrads)) +\
2*dot(self.bfgrads.T,matrixmultiply(D,self.bfs))
self._gamma = dot(self._grad,self._grad)
return
def mkQmatrix(self):
#computes Q matrix which is basically density matrix weighted by the orbital eigenvalues
if self.restricted:
occ_orbe = self.orbe[0:self.nclosed]
occ_orbs = self.orbs[:, 0:self.nclosed]
Qmat = matrixmultiply(
occ_orbs,
matrixmultiply(diagonal_mat(occ_orbe), transpose(occ_orbs)))
return Qmat
if self.unrestricted:
occ_orbs_A = self.orbs_a[:, 0:self.nalpha]
occ_orbs_B = self.orbs_b[:, 0:self.nbeta]
occ_orbe_A = self.orbe_a[0:self.nalpha]
occ_orbe_B = self.orbe_b[0:self.nbeta]
Qa = matrixmultiply(
occ_orbs_A,
matrixmultiply(diagonal_mat(occ_orbe_A),
transpose(occ_orbs_A)))
Qb = matrixmultiply(
occ_orbs_B,
matrixmultiply(diagonal_mat(occ_orbe_B),
transpose(occ_orbs_B)))
return Qa, Qb
def mkdens_occs(c,occs,**kwargs):
"Density matrix from a set of occupations (e.g. from FD expression)."
tol = kwargs.get('tol',settings.FDOccTolerance)
verbose = kwargs.get('verbose')
# Determine how many orbs have occupations greater than 0
norb = 0
for fi in occs:
if fi < tol: break
norb += 1
if verbose:
print "mkdens_occs: %d occupied orbitals found" % norb
# Determine how many doubly occupied orbitals we have
nclosed = 0
for i in xrange(norb):
if abs(1.-occs[i]) > tol: break
nclosed += 1
if verbose:
print "mkdens_occs: %d closed-shell orbitals found" % nclosed
D = mkdens(c,0,nclosed)
for i in xrange(nclosed,norb):
D = D + occs[i]*matrixmultiply(c[:,i:i+1],transpose(c[:,i:i+1]))
return D
def mkQmatrix(self):
#computes Q matrix which is basically density matrix weighted by the orbital eigenvalues
if self.restricted:
occ_orbe = self.orbe[0:self.nclosed]
occ_orbs = self.orbs[:,0:self.nclosed]
Qmat = matrixmultiply( occ_orbs, matrixmultiply( diagonal_mat(occ_orbe), transpose(occ_orbs) ) )
return Qmat
if self.unrestricted:
occ_orbs_A = self.orbs_a[:,0:self.nalpha]
occ_orbs_B = self.orbs_b[:,0:self.nbeta]
occ_orbe_A = self.orbe_a[0:self.nalpha]
occ_orbe_B = self.orbe_b[0:self.nbeta]
Qa = matrixmultiply( occ_orbs_A, matrixmultiply( diagonal_mat(occ_orbe_A), transpose(occ_orbs_A) ) )
Qb = matrixmultiply( occ_orbs_B, matrixmultiply( diagonal_mat(occ_orbe_B), transpose(occ_orbs_B) ) )
return Qa,Qb
def mk_B_Dmat(self, nstart, nstop):
"Form a density matrix C*Ct given eigenvectors C[nstart:nstop,:]"
d = self.orbs_b[:, nstart:nstop]
Dmat = matrixmultiply(d, transpose(d))
return Dmat
def outprod(A):
"D = outprod(A) : Return the outer product A*A'"
return matrixmultiply(A,A.T)
def mkdens(c,nstart,nstop):
"Form a density matrix C*Ct given eigenvectors C[nstart:nstop,:]"
d = c[:,nstart:nstop]
Dmat = matrixmultiply(d,d.T)
return Dmat
def mk_B_Dmat(self,nstart,nstop):
"Form a density matrix C*Ct given eigenvectors C[nstart:nstop,:]"
d = self.orbs_b[:,nstart:nstop]
Dmat = matrixmultiply(d,transpose(d))
return Dmat
def outprod(A):
"D = outprod(A) : Return the outer product A*A'"
return matrixmultiply(A, A.T)
def mkdens(c, nstart, nstop):
"Form a density matrix C*Ct given eigenvectors C[nstart:nstop,:]"
d = c[:, nstart:nstop]
Dmat = matrixmultiply(d, d.T)
return Dmat
