예제 #1
0
 def spin_square(self, fcivec, norb, nelec):
     from pyscf.fci import spin_op
     if self.nroots == 1:
         return spin_op.spin_square0(fcivec, norb, nelec)
     else:
         ss = [spin_op.spin_square0(c, norb, nelec) for c in fcivec]
         return [x[0] for x in ss], [x[1] for x in ss]
예제 #2
0
 def print_line (c, ne):
     try:
         ss, smult = spin_square0 (c, norb, ne)
         hc = contract_2e (eri, c, norb, ne)
         chc = c.conj ().ravel ().dot (hc.ravel ())
     except AssertionError as e:
         assert (any ([n<0 for n in ne]))
         ss, smult, chc = (0.0, 1.0, 0.0)
     cc = linalg.norm (c)
     ndeta, ndetb = c.shape
     print (" {:>6d} {:>6d} {:>5d} {:>5d} {:5.3f} {:13.9f} {:5.3f} {:5.3f}".format (ne[0], ne[1], ndeta, ndetb, cc, chc, ss, smult))
예제 #3
0
 def test_spin_square(self):
     norb, nelec = 10, 4
     strs = cistring.make_strings(range(norb), nelec)
     numpy.random.seed(11)
     mask = numpy.random.random(len(strs)) > .6
     strsa = strs[mask]
     mask = numpy.random.random(len(strs)) > .7
     strsb = strs[mask]
     ci_strs = (strsa, strsb)
     ci_coeff = selected_ci._as_SCIvector(numpy.random.random((len(strsa),len(strsb))), ci_strs)
     ci0 = selected_ci.to_fci(ci_coeff, norb, (nelec,nelec))
     ss0 = selected_ci.spin_square(ci_coeff, norb, (nelec,nelec))
     ss1 = spin_op.spin_square0(ci0, norb, (nelec,nelec))
     self.assertAlmostEqual(ss0[0], ss1[0], 9)
예제 #4
0
 def spin_square(self, fcivec, norb, nelec):
     nelec = _unpack_nelec(nelec, self.spin)
     return spin_op.spin_square0(fcivec, norb, nelec)
예제 #5
0
 def spin_square(self, fcivec, norb, nelec):
     nelec = _unpack_nelec(nelec, self.spin)
     return spin_op.spin_square0(fcivec, norb, nelec)
예제 #6
0
def get_cc_chc_smult (eri, c, norb, ne):
    cc = c.conj ().ravel ().dot (c.ravel ())
    chc = c.conj ().ravel ().dot (contract_2e (eri, c, norb, ne).ravel ())
    ss, smult = spin_square0 (c, norb, ne)
    return cc, chc, smult
