예제 #1
0
파일: core.py 프로젝트: vahtras/vb
    def energygrad(self):
        """
        #  N = <0|0>
        # dN = 2<d0|0>
        #  E = <0|H|0>/<0|0>
        # dE = 2<d0|H-E|0>/<0|0>
        """
        h_struct_grad = full.matrix(len(self.structs))
        h_orb_grad = full.matrix(Nod.C.shape)

        for s1, (str1, cstr1) in enumerate(zip(self.structs, self.coef)):
            for str2, cstr2 in zip(self.structs, self.coef):
                for det1, cdet1 in zip(str1.nods, str1.coef):
                    for det2, cdet2 in zip(str2.nods, str2.coef):
                        det12 = BraKet(det1, det2)

                        h_struct_grad[s1] += \
                            2*(cdet1*cstr2*cdet2)*\
                            det12.overlap()*\
                            det12.energy((self.h, self.h))

                        h_orb_grad += \
                            cstr1*cdet1*cstr2*cdet2*\
                            det12.energy_gradient((self.h, self.h))

        N = self.norm()
        E = self.energy()

        n_struct_grad, n_orb_grad = self.normgrad()

        structgrad = (1/N)*(h_struct_grad - E*n_struct_grad)
        orbgrad = (1/N)*(h_orb_grad - E*n_orb_grad)
        return (structgrad, orbgrad[:, :])
예제 #2
0
파일: core.py 프로젝트: vahtras/vb
 def normhess(self):
     """
     Numerical norm Hessian
     #  N = <0|0>
     # d2<0|0> = <d20|0> + <0|d20> + 2<d0|d0> = 2<0|d20> + 2<d0|d0>
     """
     n_struct_hess = full.matrix(self.coef.shape*2)
     n_orb_structhess = full.matrix(Nod.C.shape + self.coef.shape)
     n_orb_hess = full.matrix(Nod.C.shape*2)
     #
     for s1, (str1, cstr1) in enumerate(zip(self.structs, self.coef)):
         for s2, (str2, cstr2) in enumerate(zip(self.structs, self.coef)):
             for det1, cdet1 in zip(str1.nods, str1.coef):
                 for det2, cdet2 in zip(str2.nods, str2.coef):
                     #
                     bk12 = BraKet(det1, det2)
                     #
                     n_struct_hess[s1, s2] += (cdet1*cdet2)*bk12.overlap()
                     n_orb_structhess[:, :, s1] += \
                         cdet1*cstr2*cdet2*bk12.overlap_gradient()
                     n_orb_hess += \
                         cstr1*cdet1*cstr2*cdet2*bk12.overlap_hessian()
     n_struct_hess *= 2
     n_orb_structhess *= 2
     #n_orb_hess
     return n_struct_hess, n_orb_structhess, n_orb_hess
예제 #3
0
파일: scipyifc.py 프로젝트: vahtras/vb
 def constraint(x, self):
     self.x = x
     mo = self.C[:, i]
     sg = full.matrix(self.coef.shape)
     og = full.matrix(self.C.shape)
     og[:, i] = 2*vb.Nod.S*mo
     return self.so2x(sg, og)
예제 #4
0
파일: test_vb.py 프로젝트: vahtras/vb
 def numgrad(self, func, delta=1e-3):
     """
     # Numerical gradient
     """
     deltah = delta/2
     #
     # structure coefficients
     #
     structgrad = full.matrix(len(self.structs))
     #
     #
     for s in range(structgrad.shape[0]):
         self.coef[s] += deltah
         ep = func()
         self.coef[s] -= delta
         em = func()
         self.coef[s] += deltah
         structgrad[s] = (ep - em)/delta
     #
     # orbital gradient
     #
     r, c = Nod.C.shape
     orbgrad = full.matrix((r, c))
     for m in range(c):
         for t in range(r):
             Nod.C[t, m] += deltah
             ep = func()
             Nod.C[t, m] -= delta
             em = func()
             orbgrad[t, m] = (ep - em)/delta
             Nod.C[t, m] += deltah
     return (structgrad, orbgrad[:, :])
예제 #5
0
 def test_quadrupole_total(self, molfrag):
     rRab = full.matrix((6, molfrag.noa, molfrag.noa))
     RRab = full.matrix((6, molfrag.noa, molfrag.noa))
     Rabc = 1.0 * molfrag.Rab
     for a in range(molfrag.noa):
         for b in range(molfrag.noa):
             Rabc[a, b, :] -= molfrag.Rc
     for a in range(molfrag.noa):
         for b in range(molfrag.noa):
             ij = 0
             for i in range(3):
                 for j in range(i, 3):
                     rRab[ij, a, b] = (
                         molfrag.Dab[i, a, b] * Rabc[a, b, j]
                         + molfrag.Dab[j, a, b] * Rabc[a, b, i]
                     )
                     RRab[ij, a, b] = (
                         molfrag.Qab[a, b]
                         * (molfrag.R[a, i] - molfrag.Rc[i])
                         * (molfrag.R[b, j] - molfrag.Rc[j])
                     )
                     ij += 1
     QUcab = molfrag.QUab + rRab + RRab
     QUc = QUcab.sum(axis=2).sum(axis=1).view(full.matrix)
     self.assert_allclose(QUc, ref.QUc)
예제 #6
0
파일: core.py 프로젝트: vahtras/vb
 def contravariant_transition_density_ao_mo(self):
     """Return contravariant density matrix in mix ao,mo basis"""
     d_am = (full.matrix(Nod.C.shape), full.matrix(Nod.C.shape))
     CK = self.K.orbitals()
     for s in (0, 1):
         if self.K(s) and self.L(s):
             d_am[s][:, self.L(s)] = CK[s]*self.transition_density[s]
     return d_am
예제 #7
0
파일: core.py 프로젝트: vahtras/vb
 def contravariant_transition_density_mo_ao(self):
     """Return contravariant density matrix in mix mo,ao basis"""
     d_ma = (full.matrix(Nod.C.shape[::-1]), full.matrix(Nod.C.shape[::-1]))
     CL = self.L.orbitals()
     for s in (0, 1):
         if self.K(s) and self.L(s):
             d_ma[s][self.K(s), :] = self.transition_density[s]*CL[s].T
     return d_ma
예제 #8
0
파일: test_opt.py 프로젝트: vahtras/vb
 def fun(coef, wf):
     grad = full.matrix(coef.size)
     VBTestH2C.update_wf(coef, wf)
     mo = wf.C[:, i]
     dc2 = 2*vb.Nod.S*mo
     tmp = full.matrix(wf.C.shape)
     tmp[:, i] = dc2
     grad[wf.coef.size:] = tmp.block(*wf.blockdims).ravel(order='F')
     return grad
