def test_distance(): mol1 = oddt.toolkit.readstring('sdf', ASPIRIN_SDF) d = distance(mol1.coords, mol1.coords) n_atoms = len(mol1.coords) assert d.shape, (n_atoms == n_atoms) assert_array_equal(d[np.eye(len(mol1.coords), dtype=bool)], np.zeros(n_atoms)) d = distance(mol1.coords, mol1.coords.mean(axis=0).reshape(1, 3)) assert d.shape, (n_atoms == 1) ref_dist = [[3.556736951371501], [2.2058040428631056], [2.3896002745745415], [1.6231668718498249], [0.7772981740050453], [2.0694947503940004], [2.8600587871157184], [2.9014207091233857], [2.1850791695403564], [0.9413368403116871], [1.8581710293650173], [2.365629642108773], [2.975007440512798]] assert_array_almost_equal(d, ref_dist)
def calc_halogen_bond_interactions(protein, mol, key_inters_defs, mol_key_inters, filter_strict=False): protein_atoms, ligand_atoms, strict = oddt.interactions.halogenbonds( protein, mol) inters = {} for p, l, s in zip(protein_atoms, ligand_atoms, strict): if s or not filter_strict: c = get_canonical_residue(p) dist = spatial.distance(np.array([p['coords']]), np.array([l['coords']]))[0][0] p_coords = (p['coords'][0].item(), p['coords'][1].item(), p['coords'][2].item()) l_coords = (l['coords'][0].item(), l['coords'][1].item(), l['coords'][2].item()) t = interactions.Interaction(c, p_coords, l_coords, dist, l['id'].item()) if c in inters: current_value = inters[c] if dist < current_value.distance: inters[c] = t else: inters[c] = t if key_inters_defs and c in key_inters_defs: mol_key_inters.append(interactions.I_TYPE_HALOGEN + ':' + c) if inters: return interactions.InteractionType(interactions.I_NAME_HALOGEN, list(inters.values())) else: return None
def calc_pi_stacking_interactions(protein, mol, key_inters_defs, mol_key_inters, filter_strict=False): protein_atoms, ligand_atoms, strict_parallel, strict_perpendicular = oddt.interactions.pi_stacking( protein, mol) inters = {} for p, l, s1, s2 in zip(protein_atoms, ligand_atoms, strict_parallel, strict_perpendicular): if (s1 or s2) or not filter_strict: c = get_canonical_residue(p) dist = spatial.distance(np.array([p['centroid']]), np.array([l['centroid']]))[0][0] p_coords = (p['centroid'][0].item(), p['centroid'][1].item(), p['centroid'][2].item()) l_coords = (l['centroid'][0].item(), l['centroid'][1].item(), l['centroid'][2].item()) t = interactions.Interaction(c, p_coords, l_coords, dist, None) if c in inters: current_value = inters[c] if dist < current_value.distance: inters[c] = t else: inters[c] = t if key_inters_defs and c in key_inters_defs: mol_key_inters.append(interactions.I_TYPE_PI_STACKING + ':' + c) if inters: return interactions.InteractionType(interactions.I_NAME_PI_STACKING, list(inters.values())) else: return None
def close_contacts(x, y, cutoff, x_column='coords', y_column='coords', cutoff_low=0.): """Returns pairs of atoms which are within close contac distance cutoff. The cutoff is semi-inclusive, i.e (cutoff_low, cutoff]. Parameters ---------- x, y : atom_dict-type numpy array Atom dictionaries generated by oddt.toolkit.Molecule objects. cutoff : float Cutoff distance for close contacts x_column, ycolumn : string, (default='coords') Column containing coordinates of atoms (or pseudo-atoms, i.e. ring centroids) cutoff_low : float (default=0.) Lower bound of contacts to find (exclusive). Zero by default. .. versionadded:: 0.6 Returns ------- x_, y_ : atom_dict-type numpy array Aligned pairs of atoms in close contact for further processing. """ if len(x[x_column]) > 0 and len(x[x_column]) > 0: d = distance(x[x_column], y[y_column]) index = np.argwhere((d > cutoff_low) & (d <= cutoff)) return x[index[:, 0]], y[index[:, 1]] else: return x[[]], y[[]]
def calc_salt_bridge_interactions(protein, mol, key_inters_defs, mol_key_inters, exact_protein=False, exact_ligand=False): inters = {} protein_atoms, ligand_atoms = oddt.interactions.salt_bridges( protein, mol, mol1_exact=exact_protein, mol2_exact=exact_ligand) for p, l in zip(protein_atoms, ligand_atoms): c = get_canonical_residue(p) dist = spatial.distance(np.array([p['coords']]), np.array([l['coords']]))[0][0] p_coords = (p['coords'][0].item(), p['coords'][1].item(), p['coords'][2].item()) l_coords = (l['coords'][0].item(), l['coords'][1].item(), l['coords'][2].item()) t = interactions.Interaction(c, p_coords, l_coords, dist, l['id'].item()) if c in inters: current_value = inters[c] if dist < current_value.distance: inters[c] = t else: inters[c] = t if key_inters_defs and c in key_inters_defs: mol_key_inters.append(interactions.I_TYPE_SALT_BRIDGE + ':' + c) if inters: return interactions.InteractionType(interactions.I_NAME_SALT_BRIDGE, list(inters.values())) else: return None
def close_contacts(x, y, cutoff, x_column = 'coords', y_column = 'coords'): """ Returns pairs of atoms which are within close contac distance cutoff. Parameters ---------- x, y : atom_dict-type numpy array Atom dictionaries generated by oddt.toolkit.Molecule objects. cutoff : float Cutoff distance for close contacts x_column, ycolumn : string, (default='coords') Column containing coordinates of atoms (or pseudo-atoms, i.e. ring centroids) Returns ------- x_, y_ : atom_dict-type numpy array Aligned pairs of atoms in close contact for further processing. """ if len(x[x_column]) > 0 and len(x[x_column]) > 0: d = distance(x[x_column], y[y_column]) index = np.argwhere((d > 0) & (d <= cutoff)) return x[index[:,0]], y[index[:,1]] else: return x[[]], y[[]]
def score_intra(self, coords = None): if coords is None: coords = self.lig_dict['coords'] # Intra-molceular r = distance(coords, coords) d = (r - self.lig_dict['radius'][:,np.newaxis] - self.lig_dict['radius'][np.newaxis,:]) mask = self.lig_distant_members & (r < 8) intra=[] # Gauss 1 intra.append(np.exp(-(d[mask]/0.5)**2).sum()) # Gauss 2 intra.append(np.exp(-((d[mask]-3.)/2.)**2).sum()) # Repiulsion intra.append((d[(d < 0) & mask]**2).sum()) # Hydrophobic if not 'hyd' in self.mask_intra: self.mask_intra['hyd'] = (self.lig_dict['ishydrophobe'] | self.lig_dict['ishalogen'])[:,np.newaxis] * (self.lig_dict['ishydrophobe'] | self.lig_dict['ishalogen'])[np.newaxis,:] mask_hyd = mask & self.mask_intra['hyd'] d_hyd = d[mask_hyd] intra.append((d_hyd <= 0.5).sum() + (1.5 - d_hyd[(0.5 < d_hyd) & (d_hyd < 1.5)]).sum()) # H-Bonding if not 'da' in self.mask_intra: self.mask_intra['da'] = (self.lig_dict['isdonor'] | self.lig_dict['ismetal'])[...,np.newaxis]*self.lig_dict['isacceptor'][np.newaxis,...] if not 'ad' in self.mask_intra: self.mask_intra['ad'] = self.lig_dict['isacceptor'][...,np.newaxis]*(self.lig_dict['isdonor'] | self.lig_dict['ismetal'])[np.newaxis,...] d_h = d[mask & (self.mask_intra['da'] | self.mask_intra['ad'])] intra.append((d_h <= -0.7).sum() + (d_h[(-0.7 < d_h) & (d_h < 0)]/-0.7).sum()) return np.array(intra)
def close_contacts(x, y, cutoff, x_column='coords', y_column='coords'): """ Returns pairs of atoms which are within close contac distance cutoff. Parameters ---------- x, y : atom_dict-type numpy array Atom dictionaries generated by oddt.toolkit.Molecule objects. cutoff : float Cutoff distance for close contacts x_column, ycolumn : string, (default='coords') Column containing coordinates of atoms (or pseudo-atoms, i.e. ring centroids) Returns ------- x_, y_ : atom_dict-type numpy array Aligned pairs of atoms in close contact for further processing. """ if len(x[x_column]) > 0 and len(x[x_column]) > 0: d = distance(x[x_column], y[y_column]) index = np.argwhere((d > 0) & (d <= cutoff)) return x[index[:, 0]], y[index[:, 1]] else: return x[[]], y[[]]
def calc_hydrogen_bond_interactions(protein, mol, key_inters_defs, mol_key_inters, filter_strict=False, exact_protein=False, exact_ligand=False): """ Calculate H-bond interactions Parameters: protein (Molecule): The protein mol (Molecule): The ligand to test key_inters_defs (List): Optional list of key H-bond interactions mol_key_inters (List): List to add the key H-bond interactions to filter_strict (Bool): Whether to use strict matching Returns: InteractionType: The interactions """ # first apply a fix that's needed to handle the mis-assignment of donor atoms for a particular tautomeric # form: nc[n;H1]. See https://groups.google.com/g/oddt/c/fqzmhSqprw8/m/nmaaUlCDAgAJ # mol.atom_dict.setflags(write=True) # matches = oddt.toolkit.Smarts('[n;H0]').findall(mol) # for (idx,) in matches: # # idx assumes 0 based indexing e.g. RDKit. OBabel uses 1 based indexing. # mol.atom_dict['isdonor'][idx] = False # mol.atom_dict.setflags(write=False) # end of fix protein_atoms, ligand_atoms, strict = oddt.interactions.hbonds( protein, mol, mol1_exact=exact_protein, mol2_exact=exact_ligand) inters = {} for p, l, s in zip(protein_atoms, ligand_atoms, strict): if s or not filter_strict: c = get_canonical_hbond(p) dist = spatial.distance(np.array([p['coords']]), np.array([l['coords']]))[0][0] p_coords = (p['coords'][0].item(), p['coords'][1].item(), p['coords'][2].item()) l_coords = (l['coords'][0].item(), l['coords'][1].item(), l['coords'][2].item()) t = interactions.Interaction(c, p_coords, l_coords, dist, l['id'].item()) if c in inters: current_value = inters[c] if dist < current_value.distance: inters[c] = t else: inters[c] = t if key_inters_defs and c in key_inters_defs: mol_key_inters.append(interactions.I_TYPE_HBOND + ':' + c) if inters: # print(' found', len(inters), 'h-bonds') return interactions.InteractionType(interactions.I_NAME_HBOND, list(inters.values())) else: return None
def test_distance(): mol1 = oddt.toolkit.readstring('sdf', ASPIRIN_SDF) d = distance(mol1.coords, mol1.coords) n_atoms = len(mol1.coords) assert_equal(d.shape, (n_atoms, n_atoms)) assert_array_equal(d[np.eye(len(mol1.coords), dtype=bool)], np.zeros(n_atoms)) d = distance(mol1.coords, mol1.coords.mean(axis=0).reshape(1, 3)) assert_equal(d.shape, (n_atoms, 1)) ref_dist = [[3.556736951371501], [2.2058040428631056 ], [2.3896002745745415], [1.6231668718498249], [0.7772981740050453 ], [2.0694947503940004], [2.8600587871157184], [2.9014207091233857], [2.1850791695403564], [0.9413368403116871], [1.8581710293650173], [2.365629642108773], [2.975007440512798]] assert_array_almost_equal(d, ref_dist)
def calc_hydrophobic_interactions(protein, mol, key_inters_defs, mol_key_inters): """ Calculate hydrophobic interactions. ODDT generates hydrophobic interactions for all pairs of atoms that are within the specification which results in multiple interactions between the same hydrophobic region of the ligand and protein. We reduce those down to a single interaction, the one that is the shortest. ODDT also seems to generate hydrophobic interactions that are complete duplicates, and the de-duplication process removes these as well. Parameters: protein (Molecule): The protein mol (Molecule): The ligand to test key_inters_defs (List): Optional list of key H-bond interactions mol_key_inters (List): List to add the key H-bond interactions to Returns: InteractionType: The interactions """ inters = {} protein_atoms, ligand_atoms = oddt.interactions.hydrophobic_contacts( protein, mol) for p, l in zip(protein_atoms, ligand_atoms): c = get_canonical_residue(p) dist = spatial.distance(np.array([p['coords']]), np.array([l['coords']]))[0][0] p_coords = (p['coords'][0].item(), p['coords'][1].item(), p['coords'][2].item()) l_coords = (l['coords'][0].item(), l['coords'][1].item(), l['coords'][2].item()) t = interactions.Interaction(c, p_coords, l_coords, dist, l['id'].item()) if c in inters: current_value = inters[c] if dist < current_value.distance: inters[c] = t else: inters[c] = t if key_inters_defs and c in key_inters_defs: mol_key_inters.append(interactions.I_TYPE_HYDROPHOBIC + ':' + c) if inters: # print(' found', len(inters), 'hydrophobics') return interactions.InteractionType(interactions.I_NAME_HYDROPHOBIC, list(inters.values())) else: return None
def score_inter(self, coords=None): if coords is None: coords = self.lig_dict['coords'] # Inter-molecular r = distance(self.rec_dict['coords'], coords) d = (r - self.rec_dict['radius'][:, np.newaxis] - self.lig_dict['radius'][np.newaxis, :]) mask = r < 8 inter = [] # Gauss 1 inter.append(np.exp(-(d[mask] / 0.5)**2).sum()) # Gauss 2 inter.append(np.exp(-((d[mask] - 3.) / 2.)**2).sum()) # Repiulsion inter.append((d[(d < 0) & mask]**2).sum()) # Hydrophobic if 'hyd' not in self.mask_inter: self.mask_inter['hyd'] = ( (self.rec_dict['ishydrophobe'] | self.rec_dict['ishalogen'])[:, np.newaxis] * (self.lig_dict['ishydrophobe'] | self.lig_dict['ishalogen'])[np.newaxis, :]) mask_hyd = mask & self.mask_inter['hyd'] d_hyd = d[mask_hyd] inter.append((d_hyd <= 0.5).sum() + (1.5 - d_hyd[(0.5 < d_hyd) & (d_hyd < 1.5)]).sum()) # H-Bonding if 'da' not in self.mask_inter: self.mask_inter['da'] = ( (self.rec_dict['isdonor'] | self.rec_dict['ismetal'])[:, np.newaxis] * self.lig_dict['isacceptor'][np.newaxis, :]) if 'ad' not in self.mask_inter: self.mask_inter['ad'] = ( self.rec_dict['isacceptor'][:, np.newaxis] * (self.lig_dict['isdonor'] | self.lig_dict['ismetal'])[np.newaxis, :]) d_h = d[mask & (self.mask_inter['da'] | self.mask_inter['ad'])] inter.append((d_h <= -0.7).sum() + (d_h[(-0.7 < d_h) & (d_h < 0)] / -0.7).sum()) return np.array(inter)
def score_intra(self, coords=None): if coords is None: coords = self.lig_dict['coords'] # Intra-molceular r = distance(coords, coords) d = (r - self.lig_dict['radius'][:, np.newaxis] - self.lig_dict['radius'][np.newaxis, :]) mask = self.lig_distant_members & (r < 8) intra = [] # Gauss 1 intra.append(np.exp(-(d[mask] / 0.5)**2).sum()) # Gauss 2 intra.append(np.exp(-((d[mask] - 3.) / 2.)**2).sum()) # Repiulsion intra.append((d[(d < 0) & mask]**2).sum()) # Hydrophobic if 'hyd' not in self.mask_intra: self.mask_intra['hyd'] = ((self.lig_dict['ishydrophobe'] | self.lig_dict['ishalogen'])[:, np.newaxis] * (self.lig_dict['ishydrophobe'] | self.lig_dict['ishalogen'])[np.newaxis, :]) mask_hyd = mask & self.mask_intra['hyd'] d_hyd = d[mask_hyd] intra.append((d_hyd <= 0.5).sum() + (1.5 - d_hyd[(0.5 < d_hyd) & (d_hyd < 1.5)]).sum()) # H-Bonding if 'da' not in self.mask_intra: self.mask_intra['da'] = ((self.lig_dict['isdonor'] | self.lig_dict['ismetal'])[..., np.newaxis] * self.lig_dict['isacceptor'][np.newaxis, ...]) if 'ad' not in self.mask_intra: self.mask_intra['ad'] = (self.lig_dict['isacceptor'][..., np.newaxis] * (self.lig_dict['isdonor'] | self.lig_dict['ismetal'])[np.newaxis, ...]) d_h = d[mask & (self.mask_intra['da'] | self.mask_intra['ad'])] intra.append((d_h <= -0.7).sum() + (d_h[(-0.7 < d_h) & (d_h < 0)] / -0.7).sum()) return np.array(intra)
def close_contacts(x, y, cutoff, x_column='coords', y_column='coords', cutoff_low=0.): """Returns pairs of atoms which are within close contac distance cutoff. The cutoff is semi-inclusive, i.e (cutoff_low, cutoff]. Parameters ---------- x, y : atom_dict-type numpy array Atom dictionaries generated by oddt.toolkit.Molecule objects. cutoff : float Cutoff distance for close contacts x_column, ycolumn : string, (default='coords') Column containing coordinates of atoms (or pseudo-atoms, i.e. ring centroids) cutoff_low : float (default=0.) Lower bound of contacts to find (exclusive). Zero by default. .. versionadded:: 0.6 Returns ------- x_, y_ : atom_dict-type numpy array Aligned pairs of atoms in close contact for further processing. """ if len(x[x_column]) > 0 and len(x[x_column]) > 0: d = distance(x[x_column], y[y_column]) index = np.argwhere((d > cutoff_low) & (d <= cutoff)) return x[index[:, 0]], y[index[:, 1]] else: return x[[]], y[[]]
def peakmem_distance_protein(self): distance(self.protein.coords, self.protein.coords)
def detect_secondary_structure(res_dict): """Detect alpha helices and beta sheets in res_dict by phi and psi angles""" first = res_dict[:-1] second = res_dict[1:] psi = dihedral(first['N'], first['CA'], first['C'], second['N']) phi = dihedral(first['C'], second['N'], second['CA'], second['C']) d = second['id'] - first['id'] # Alpha helices res_mask_alpha = ( ((phi > -145) & (phi < -35) & (psi > -70) & (psi < 50) & (d == 1)) ) # alpha res_mask_alpha = np.union1d(np.argwhere(res_mask_alpha), np.argwhere(res_mask_alpha)) # Ignore groups smaller than 3 for mask_group in np.split( res_mask_alpha, np.argwhere(np.diff(res_mask_alpha) != 1).flatten() + 1): if len(mask_group) >= 3: res_dict['isalpha'][mask_group] = True # Alpha helices have to form H-Bonds hbond_dist_mask = np.abs( res_dict[res_dict['isalpha']]['id'] - res_dict[res_dict['isalpha']]['id'][:, np.newaxis]) >= 3 hbond_mask = distance(res_dict[res_dict['isalpha']]['N'], res_dict[res_dict['isalpha']]['O']) < 3.5 p_mask = ((hbond_mask & hbond_dist_mask).any(axis=0) | (hbond_mask & hbond_dist_mask).any(axis=1)) res_dict['isalpha'][np.argwhere( res_dict['isalpha']).flatten()[~p_mask]] = False # Ignore groups smaller than 3 res_mask_alpha = np.argwhere(res_dict['isalpha']).flatten() for mask_group in np.split( res_mask_alpha, np.argwhere(np.diff(res_mask_alpha) != 1).flatten() + 1): if 0 < len(mask_group) < 3: res_dict['isalpha'][mask_group] = False # Beta sheets res_mask_beta = ( ((phi >= -180) & (phi < -40) & (psi <= 180) & (psi > 90) & (d == 1)) | ((phi >= -180) & (phi < -70) & (psi <= -165) & (d == 1))) # beta res_mask_beta = np.union1d(np.argwhere(res_mask_beta), np.argwhere(res_mask_beta)) # Ignore groups smaller than 3 for mask_group in np.split( res_mask_beta, np.argwhere(np.diff(res_mask_beta) != 1).flatten() + 1): if len(mask_group) >= 3: res_dict['isbeta'][mask_group] = True # Beta strands have to be alongside eachother res_dist_mask = np.abs(res_dict[res_dict['isbeta']]['id'] - res_dict[res_dict['isbeta']]['id'][:, np.newaxis]) >= 4 hbond_mask = distance(res_dict[res_dict['isbeta']]['N'], res_dict[res_dict['isbeta']]['O']) < 3.5 ca_mask = distance(res_dict[res_dict['isbeta']]['CA'], res_dict[res_dict['isbeta']]['CA']) < 4.5 p_mask = ((hbond_mask & res_dist_mask).any(axis=0) | (hbond_mask & res_dist_mask).any(axis=1) | (ca_mask & res_dist_mask).any(axis=0)) res_dict['isbeta'][np.argwhere( res_dict['isbeta']).flatten()[~p_mask]] = False # Ignore groups smaller than 3 res_mask_beta = np.argwhere(res_dict['isbeta']).flatten() for mask_group in np.split( res_mask_beta, np.argwhere(np.diff(res_mask_beta) != 1).flatten() + 1): if 0 < len(mask_group) < 3: res_dict['isbeta'][mask_group] = False return res_dict
def detect_secondary_structure(res_dict): """Detect alpha helices and beta sheets in res_dict by phi and psi angles""" first = res_dict[:-1] second = res_dict[1:] psi = dihedral(first['N'], first['CA'], first['C'], second['N']) phi = dihedral(first['C'], second['N'], second['CA'], second['C']) d = second['id'] - first['id'] # Alpha helices res_mask_alpha = (((phi > -145) & (phi < -35) & (psi > -70) & (psi < 50) & (d == 1))) # alpha res_mask_alpha = np.union1d(np.argwhere(res_mask_alpha), np.argwhere(res_mask_alpha)) # Ignore groups smaller than 3 for mask_group in np.split(res_mask_alpha, np.argwhere(np.diff(res_mask_alpha) != 1).flatten() + 1): if len(mask_group) >= 3: res_dict['isalpha'][mask_group] = True # Alpha helices have to form H-Bonds hbond_dist_mask = np.abs(res_dict[res_dict['isalpha']]['resnum'] - res_dict[res_dict['isalpha']]['resnum'][:, np.newaxis]) >= 3 hbond_mask = distance(res_dict[res_dict['isalpha']]['N'], res_dict[res_dict['isalpha']]['O']) < 3.5 p_mask = ((hbond_mask & hbond_dist_mask).any(axis=0) | (hbond_mask & hbond_dist_mask).any(axis=1)) res_dict['isalpha'][np.argwhere(res_dict['isalpha']).flatten()[~p_mask]] = False # Ignore groups smaller than 3 res_mask_alpha = np.argwhere(res_dict['isalpha']).flatten() for mask_group in np.split(res_mask_alpha, np.argwhere(np.diff(res_mask_alpha) != 1).flatten() + 1): if 0 < len(mask_group) < 3: res_dict['isalpha'][mask_group] = False # Beta sheets res_mask_beta = (((phi >= -180) & (phi < -40) & (psi <= 180) & (psi > 90) & (d == 1)) | ((phi >= -180) & (phi < -70) & (psi <= -165) & (d == 1))) # beta res_mask_beta = np.union1d(np.argwhere(res_mask_beta), np.argwhere(res_mask_beta)) # Ignore groups smaller than 3 for mask_group in np.split(res_mask_beta, np.argwhere(np.diff(res_mask_beta) != 1).flatten() + 1): if len(mask_group) >= 3: res_dict['isbeta'][mask_group] = True # Beta strands have to be alongside eachother res_dist_mask = np.abs(res_dict[res_dict['isbeta']]['resnum'] - res_dict[res_dict['isbeta']]['resnum'][:, np.newaxis]) >= 4 hbond_mask = distance(res_dict[res_dict['isbeta']]['N'], res_dict[res_dict['isbeta']]['O']) < 3.5 ca_mask = distance(res_dict[res_dict['isbeta']]['CA'], res_dict[res_dict['isbeta']]['CA']) < 4.5 p_mask = ((hbond_mask & res_dist_mask).any(axis=0) | (hbond_mask & res_dist_mask).any(axis=1) | (ca_mask & res_dist_mask).any(axis=0)) res_dict['isbeta'][np.argwhere(res_dict['isbeta']).flatten()[~p_mask]] = False # Ignore groups smaller than 3 res_mask_beta = np.argwhere(res_dict['isbeta']).flatten() for mask_group in np.split(res_mask_beta, np.argwhere(np.diff(res_mask_beta) != 1).flatten() + 1): if 0 < len(mask_group) < 3: res_dict['isbeta'][mask_group] = False return res_dict
def peakmem_distance_complex(self): for mol in self.mols: distance(mol.coords, self.protein.coords)
def peakmem_distance_mol(self): for mol in self.mols: distance(mol.coords, mol.coords)
def time_distance_mol(self): for mol in self.mols: distance(mol.coords, mol.coords)
def peakmem_distance_protein(self): distance(self.protein.coords, self.protein.coords)
def time_distance_protein(self): distance(self.protein.coords, self.protein.coords)
def calc_pi_cation_interactions(protein, mol, key_inters_defs, mol_key_inters, filter_strict=False, exact_protein=False, exact_ligand=False): """ Pi-cation calculations are directional so are run in both directions (protein->ligand and ligand-> protein). Hence this method runs the pi_cation() calculation twice. :param protein: :param mol: :param key_inters_defs: :param mol_key_inters: :param filter_strict: :param exact_protein: :param exact_ligand: :return: """ inters = {} # first treat the protein as the pi and the ligand as the cation rings, cation, strict = oddt.interactions.pi_cation( protein, mol, cation_exact=exact_ligand) for ring, cat, s in zip(rings, cation, strict): if s or not filter_strict: dist = spatial.distance(np.array([ring['centroid']]), np.array([cat['coords']]))[0][0] c = get_canonical_residue(ring) p_coords = (ring['centroid'][0].item(), ring['centroid'][1].item(), ring['centroid'][2].item()) l_coords = (cat['coords'][0].item(), cat['coords'][1].item(), cat['coords'][2].item()) t = interactions.Interaction(c, p_coords, l_coords, dist, None) if c in inters: current_value = inters[c] if dist < current_value.distance: inters[c] = t else: inters[c] = t if key_inters_defs and c in key_inters_defs: mol_key_inters.append(interactions.I_TYPE_PI_CATION + ':' + c) # now with the ligand as the pi and the protein as the cation rings, cation, strict = oddt.interactions.pi_cation( mol, protein, cation_exact=exact_protein) for ring, cat, s in zip(rings, cation, strict): if s or not filter_strict: dist = spatial.distance(np.array([ring['centroid']]), np.array([cat['coords']]))[0][0] c = get_canonical_residue(ring) p_coords = (cat['coords'][0].item(), cat['coords'][1].item(), cat['coords'][2].item()) l_coords = (ring['centroid'][0].item(), ring['centroid'][1].item(), ring['centroid'][2].item()) t = interactions.Interaction(c, p_coords, l_coords, dist, None) if c in inters: current_value = inters[c] if dist < current_value.distance: inters[c] = t else: inters[c] = t if key_inters_defs and c in key_inters_defs: mol_key_inters.append(interactions.I_TYPE_PI_CATION + ':' + c) if inters: return interactions.InteractionType(interactions.I_NAME_PI_CATION, list(inters.values())) else: return None
def peakmem_distance_complex(self): for mol in self.mols: distance(mol.coords, self.protein.coords)
def peakmem_distance_mol(self): for mol in self.mols: distance(mol.coords, mol.coords)
def time_distance_mol(self): for mol in self.mols: distance(mol.coords, mol.coords)
def time_distance_protein(self): distance(self.protein.coords, self.protein.coords)