Beispiel #1
0
    def test_dampmut(self):
        tconfig.setup(key, xyz, dloop=True)

        n = len(tconfig.r_list)

        index = [2, 4]

        for i in range(n):
            dmpik = damping.dampmut(tconfig.r_list[i], tconfig.alphai_list[i],
                                    tconfig.alphak_list[i])
            for j in index:
                self.assertEqual(round(kdmpik[i][j], 5), round(dmpik[j], 5))
Beispiel #2
0
    def test_atomid(self):

        key = f'{path}/testitems/water21test.key'
        xyz = f'{path}/testitems/waterwater.xyz'
        tconfig.setup(key, xyz)

        for i in tconfig.ATOMID:
            i.rotmat(tconfig.ATOMID)
            i.rotsite()

        n = len(tconfig.atomtype[0])

        rotmat = [np.array([[-0.85607447,  0.,          0.5168525 ],
                            [ 0.,         -1.,          0.        ],
                            [ 0.5168525,   0.,          0.85607447]]),
                np.array([[-0.11350188,  0.,         -0.99353778],
                          [ 0.,          1.,          0.        ],
                          [ 0.99353778,  0.,         -0.11350188]]),
                np.array([[ 0.93207075,  0.,          0.36227631],
                          [ 0.,         -1.,          0.        ],
                          [ 0.36227631,  0.,         -0.93207075]]),
                np.array([[ 0.,         -0.86273158,  0.50566216],
                          [-1.,         -0.,          0.        ],
                          [ 0.,         -0.50566216, -0.86273158]]),
                np.array([[ 4.00153410e-01,  8.62731581e-01, -3.09146353e-01],
                          [-6.11369365e-01,  2.77555756e-17, -7.91345373e-01],
                          [-6.82718645e-01,  5.05662159e-01,  5.27447659e-01]]),
                np.array([[ 4.00153410e-01, -8.62731581e-01, -3.09146353e-01],
                          [ 6.11369365e-01,  2.77555756e-17,  7.91345373e-01],
                          [-6.82718645e-01, -5.05662159e-01,  5.27447659e-01]])]

        pole = [np.array([-0.374842, 0.0, 0.0, 0.02863695393261772, 0.06349786711892166, 0.0, 0.0, 0.0, -0.057043769783220545, 0.0, 0.0, 0.0, -0.006454097335701115]),
                np.array([0.187421, 0.0, 0.0, -0.10589682669043772, 0.006247996344765849, 0.0, 0.0006849497606354099, 0.0, 0.004089723196031596, 0.0, 0.0006849497606354099, 0.0, -0.010337719540797445]),
                np.array([0.187421, 0.0, 0.0, -0.10589682669043772, 0.006247996344765849, 0.0, 0.0006849497606354099, 0.0, 0.004089723196031596, 0.0, 0.0006849497606354099, 0.0, -0.010337719540797445]),
                np.array([-0.374842, 0.0, 0.0, 0.02863695393261772, 0.06349786711892166, 0.0, 0.0, 0.0, -0.057043769783220545, 0.0, 0.0, 0.0, -0.006454097335701115]),
                np.array([0.187421, 0.0, 0.0, -0.10589682669043772, 0.006247996344765849, 0.0, 0.0006849497606354099, 0.0, 0.004089723196031596, 0.0, 0.0006849497606354099, 0.0, -0.010337719540797445]),
                np.array([0.187421, 0.0, 0.0, -0.10589682669043772, 0.006247996344765849, 0.0, 0.0006849497606354099, 0.0, 0.004089723196031596, 0.0, 0.0006849497606354099, 0.0, -0.010337719540797445])]

        rpole = [np.array([-0.374842, 0.014801081257770974, 0.0, 0.024515365062338562, 0.04481114362986063, 0.0, -0.030951242019077944, 0.0, -0.057043769783220545, 0.0, -0.030951242019077944, 0.0, 0.01223262615335991]),
                 np.array([0.187421, 0.10521249821235, 0.0, 0.012019489299502403, -0.009969569720161681, 0.0, -0.002537646589370999, 0.0, 0.004089723196031596, 0.0, -0.002537646589370999, 0.0, 0.005879846524130083]),
                 np.array([0.187421, -0.03836391140936379, 0.0, 0.0987033343128746, 0.004533788668292257, 0.0, 0.005095292897111618, 0.0, 0.004089723196031596, 0.0, 0.005095292897111618, 0.0, -0.008623511864323854]),
                 np.array([-0.374842, 0.01448062395724662, 0.0, -0.024706004540347774, -0.04410828298700111, 0.0, -0.022069780726477247, 0.0, 0.06349786711892166, 0.0, -0.022069780726477247, 0.0, -0.019389584131920556]),
                 np.array([0.187421, 0.03273761779816242, 0.08380096380258448, -0.05585503334314615, 0.002886995206979475, -0.004144993603861457, 0.002052025054034695, -0.004144993603861457, -0.003475671731847581, 0.007071948770927506, 0.002052025054034695, 0.007071948770927506, 0.0005886765248681071]),
                 np.array([0.187421, 0.03273761779816242, -0.08380096380258448, -0.05585503334314615, 0.002886995206979475, 0.004144993603861457, 0.002052025054034695, 0.004144993603861457, -0.003475671731847581, -0.007071948770927506, 0.002052025054034695, -0.007071948770927506, 0.0005886765248681071])]

        self.assertEqual(tconfig.atomtype[0], [i.atomtype for i in tconfig.ATOMID])
        self.assertEqual([i.tolist() for i in tconfig.coordinates[0]], [i.coordinates.tolist() for i in tconfig.ATOMID])
        self.assertEqual(tconfig.connectivity[0], [i.connectivity for i in tconfig.ATOMID])
        self.assertEqual([np.round(i,6).tolist() for i in rotmat], [np.round(i.a,6).tolist() for i in tconfig.ATOMID])
        self.assertEqual([np.round(i,6).tolist() for i in pole], [np.round(i.pole,6).tolist() for i in tconfig.ATOMID])
        self.assertEqual([np.round(i,6).tolist() for i in rpole], [np.round(i.rpole,6).tolist() for i in tconfig.ATOMID])