예제 #9
0
파일: core.py 프로젝트: vahtras/loprop
    def QUab(self):
        """Quadrupole moment"""
        if self._QUab is not None: return self._QUab

        D = self.D
        R = self.R
        Rc = self.Rc
        dRab = self.dRab
        Qab = self.Qab
        Dab = self.Dab

        lab = ("XXSECMOM", "XYSECMOM", "XZSECMOM", 
                           "YYSECMOM", "YZSECMOM", 
                                       "ZZSECMOM")

        xy = self.getprop(*lab)

        noa = self.noa
        QUab = full.matrix((6, noa, noa))
        rrab = full.matrix((6, noa, noa))
        rRab = full.matrix((6, noa, noa))
        RRab = full.matrix((6, noa, noa))
        Rab = self.Rab
        for a in range(noa):
            for b in range(noa):
                ij = 0
                for i in range(3):
                    for j in range(i, 3):
                        rrab[ij, a, b] = -(
                            xy[ij].subblock[a][b]&D.subblock[a][b]
                            ) 
                        rRab[ij, a, b] = Dab[i, a, b]*Rab[a,b,j]+Dab[j, a, b]*Rab[a,b,i]
                        RRab[ij, a, b] = Rab[a,b,i]*Rab[a,b,j]*Qab[a, b]
                        ij += 1
        QUab = rrab-rRab-RRab
        self._QUab = QUab
        #
        # Addition term - gauge correction summing up bonds
        #
        dQUab = full.matrix(self.QUab.shape)
        for a in range(noa):
            for b in range(noa):
                ij = 0
                for i in range(3):
                    for j in range(i, 3):
                        dQUab[ij, a, b] = dRab[a, b, i]*Dab[j, a, b] \
                                      +dRab[a, b, j]*Dab[i, a, b]
                        ij += 1
        self.dQUab = - dQUab

        return self._QUab
예제 #10
0
파일: core.py 프로젝트: vahtras/vb
    def project_virtual_occupied(self, h1):
        """Rhs derivative <K|h|dL/dC(mu, m)>"""

        D_mo = self.transition_density
        delta = self.co_contravariant_transition_delta()

        K_h_dL = (full.matrix(Nod.C.shape), full.matrix(Nod.C.shape))

        CK = self.K.orbitals()
        for s in (0, 1):
            if self.K(s) and self.L(s):
                K_h_dL[s][:, self.L(s)] += \
                    delta[s]*h1[s].T*CK[s]*D_mo[s]*self.overlap()
        return K_h_dL
예제 #11
0
파일: core.py 프로젝트: vahtras/vb
 def full_mo_transition_density(self):
     """
     Return mo transition density matrix in full mo basis
     """
     if self._ftd is None:
         _, mo = Nod.C.shape
         D_KL = self.transition_density
         self._ftd = (full.matrix((mo, mo)), full.matrix((mo, mo)))
         for s in (0, 1):
             if self.K(s) and self.L(s):
                 D_KL[s].scatter(
                     self._ftd[s], rows=self.K(s), columns=self.L(s)
                     )
     return self._ftd
예제 #12
0
def fock(D, component, **kwargs):
    """ Generate two-electron spin-orbit Fock matrix 
        from integral file AO2SOINT
   """

    hfc = kwargs.get('hfc', 1.0)
    hfx = kwargs.get('hfx', 1.0)

    #
    left = 1
    right = 2

    nbast, _ = D.shape
    J = matrix((nbast, nbast))
    JL = matrix((nbast, nbast))
    JR = matrix((nbast, nbast))
    K = matrix((nbast, nbast))

    for buf, ibuf in two.list_buffers(label='AO2SOINT', **kwargs):
        for g, ig in zip(buf, ibuf):
            if ig[0] == 0:
                comp = "*xyz"[ig[1]]
            else:
                #print comp, ig, g, component
                if comp != component:
                    continue
                p, q, r, s = ig
                s, r, q, p = (p - 1, q - 1, r - 1, s - 1)
                if (p == q): g *= 0.5
                x = 1.5 * g

                JL[r, s] += g * (D[p, q] + D[q, p])
                JL[s, r] -= g * (D[p, q] + D[q, p])
                JR[p, q] += 2 * g * (D[r, s] - D[s, r])
                JR[q, p] += 2 * g * (D[r, s] - D[s, r])

                K[p, s] -= x * D[r, q]
                K[s, p] += x * D[q, r]
                K[p, r] += x * D[s, q]
                K[r, p] -= x * D[q, s]
                K[q, s] -= x * D[r, p]
                K[s, q] += x * D[p, r]
                K[q, r] += x * D[s, p]
                K[r, q] -= x * D[p, s]

    J = JR + JL
    F = hfc * J + hfx * K
    return F
예제 #13
0
파일: nod.py 프로젝트: vahtras/vb
def Dao(K, L):
    """
    # Return intermediate normalized ao transition density matrix given
    # determinants K and L
    # as [Dalpha, Dbeta]
    """

    if abs(K*L) < SINGULAR_OVERLAP_THRESHOLD:
        raise SingularOverlapError

    CK = K.orbitals()
    CL = L.orbitals()
    #
    D = []

    for s in range(2):
        if CK[s] is None or CL[s] is None:
            #
            # if None orbitals set atomic density to zero matrix
            #
            D.append(full.matrix(Nod.S.shape))
        else:
            SLK = CL[s].T*Nod.S*CK[s]
            try:
                D.append(CK[s]*(CL[s].T/SLK))
            except LinAlgError:
                raise SingularOverlapError

    return D
예제 #14
0
def vb_transform2(Dma, Dam, Delta1, Delta2, **kwargs):
    filename = kwargs.get('filename', '/tmp/AOTWOINT')
    H_umvn = matrix(Dam[0].shape + Dam[0].shape)
    for ig, g in list_integrals(filename):
        p, q, r, s = ig
        s, r, q, p = p-1, q-1, r-1, s-1
        if p == q: g *= 0.5
        if r == s: g *= 0.5
        if (p, q) == (r, s): g *= 0.5

        for d1a, d2a, D1a, D2a in zip(Dma, Dam, Delta1, Delta2):
            for d1b, d2b, D1b, D2b in zip(Dma, Dam, Delta1, Delta2):
               H_umvn += D1a[p,:].x(d1a[:, q].x(D2b[:, s].x(d2b[r, :]*g)))
               H_umvn += D1a[q,:].x(d1a[:, p].x(D2b[:, s].x(d2b[r, :]*g)))
               H_umvn += D1a[p,:].x(d1a[:, q].x(D2b[:, r].x(d2b[s, :]*g)))
               H_umvn += D1a[q,:].x(d1a[:, p].x(D2b[:, r].x(d2b[s, :]*g)))

               H_umvn += D1a[r,:].x(d1a[:, s].x(D2b[:, q].x(d2b[p, :]*g)))
               H_umvn += D1a[r,:].x(d1a[:, s].x(D2b[:, p].x(d2b[q, :]*g)))
               H_umvn += D1a[s,:].x(d1a[:, r].x(D2b[:, q].x(d2b[p, :]*g)))
               H_umvn += D1a[s,:].x(d1a[:, r].x(D2b[:, p].x(d2b[q, :]*g)))

            H_umvn -= D1a[p, :].x(d1a[:, s].x(D2a[:, q].x(d2a[r, :]*g)))
            H_umvn -= D1a[q, :].x(d1a[:, s].x(D2a[:, p].x(d2a[r, :]*g)))
            H_umvn -= D1a[p, :].x(d1a[:, r].x(D2a[:, q].x(d2a[s, :]*g)))
            H_umvn -= D1a[q, :].x(d1a[:, r].x(D2a[:, p].x(d2a[s, :]*g)))

            H_umvn -= D1a[r, :].x(d1a[:, q].x(D2a[:, s].x(d2a[p, :]*g)))
            H_umvn -= D1a[r, :].x(d1a[:, p].x(D2a[:, s].x(d2a[q, :]*g)))
            H_umvn -= D1a[s, :].x(d1a[:, q].x(D2a[:, r].x(d2a[p, :]*g)))
            H_umvn -= D1a[s, :].x(d1a[:, p].x(D2a[:, r].x(d2a[q, :]*g)))

    return H_umvn
