Example #1
0
    def test_ibo_PM(self):
        mf = scf.RHF(mol).run()
        b = ibo.PM(mol, mf.mo_coeff[:,mf.mo_occ>0], exponent=4).kernel()
        pop = pipek.atomic_pops(mol, b)
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 3.9206879872618576, 5)

        b = ibo.PM(mol, mf.mo_coeff[:,mf.mo_occ>0], exponent=2).kernel()
        pop = pipek.atomic_pops(mol, b)
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 3.9206879872618576, 5)
Example #2
0
    def test_ibo_PM(self):
        mf = scf.RHF(mol).run()
        b = ibo.ibo(mol, mf.mo_coeff[:,mf.mo_occ>0], locmethod='PM', exponent=4).kernel()
        pop = pipek.atomic_pops(mol, b)
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 3.9201797890974261, 5)

        b = ibo.ibo(mol, mf.mo_coeff[:,mf.mo_occ>0], locmethod='PM', exponent=2).kernel()
        pop = pipek.atomic_pops(mol, b)
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 3.9201797890974261, 5)
Example #3
0
    def test_pipek_atomic_pops(self):
        pop = pipek.atomic_pops(h2o, mf_h2o.mo_coeff[:,3:8], method='meta_lowdin')
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 2.8858772271976187, 6)

        pop = pipek.atomic_pops(h2o, mf_h2o.mo_coeff[:,3:8], method='lowdin')
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 2.8271629470491471, 6)

        pop = pipek.atomic_pops(h2o, mf_h2o.mo_coeff[:,3:8], method='mulliken')
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 2.9542028242581448, 6)
Example #4
0
    def test_ibo(self):
        mf = scf.RHF(mol).run()
        b = ibo.ibo(mol, mf.mo_coeff[:,mf.mo_occ>0], exponent=4)
        s_b = reduce(numpy.dot, (b.T, mf.get_ovlp(), b))
        self.assertTrue(abs(s_b.diagonal() - 1).max() < 1e-9)
        pop = pipek.atomic_pops(mol, b)
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 4.0663610846219127, 5)

        b = ibo.ibo(mol, mf.mo_coeff[:,mf.mo_occ>0], exponent=2)
        s_b = reduce(numpy.dot, (b.T, mf.get_ovlp(), b))
        self.assertTrue(abs(s_b.diagonal() - 1).max() < 1e-9)
        pop = pipek.atomic_pops(mol, b)
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 4.0663609732471571, 5)
Example #5
0
 def test_pipek(self):
     idx = numpy.array([17,20,21,22,23,30,36,41,42,47,48,49])-1
     loc = pipek.PipekMezey(mol)
     mo = loc.kernel(mf.mo_coeff[:,idx])
     pop = pipek.atomic_pops(mol, mo)
     z = numpy.einsum('xii,xii->', pop, pop)
     self.assertAlmostEqual(z, 12, 4)
Example #6
0
 def test_pipek(self):
     idx = numpy.array([17,20,21,22,23,30,36,41,42,47,48,49])-1
     loc = pipek.PipekMezey(mol)
     mo = loc.kernel(mf.mo_coeff[:,idx])
     pop = pipek.atomic_pops(mol, mo)
     z = numpy.einsum('xii,xii->', pop, pop)
     self.assertAlmostEqual(z, 12, 9)
Example #7
0
    def test_pipek_atomic_pops(self):
        pop = pipek.atomic_pops(h2o,
                                mf_h2o.mo_coeff[:, 3:8],
                                method='meta_lowdin')
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 2.8858772271976187, 6)

        pop = pipek.atomic_pops(h2o, mf_h2o.mo_coeff[:, 3:8], method='lowdin')
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 2.8271629470491471, 6)

        pop = pipek.atomic_pops(h2o,
                                mf_h2o.mo_coeff[:, 3:8],
                                method='mulliken')
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 2.9542028242581448, 6)
Example #8
0
 def test_pipek_becke_scheme(self):
     loc = pipek.PipekMezey(h2o, mf_h2o.mo_coeff[:, 3:8])
     loc.pop_method = 'becke'
     mo = loc.kernel()
     pop = pipek.atomic_pops(h2o, mo)
     z = numpy.einsum('xii,xii->', pop, pop)
     self.assertAlmostEqual(z, 3.548139685217463, 4)