Beispiel #3
0
    def test_damprep(self):
        tconfig.setup(key, xyz, dloop=True)

        n = len(tconfig.r_list)

        for i in range(n):
            dmpikr = damping.damprep(tconfig.r_list[i], tconfig.r2_list[i],
                                     tconfig.rr1_list[i], tconfig.rr3_list[i],
                                     tconfig.rr5_list[i], tconfig.rr7_list[i],
                                     tconfig.rr9_list[i], 9,
                                     tconfig.dmppri_list[i],
                                     tconfig.dmpprk_list[i])
            self.assertListEqual(list(np.round(kdmpikr[i], 5)),
                                 list(np.round(list(dmpikr), 5)))
Beispiel #4
0
    def test_damppole(self):
        tconfig.setup(key, xyz, dloop=True)

        n = len(tconfig.r_list)

        for i in range(n):
            dmpi, dmpk, dmpik = damping.damppole(tconfig.r_list[i], 9,
                                                 tconfig.alphai_list[i],
                                                 tconfig.alphak_list[i])
            self.assertListEqual(list(np.round(kdmpi[i], 5)),
                                 list(np.round(list(dmpi), 5)))
            self.assertListEqual(list(np.round(kdmpk[i], 5)),
                                 list(np.round(list(dmpk), 5)))
            self.assertListEqual(list(np.round(kdmpik[i], 5)),
                                 list(np.round(list(dmpik), 5)))
Beispiel #5
0
    def test_empole3a(self):
        key = f'{path}/testitems/water21test.key'
        xyz = f'{path}/testitems/waterwater.xyz'
        tconfig.setup(key, xyz)

        kem = -8.503511879615823
        keinter = -8.503511879615823
        knem = 9

        config.rotmat(tconfig.ATOMID)

        em, einter, nem = empole3.empole3a(tconfig.ATOMID)

        self.assertEqual(np.round(kem, 6), np.round(em, 6))
        self.assertEqual(np.round(keinter, 6), np.round(einter, 6))
        self.assertEqual(knem, nem)
Beispiel #6
0
    def test_epolar3m(self):

        kep = -0.96210636
        knep = 27

        tconfig.setup(key, xyz, dloop=True)

        config.rotmat(tconfig.ATOMID)

        config.dfield0(tconfig.ATOMID)

        induce.induce0m(tconfig.ATOMID)

        ep, einter, nep = epolar3.epolar3m(tconfig.ATOMID)

        self.assertEqual(round(kep, 4), round(ep, 4))
        self.assertEqual(knep, nep)
Beispiel #7
0
    def test_dampmutm(self):
        tconfig.setup(key, xyz, dloop=True)

        n = len(tconfig.r_list)

        indexi = [2]
        indexk = [2]
        indexik = [2, 4, 6]

        for i in range(n):
            dmpi, dmpk, dmpik = damping.dampmutm(tconfig.r_list[i],
                                                 tconfig.alphai_list[i],
                                                 tconfig.alphak_list[i])
            for j in indexi:
                self.assertEqual(round(kdmpi[i][j], 5), round(dmpi[j], 5))
            for j in indexk:
                self.assertEqual(round(kdmpk[i][j], 5), round(dmpk[j], 5))
            for j in indexik:
                self.assertEqual(round(kdmpik[i][j], 5), round(dmpik[j], 5))