예제 #15
0
def vb_transform(dens, delta, **kwargs):
    filename = kwargs.get('filename', '/tmp/AOTWOINT')
    a, m = dens[0].shape
    H_uvmn = matrix((a, a, m, m))
    for ig, g in list_integrals(filename):
        p, q, r, s = ig
        s, r, q, p = p-1, q-1, r-1, s-1
        if p == q: g *= 0.5
        if r == s: g *= 0.5
        if (p, q) == (r, s): g *= 0.5

        for d1, D1 in zip(dens, delta):
            for d2, D2 in zip(dens, delta):
                H_uvmn += D1[:, q].x(D2[:, s].x(d1[p, :].x(d2[r, :]*g)))
                H_uvmn += D1[:, p].x(D2[:, s].x(d1[q, :].x(d2[r, :]*g)))
                H_uvmn += D1[:, q].x(D2[:, r].x(d1[p, :].x(d2[s, :]*g)))
                H_uvmn += D1[:, p].x(D2[:, r].x(d1[q, :].x(d2[s, :]*g)))
                H_uvmn += D1[:, s].x(D2[:, q].x(d1[r, :].x(d2[p, :]*g)))
                H_uvmn += D1[:, r].x(D2[:, q].x(d1[s, :].x(d2[p, :]*g)))
                H_uvmn += D1[:, s].x(D2[:, p].x(d1[r, :].x(d2[q, :]*g)))
                H_uvmn += D1[:, r].x(D2[:, p].x(d1[s, :].x(d2[q, :]*g)))

            H_uvmn -= D1[:, s].x(D1[:, q].x(d1[p, :].x(d1[r, :]*g)))
            H_uvmn -= D1[:, s].x(D1[:, p].x(d1[q, :].x(d1[r, :]*g)))
            H_uvmn -= D1[:, r].x(D1[:, q].x(d1[p, :].x(d1[s, :]*g)))
            H_uvmn -= D1[:, r].x(D1[:, p].x(d1[q, :].x(d1[s, :]*g)))
            H_uvmn -= D1[:, q].x(D1[:, s].x(d1[r, :].x(d1[p, :]*g)))
            H_uvmn -= D1[:, q].x(D1[:, r].x(d1[s, :].x(d1[p, :]*g)))
            H_uvmn -= D1[:, p].x(D1[:, s].x(d1[r, :].x(d1[q, :]*g)))
            H_uvmn -= D1[:, p].x(D1[:, r].x(d1[s, :].x(d1[q, :]*g)))
        
    return H_uvmn.transpose(0, 2, 1, 3)
예제 #16
0
 def test_quadrupole_allbonds(self):
     QU = full.matrix(ref.QU.shape)
     QUab = self.m.QUab
     for ab, a, b in pairs(self.m.noa):
         QU[:, ab] += QUab[:, a, b ] 
         if a != b: QU[:, ab] += QUab[:, b, a] 
     self.assert_allclose(QU, ref.QU)
예제 #17
0
파일: core.py 프로젝트: vahtras/loprop
    def Bab(self):
        """Localized hyperpolariziabilities"""
        if self._Bab is not None: return self._Bab

        D2k = self.D2k
        Rab = self.Rab
        d2Qa = self.d2Qa
        x = self.x

        labs = ('XDIPLEN ', 'YDIPLEN ', 'ZDIPLEN ')
        qlabs = [labs[i] + labs[j] for i in range(3) for j in range(i,3)]
        Bab = full.matrix( (self.nfreqs, 3, 6, self.noa, self.noa) )


        #correction term for shifting origin from O to Rab
        for i, li in enumerate(labs):
            for jk,ljk in enumerate(qlabs):
                for a in range(self.noa):
                    for b in range(self.noa):
                        for iw, w in enumerate(self.freqs):
                            Bab[iw, i, jk, a, b] = (
                                -x[i].subblock[a][b] & D2k [(ljk, w, w)].subblock[a][b]
                                )
                    for iw in self.rfreqs:
                        Bab[iw, i, jk, a, a] -= d2Qa[iw, a, jk]*Rab[a, a, i]

        self._Bab = Bab
        return self._Bab
예제 #18
0
파일: dens.py 프로젝트: vahtras/daltools
def ifc(filename="SIRIFC", ifc_=None):
    """
    Return inactive/active densities from orbitals on interface file SIRIFC
    """
    if ifc_ is None:
        ifc_ = sirifc.sirifc(filename)
    Di = blocked.BlockDiagonalMatrix(ifc_.nbas, ifc_.nbas)
    for isym in range(ifc_.nsym):
        if ifc_.nish[isym]:
            Ci = ifc_.cmo.subblock[isym]
            Cocci = Ci[:, : ifc_.nish[isym]]
            Di.subblock[isym] = 2 * Cocci @ Cocci.T
    Di = Di.unblock()
    if ifc_.nasht:
        cmoa = blocked.BlockDiagonalMatrix(ifc_.nbas, ifc_.nash)
        for isym in range(ifc_.nsym):
            if ifc_.nash[isym]:
                nishi = ifc_.nish[isym]
                nocci = ifc_.nish[isym] + ifc_.nash[isym]
                cmoa.subblock[isym] = ifc_.cmo.subblock[isym][:, nishi:nocci]
        cmoa = cmoa.unblock()
        Dv = cmoa @ ifc_.dv.unpack() @ cmoa.T
    else:
        Dv = full.matrix((ifc_.nbast, ifc_.nbast))
    return Di, Dv
예제 #19
0
파일: test_opt.py 프로젝트: vahtras/vb
 def constraint_norm_grad(coef, wf):
     grad = full.matrix(coef.size)
     VBTestH2C.update_wf(coef, wf)
     sg, og = wf.normgrad()
     grad[:wf.coef.size] = sg
     grad[wf.coef.size:] = og.block(*wf.blockdims).ravel(order='F')
     return grad
예제 #20
0
 def test_dipole_allbonds(self):
     D = full.matrix(ref.D.shape)
     Dab = self.m.Dab
     for ab, a, b in pairs(self.m.noa):
         D[:, ab] += Dab[:, a, b ] 
         if a != b: D[:, ab] += Dab[:, b, a] 
     self.assert_allclose(D, ref.D)
