Example #1
0
    def parse_gamout(self, gamout, mol):
        result = gparse(gamout)
        if not result.success:
            raise GamessError(result.error_message)

        nmol = Chem.Mol(mol)
        conf = nmol.GetConformer(0)
        nmol.SetDoubleProp("total_energy", result.total_energy)
        nmol.SetDoubleProp("H**O", result.H**O)
        nmol.SetDoubleProp("LUMO", result.LUMO)
        nmol.SetDoubleProp("nHOMO", result.nHOMO)
        nmol.SetDoubleProp("nLUMO", result.nLUMO)
        nmol.SetDoubleProp("dipole_moment", result.dipole_moment[3])
        nmol.SetDoubleProp("dx", result.dipole_moment[0])
        nmol.SetDoubleProp("dy", result.dipole_moment[1])
        nmol.SetDoubleProp("dz", result.dipole_moment[2])
        nmol.SetProp("orbital_energies",
                     " ".join([str(v) for v in result.orbital_energies]))
        nmol.SetProp("program", "GAMESS")
        nmol.SetProp("basis", str(self._options['basis']))
        nmol.SetProp("method", str(self._options['contrl']))

        for i, cds in enumerate(result.coordinates):
            conf.SetAtomPosition(i, cds)

        for i, c in enumerate(
                zip(result.mulliken_charges, result.lowdin_charges)):
            atom = nmol.GetAtomWithIdx(i)
            atom.SetDoubleProp("mulliken_charge", c[0])
            atom.SetDoubleProp("lowdin_charge", c[1])
        Chem.CreateAtomDoublePropertyList(nmol, "mulliken_charge")
        Chem.CreateAtomDoublePropertyList(nmol, "lowdin_charge")

        result.mol = nmol
        return result
Example #2
0
    def testCreateLists(self):
        suppl = Chem.SDMolSupplier()
        suppl.SetData(self.sdf)
        m = suppl[0]
        self.assertTrue(m.GetAtomWithIdx(0).HasProp("NumHeavyNeighbors"))
        m.ClearProp("atom.iprop.NumHeavyNeighbors")
        self.assertFalse(m.HasProp("atom.iprop.NumHeavyNeighbors"))
        Chem.CreateAtomIntPropertyList(m, "NumHeavyNeighbors")
        self.assertTrue(m.HasProp("atom.iprop.NumHeavyNeighbors"))

        self.assertTrue(m.GetAtomWithIdx(0).HasProp("PartialCharge"))
        m.ClearProp("atom.dprop.PartialCharge")
        self.assertFalse(m.HasProp("atom.dprop.PartialCharge"))
        Chem.CreateAtomDoublePropertyList(m, "PartialCharge")
        self.assertTrue(m.HasProp("atom.dprop.PartialCharge"))

        self.assertTrue(m.GetAtomWithIdx(0).HasProp("IsCarbon"))
        m.ClearProp("atom.bprop.IsCarbon")
        self.assertFalse(m.HasProp("atom.bprop.IsCarbon"))
        Chem.CreateAtomBoolPropertyList(m, "IsCarbon")
        self.assertTrue(m.HasProp("atom.bprop.IsCarbon"))

        self.assertTrue(m.GetAtomWithIdx(0).HasProp("PartiallyMissing"))
        m.ClearProp("atom.prop.PartiallyMissing")
        self.assertFalse(m.HasProp("atom.prop.PartiallyMissing"))
        Chem.CreateAtomStringPropertyList(m, "PartiallyMissing")
        self.assertTrue(m.HasProp("atom.prop.PartiallyMissing"))
        self.assertEqual(m.GetProp("atom.prop.PartiallyMissing"),
                         "one n/a three")
        Chem.CreateAtomStringPropertyList(m,
                                          "PartiallyMissing",
                                          missingValueMarker="?")
        self.assertTrue(m.HasProp("atom.prop.PartiallyMissing"))
        self.assertEqual(m.GetProp("atom.prop.PartiallyMissing"),
                         "[?] one ? three")
Example #3
0
def molecule_to_rdkit(molecule):
    if molecule._rdmol is None:
        rdmol = rdmol_from_qcelemental(molecule.qcmol, guess_connectivity=True)
    else:
        rdmol = Chem.Mol(molecule._rdmol)

    for conformer in molecule.conformers:
        add_conformer_from_coordinates(rdmol, conformer.coordinates)

    charges = molecule.charges
    if charges is not None:
        for charge, atom in zip(charges, rdmol.GetAtoms()):
            atom.SetDoubleProp("PartialCharge", charge)
        Chem.CreateAtomDoublePropertyList(rdmol, "PartialCharge")
    rdmol.UpdatePropertyCache(strict=False)
    return Chem.Mol(rdmol)