Beispiel #8
0
    def test_dfield0m(self):

        kfieldp = [[
            0.02379644, 0.0335467, 0.01730396, 0.05066768, 0.01820036,
            0.01820036
        ], [0., 0., 0., 0., 0.01092463, -0.01092463],
                   [
                       0.00623291, 0.00776782, -0.0017124, -0.00968786,
                       -0.01237913, -0.01237913
                   ]]

        tconfig.setup(key, xyz, dloop=True)

        config.rotmat(tconfig.ATOMID)

        field, fieldp = induce.dfield0m(tconfig.ATOMID)

        for i in range(3):
            self.assertListEqual(list(np.round(kfieldp[i], 5)),
                                 list(np.round(fieldp[i], 5)))
Beispiel #9
0
    def test_dfield0a(self):

        kfieldp = [[
            0.02619577, 0.07496387, 0.01744932, 0.04682931, 0.01790609,
            0.01790609
        ], [0., 0., 0., 0., 0.01083918, -0.01083918],
                   [
                       0.00620645, 0.0047009, -0.00175382, -0.00948837,
                       -0.01230889, -0.01230889
                   ]]

        tconfig.setup(key, xyz, dloop=True)

        config.rotmat(tconfig.ATOMID)

        field, fieldp = induce.dfield0a(tconfig.ATOMID)

        for i in range(3):
            self.assertListEqual(list(np.round(kfieldp[i], 5)),
                                 list(np.round(fieldp[i], 5)))
Beispiel #10
0
    def test_epolar3a(self):

        kep = -0.96210636
        keinter = -0.96210636
        knep = 9

        tconfig.setup(key, xyz, dloop=True)

        config.rotmat(tconfig.ATOMID)

        config.dfield0(tconfig.ATOMID)

        induce.induce0m(tconfig.ATOMID)

        config.param_dict['epolar3a'] = True

        ep, einter, nep = epolar3.epolar3(tconfig.ATOMID)

        self.assertEqual(round(kep, 4), round(ep, 4))
        self.assertEqual(round(keinter, 4), round(einter, 4))
        self.assertEqual(knep, nep)
Beispiel #11
0
    def test_induce0m(self):

        kuind = [[2.38082614e-02, -7.18338014e-20, 4.60949086e-03],
                 [3.35357882e-02, 6.41583027e-19, 8.46639724e-04],
                 [9.13084719e-03, 9.98402841e-20, -5.18881980e-03],
                 [4.11632270e-02, -1.59110481e-19, -8.14876329e-03],
                 [6.05978292e-03, 5.06831844e-03, -5.04490841e-03],
                 [6.05978292e-03, -5.06831844e-03, -5.04490841e-03]]

        tconfig.setup(key, xyz, dloop=True)

        config.rotmat(tconfig.ATOMID)

        config.dfield0(tconfig.ATOMID)

        induce.induce0m(tconfig.ATOMID)

        n = len(tconfig.ATOMID)

        for i in range(n):
            self.assertListEqual(list(np.round(kuind[i], 3)),
                                 list(np.round(tconfig.ATOMID[i].uind, 3)))
Beispiel #12
0
    def test_katom(self):
        key = f'{path}/testitems/water21test.key'
        xyz = f'{path}/testitems/waterwater.xyz'
        tconfig.setup(key, xyz)

        for k in tconfig.atom_dict.keys():
            self.assertEqual(tconfig.atom_dict[k], tconfig.ATOM[k].returnlist())
        for k in tconfig.bond_dict.keys():
            self.assertEqual(tconfig.bond_dict[k], tconfig.BOND[k].returnlist())
        for k in tconfig.angle_dict.keys():
            self.assertEqual(tconfig.angle_dict[k], tconfig.ANGLE[k].returnlist())
        for k in tconfig.repel_dict.keys():
            self.assertEqual(tconfig.repel_dict[k], tconfig.REPEL[k].returnlist())
        for k in tconfig.disp_dict.keys():
            self.assertEqual(tconfig.disp_dict[k], tconfig.DISP[k].returnlist())
        for k in tconfig.mpole_dict.keys():
            self.assertTrue(set(tconfig.mpole_dict[k]).issubset(set(tconfig.MPOLE[k].returnlist())))
        for k in tconfig.chgpen_dict.keys():
            self.assertEqual(tconfig.chgpen_dict[k], tconfig.CHGPEN[k].returnlist())
        for k in tconfig.polarize_dict.keys():
            self.assertEqual(tconfig.polarize_dict[k], tconfig.POLARIZE[k].returnlist())
        for k in tconfig.chgtrn_dict.keys():
            self.assertEqual(tconfig.chgtrn_dict[k], tconfig.CHGTRN[k].returnlist())