예제 #21
0
파일: test_opt.py 프로젝트: vahtras/vb
 def wf_gradient(coef, wf):
     grad = full.matrix(coef.size)
     VBTestH2C.update_wf(coef, wf)
     sg, og = wf.energygrad()
     grad[:wf.coef.size] = sg
     grad[wf.coef.size:] = og.block(*wf.blockdims).ravel(order='F')
     return grad
예제 #22
0
 def test_quadrupole_allbonds(self, molfrag):
     QU = full.matrix(ref.QU.shape)
     QUab = molfrag.QUab
     for ab, a, b in pairs(molfrag.noa):
         QU[:, ab] += QUab[:, a, b]
         if a != b:
             QU[:, ab] += QUab[:, b, a]
     self.assert_allclose(QU, ref.QU)
예제 #23
0
 def test_dipole_allbonds(self, molfrag):
     D = full.matrix(ref.D.shape)
     Dab = molfrag.Dab
     for ab, a, b in pairs(molfrag.noa):
         D[:, ab] += Dab[:, a, b]
         if a != b:
             D[:, ab] += Dab[:, b, a]
     self.assert_allclose(D, ref.D)
예제 #24
0
파일: rohf.py 프로젝트: vahtras/dalmisc
def mkB2(vecs):
    B = full.matrix(len(vecs) + 1, len(vecs) + 1)
    for i in range(len(vecs)):
        for j in range(len(vecs)):
            B[i, j] = -(vecs[i] * vecs[j]).tr()
        B[i, len(vecs)] = -1
        B[len(vecs), i] = -1
    return B
예제 #25
0
파일: scipyifc.py 프로젝트: vahtras/vb
 def grad(x, self):
     _x = self.x
     self.x = x
     p = self.p
     dL = full.matrix(len(x))
     dL[:len(p)] = self.gp(p) - sum(l*c['jac'](p) for l, c in zip(self.l, self.cp))
     dL[len(p):] = [-c['fun'](p) for c in self.cp]
     self.x = _x
     return dL
예제 #26
0
파일: core.py 프로젝트: vahtras/vb
    def project_occupied_virtual(self, h1):
        """Lhs derivative <dK/dC(mu,m)|h|L>"""

        D_mo = self.transition_density
        delta = self.contra_covariant_transition_delta()

        dK_h_La = full.matrix(Nod.C.shape[::-1])
        dK_h_Lb = full.matrix(Nod.C.shape[::-1])

        CL = self.L.orbitals()
        if self.L(0):
            dK_h_La[self.K(0), :] += \
                D_mo[0]*CL[0].T*h1[0].T*delta[0]*self.overlap()
        if self.L(1):
            dK_h_Lb[self.K(1), :] += \
                D_mo[1]*CL[1].T*h1[1].T*delta[1]*self.overlap()

        return dK_h_La.T, dK_h_Lb.T
예제 #27
0
파일: rspvec.py 프로젝트: vahtras/daltools
def tovec(mat, ifc, tmpdir="/tmp"):
    """Vector to matrix"""

    lwop = ifc.nisht * ifc.nasht + ifc.nocct * (ifc.norbt - ifc.nocct)
    N = full.matrix((2 * lwop, ))
    for ij, (i, j) in enumerate(jwop(ifc)):
        N[ij] = mat[i, j]
        N[ij + lwop] = mat[j, i]
    return N
예제 #28
0
 def test_quadrupole_total(self):
     rrab=full.matrix((6, self.m.noa, self.m.noa))
     rRab=full.matrix((6, self.m.noa, self.m.noa))
     RRab=full.matrix((6, self.m.noa, self.m.noa))
     Rabc = 1.0*self.m.Rab
     for a in range(self.m.noa):
         for b in range(self.m.noa):
             Rabc[a,b,:] -= self.m.Rc
     for a in range(self.m.noa):
         for b in range(self.m.noa):
             ij = 0
             for i in range(3):
                 for j in range(i,3):
                     rRab[ij, a, b] = self.m.Dab[i, a, b]*Rabc[a, b, j]\
                                    + self.m.Dab[j, a, b]*Rabc[a, b, i]
                     RRab[ij, a, b] = self.m.Qab[a, b]*(self.m.R[a, i] - self.m.Rc[i])*(self.m.R[b, j] - self.m.Rc[j])
                     ij += 1
     QUcab = self.m.QUab + rRab + RRab
     QUc = QUcab.sum(axis=2).sum(axis=1).view(full.matrix)
     self.assert_allclose(QUc, ref.QUc)
예제 #29
0
파일: core.py 프로젝트: vahtras/vb
 def ao_density(self):
     """Electron number check"""
     D_ao = full.matrix(Nod.S.shape)
     for S, CS in zip(self.structs, self.coef):
         for T, CT in zip(self.structs, self.coef):
             for K, CK in zip(S.nods, S.coef):
                 for L, CL in zip(T.nods, T.coef):
                     KL = BraKet(K, L)
                     DKL = KL.transition_ao_density
                     D_ao += sum(DKL)*CS*CT*CK*CL*KL.overlap()
     return D_ao/self.norm()
예제 #30
0
파일: scipyifc.py 프로젝트: vahtras/vb
 def hess(x, self):
     _x = self.x
     self.x = x
     p = self.p
     d2L = full.matrix((len(x), len(x)))
     d2L[:len(p), :len(p)] = self.hp(p) - sum(l*c['hes'](p) for l, c in zip(self.l, self.cp))
     for i, c in enumerate(self.cp):
         d2L[:len(p), len(p) + i] = -c['jac'](p)
     d2L[len(p):, :len(p)] = d2L[:len(p), len(p):].T
     d2L[len(p):, len(p):] = 0.0
     self.x = _x
     return d2L
예제 #31
0
def tovec(mat, ifc, tmpdir='/tmp'):
    """Vector to matrix"""
    import os
    from util import full
    lwop = ifc.nisht*ifc.nasht + ifc.nocct*(ifc.norbt-ifc.nocct)
    N = full.matrix((2*lwop,))
    ij = 0
    for i, j in  jwop(ifc):
        N[ij] = mat[i, j]
        N[ij+lwop] = mat[j, i]
        ij += 1
    return N
예제 #32
0
파일: rspvec.py 프로젝트: vahtras/daltools
def tomat(N, ifc, tmpdir="/tmp"):
    """Vector to matrix"""

    norbt = ifc.norbt
    new = full.matrix((norbt, norbt))
    lwop = len(N) // 2

    for ij, (i, j) in enumerate(jwop(ifc)):
        new[i, j] = N[ij]
        new[j, i] = N[ij + lwop]

    return new
예제 #33
0
    def get_dens(self, ndim, idim, nocc=None):
        if nocc is None:
            nocc_ = [1]*len(ndim)
        else:
            nocc_ = nocc

        dens = matrix((self.nbast, self.nbast))
        for ni, no, offset in zip(ndim, nocc_, idim):
            if ni > 0:
                cmoi = self.cmo[:, offset: offset + ni]
                dens += no*cmoi*cmoi.T

        return dens
