def sucess_analyses(output, leader_list, n, ref): print "Calculating RMSD with the reference" ext = ref.split(".")[1] conv = OBConversion() conv.SetInFormat(ext) mol = OBMol() conv.ReadFile(mol, ref) str_info = "\t%s\t %20s\t %20s\n" % ("File", "Model", "RMSD") for i in range(0, n): rmsd = getRMSD(leader_list[i], mol) str_info += "%s\t%20s \t%20.3f\n" % (leader_list[i].getFileBelow(), leader_list[i].getID(), rmsd) out_log = file(output + "_rmsd_" + ".info", "w") out_log.write(str_info) out_log.close()
def atom_count(str_data, in_format): mol = OBMol() conv = OBConversion() conv.SetInFormat(in_format) conv.ReadString(mol, str_data) return mol.NumAtoms()
def atoms_positions_parser(input): """ :param input: The input string :type input: str :rtype: Molecule """ lines = input.split('\n') element_table = OBElementTable() mol = OBMol() for line in lines: matches = search(atoms_positions_pattern, line) # Create the atom atom = mol.NewAtom() # Set the proper atomic number with respect of the atomic symbol atomic_number = element_table.GetAtomicNum(matches.group(2)) atom.SetAtomicNum(atomic_number) # Set the atom vector x = float(matches.group(3)) * 0.529177 y = float(matches.group(4)) * 0.529177 z = float(matches.group(5)) * 0.529177 atom.SetVector(x, y, z) return Molecule(mol)
def InitializeFragment(self, atomicNum): mol=OBMol() atom=Atom(self, atomicNum) for mol in self.miner.GetAllMolecules(): for a in OBMolAtomIter(mol): if atom.Match(a): self.embedings.append(Embeding({atom.atomIndex : a.GetIdx()}, molecule=mol, fragment=self))
def convert_str(str_data, in_format, out_format): mol = OBMol() conv = OBConversion() conv.SetInFormat(in_format) conv.SetOutFormat(out_format) conv.ReadString(mol, str_data) return (conv.WriteString(mol), conv.GetOutFormat().GetMIMEType())
def cjson_to_ob_molecule(cjson): cjson_str = json.dumps(cjson) sdf_str = avo_convert_str(cjson_str, 'cjson', 'sdf') conv = OBConversion() conv.SetInFormat('sdf') conv.SetOutFormat('sdf') mol = OBMol() conv.ReadString(mol, sdf_str) return mol
def __init__(self, smile): self._smile = smile.strip() conv = OBConversion() if not conv.SetInAndOutFormats('smi', 'inchi'): raise 'Problem with openbabel' mol = OBMol() if not conv.ReadString(mol, self._smile): raise TypeError, "No such smile: %s" % self._smile self._inchi = conv.WriteString(mol).strip()
def all_to_all(): """Function to compare all to all""" # Set up the OpenBaebel conversion modules sdconv = OBConversion() ligref = OBMol() # Define the residues and the proteisn to analyse res_d, prot_list = get_dict("myFirstFile.txt") # Now read in the ligand sdconv.SetInFormat("sdf") notatend = sdconv.ReadFile(ligref, "../mols.sdf") out_d = {} counter = 0 # Now read the ligand file while notatend: lig_name = ligref.GetTitle().strip(",") prot_name = lig_name.split("_")[0] if prot_name not in prot_list: ligref = OBMol() notatend = sdconv.Read(ligref) continue ligref.AddHydrogens() counter += 1 print counter for j, my_prot in enumerate(prot_list): protref = read_prot( r"C:\www\Protoype\media_coninchi\pdb" + "\\" + my_prot + "al.pdb", res_d) # Get the reference dictionary refresdict = pp.getresiduedict(protref, res_d) # Update this dict, to only residues in the binding site new_d = get_fp(protref, ligref, res_d) # Make sure it is a unique name for the output while lig_name in out_d: lig_name = lig_name + "Z" # Add it to the dict out_d[lig_name + my_prot] = {} for res in new_d: # Assign each residue the scores for each molecule out_d[lig_name + my_prot][res] = new_d[res] # Make the ligand ligref = OBMol() notatend = sdconv.Read(ligref) # Now write the results out write_res(out_d, res_d)
def LoadMolFromSmiles(smiles): """Returns an OBMol construcetd from an SMILES code""" smiles = sorted(smiles.split("."), key=len)[-1] ## Strip salts mol=OBMol() loader=OBConversion() loader.SetInAndOutFormats("smi","smi") if not loader.ReadString(mol, smiles): return None mol.smilesCode=smiles return mol
def to_inchi(str_data, in_format): mol = OBMol() conv = OBConversion() conv.SetInFormat(in_format) # Hackish for now, convert to xyz first... conv.SetOutFormat('xyz') conv.ReadString(mol, str_data) xyz = conv.WriteString(mol) # Now convert to inchi and inchikey. mol = OBMol() conv.SetInFormat('xyz') conv.ReadString(mol, xyz) conv.SetOutFormat('inchi') inchi = conv.WriteString(mol).rstrip() conv.SetOptions("K", conv.OUTOPTIONS) inchikey = conv.WriteString(mol).rstrip() return (inchi, inchikey)
def to_inchi(str_data, in_format): mol = OBMol() conv = OBConversion() conv.SetInFormat(in_format) conv.ReadString(mol, str_data) conv.SetOutFormat('inchi') inchi = conv.WriteString(mol).rstrip() conv.SetOptions('K', conv.OUTOPTIONS) inchikey = conv.WriteString(mol).rstrip() return (inchi, inchikey)
def get_formula(str_data, in_format): # Inchi must start with 'InChI=' if in_format == 'inchi' and not str_data.startswith('InChI='): str_data = 'InChI=' + str_data validate_start_of_inchi(str_data) # Get the molecule using the "Hill Order" - i. e., C first, then H, # and then alphabetical. mol = OBMol() conv = OBConversion() conv.SetInFormat(in_format) conv.ReadString(mol, str_data) return mol.GetFormula()
def type_mof(filename, output_dir, ff="uff", output_files=True): obconversion = OBConversion() obconversion.SetInAndOutFormats("cif", "xyz") obmol = OBMol() # Read MOF file and unit cell and write xyz file obconversion.ReadFile(obmol, filename) unitcell = openbabel.toUnitCell(obmol.GetData(openbabel.UnitCell)) uc = [ unitcell.GetA(), unitcell.GetB(), unitcell.GetC(), unitcell.GetAlpha(), unitcell.GetBeta(), unitcell.GetGamma() ] obconversion.WriteFile(obmol, 'mof_tmp.xyz') # Replicate unit cell using angstrom mol = Molecule(read='mof_tmp.xyz') mol.set_cell(uc) n_atoms = len(mol.atoms) mol333 = mol.replicate([3, 3, 3], center=True) print(mol333.cell) mol333.write('mof333.cif', cell=mol333.cell.to_list()) # Type FF obconversion.ReadFile(obmol, 'mof333.cif') ff = OBForceField.FindForceField("UFF") if not ff.Setup(obmol): print("Error: could not setup force field") ff.GetAtomTypes(obmol) # Get atom types for the middle cell types = [] for atom_idx, obatom in enumerate(OBMolAtomIter(obmol)): if atom_idx >= n_atoms * 13 and atom_idx < n_atoms * 14: ff_atom_type = obatom.GetData("FFAtomType").GetValue() types.append(ff_atom_type) if output_files: mof_name = os.path.splitext(os.path.basename(filename))[0] with open(os.path.join(output_dir, mof_name + "-obabel.log"), 'w') as f: f.write("NOTE: types order is the same as the CIF input file.\n") f.write("types= %s" % str(types)) uniq_types = sorted(set(types)) return [str(i) for i in uniq_types]
def get_inchikey(ser): try: if 'inchikey' in ser: return ser.inchikey if ser.inchi is None or ser.inchi == '': raise Exception('Empty inchi') mol = OBMol() ob_conversion.ReadString(mol, ser.inchi) return ob_conversion.WriteString(mol).strip('\n') except Exception as e: LOG.warning(e) return '{}-{}-{}'.format(ser.formula, ser['name'], ser['id'])
def one_to_many(): """Function to take multiple confs of ONE ligand and generate their PLIFS against one template protein""" # Set up the OpenBaebel conversion modules sdconv = OBConversion() ligref = OBMol() # Define the residues and the proteisn to analyse res_d, prot_list = get_dict("myFirstFile.txt") # Now read in the ligand sdconv.SetInFormat("sdf") notatend = sdconv.ReadFile(ligref, "../out.sdf") out_d = {} counter = 0 my_prot = "1qmz" protref = read_prot( r"C:\www\Protoype\media_coninchi\pdb" + "\\" + my_prot + "al.pdb", res_d) # Now read the ligand file while notatend: lig_name = ligref.GetTitle().strip(",") prot_name = lig_name.split("_")[0] ligref.AddHydrogens() counter += 1 print counter # Get the reference dictionary refresdict = pp.getresiduedict(protref, res_d) # Update this dict, to only residues in the binding site new_d = get_fp(protref, ligref, res_d) # Add it to the dict out_d[lig_name + str(counter)] = {} for res in new_d: # Assign each residue the scores for each molecule out_d[lig_name + str(counter)][res] = new_d[res] # Make the ligand ligref = OBMol() notatend = sdconv.Read(ligref) # Now write the results out write_res(out_d, res_d)
def ToCannonicalSmiles(self): atomCache={} mol=OBMol() for sourceAtom in self.atoms: atom=mol.NewAtom() atom.SetAtomicNum(sourceAtom.GetAtomicNum()) if sourceAtom.IsAromatic(): atom.SetAromatic() atom.SetSpinMultiplicity(2) atomCache[sourceAtom]=atom for sourceBond in self.bonds: mol.AddBond(atomCache[sourceBond.atom1].GetIdx(), atomCache[sourceBond.atom2].GetIdx(), sourceBond.GetBondOrder()) writer=OBConversion() writer.SetInAndOutFormats("smi", "can") return writer.WriteString(mol).strip()
def get_atomic_fragments_from_mol(xyz): """Get the fragments around each atom Args: xyz (string): XYZ file for the """ # Read in the molecule mol = OBMol() converter.ReadString(mol, xyz) # Determine ring types OBRingTyper().AssignTypes(mol) # For each atom, get its local environment return [get_atomic_environment(atom) for atom in OBMolAtomIter(mol)]
def read_prot(prot_file, res_d): """Function to read in a protein to an OBMol""" conv = OBConversion() protref = OBMol() conv.SetInFormat("pdb") conv.ReadFile(protref, prot_file) # Now assign the residue names i = 0 my_res = [] for residue in OBResidueIter(protref): i += 1 residue.SetName(residue.GetName() + str(residue.GetNum())) my_res.append(residue.GetName()) # Now check that all the residues exist and print out if not fail_counter = 0 fail_list = [] # Loop through the res and check they are in the list for res_me in res_d: if res_me not in my_res: fail_counter += 1 fail_list.append(res_me) # If it's out of register by one do again if fail_counter > 0: i = 0 my_res = [] for residue in OBResidueIter(protref): i += 1 residue.SetName(residue.GetName() + str(residue.GetNum())) my_res.append(residue.GetName()) # Now check that all the residues exist and print out if not fail_counter = 0 fail_list = [] # Loop through the res and check they are in the list for res_me in res_d: if res_me not in my_res: fail_counter += 1 fail_list.append(res_me) out_err.write(prot_file + ",") out_err.write(str(fail_counter) + "\n") out_err.write(str(fail_list)) out_err.write(str(my_res)) out_err.write(str(res_d)) protref.AddHydrogens() return protref
def ToOBMol(self): atomCache={} mol=OBMol() mol.BeginModify() for sourceAtom in self.atoms: atom=mol.NewAtom() atom.SetAtomicNum(sourceAtom.GetAtomicNum()) if sourceAtom.IsAromatic(): atom.SetAromatic() ## atom.SetSpinMultiplicity(2) atomCache[sourceAtom]=atom for sourceBond in self.bonds: mol.AddBond(atomCache[sourceBond.atom1].GetIdx(), atomCache[sourceBond.atom2].GetIdx(), sourceBond.GetBondOrder()) ## mol.SetAromaticPerceived() mol.AssignSpinMultiplicity() ## mol.UnsetAromaticPerceived() mol.EndModify() return mol
def convert_str(str_data, in_format, out_format, gen3d=False, add_hydrogens=False, perceive_bonds=False, out_options=None): # Make sure that the start of InChI is valid before passing it to # Open Babel, or Open Babel will crash the server. if in_format.lower() == 'inchi': validate_start_of_inchi(str_data) if out_options is None: out_options = {} obMol = OBMol() conv = OBConversion() conv.SetInFormat(in_format) conv.SetOutFormat(out_format) conv.ReadString(obMol, str_data) if add_hydrogens: obMol.AddHydrogens() if gen3d: # Generate 3D coordinates for the input mol = pybel.Molecule(obMol) mol.make3D() if perceive_bonds: obMol.ConnectTheDots() obMol.PerceiveBondOrders() for option, value in out_options.items(): conv.AddOption(option, conv.OUTOPTIONS, value) return (conv.WriteString(obMol), conv.GetOutFormat().GetMIMEType())
def properties(str_data, in_format, add_hydrogens=False): # Returns a dict with the atom count, formula, heavy atom count, # mass, and spaced formula. if in_format == 'inchi' and not str_data.startswith('InChI='): # Inchi must start with 'InChI=' str_data = 'InChI=' + str_data validate_start_of_inchi(str_data) mol = OBMol() conv = OBConversion() conv.SetInFormat(in_format) conv.ReadString(mol, str_data) if add_hydrogens: mol.AddHydrogens() props = {} props['atomCount'] = mol.NumAtoms() props['formula'] = mol.GetFormula() props['heavyAtomCount'] = mol.NumHvyAtoms() props['mass'] = mol.GetMolWt() props['spacedFormula'] = mol.GetSpacedFormula() return props
firstline = conflist.readline() mollisttemp = [line for line in conflist] mollist = [] scorelist = [] for mol in mollisttemp: mollist.append(mol.split(',')[0]) scorelist.append(mol.split(',')[1]) os.chdir('..') # opening the molecule files pbf = protein_ligand_folder + '/protein_bindingsite_fixed.mol2' conv = OBConversion() conv.SetInFormat("mol2") protfix = OBMol() protref = OBMol() ligref = OBMol() docklig = OBMol() dockprot = OBMol() conv.ReadFile(protfix, pbf) conv.ReadFile(protref, protein_reference) conv.ReadFile(ligref, ligand_reference) refresdict = getresiduedict(protref, residue_of_choice) refringdict = getringdict(protref) fixringdict = getringdict(protfix) ringinteraction(refresdict, refringdict, residue_of_choice, protref, ligref)
(*i).c->GetType(), (*i).d->GetType(), (*i).V, (*i).n, (*i).cosNPhi0, (*i).tor * RAD_TO_DEG, (*i).energy); ``` """ import sys sys.path.insert(0, "/usr/local/lib/python3.6/site-packages") import os from openbabel import OBMol, OBConversion, OBMolAtomIter, OBForceField mof = "csdac-linkers-cml/uio66-HNC3-alkane.cml" obconversion = OBConversion() obconversion.SetInAndOutFormats("cml", "cml") obmol = OBMol() obconversion.ReadFile(obmol, mof) ff = OBForceField.FindForceField("UFF") ff.SetLogToStdOut() ff.SetLogLevel(3) if not ff.Setup(obmol): print("Error: could not setup force field") ff.GetAtomTypes(obmol) for atom_idx, obatom in enumerate(OBMolAtomIter(obmol)): ff_atom_type = obatom.GetData("FFAtomType").GetValue() print(ff_atom_type) print(ff.Energy(True)) print(ff.E_Torsion())
def django_run(target, opt="XTAL"): """Function to take multiple confs of ONE ligand and generate their PLIFS against one template protein""" # Set up the OpenBaebel conversion modules sdconv = OBConversion() ligref = OBMol() # Define the residues and the proteisn to analyse if os.path.isfile( os.path.join(os.path.split(sys.argv[0])[0], 'data/res_def.py')): res_d = [ trans_res(x) for x in ast.literal_eval( open( os.path.join( os.path.split(sys.argv[0])[0], 'data/res_def.py')).read())[target.title].split() ] print res_d # Molecules # Now read in the ligand plif_method = PlifMethod() plif_method.text = "PYPLIF" feature_list = [ "POLAR", "FACE", "EDGE", "ACCEPTOR", "DONOR", "NEGATIVE", "POSITIVE" ] try: plif_method.validate_unique() plif_method.save() except ValidationError: plif_method = PlifMethod.objects.get(text="PYPLIF") out_d = {} counter = 0 # Create a file for the protein t = tempfile.NamedTemporaryFile(suffix=".pdb", delete=False) my_prot = Protein.objects.get(code=target.title + "TEMP") t.write(my_prot.pdb_info.name) t.close() protref = read_prot(t.name, res_d) t = tempfile.NamedTemporaryFile(suffix=".sdf", delete=False) t.close() sdconv.SetInFormat("sdf") if opt == "XTAL": mols = Molecule.objects.exclude( prot_id__code__contains=target.title).filter( prot_id__target_id=target) elif opt == "LLOOMMPPAA": mols = [] sps = SynthPoint.objects.filter(target_id=target) for s in sps: mols.extend([m for m in s.mol_id.all()]) else: print "UNKNOWN OPTION" return for dj_mol in mols: out_sd = Chem.SDWriter(t.name) out_sd.write(Chem.MolFromMolBlock(str(dj_mol.sdf_info))) out_sd.close() sdconv.ReadFile(ligref, t.name) # Now make the new plif new_plif = Plif() new_plif.mol_id = dj_mol new_plif.prot_id = my_prot new_plif.method_id = plif_method try: new_plif.validate_unique() new_plif.save() except ValidationError: new_plif = Plif.objects.get(mol_id=dj_mol, prot_id=my_prot, method_id=plif_method) lig_name = ligref.GetTitle().strip(",") prot_name = lig_name.split("_")[0] ligref.AddHydrogens() counter += 1 refresdict = pp.getresiduedict(protref, res_d) new_d = get_fp(protref, ligref, res_d) for res in new_d: new_res = PlifRes() new_res.res_name = res[:3] new_res.res_num = int(res[3:]) new_res.prot_id = my_prot try: new_res.validate_unique() new_res.save() except ValidationError: new_res = PlifRes.objects.get(res_name=res[:3], res_num=int(res[3:]), prot_id=my_prot) new_plif.res_id.add(new_res) for bit_num, bit in enumerate(new_d[res]): new_bit = PlifBit() new_bit.feature = feature_list[bit_num] new_bit.method_id = plif_method new_bit.res_id = new_res try: new_bit.validate_unique() new_bit.save() my_fun(dj_mol, new_bit, new_plif, bit) except ValidationError: new_bit = PlifBit.objects.get( feature=feature_list[bit_num], method_id=plif_method, res_id=new_res) new_bit.save() new_plif.bit_id.add(new_bit) my_fun(dj_mol, new_bit, new_plif, bit) ligref = OBMol() notatend = sdconv.Read(ligref)