3 from ost
import LogWarning
13 """ :class:`LigandScorer` implementing lDDT-PLI.
15 lDDT-PLI is an lDDT score considering contacts between ligand and
16 receptor. Where receptor consists of protein and nucleic acid chains that
17 pass the criteria for :class:`chain mapping <ost.mol.alg.chain_mapping>`.
18 This means ignoring other ligands, waters, short polymers as well as any
19 incorrectly connected chains that may be in proximity.
21 :class:`LDDTPLIScorer` computes a score for a specific pair of target/model
22 ligands. Given a target/model ligand pair, all possible mappings of
23 model chains onto their chemically equivalent target chains are enumerated.
24 For each of these enumerations, all possible symmetries, i.e. atom-atom
25 assignments of the ligand as given by :class:`LigandScorer`, are evaluated
26 and an lDDT-PLI score is computed. The best possible lDDT-PLI score is
29 By default, classic lDDT is computed. That means, contacts within
30 *lddt_pli_radius* are identified in the target and checked if they're
31 conserved in the model. Added contacts are not penalized. That means if
32 the ligand is nicely placed in the correct pocket, but that pocket now
33 suddenly interacts with MORE residues in the model, you still get a high
34 score. You can penalize for these added contacts with the
35 *add_mdl_contacts* flag. This additionally considers contacts within
36 *lddt_pli_radius* in the model but only if the involved atoms can
37 be mapped to the target. This is a requirement to 1) extract the respective
38 reference distance from the target 2) avoid usage of contacts for which
39 we have no experimental evidence. One special case are
40 contacts from chains that are NOT mapped to the target binding site. It is
41 very well possible that we have experimental evidence for this chain though
42 its just too far away from the target binding site.
43 We therefore try to map these contacts to the chain in the target with
44 equivalent sequence that is closest to the target binding site. If the
45 respective atoms can be mapped there, the contact is considered not
46 fulfilled and added as penalty.
48 Populates :attr:`LigandScorer.aux_data` with following :class:`dict` keys:
51 * lddt_pli_n_contacts: Number of contacts considered in lDDT computation
52 * target_ligand: The actual target ligand for which the score was computed
53 * model_ligand: The actual model ligand for which the score was computed
54 * bs_ref_res: :class:`set` of residues with potentially non-zero
55 contribution to score. That is every residue with at least one
56 atom within *lddt_pli_radius* + max(*lddt_pli_thresholds*) of
58 * bs_mdl_res: Same for model
60 :param model: Passed to parent constructor - see :class:`LigandScorer`.
61 :type model: :class:`ost.mol.EntityHandle`/:class:`ost.mol.EntityView`
62 :param target: Passed to parent constructor - see :class:`LigandScorer`.
63 :type target: :class:`ost.mol.EntityHandle`/:class:`ost.mol.EntityView`
64 :param model_ligands: Passed to parent constructor - see
65 :class:`LigandScorer`.
66 :type model_ligands: :class:`list`
67 :param target_ligands: Passed to parent constructor - see
68 :class:`LigandScorer`.
69 :type target_ligands: :class:`list`
70 :param resnum_alignments: Passed to parent constructor - see
71 :class:`LigandScorer`.
72 :type resnum_alignments: :class:`bool`
73 :param rename_ligand_chain: Passed to parent constructor - see
74 :class:`LigandScorer`.
75 :type rename_ligand_chain: :class:`bool`
76 :param substructure_match: Passed to parent constructor - see
77 :class:`LigandScorer`.
78 :type substructure_match: :class:`bool`
79 :param coverage_delta: Passed to parent constructor - see
80 :class:`LigandScorer`.
81 :type coverage_delta: :class:`float`
82 :param max_symmetries: Passed to parent constructor - see
83 :class:`LigandScorer`.
84 :type max_symmetries: :class:`int`
85 :param lddt_pli_radius: lDDT inclusion radius for lDDT-PLI.
86 :type lddt_pli_radius: :class:`float`
87 :param add_mdl_contacts: Whether to add mdl contacts.
88 :type add_mdl_contacts: :class:`bool`
89 :param lddt_pli_thresholds: Distance difference thresholds for lDDT.
90 :type lddt_pli_thresholds: :class:`list` of :class:`float`
91 :param lddt_pli_binding_site_radius: Pro param - dont use. Providing a value
92 Restores behaviour from previous
93 implementation that first extracted a
94 binding site with strict distance
95 threshold and computed lDDT-PLI only on
96 those target residues whereas the
97 current implementation includes every
98 atom within *lddt_pli_radius*.
99 :type lddt_pli_binding_site_radius: :class:`float`
102 def __init__(self, model, target, model_ligands=None, target_ligands=None,
103 resnum_alignments=False, rename_ligand_chain=False,
104 substructure_match=False, coverage_delta=0.2,
105 max_symmetries=1e5, lddt_pli_radius=6.0,
106 add_mdl_contacts=False,
107 lddt_pli_thresholds = [0.5, 1.0, 2.0, 4.0],
108 lddt_pli_binding_site_radius=None):
110 super().
__init__(model, target, model_ligands = model_ligands,
111 target_ligands = target_ligands,
112 resnum_alignments = resnum_alignments,
113 rename_ligand_chain = rename_ligand_chain,
114 substructure_match = substructure_match,
115 coverage_delta = coverage_delta,
116 max_symmetries = max_symmetries)
134 "There were no lDDT contacts between the "
135 "binding site and the ligand, and lDDT-PLI "
138 "Unknown error occured in LDDTPLIScorer")
140 def _compute(self, symmetries, target_ligand, model_ligand):
141 """ Implements interface from parent
153 score = result[
"lddt_pli"]
155 if score
is None or np.isnan(score):
156 if result[
"lddt_pli_n_contacts"] == 0:
164 target_ligand_state = 0
165 model_ligand_state = 0
167 return (score, pair_state, target_ligand_state, model_ligand_state,
170 def _score_dir(self):
171 """ Implements interface from parent
175 def _compute_lddt_pli_add_mdl_contacts(self, symmetries, target_ligand,
182 trg_residues, trg_bs, trg_chains, trg_ligand_chain, \
183 trg_ligand_res, scorer, chem_groups = \
186 trg_bs_center = trg_bs.geometric_center
192 ref_indices = [a.copy()
for a
in scorer.ref_indices_ic]
193 ref_distances = [a.copy()
for a
in scorer.ref_distances_ic]
197 ligand_start_idx = scorer.chain_start_indices[-1]
198 for at_idx
in range(ligand_start_idx):
199 mask = ref_indices[at_idx] >= ligand_start_idx
200 ref_indices[at_idx] = ref_indices[at_idx][mask]
201 ref_distances[at_idx] = ref_distances[at_idx][mask]
203 mdl_residues, mdl_bs, mdl_chains, mdl_ligand_chain, mdl_ligand_res, \
222 chain_mappings = list(chain_mapping._ChainMappings(chem_groups,
227 ligand_atom_mappings = [set()
for a
in mdl_ligand_res.atoms]
228 for (trg_sym, mdl_sym)
in symmetries:
229 for trg_i, mdl_i
in zip(trg_sym, mdl_sym):
230 ligand_atom_mappings[mdl_i].add(trg_i)
232 mdl_ligand_pos = np.zeros((mdl_ligand_res.GetAtomCount(), 3))
233 for a_idx, a
in enumerate(mdl_ligand_res.atoms):
235 mdl_ligand_pos[a_idx, 0] = p[0]
236 mdl_ligand_pos[a_idx, 1] = p[1]
237 mdl_ligand_pos[a_idx, 2] = p[2]
239 trg_ligand_pos = np.zeros((trg_ligand_res.GetAtomCount(), 3))
240 for a_idx, a
in enumerate(trg_ligand_res.atoms):
242 trg_ligand_pos[a_idx, 0] = p[0]
243 trg_ligand_pos[a_idx, 1] = p[1]
244 trg_ligand_pos[a_idx, 2] = p[2]
246 mdl_lig_hashes = [a.hash_code
for a
in mdl_ligand_res.atoms]
248 symmetric_atoms = np.asarray(sorted(list(scorer.symmetric_atoms)),
270 scoring_cache = list()
271 penalty_cache = list()
273 for mapping
in chain_mappings:
276 flat_mapping = dict()
277 for trg_chem_group, mdl_chem_group
in zip(chem_groups, mapping):
278 for a,b
in zip(trg_chem_group, mdl_chem_group):
279 if a
is not None and b
is not None:
284 bs_atom_mapping = dict()
285 for mdl_cname, ref_cname
in flat_mapping.items():
286 aln = cut_ref_mdl_alns[(ref_cname, mdl_cname)]
287 ref_ch = trg_bs.Select(f
"cname={mol.QueryQuoteName(ref_cname)}")
288 mdl_ch = mdl_bs.Select(f
"cname={mol.QueryQuoteName(mdl_cname)}")
289 aln.AttachView(0, ref_ch)
290 aln.AttachView(1, mdl_ch)
292 ref_r = col.GetResidue(0)
293 mdl_r = col.GetResidue(1)
294 if ref_r.IsValid()
and mdl_r.IsValid():
295 for mdl_a
in mdl_r.atoms:
296 ref_a = ref_r.FindAtom(mdl_a.GetName())
298 ref_h = ref_a.handle.hash_code
299 if ref_h
in scorer.atom_indices:
300 mdl_h = mdl_a.handle.hash_code
301 bs_atom_mapping[mdl_h] = \
302 scorer.atom_indices[ref_h]
307 for mdl_a_idx, mdl_a
in enumerate(mdl_ligand_res.atoms):
309 trg_bs_indices = list()
310 close_a = mdl_bs.FindWithin(mdl_a.GetPos(),
313 mdl_a_hash_code = a.hash_code
314 if mdl_a_hash_code
in bs_atom_mapping:
315 trg_bs_indices.append(bs_atom_mapping[mdl_a_hash_code])
316 elif mdl_a_hash_code
not in mdl_lig_hashes:
317 if a.GetChain().GetName()
in flat_mapping:
319 at_key = (a.GetResidue().GetNumber(), a.name)
320 cname = a.GetChain().name
321 cname_key = (flat_mapping[cname], cname)
330 n_penalties.append(n_penalty)
332 trg_bs_indices = np.asarray(sorted(trg_bs_indices))
334 for trg_a_idx
in ligand_atom_mappings[mdl_a_idx]:
338 mask = np.isin(trg_bs_indices,
339 ref_indices[ligand_start_idx + trg_a_idx],
340 assume_unique=
True, invert=
True)
341 added_indices = np.asarray([], dtype=np.int64)
342 added_distances = np.asarray([], dtype=np.float64)
345 added_indices = trg_bs_indices[mask]
346 tmp = scorer.positions.take(added_indices, axis=0)
347 np.subtract(tmp, trg_ligand_pos[trg_a_idx][
None, :],
349 np.square(tmp, out=tmp)
350 tmp = tmp.sum(axis=1)
351 np.sqrt(tmp, out=tmp)
352 added_distances = tmp
355 sym_mask = np.isin(added_indices, symmetric_atoms,
358 cache[(mdl_a_idx, trg_a_idx)] = (added_indices,
360 added_indices[sym_mask],
361 added_distances[sym_mask])
363 scoring_cache.append(cache)
364 penalty_cache.append(n_penalties)
372 non_mapped_cache = dict()
379 best_result = {
"lddt_pli":
None,
380 "lddt_pli_n_contacts": 0}
383 ligand_aln = seq.CreateAlignment()
384 trg_s = seq.CreateSequence(trg_ligand_chain.name,
385 trg_ligand_res.GetOneLetterCode())
386 mdl_s = seq.CreateSequence(mdl_ligand_chain.name,
387 mdl_ligand_res.GetOneLetterCode())
388 ligand_aln.AddSequence(trg_s)
389 ligand_aln.AddSequence(mdl_s)
390 ligand_at_indices = list(range(ligand_start_idx, scorer.n_atoms))
392 sym_idx_collector = [
None] * scorer.n_atoms
393 sym_dist_collector = [
None] * scorer.n_atoms
395 for mapping, s_cache, p_cache
in zip(chain_mappings, scoring_cache,
398 lddt_chain_mapping = dict()
400 for ref_chem_group, mdl_chem_group
in zip(chem_groups, mapping):
401 for ref_ch, mdl_ch
in zip(ref_chem_group, mdl_chem_group):
403 if mdl_ch
is not None:
404 lddt_chain_mapping[mdl_ch] = ref_ch
405 lddt_alns[mdl_ch] = cut_ref_mdl_alns[(ref_ch, mdl_ch)]
408 lddt_chain_mapping[mdl_ligand_chain.name] = trg_ligand_chain.name
409 lddt_alns[mdl_ligand_chain.name] = ligand_aln
413 pos, _, _, _, _, _, lddt_symmetries = \
414 scorer._ProcessModel(mdl_bs, lddt_chain_mapping,
415 residue_mapping = lddt_alns,
417 check_resnames =
False)
427 unmapped_chains = list()
428 already_mapped = set()
429 for mdl_ch
in mdl_chains:
430 if mdl_ch
not in lddt_chain_mapping:
437 if chem_grp_idx
is None:
438 raise RuntimeError(
"This should never happen... "
442 for trg_ch
in self.
_chain_mapper_chain_mapper.chem_groups[chem_grp_idx]:
443 if trg_ch
not in lddt_chain_mapping.values():
444 if trg_ch
not in already_mapped:
445 ch = self.
_chain_mapper_chain_mapper.target.FindChain(trg_ch)
446 c = ch.geometric_center
448 if closest_dist
is None or d < closest_dist:
451 if closest_ch
is not None:
452 unmapped_chains.append((closest_ch, mdl_ch))
453 already_mapped.add(closest_ch)
455 for (trg_sym, mdl_sym)
in symmetries:
458 for mdl_i, trg_i
in zip(mdl_sym, trg_sym):
459 pos[ligand_start_idx + trg_i, :] = mdl_ligand_pos[mdl_i, :]
462 funky_ref_indices = [np.copy(a)
for a
in ref_indices]
463 funky_ref_distances = [np.copy(a)
for a
in ref_distances]
470 for idx
in symmetric_atoms:
471 sym_idx_collector[idx] = list()
472 sym_dist_collector[idx] = list()
476 for mdl_i, trg_i
in zip(mdl_sym, trg_sym):
477 added_penalty += p_cache[mdl_i]
478 cache = s_cache[mdl_i, trg_i]
479 full_trg_i = ligand_start_idx + trg_i
480 funky_ref_indices[full_trg_i] = \
481 np.append(funky_ref_indices[full_trg_i], cache[0])
482 funky_ref_distances[full_trg_i] = \
483 np.append(funky_ref_distances[full_trg_i], cache[1])
484 for idx, d
in zip(cache[2], cache[3]):
485 sym_idx_collector[idx].append(full_trg_i)
486 sym_dist_collector[idx].append(d)
488 for idx
in symmetric_atoms:
489 funky_ref_indices[idx] = \
490 np.append(funky_ref_indices[idx],
491 np.asarray(sym_idx_collector[idx],
493 funky_ref_distances[idx] = \
494 np.append(funky_ref_distances[idx],
495 np.asarray(sym_dist_collector[idx],
507 N = sum([len(funky_ref_indices[i])
for i
in ligand_at_indices])
511 if len(unmapped_chains) > 0:
518 conserved = np.sum(scorer._EvalAtoms(pos, ligand_at_indices,
521 funky_ref_distances),
525 score = np.mean(conserved/N)
527 if score
is not None and score > best_score:
529 best_result = {
"lddt_pli": score,
530 "lddt_pli_n_contacts": N}
533 best_result[
"target_ligand"] = target_ligand
534 best_result[
"model_ligand"] = model_ligand
535 best_result[
"bs_ref_res"] = trg_residues
536 best_result[
"bs_mdl_res"] = mdl_residues
541 def _compute_lddt_pli_classic(self, symmetries, target_ligand,
552 trg_residues, trg_bs, trg_chains, trg_ligand_chain, \
553 trg_ligand_res, scorer, chem_groups = \
560 ref_indices = [a.copy()
for a
in scorer.ref_indices_ic]
561 ref_distances = [a.copy()
for a
in scorer.ref_distances_ic]
565 ligand_start_idx = scorer.chain_start_indices[-1]
566 ligand_at_indices = list(range(ligand_start_idx, scorer.n_atoms))
567 n_exp = sum([len(ref_indices[i])
for i
in ligand_at_indices])
569 mdl_residues, mdl_bs, mdl_chains, mdl_ligand_chain, mdl_ligand_res, \
574 return {
"lddt_pli":
None,
575 "lddt_pli_n_contacts": 0,
576 "target_ligand": target_ligand,
577 "model_ligand": model_ligand,
578 "bs_ref_res": trg_residues,
579 "bs_mdl_res": mdl_residues}
583 for at_idx
in range(ligand_start_idx):
584 mask = ref_indices[at_idx] >= ligand_start_idx
585 ref_indices[at_idx] = ref_indices[at_idx][mask]
586 ref_distances[at_idx] = ref_distances[at_idx][mask]
606 l_aln = seq.CreateAlignment()
607 l_aln.AddSequence(seq.CreateSequence(trg_ligand_chain.name,
608 trg_ligand_res.GetOneLetterCode()))
609 l_aln.AddSequence(seq.CreateSequence(mdl_ligand_chain.name,
610 mdl_ligand_res.GetOneLetterCode()))
612 mdl_ligand_pos = np.zeros((model_ligand.GetAtomCount(), 3))
613 for a_idx, a
in enumerate(model_ligand.atoms):
615 mdl_ligand_pos[a_idx, 0] = p[0]
616 mdl_ligand_pos[a_idx, 1] = p[1]
617 mdl_ligand_pos[a_idx, 2] = p[2]
619 for mapping
in chain_mapping._ChainMappings(chem_groups, chem_mapping):
621 lddt_chain_mapping = dict()
623 for ref_chem_group, mdl_chem_group
in zip(chem_groups, mapping):
624 for ref_ch, mdl_ch
in zip(ref_chem_group, mdl_chem_group):
626 if mdl_ch
is not None:
627 lddt_chain_mapping[mdl_ch] = ref_ch
628 lddt_alns[mdl_ch] = cut_ref_mdl_alns[(ref_ch, mdl_ch)]
631 lddt_chain_mapping[mdl_ligand_chain.name] = trg_ligand_chain.name
632 lddt_alns[mdl_ligand_chain.name] = l_aln
636 pos, _, _, _, _, _, lddt_symmetries = \
637 scorer._ProcessModel(mdl_bs, lddt_chain_mapping,
638 residue_mapping = lddt_alns,
640 check_resnames =
False)
642 for (trg_sym, mdl_sym)
in symmetries:
643 for mdl_i, trg_i
in zip(mdl_sym, trg_sym):
644 pos[ligand_start_idx + trg_i, :] = mdl_ligand_pos[mdl_i, :]
654 conserved = np.sum(scorer._EvalAtoms(pos, ligand_at_indices,
657 ref_distances), axis=0)
658 score = np.mean(conserved/n_exp)
660 if score > best_score:
664 best_result = {
"lddt_pli": best_score,
665 "lddt_pli_n_contacts": n_exp,
666 "target_ligand": target_ligand,
667 "model_ligand": model_ligand,
668 "bs_ref_res": trg_residues,
669 "bs_mdl_res": mdl_residues}
673 def _lddt_pli_unmapped_chain_penalty(self, unmapped_chains,
680 for ch_tuple
in unmapped_chains:
681 if ch_tuple
not in non_mapped_cache:
687 mdl_cname = ch_tuple[1]
688 query =
"cname=" + mol.QueryQuoteName(mdl_cname)
689 mdl_bs_ch = mdl_bs.Select(query)
690 for a
in mdl_ligand_res.atoms:
694 for close_a
in close_atoms:
695 at_key = (close_a.GetResidue().GetNumber(),
699 counts[a.hash_code] = N
702 non_mapped_cache[ch_tuple] = counts
706 counts = non_mapped_cache[ch_tuple]
707 lig_hash_codes = [a.hash_code
for a
in mdl_ligand_res.atoms]
709 n_exp += counts[lig_hash_codes[i]]
714 def _lddt_pli_get_mdl_data(self, model_ligand):
720 for at
in model_ligand.atoms:
721 close_atoms = mdl.FindWithin(at.GetPos(), self.
lddt_pli_radiuslddt_pli_radius)
722 for close_at
in close_atoms:
723 mdl_residues.add(close_at.GetResidue())
726 for r
in mdl.residues:
727 r.SetIntProp(
"bs", 0)
728 for at
in model_ligand.atoms:
729 close_atoms = mdl.FindWithin(at.GetPos(), max_r)
730 for close_at
in close_atoms:
731 close_at.GetResidue().SetIntProp(
"bs", 1)
733 mdl_bs = mol.CreateEntityFromView(mdl.Select(
"grbs:0=1"),
True)
734 mdl_chains = set([ch.name
for ch
in mdl_bs.chains])
736 mdl_editor = mdl_bs.EditXCS(mol.BUFFERED_EDIT)
737 mdl_ligand_chain =
None
738 for cname
in [
"hugo_the_cat_terminator",
"ida_the_cheese_monster"]:
741 mdl_ligand_chain = mdl_editor.InsertChain(cname)
745 if mdl_ligand_chain
is None:
746 raise RuntimeError(
"Fuck this, I'm out...")
747 mdl_ligand_res = mdl_editor.AppendResidue(mdl_ligand_chain,
750 mdl_editor.RenameResidue(mdl_ligand_res,
"LIG")
751 mdl_editor.SetResidueNumber(mdl_ligand_res,
mol.ResNum(1))
753 chem_mapping = list()
755 chem_mapping.append([x
for x
in m
if x
in mdl_chains])
767 def _lddt_pli_get_trg_data(self, target_ligand, max_r = None):
776 for at
in target_ligand.atoms:
777 close_atoms = trg.FindWithin(at.GetPos(), max_r)
778 for close_at
in close_atoms:
779 trg_residues.add(close_at.GetResidue())
781 for r
in trg.residues:
782 r.SetIntProp(
"bs", 0)
784 for r
in trg_residues:
785 r.SetIntProp(
"bs", 1)
787 trg_bs = mol.CreateEntityFromView(trg.Select(
"grbs:0=1"),
True)
788 trg_chains = set([ch.name
for ch
in trg_bs.chains])
790 trg_editor = trg_bs.EditXCS(mol.BUFFERED_EDIT)
791 trg_ligand_chain =
None
792 for cname
in [
"hugo_the_cat_terminator",
"ida_the_cheese_monster"]:
795 trg_ligand_chain = trg_editor.InsertChain(cname)
799 if trg_ligand_chain
is None:
800 raise RuntimeError(
"Fuck this, I'm out...")
802 trg_ligand_res = trg_editor.AppendResidue(trg_ligand_chain,
805 trg_editor.RenameResidue(trg_ligand_res,
"LIG")
806 trg_editor.SetResidueNumber(trg_ligand_res,
mol.ResNum(1))
808 compound_name = trg_ligand_res.name
809 compound = lddt.CustomCompound.FromResidue(trg_ligand_res)
810 custom_compounds = {compound_name: compound}
813 custom_compounds = custom_compounds,
818 chem_groups.append([x
for x
in g
if x
in trg_chains])
831 def _lddt_pli_cut_ref_mdl_alns(self, chem_groups, chem_mapping, mdl_bs,
833 cut_ref_mdl_alns = dict()
834 for ref_chem_group, mdl_chem_group
in zip(chem_groups, chem_mapping):
835 for ref_ch
in ref_chem_group:
837 ref_bs_chain = ref_bs.FindChain(ref_ch)
838 query =
"cname=" + mol.QueryQuoteName(ref_ch)
839 ref_view = self.
_chain_mapper_chain_mapper.target.Select(query)
841 for mdl_ch
in mdl_chem_group:
844 aln.AttachView(0, ref_view)
846 mdl_bs_chain = mdl_bs.FindChain(mdl_ch)
847 query =
"cname=" + mol.QueryQuoteName(mdl_ch)
850 cut_mdl_seq = [
'-'] * aln.GetLength()
851 cut_ref_seq = [
'-'] * aln.GetLength()
852 for i, col
in enumerate(aln):
855 r = col.GetResidue(0)
857 bs_r = ref_bs_chain.FindResidue(r.GetNumber())
859 cut_ref_seq[i] = col[0]
862 r = col.GetResidue(1)
864 bs_r = mdl_bs_chain.FindResidue(r.GetNumber())
866 cut_mdl_seq[i] = col[1]
868 cut_ref_seq =
''.join(cut_ref_seq)
869 cut_mdl_seq =
''.join(cut_mdl_seq)
870 cut_aln = seq.CreateAlignment()
871 cut_aln.AddSequence(seq.CreateSequence(ref_ch, cut_ref_seq))
872 cut_aln.AddSequence(seq.CreateSequence(mdl_ch, cut_mdl_seq))
873 cut_ref_mdl_alns[(ref_ch, mdl_ch)] = cut_aln
874 return cut_ref_mdl_alns
877 def _mappable_atoms(self):
878 """ Stores mappable atoms given a chain mapping
880 Store for each ref_ch,mdl_ch pair all mdl atoms that can be
881 mapped. Don't store mappable atoms as hashes but rather as tuple
882 (mdl_r.GetNumber(), mdl_a.GetName()). Reason for that is that one might
883 operate on Copied EntityHandle objects without corresponding hashes.
884 Given a tuple defining c_pair: (ref_cname, mdl_cname), one
885 can check if a certain atom is mappable by evaluating:
886 if (mdl_r.GetNumber(), mdl_a.GetName()) in self._mappable_atoms(c_pair)
890 for (ref_cname, mdl_cname), aln
in self.
_ref_mdl_alns_ref_mdl_alns.items():
892 ref_query = f
"cname={mol.QueryQuoteName(ref_cname)}"
893 mdl_query = f
"cname={mol.QueryQuoteName(mdl_cname)}"
894 ref_ch = self.
_chain_mapper_chain_mapper.target.Select(ref_query)
896 aln.AttachView(0, ref_ch)
897 aln.AttachView(1, mdl_ch)
899 ref_r = col.GetResidue(0)
900 mdl_r = col.GetResidue(1)
901 if ref_r.IsValid()
and mdl_r.IsValid():
902 for mdl_a
in mdl_r.atoms:
903 if ref_r.FindAtom(mdl_a.name).IsValid():
904 c_key = (ref_cname, mdl_cname)
905 at_key = (mdl_r.GetNumber(), mdl_a.name)
911 def _chem_mapping(self):
919 def _chem_group_alns(self):
927 def _ref_mdl_alns(self):
930 chain_mapping._GetRefMdlAlns(self.
_chain_mapper_chain_mapper.chem_groups,
937 def _chain_mapping_mdl(self):
945 __all__ = (
'LDDTPLIScorer',)
def __init__(self, model, target, model_ligands=None, target_ligands=None, resnum_alignments=False, rename_ligand_chain=False, substructure_match=False, coverage_delta=0.2, max_symmetries=1e5, lddt_pli_radius=6.0, add_mdl_contacts=False, lddt_pli_thresholds=[0.5, 1.0, 2.0, 4.0], lddt_pli_binding_site_radius=None)
lddt_pli_binding_site_radius
def _lddt_pli_get_trg_data(self, target_ligand, max_r=None)
def _mappable_atoms(self)
def _chem_group_alns(self)
def _compute_lddt_pli_classic(self, symmetries, target_ligand, model_ligand)
def _lddt_pli_unmapped_chain_penalty(self, unmapped_chains, non_mapped_cache, mdl_bs, mdl_ligand_res, mdl_sym)
def _lddt_pli_cut_ref_mdl_alns(self, chem_groups, chem_mapping, mdl_bs, ref_bs)
def _lddt_pli_get_mdl_data(self, model_ligand)
def _chain_mapping_mdl(self)
def _compute_lddt_pli_add_mdl_contacts(self, symmetries, target_ligand, model_ligand)
Real DLLEXPORT_OST_GEOM Distance(const Line2 &l, const Vec2 &v)