예제 #34
0
    def test_polarizability_nobonds(self, molfrag):

        Aab = molfrag.Aab[0] + molfrag.dAab[0] / 2
        noa = molfrag.noa

        Acmp = full.matrix((6, noa))
        Aa = Aab.sum(axis=3).view(full.matrix)

        for a in range(noa):
            Acmp[:, a] = Aa[:, :, a].pack()

        # atoms
        self.assert_allclose(Acmp, ref.Aa, atol=0.07)
예제 #35
0
    def get_dens(self, ndim, idim, nocc=None):
        if nocc is None:
            nocc_ = [1] * len(ndim)
        else:
            nocc_ = nocc

        dens = matrix((self.nbast, self.nbast))
        for ni, no, offset in zip(ndim, nocc_, idim):
            if ni > 0:
                cmoi = self.cmo[:, offset:offset + ni]
                dens += no * cmoi * cmoi.T

        return dens
예제 #36
0
    def test_bond_charge_shift(self, molfrag):
        dQab = molfrag.dQab[0]
        noa = molfrag.noa

        dQabref = (ref.dQab[:, 1:7:2] - ref.dQab[:, 2:7:2]) / (2 * ref.ff)
        dQabcmp = full.matrix((3, 3))
        ab = 0
        for a in range(noa):
            for b in range(a):
                dQabcmp[ab, :] = dQab[a, b, :]
                ab += 1
        # The sign difference is because mocas sets up rhs with opposite sign
        self.assert_allclose(-dQabref, dQabcmp, atol=0.006)
예제 #37
0
    def test_bond_charge_shift(self):
        dQab = self.m.dQab[0]
        noa = self.m.noa

        dQabref = (ref.dQab[:, 1:7:2] - ref.dQab[:, 2:7:2])/(2*ref.ff)
        dQabcmp = full.matrix((3, 3))
        ab = 0
        for a in range(noa):
            for b in range(a):
                dQabcmp[ab, :] = dQab[a, b, :]
                ab += 1
    # The sign difference is because mocas sets up rhs with opposite sign
        self.assert_allclose(-dQabref, dQabcmp, atol=0.006)
예제 #38
0
파일: core.py 프로젝트: vahtras/loprop
    def QUc(self):
        if self._QUc is not None: return self._QUc

        rrab=full.matrix((6, self.noa, self.noa))
        rRab=full.matrix((6, self.noa, self.noa))
        RRab=full.matrix((6, self.noa, self.noa))
        Rabc = 1.0*self.Rab
        for a in range(self.noa):
            for b in range(self.noa):
                Rabc[a,b,:] -= self.Rc
        for a in range(self.noa):
            for b in range(self.noa):
                ij = 0
                for i in range(3):
                    for j in range(i,3):
                        rRab[ij, a, b] = self.Dab[i, a, b]*Rabc[a, b, j]\
                                       + self.Dab[j, a, b]*Rabc[a, b, i]
                        RRab[ij, a, b] = self.Qab[a, b]*(self.R[a, i] - self.Rc[i])*(self.R[b, j] - self.Rc[j])
                        ij += 1
        QUcab = self.QUab + rRab + RRab
        self._QUc = QUcab.sum(axis=2).sum(axis=1).view(full.matrix)
        return self._QUc
예제 #39
0
def tomat(N, ifc, tmpdir='/tmp'):
    """Vector to matrix"""
    import os
    from util import full
    norbt = ifc.norbt
    new = full.matrix((norbt, norbt))
    lwop = len(N)/2
    ij = 0
    for i, j in jwop(ifc):
        new[i, j] = N[ij]
        new[j, i] = N[ij+lwop]
        ij += 1
    return new
예제 #40
0
파일: test_scipyifc.py 프로젝트: vahtras/vb
    def setUp(self):
        self.tmp = os.path.join(os.path.dirname(__file__), 'test_h2_c')
        def tmp(fil):
            return os.path.join(self.tmp, fil)

        self.qcifc = QuantumChemistry.get_factory('Dalton', tmpdir=self.tmp)
        vb.Nod.tmpdir = self.tmp
        vb.Nod.C = full.matrix((10, 2))
        vb.Nod.C[0, 0] = 1.0
        vb.Nod.C[5, 1] = 1.0
        vb.Nod.S = self.qcifc.get_overlap()
        self.blockdims = ((5, 5), (1, 1))
        self.wf = vb.WaveFunction(
            [vb.Structure(
                [vb.Nod([0], [1]), vb.Nod([1], [0])],
                [1.0, 1.0]
                ),
             vb.Structure([vb.Nod([0], [0])], [1.0]),
             vb.Structure([vb.Nod([1], [1])], [1.0]),
            ],
            [1.0, 0.0, 0.0],
            tmpdir = self.tmp,
            blockdims=self.blockdims
        )

        # In this setup we have local expansions of mos, leading to a block diagonal C
        self.final = full.matrix(13)
        self.final_coef =[0.83675, 0.09850, 0.09850]
        self.final[:3] = self.final_coef
        self.final_C = full.init([
            [0.7633862173, 0.3075441467, 0.0, 0.0, 0.0328947818,0,0,0,0,0],
            [0,0,0,0,0, 0.7633862173, 0.3075441467, 0.0, 0.0, -0.0328947818]
            ])
        self.final[3:8] = self.final_C[:5, 0]
        self.final[8:13] = self.final_C[5:, 1]

        self.wf.normalize_structures()
        self.xfg = VBMinimizer(self.wf)
예제 #41
0
    def test_polarizability_nobonds(self):

        Aab = self.m.Aab[0] + self.m.dAab[0]/2
        noa = self.m.noa

        Acmp = full.matrix((6, noa ))
        Aa = Aab.sum(axis=3).view(full.matrix)
        
        ab = 0
        for a in range(noa):
            Acmp[:, a,] = Aa[:, :, a].pack()

        # atoms
        self.assert_allclose(Acmp, ref.Aa, atol=0.07)
예제 #42
0
파일: dalton.py 프로젝트: robertodr/loprop
 def get_molecule_info(self):
     """
  `   Get overlap, nuclear charges and coordinates from AOONEINT
     """
     #
     # Data from the ISORDK section in AOONEINT
     #
     isordk = one.readisordk(filename=self.aooneint)
     #
     # Number of nuclei
     #
     N = isordk["nucdep"]
     #
     # MXCENT , Fix dimension defined in nuclei.h
     #
     mxcent = len(isordk["chrn"])
     #
     # Nuclear charges
     #
     self.Z = full.matrix((N, ))
     self.Z[:] = isordk["chrn"][:N]
     #
     # Nuclear coordinates
     #
     R = full.matrix((mxcent * 3, ))
     R[:] = isordk["cooo"][:]
     self.R = R.reshape((mxcent, 3), order="F")[:N, :]
     #
     # Bond center matrix and half bond vector
     #
     noa = self.noa
     self.Rab = full.matrix((noa, noa, 3))
     self.dRab = full.matrix((noa, noa, 3))
     for a in range(noa):
         for b in range(noa):
             self.Rab[a, b, :] = (self.R[a, :] + self.R[b, :]) / 2
             self.dRab[a, b, :] = (self.R[a, :] - self.R[b, :]) / 2