예제 #7
0
파일: sacasscf.py 프로젝트: riddhish-P/mrh
 def debug_lagrange(self,
                    Lvec,
                    bvec,
                    Aop,
                    Adiag,
                    iroot=None,
                    mo=None,
                    ci=None,
                    **kwargs):
     if iroot is None: iroot = self.iroot
     if mo is None: mo = self.base.mo_coeff
     if ci is None: ci = self.base.ci
     lib.logger.info(
         self,
         '{} gradient: iroot = {}'.format(self.base.__class__.__name__,
                                          iroot))
     ngorb = self.ngorb
     nci = self.nci
     nroots = self.nroots
     ndet = nci // nroots
     ncore = self.base.ncore
     ncas = self.base.ncas
     nelecas = self.base.nelecas
     nocc = ncore + ncas
     nlag = self.nlag
     ci = np.asarray(self.base.ci).reshape(nroots, -1)
     err = Aop(Lvec) + bvec
     eorb = self.base.unpack_uniq_var(err[:ngorb])
     eci = err[ngorb:].reshape(nroots, -1)
     borb = self.base.unpack_uniq_var(bvec[:ngorb])
     bci = bvec[ngorb:].reshape(nroots, -1)
     Lorb = self.base.unpack_uniq_var(Lvec[:ngorb])
     Lci = Lvec[ngorb:].reshape(nroots, ndet)
     Aci = Adiag[ngorb:].reshape(nroots, ndet)
     Lci_ci_ovlp = (
         np.asarray(ci).reshape(nroots, -1).conjugate() @ Lci.T).T
     Lci_Lci_ovlp = (Lci.conjugate() @ Lci.T).T
     eci_ci_ovlp = (
         np.asarray(ci).reshape(nroots, -1).conjugate() @ eci.T).T
     bci_ci_ovlp = (
         np.asarray(ci).reshape(nroots, -1).conjugate() @ bci.T).T
     ci_ci_ovlp = ci.conjugate() @ ci.T
     lib.logger.debug(
         self,
         "{} gradient RHS, inactive-active orbital rotations:\n{}".format(
             self.base.__class__.__name__, borb[:ncore, ncore:nocc]))
     lib.logger.debug(
         self,
         "{} gradient RHS, inactive-external orbital rotations:\n{}".format(
             self.base.__class__.__name__, borb[:ncore, nocc:]))
     lib.logger.debug(
         self,
         "{} gradient RHS, active-external orbital rotations:\n{}".format(
             self.base.__class__.__name__, borb[ncore:nocc, nocc:]))
     lib.logger.debug(
         self,
         "{} gradient residual, inactive-active orbital rotations:\n{}".
         format(self.base.__class__.__name__, eorb[:ncore, ncore:nocc]))
     lib.logger.debug(
         self,
         "{} gradient residual, inactive-external orbital rotations:\n{}".
         format(self.base.__class__.__name__, eorb[:ncore, nocc:]))
     lib.logger.debug(
         self,
         "{} gradient residual, active-external orbital rotations:\n{}".
         format(self.base.__class__.__name__, eorb[ncore:nocc, nocc:]))
     lib.logger.debug(
         self,
         "{} gradient Lagrange factor, inactive-active orbital rotations:\n{}"
         .format(self.base.__class__.__name__, Lorb[:ncore, ncore:nocc]))
     lib.logger.debug(
         self,
         "{} gradient Lagrange factor, inactive-external orbital rotations:\n{}"
         .format(self.base.__class__.__name__, Lorb[:ncore, nocc:]))
     lib.logger.debug(
         self,
         "{} gradient Lagrange factor, active-external orbital rotations:\n{}"
         .format(self.base.__class__.__name__, Lorb[ncore:nocc, nocc:]))
     '''
     lib.logger.debug (self, "{} gradient RHS, inactive-inactive orbital rotations (redundant!):\n{}".format (
         self.base.__class__.__name__, borb[:ncore,:ncore]))
     lib.logger.debug (self, "{} gradient RHS, active-active orbital rotations (redundant!):\n{}".format (
         self.base.__class__.__name__, borb[ncore:nocc,ncore:nocc]))
     lib.logger.debug (self, "{} gradient RHS, external-external orbital rotations (redundant!):\n{}".format (
         self.base.__class__.__name__, borb[nocc:,nocc:]))
     lib.logger.debug (self, "{} gradient Lagrange factor, inactive-inactive orbital rotations (redundant!):\n{}".format (
         self.base.__class__.__name__, Lorb[:ncore,:ncore]))
     lib.logger.debug (self, "{} gradient Lagrange factor, active-active orbital rotations (redundant!):\n{}".format (
         self.base.__class__.__name__, Lorb[ncore:nocc,ncore:nocc]))
     lib.logger.debug (self, "{} gradient Lagrange factor, external-external orbital rotations (redundant!):\n{}".format (
         self.base.__class__.__name__, Lorb[nocc:,nocc:]))
     '''
     lib.logger.debug(
         self,
         "{} gradient Lagrange factor, CI part overlap with true CI SA space:\n{}"
         .format(self.base.__class__.__name__, Lci_ci_ovlp))
     lib.logger.debug(
         self,
         "{} gradient Lagrange factor, CI part self overlap matrix:\n{}".
         format(self.base.__class__.__name__, Lci_Lci_ovlp))
     lib.logger.debug(
         self,
         "{} gradient Lagrange factor, CI vector self overlap matrix:\n{}".
         format(self.base.__class__.__name__, ci_ci_ovlp))
     lib.logger.debug(
         self,
         "{} gradient Lagrange factor, CI part response overlap with SA space:\n{}"
         .format(self.base.__class__.__name__, bci_ci_ovlp))
     lib.logger.debug(
         self,
         "{} gradient Lagrange factor, CI part residual overlap with SA space:\n{}"
         .format(self.base.__class__.__name__, eci_ci_ovlp))
     neleca, nelecb = _unpack_nelec(nelecas)
     spin = neleca - nelecb + 1
     csf = CSFTransformer(ncas, neleca, nelecb, spin)
     ecsf = csf.vec_det2csf(eci, normalize=False, order='C')
     err_norm_det = linalg.norm(err)
     err_norm_csf = linalg.norm(np.append(eorb, ecsf.ravel()))
     lib.logger.debug(
         self,
         "{} gradient: determinant residual = {}, CSF residual = {}".format(
             self.base.__class__.__name__, err_norm_det, err_norm_csf))
     ci_lbls, ci_csf = csf.printable_largest_csf(ci,
                                                 10,
                                                 isdet=True,
                                                 normalize=True,
                                                 order='C')
     bci_lbls, bci_csf = csf.printable_largest_csf(bci,
                                                   10,
                                                   isdet=True,
                                                   normalize=False,
                                                   order='C')
     eci_lbls, eci_csf = csf.printable_largest_csf(eci,
                                                   10,
                                                   isdet=True,
                                                   normalize=False,
                                                   order='C')
     Lci_lbls, Lci_csf = csf.printable_largest_csf(Lci,
                                                   10,
                                                   isdet=True,
                                                   normalize=False,
                                                   order='C')
     Aci_lbls, Aci_csf = csf.printable_largest_csf(Aci,
                                                   10,
                                                   isdet=True,
                                                   normalize=False,
                                                   order='C')
     ncsf = bci_csf.shape[1]
     for iroot in range(self.nroots):
         lib.logger.debug(
             self,
             "{} gradient Lagrange factor, CI part root {} spin square: {}".
             format(self.base.__class__.__name__, iroot,
                    spin_square0(Lci[iroot], ncas, nelecas)))
         lib.logger.debug(self, "Base CI vector")
         for icsf in range(ncsf):
             lib.logger.debug(
                 self, '{} {}'.format(ci_lbls[iroot, icsf], ci_csf[iroot,
                                                                   icsf]))
         lib.logger.debug(self, "CI gradient:")
         for icsf in range(ncsf):
             lib.logger.debug(
                 self, '{} {}'.format(bci_lbls[iroot, icsf], bci_csf[iroot,
                                                                     icsf]))
         lib.logger.debug(self, "CI residual:")
         for icsf in range(ncsf):
             lib.logger.debug(
                 self, '{} {}'.format(eci_lbls[iroot, icsf], eci_csf[iroot,
                                                                     icsf]))
         lib.logger.debug(self, "CI Lagrange vector:")
         for icsf in range(ncsf):
             lib.logger.debug(
                 self, '{} {}'.format(Lci_lbls[iroot, icsf], Lci_csf[iroot,
                                                                     icsf]))
         lib.logger.debug(self, "Diagonal of Hessian matrix CI part:")
         for icsf in range(ncsf):
             lib.logger.debug(
                 self, '{} {}'.format(Aci_lbls[iroot, icsf], Aci_csf[iroot,
                                                                     icsf]))
     '''
예제 #8
0
    h1e = reduce(numpy.dot, (m.mo_coeff.T, m.get_hcore(), m.mo_coeff))
    eri = ao2mo.kernel(m._eri, m.mo_coeff, compact=False)
    eri = eri.reshape(norb, norb, norb, norb)

    e1, c1 = kernel(h1e, eri, norb, nelec)
    e2, c2 = direct_spin1.kernel(h1e, eri, norb, nelec)
    print(e1, e1 - -11.894559902235565, 'diff to FCI', e1 - e2)

    print(c1.shape, c2.shape)
    dm1_1 = make_rdm1(c1, norb, nelec)
    dm1_2 = direct_spin1.make_rdm1(c2, norb, nelec)
    print(abs(dm1_1 - dm1_2).sum())
    dm2_1 = make_rdm2(c1, norb, nelec)
    dm2_2 = direct_spin1.make_rdm12(c2, norb, nelec)[1]
    print(abs(dm2_1 - dm2_2).sum())

    myci = SelectedCI()
    e, c = kernel_fixed_space(myci, h1e, eri, norb, nelec, c1._strs)
    print(e - -11.894559902235565)

    print(myci.large_ci(c1, norb, nelec))
    print(
        myci.spin_square(c1, norb, nelec)[0] -
        spin_op.spin_square0(to_fci(c1, norb, nelec), norb, nelec)[0])

    myci = SelectedCI()
    myci = addons.fix_spin_(myci)
    e1, c1 = myci.kernel(h1e, eri, norb, nelec)
    print(e1, e1 - -11.89467612053687)
    print(myci.spin_square(c1, norb, nelec))
예제 #9
0
파일: select_ci.py 프로젝트: eronca/pyscf
    nelec = mol.nelectron
    h1e = reduce(numpy.dot, (m.mo_coeff.T, m.get_hcore(), m.mo_coeff))
    eri = ao2mo.kernel(m._eri, m.mo_coeff, compact=False)
    eri = eri.reshape(norb,norb,norb,norb)

    e1, c1 = kernel(h1e, eri, norb, nelec)
    e2, c2 = direct_spin1.kernel(h1e, eri, norb, nelec)
    print(e1, e1 - -11.894559902235565, 'diff to FCI', e1-e2)

    print(c1.shape, c2.shape)
    dm1_1 = make_rdm1(c1, norb, nelec)
    dm1_2 = direct_spin1.make_rdm1(c2, norb, nelec)
    print(abs(dm1_1 - dm1_2).sum())
    dm2_1 = make_rdm2(c1, norb, nelec)
    dm2_2 = direct_spin1.make_rdm12(c2, norb, nelec)[1]
    print(abs(dm2_1 - dm2_2).sum())

    myci = SelectCI()
    e, c = kernel_fixed_space(myci, h1e, eri, norb, nelec, c1._strs)
    print(e - -11.894559902235565)

    print(myci.large_ci(c1, norb, nelec))
    print(myci.spin_square(c1, norb, nelec)[0] -
          spin_op.spin_square0(to_fci(c1, norb, nelec), norb, nelec)[0])

    myci = SelectCI()
    myci = addons.fix_spin_(myci)
    e1, c1 = myci.kernel(h1e, eri, norb, nelec)
    print(e1, e1 - -11.89467612053687)
    print(myci.spin_square(c1, norb, nelec))
예제 #10
0
    norb = m.mo_coeff.shape[1]
    nelec = mol.nelectron
    h1e = reduce(numpy.dot, (m.mo_coeff.T, m.get_hcore(), m.mo_coeff))
    eri = ao2mo.kernel(m._eri, m.mo_coeff, compact=False)
    eri = eri.reshape(norb, norb, norb, norb)

    e1, c1 = kernel(h1e, eri, norb, nelec)
    e2, c2 = direct_spin1.kernel(h1e, eri, norb, nelec)
    print(e1, e1 - -11.894559902235565, "diff to FCI", e1 - e2)

    print(c1.shape, c2.shape)
    dm1_1 = make_rdm1(c1, norb, nelec)
    dm1_2 = direct_spin1.make_rdm1(c2, norb, nelec)
    print(abs(dm1_1 - dm1_2).sum())
    dm2_1 = make_rdm2(c1, norb, nelec)
    dm2_2 = direct_spin1.make_rdm12(c2, norb, nelec)[1]
    print(abs(dm2_1 - dm2_2).sum())

    myci = SelectCI()
    e, c = kernel_fixed_space(myci, h1e, eri, norb, nelec, c1._strs)
    print(e - -11.894559902235565)

    print(myci.large_ci(c1, norb, nelec))
    print(myci.spin_square(c1, norb, nelec)[0] - spin_op.spin_square0(to_fci(c1, norb, nelec), norb, nelec)[0])

    myci = SelectCI()
    myci = addons.fix_spin_(myci)
    e1, c1 = myci.kernel(h1e, eri, norb, nelec)
    print(e1, e1 - -11.89467612053687)
    print(myci.spin_square(c1, norb, nelec))
예제 #11
0
 def spin_square(self, fcivec, norb, nelec):
     if self.nroots == 1:
         return spin_op.spin_square0(fcivec, norb, nelec)
     else:
         ss = [spin_op.spin_square0(c, norb, nelec) for c in fcivec]
         return [x[0] for x in ss], [x[1] for x in ss]