Example #9
0
 def test_pipek_exp4(self):
     loc = pipek.PipekMezey(h2o, mf_h2o.mo_coeff[:, 3:8])
     loc.exponent = 4
     loc.max_cycle = 100
     mo = loc.kernel()
     pop = pipek.atomic_pops(h2o, mo)
     z = numpy.einsum('xii,xii->', pop, pop)
     self.assertAlmostEqual(z, 3.5368940222128247, 4)
Example #10
0
 def test_pipek_exp4(self):
     loc = pipek.PipekMezey(h2o, mf_h2o.mo_coeff[:,3:8])
     loc.exponent = 4
     loc.max_cycle = 100
     mo = loc.kernel()
     pop = pipek.atomic_pops(h2o, mo)
     z = numpy.einsum('xii,xii->', pop, pop)
     self.assertAlmostEqual(z, 3.5368940222128247, 4)
Example #11
0
 def test_vvo(self):
     mf = scf.RHF(mol).run()
     nocc = numpy.sum(mf.mo_occ > 0)
     b = vvo.vvo(mol, mf.mo_coeff[:, 0:nocc], mf.mo_coeff[:, nocc:])
     s_b = reduce(numpy.dot, (b.T, mf.get_ovlp(), b))
     self.assertTrue(abs(s_b.diagonal() - 1).max() < 1e-9)
     pop = pipek.atomic_pops(mol, b)
     z = numpy.einsum('xii,xii->', pop, pop)
     self.assertAlmostEqual(z, 0.6695907625196215, 5)
Example #12
0
 def test_pipek(self):
     idx = numpy.array([17, 20, 21, 22, 23, 30, 36, 41, 42, 47, 48, 49]) - 1
     # Initial guess from Boys localization. Otherwise uncertainty between
     # two solutions found in PM kernel
     mo = boys.Boys(mol, mf.mo_coeff[:, idx]).kernel()
     loc = pipek.PipekMezey(mol, mo)
     loc.max_cycle = 100
     mo = loc.kernel()
     pop = pipek.atomic_pops(mol, mo)
     z = numpy.einsum('xii,xii->', pop, pop)
     self.assertAlmostEqual(z, 12, 4)
Example #13
0
    def test_livvo_PM(self):
        mf = scf.RHF(mol).run()
        nocc = numpy.sum(mf.mo_occ > 0)
        b = vvo.livvo(mol,
                      mf.mo_coeff[:, 0:nocc],
                      mf.mo_coeff[:, nocc:],
                      locmethod='PM',
                      exponent=4).kernel()
        pop = pipek.atomic_pops(mol, b)
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 0.6695907625196215, 5)

        b = vvo.livvo(mol,
                      mf.mo_coeff[:, 0:nocc],
                      mf.mo_coeff[:, nocc:],
                      locmethod='PM',
                      exponent=2).kernel()
        pop = pipek.atomic_pops(mol, b)
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 0.6695907625196215, 5)
Example #14
0
    def test_livvo(self):
        mf = scf.RHF(mol).run()
        nocc = numpy.sum(mf.mo_occ > 0)
        b = vvo.livvo(mol,
                      mf.mo_coeff[:, 0:nocc],
                      mf.mo_coeff[:, nocc:],
                      exponent=4)
        s_b = reduce(numpy.dot, (b.T, mf.get_ovlp(), b))
        self.assertTrue(abs(s_b.diagonal() - 1).max() < 1e-9)
        pop = pipek.atomic_pops(mol, b)
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 1.073138251815934, 5)

        b = vvo.livvo(mol,
                      mf.mo_coeff[:, 0:nocc],
                      mf.mo_coeff[:, nocc:],
                      exponent=2)
        s_b = reduce(numpy.dot, (b.T, mf.get_ovlp(), b))
        self.assertTrue(abs(s_b.diagonal() - 1).max() < 1e-9)
        pop = pipek.atomic_pops(mol, b)
        z = numpy.einsum('xii,xii->', pop, pop)
        self.assertAlmostEqual(z, 1.073138251815934, 5)