예제 #43
0
파일: rohf.py 프로젝트: vahtras/dalmisc
def mkB3(avecs, bvecs, unrest):
    dim = len(avecs)
    B = full.matrix((dim + 1, dim + 1))
    for i in range(dim):
        for j in range(dim):
            if unrest:
                B[i, j] = -(avecs[i] @ avecs[j]).tr() - (
                    bvecs[i] @ bvecs[j]).tr()
            else:
                vecsi = avecs[i] + bvecs[i]
                vecsj = avecs[j] + bvecs[j]
                B[i, j] = (vecsi @ vecsj.T).tr()
        B[i, dim] = -1
        B[dim, i] = -1
    return B
예제 #44
0
 def pv(self):
     """Get two-electron density"""
     if self._pv is None:
         with FortranBinary(self.name) as fb:
             fb.find(self.ifclabel)
             for i in range(7):
                 fb.next()
             m2ashy = max(self.nnashx**2, 4)
             dbl = fb.readbuf(m2ashy, self.FLOAT)
         self._pv = full.matrix((self.nnashx, self.nnashx))
         n = 0
         for i in range(self.nnashx):
             for j in range(self.nnashx):
                 self._pv[j, i] = dbl[n]
                 n += 1
         assert n == self.nnashx**2
     return self._pv
예제 #45
0
    def test_polarizability_allbonds_atoms(self, molfrag):

        Aab = molfrag.Aab[0]  # + molfrag.dAab[0]
        noa = molfrag.noa

        Acmp = full.matrix(ref.Aab.shape)

        ab = 0
        for a in range(noa):
            for b in range(a):
                Acmp[:, ab] = (Aab[:, :, a, b] + Aab[:, :, b, a]).pack()
                ab += 1
            Acmp[:, ab] = Aab[:, :, a, a].pack()
            ab += 1
        # atoms
        self.assert_allclose(ref.Aab[:, 0], Acmp[:, 0], atol=0.005)
        self.assert_allclose(ref.Aab[:, 2], Acmp[:, 2], atol=0.005)
        self.assert_allclose(ref.Aab[:, 5], Acmp[:, 5], atol=0.005)
예제 #46
0
    def test_polarizability_allbonds_bonds(self, molfrag):

        Aab = molfrag.Aab[0] + molfrag.dAab[0] / 2
        noa = molfrag.noa

        Acmp = full.matrix(ref.Aab.shape)

        ab = 0
        for a in range(noa):
            for b in range(a):
                Acmp[:, ab] = (Aab[:, :, a, b] + Aab[:, :, b, a]).pack()
                ab += 1
            Acmp[:, ab] = Aab[:, :, a, a].pack()
            ab += 1
        # atoms
        self.assert_allclose(ref.Aab[:, 1], Acmp[:, 1], atol=0.150, err_msg="H1O")
        self.assert_allclose(ref.Aab[:, 3], Acmp[:, 3], atol=0.150, err_msg="H2O")
        self.assert_allclose(ref.Aab[:, 4], Acmp[:, 4], atol=0.005, err_msg="H2H1")
예제 #47
0
파일: one.py 프로젝트: robertodr/daltools
def read(label="OVERLAP", filename="AOONEINT"):
    """Read integral for label"""
    lbuf = 600
    #
    # Initialize
    #
    unlabeled = readhead(filename)
    nsym = unlabeled["nsym"]
    nbas = unlabeled["naos"]
    INT = unlabeled["int_fmt"]
    FLOAT = unlabeled["float_fmt"]
    nnbast = 0
    for nbasi in nbas:
        nnbast += nbasi * (nbasi + 1) // 2
    s = full.matrix((nnbast, ))
    #
    # Open file, locate label
    #
    aooneint = FortranBinary(filename)
    aooneint.find(label)
    #
    # Loop over records
    #

    for rec in aooneint:
        buf = rec.read(lbuf, FLOAT)
        ibuf = rec.read(lbuf, INT)
        length, = rec.read(1, INT)
        if length < 0:
            break
        for i, b in zip(ibuf[:length], buf[:length]):
            s[i - 1] = b

    _S = blocked.triangular(nbas)
    off = 0
    for isym in range(nsym):
        nbasi = nbas[isym] * (nbas[isym] + 1) // 2
        _S.subblock[isym] = np.array(s[off:off + nbasi]).view(full.triangular)
        off += nbasi
    # aooneint.close()
    return _S
예제 #48
0
파일: dens.py 프로젝트: robertodr/daltools
def cmo(F, S, filename="AOONEINT"):
    """
    Return MO coefficients from diagonalization of a provided Fock matrix F, an
    optional overlap matrix S. The returned MOs are normalized and ordered with
    respect to eigenvalue
    """
    nbast = F.shape[0]
    e, V = F.eigvec(S)
    C = full.matrix((nbast, nbast))
    N2 = (V.T @ S @ V).diagonal()
    for i in range(nbast):
        Ni = 1.0 / sqrt(N2[i])
        C[:, i] = V[:, i] * Ni
    rephase_columns(C, inplace=True)

    #
    # Finish off with Gram Schmidt because degenerate orbitals are not
    # properly orthonormalized
    #
    C = C.GS(S)
    #
    #
    return C
예제 #49
0
파일: df.py 프로젝트: vahtras/two_electron
import numpy
from util.full import matrix

d = matrix((24, 24))
f = matrix((24, 24))

d[:11, :5] = numpy.array([
     [ 2.00160706,   -0.01036708,    -0.00181429,     0.00677187,    -0.00241386],
     [-0.01036708,    1.69869523,    -0.09633899,    -0.27114604,    -0.10920586],
     [-0.00181429,   -0.09633899,     0.08874347,    -0.30570693,     0.01352778],
     [ 0.00677187,   -0.27114604,    -0.30570693,     1.28122865,    -0.01084007],
     [-0.00241386,   -0.10920586,     0.01352778,    -0.01084007,     0.00767067],
     [ 0.00006681,   -0.00823265,    -0.00653547,     0.02831209,    -0.00008716],
     [-0.00018734,   -0.00235146,     0.00228316,    -0.00791291,     0.00034070],
     [-0.00389444,    0.35145795,    -0.19737922,     0.62805954,    -0.03821221],
     [ 0.00283175,   -0.18331099,     0.08114304,    -0.24351160,     0.01800991],
     [ 0.00146798,   -0.04495921,     0.01951429,    -0.05823360,     0.00438197],
     [ 0.00123945,   -0.03923112,     0.00210759,     0.00671245,     0.00251033] 
    ])

d[:11, 5:10] = numpy.array([
    [ 0.00006681,   -0.00018734,    -0.00389444,     0.00283175,     0.00146798],
    [-0.00823265,   -0.00235146,     0.35145795,    -0.18331099,    -0.04495921],
    [-0.00653547,    0.00228316,    -0.19737922,     0.08114304,     0.01951429],
    [ 0.02831209,   -0.00791291,     0.62805954,    -0.24351160,    -0.05823360],
    [-0.00008716,    0.00034070,    -0.03821221,     0.01800991,     0.00438197],
    [ 0.00062869,   -0.00016935,     0.01321749,    -0.00506051,    -0.00120868],
    [-0.00016935,    0.00005876,    -0.00506668,     0.00207976,     0.00050004],
    [ 0.01321749,   -0.00506668,     0.45083132,    -0.18868220,    -0.04545457],
    [-0.00506051,    0.00207976,    -0.18868220,     0.07988865,     0.01926631],
    [-0.00120868,    0.00050004,    -0.04545457,     0.01926631,     0.00464710],
예제 #50
0
파일: rohf.py 프로젝트: vahtras/dalmisc
def udiis(
    Ca,
    Cb,
    na,
    nb,
    iters=10,
    fock=jensen,
    hfx=1,
    threshold=1e-6,
    maxerr=2,
    unrest=False,
    wrkdir="/tmp",
):
    print(Ca, Cb)
    saveD = 1
    saveC = 0
    E = 0
    aooneint = os.path.join(wrkdir, "AOONEINT")
    aotwoint = os.path.join(wrkdir, "AOTWOINT")
    potnuc = one.readhead(aooneint)["potnuc"]
    vecs = []
    vecsa = []
    vecsb = []
    evecsa = []
    evecsb = []
    Eit = []
    S = one.read("OVERLAP", aooneint).unpack().unblock()
    h = S.I @ one.read("ONEHAMIL", aooneint).unpack().unblock()
    Da = dens.C1D(Ca, na) @ S
    Db = dens.C1D(Cb, nb) @ S

    try:
        for i in range(iters):
            Da = dens.C1D(Ca, na) @ S
            Db = dens.C1D(Cb, nb) @ S
            print("D", (Da + Db) @ S.I)
            (Fa, Fb), = two.fockab((Da, Db), hfx=hfx, filename=aotwoint)
            Fa = h + S.I @ Fa
            Fb = h + S.I @ Fb
            E0 = E
            E = ((Da @ (h + Fa)) + (Db @ (h + Fb))).tr() / 2 + potnuc
            D = Da + Db
            print("hd", (h @ D).tr(), h & D, h & D.T)
            print("FD", Fa & Da)
            Eit.append(E)
            ga = Da @ Fa - Fa @ Da
            gb = Db @ Fb - Fb @ Db
            if unrest:
                g2 = -(ga @ ga + gb @ gb)
            else:
                g2 = -(ga + gb) @ (ga + gb)
            gn = math.sqrt(g2.tr())
            print("%2d:E = %16.12f %16.5e %16.2e" % (i + 1, E, gn, E - E0))
            if gn < threshold:
                raise Converged(gn)
            # if E > E0:
            #     raise Exception("Energy increase")
            if unrest:
                Ca = dens.cmo(Fa)
                Cb = dens.cmo(Fb)
                # Ca = Ca*Ua
                # Cb = Cb*Ub
            else:
                Ca = dens.cmo(Feff(Da, Db, Fa, Fb), S)
                Cb = Ca[:, :]
            Da = dens.C1D(Ca, na) @ S
            Db = dens.C1D(Cb, nb) @ S
            if saveD:
                vecsa.append(Da)
                vecsb.append(Db)
                evecsa.append(ga @ Da - Da @ ga)
                evecsb.append(gb @ Db - Db @ gb)
            elif saveC:
                vecsa.append(Ca)
                vecsb.append(Cb)
                evecsa.append(ga)
                evecsb.append(gb)
            else:
                vecsa.append(Fa)
                vecsb.append(Fb)
                evecsa.append(ga)
                evecsb.append(gb)
            edim = min(len(evecsa), maxerr)
            eva = evecsa[-edim:]
            evb = evecsb[-edim:]
            fva = vecsa[-edim:]
            fvb = vecsb[-edim:]
            B = mkB3(eva, evb, unrest)
            rhs = full.matrix((edim + 1, 1))
            rhs[-1, 0] = -1
            c = rhs / B
            subvecsa = full.matrix(Fa.shape)
            subvecsb = full.matrix(Fb.shape)
            for j in range(edim):
                subvecsa += c[j, 0] * fva[j]
                subvecsb += c[j, 0] * fvb[j]
            if saveD:
                Da = subvecsa
                Db = subvecsb
                (Fa, Fb), = two.fockab((Da, Db), hfx=hfx, filename=aotwoint)
                Fa = h + S.I @ Fa
                Fb = h + S.I @ Fb
                vecsa[i] = Da
                vecsb[i] = Db
            elif saveC:
                Ca = subvecsa
                Cb = subvecsb
                Da = dens.C1D(Ca, na) @ S
                Db = dens.C1D(Cb, nb) @ S
            else:
                Fa = subvecsa
                Fb = subvecsb
                Da = dens.C1D(Ca, na) @ S
                Db = dens.C1D(Cb, nb) @ S
    except Converged:
        print("Converged after %d iterations\n" % (i + 1, ))
    except Increase:
        print("Ca Cb", Ca, Cb)
        print("Da Db", Da, Db)
        print("Na Nb", Da.tr(), Db.tr())
        print("Fa Fb", Fa, Fb)
        print("E1", (h * (Da + Db)).tr())
        print("E2", (Fa * Da + Fb * Db).tr() / 2 - (h * (Da + Db)).tr() / 2)
        print("E", E - potnuc)
예제 #51
0
파일: rohf.py 프로젝트: vahtras/dalmisc
def diis(
    C,
    nisht,
    nasht,
    iters=10,
    fock=jensen,
    hfx=1,
    threshold=1e-6,
    maxerr=2,
    wrkdir="/tmp",
):
    C1 = C
    E = 0

    aooneint = pathlib.Path(wrkdir) / "AOONEINT"
    aotwoint = pathlib.Path(wrkdir) / "AOTWOINT"
    potnuc = one.readhead(aooneint)["potnuc"]
    vecs = []
    evecs = []
    h = one.read("ONEHAMIL", aooneint).unpack().unblock()
    S = one.read("OVERLAP", aooneint).unpack().unblock()
    try:
        for i in range(iters):
            Di, Da = dens.C2D(C, nisht, nasht)
            D = Di + Da
            Fc = h + two.fock(D, filename=aotwoint, hfx=hfx)
            Fo = two.fock(Da, hfc=0, filename=aotwoint) + Fc
            F = fock(S, Di, Da, Fc, Fo, C, h)
            E0 = E
            E = ((h + Fc) & D) / 2 + ((Fo - Fc) & Da) / 2 + potnuc
            g = grad(S, C1, Di, Da, Fc, Fo)
            # gao = gradao(S, C, Di, Da, Fc, Fo)
            gn = gradvec(S, C, Di, Da, Fc, Fo, nisht, nasht).norm2()
            gn /= math.sqrt(2)
            print("%2d:E = %16.12f %16.5e %16.2e" % (i + 1, E, gn, E - E0))
            if gn < threshold:
                raise Converged(gn)
            vecs.append(F)
            evecs.append(g)
            edim = min(len(evecs), maxerr)
            ev = evecs[-edim:]
            fv = vecs[-edim:]
            B = mkB(ev)
            rhs = full.matrix((edim + 1, 1))
            rhs[-1, 0] = 1
            c = rhs / B
            subevecs = full.matrix(g.shape)
            subvecs = full.matrix(F.shape)
            for i in range(edim):
                subevecs += c[i, 0] * ev[i]
                subvecs += c[i, 0] * fv[i]
            update = -subevecs
            upd = update.lower()
            upd.anti = 0
            update = upd.unpack()
            F = subvecs  # +update
            C = dens.cmo(F, S)
    except Converged:
        print("-Converged-")
    except Stop:
        print("-STOP-")
예제 #52
0
import numpy
from util.full import matrix

cmo = matrix((24, 24))
cmo[:11, :11] = numpy.array(
    [[
        1.00037005644774, 0.00213928142197, -0.00139645162733,
        0.00250320614892, -0.00168365551156, 0.00000417179213,
        -0.00010568751627, -0.00027311036476, 0.00056204660778,
        0.00052477299313, 0.00045051613113
    ],
     [
         -0.00764995676695, 0.87372007927195, -0.11446369166089,
         0.11081294767437, -0.06188049075196, 0.00122390477237,
         -0.00288482651200, 0.31909593297047, -0.14943668512171,
         -0.03635107656087, -0.02008905901125
     ],
     [
         0.00218188411380, -0.29318297900759, -0.17682717408706,
         0.79267177820451, 0.00181832874368, 0.01768753372185,
         -0.00458766924852, 0.35155848740093, -0.13271279540296,
         -0.03165237343243, 0.00704103155682
     ],
     [
         0.05189274589511, -0.14332375175701, -0.90584515407463,
         -0.28547304713507, -0.21170912054705, -0.00753222886420,
         0.00920238615519, 0.10575589422514, 0.76987725358803,
         -0.01621298099706, -0.01563551317394
     ],
     [
         0.06833791423126, 0.50854763250820, -0.61069110991343,
예제 #53
0
 def setup_class(cls):
     numpy.random.seed(0)
     cls.beta = full.matrix((3, 6)).random()
     cls.dipole = full.matrix(3).random()
예제 #54
0
def fockab(Da, Db, component, **kwargs):
    """ Generate two-electron spin-orbit Fock(alpha,beta) matrix from 
        integral file AO2SOINT
        Input: component 'x', 'y', or 'z'
               Density matrices, tuple (Da, Db)
               AO integral file, FortranBinary object, positioned
        Output Fock matrics, tuple(Fa, Fb)
    """

    hfc = kwargs.get('hfc', 1.0)
    hfx = kwargs.get('hfx', 1.0)

    Fa = matrix(Da.shape)
    Fb = matrix(Db.shape)

    for buf, ibuf in two.list_buffers(label='AO2SOINT', **kwargs):
        for g, ig in zip(buf, ibuf):
            if ig[0] == 0:
                comp = "*xyz"[ig[1]]
            else:
                #print comp, ig, g, component
                if comp != component:
                    continue
                p, q, r, s = ig
                s, r, q, p = (p - 1, q - 1, r - 1, s - 1)
                if (p == q): g *= 0.5
                j = hfc * g
                x = 3 * hfx * g

                #Fa[p,q]=(pq|rs)(2D+(r,s) + D-(r,s))
                Fapq = j * (3 * (Da[r, s] - Da[s, r]) + Db[r, s] - Db[s, r])
                Fa[p, q] += Fapq
                Fa[q, p] += Fapq

                #Fb[p,q]=(pq|rs)(-2D+(r,s) + D-(r,s))
                Fbpq = j * (-(Da[r, s] - Da[s, r]) - 3 * (Db[r, s] - Db[s, r]))
                Fb[p, q] += Fbpq
                Fb[q, p] += Fbpq

                #Fa[r,s]=(pq|rs)(2D-(p,p) + D+(p,q))
                Fars = j * (3 * (Da[p, q] + Da[q, p]) - Db[p, q] - Db[q, p])
                Fa[r, s] += Fars
                Fa[s, r] -= Fars

                #Fb[r,s]=(pq|rs)(2D+(p,q) - D-(p,q))
                Fbrs = j * (Da[p, q] + Da[q, p] - 3 * (Db[p, q] + Db[q, p]))
                Fb[r, s] += Fbrs
                Fb[s, r] -= Fbrs

                Fa[p, s] -= x * Da[r, q]
                Fa[q, s] -= x * Da[r, p]
                Fa[p, r] += x * Da[s, q]
                Fa[q, r] += x * Da[s, p]

                Fb[p, s] += x * Db[r, q]
                Fb[q, s] += x * Db[r, p]
                Fb[p, r] -= x * Db[s, q]
                Fb[q, r] -= x * Db[s, p]

                Fa[r, q] -= x * Da[p, s]
                Fa[r, p] -= x * Da[q, s]
                Fa[s, q] += x * Da[p, r]
                Fa[s, p] += x * Da[q, r]

                Fb[r, q] += x * Db[p, s]
                Fb[r, p] += x * Db[q, s]
                Fb[s, q] -= x * Db[p, r]
                Fb[s, p] -= x * Db[q, r]

    return (Fa, Fb)
예제 #55
0
1     1.481     0.000    -0.349     0.352    -0.153     0.000     0.127    -0.132    -0.000    -0.250    -0.445     0.000    -0.261
"""
PA21 = """AU
3 2 1 1
1     0.000     0.000     0.698    -0.703    -0.000     0.000    -0.284    -3.293     0.000    -0.000    -4.543    -0.000    -4.005     3.466
1    -1.481     0.000    -0.349     0.352     0.153     0.000     0.127    -0.132     0.000     0.250    -0.445     0.000    -0.261     1.576
1     1.481     0.000    -0.349     0.352    -0.153     0.000     0.127    -0.132    -0.000    -0.250    -0.445     0.000    -0.261     1.576
"""
PA22 = """AU
3 2 2 1
1     0.000     0.000     0.698    -0.703    -0.000     0.000    -0.284    -3.293     0.000    -0.000    -4.543    -0.000    -4.005     3.875    -0.000    -0.000     3.000    -0.000     3.524
1    -1.481     0.000    -0.349     0.352     0.153     0.000     0.127    -0.132     0.000     0.250    -0.445     0.000    -0.261     2.156    -0.000     1.106     1.051    -0.000     1.520
1     1.481     0.000    -0.349     0.352    -0.153     0.000     0.127    -0.132    -0.000    -0.250    -0.445     0.000    -0.261     2.156    -0.000    -1.106     1.051    -0.000     1.520
"""

Bm = matrix((3, 6))
# matrix components  (x, y, z)(T) * (xx xy xz yy yz zz)

# xxz, zxx
Bm[0, 2] = Bm[2, 0] = 14.74097586
# yyz, zyy
Bm[1, 4] = Bm[2, 3] = 3.28345383
# zzz
Bm[2, 5] = 9.20782221

OUTPUT_BY_ATOM_n0 = """\
---------------
Atomic domain 1
---------------
Domain center:            0.00000     0.00000     0.69801
Nuclear charge:           8.00000