csb.bio.fragments

1 """ 2 APIs for working with protein structure fragments and libraries. 3 4 This package contains the nuts and bolts of HHfrag. Everything here revolves 5 around the L{Target} class, which describes a protein structure prediction 6 target. One typically assigns fragments (L{Assignment}s) to the target and then 7 builds a fragment library with L{RosettaFragsetFactory}. 8 """ 9 10 import os 11 import numpy 12 13 import csb.io 14 import csb.core 15 import csb.bio.utils 16 import csb.bio.structure 17 import csb.bio.sequence 18 19 from csb.bio.structure import SecondaryStructure 20 from csb.bio.io.wwpdb import FileSystemStructureProvider, StructureParser

21 22 23 -class FragmentTypes(object):

24 25 HHfrag = 'TH' 26 Rosetta = 'NN' 27 ISites = 'IS' 28 StaticHH = 'HH'

29

30 -class Metrics(object):

31 32 RMSD = 'rmsd_to' 33 NORMALIZED_RMSD = 'nrmsd_to' 34 MDA = 'mda_to'

35 36 RANDOM_RMSD = { 5: 1.8749005857255376, 6: 2.4314283686276261, 7: 2.9021135267789608, 8: 3.2477716200172715, 9: 3.5469606556031708, 10: 3.8295465524456329, 37 11: 4.1343107114131783, 12: 4.3761697929053014, 13: 4.6707299668248394, 14: 4.9379016881069733, 15: 5.1809028645084911, 16: 5.4146957142595662, 38 17: 5.7135948448156988, 18: 5.9597935432566782, 19: 6.1337340535741962, 20: 6.3962825155503271, 21: 6.6107937773415166, 22: 6.8099096274123401, 39 23: 7.0435583846849639, 24: 7.2160956482560970, 25: 7.4547896324594962, 26: 7.6431870072434211, 27: 7.8727812194173836, 28: 8.0727393298443637, 40 29: 8.2551450998965326, 30: 8.4413583511786587, 31: 8.5958719774122052, 32: 8.7730435506242408, 33: 8.9970648837941649, 34: 9.1566521405105163, 41 35: 9.2828620878454728, 36: 9.4525824357923405, 37: 9.6322126445253300, 38: 9.7851684750961176, 39: 9.9891454649821476, 40: 10.124373939352028, 42 41: 10.284348528344765, 42: 10.390457305096271, 43: 10.565792044674239, 44: 10.676532740033737, 45: 10.789537132283652, 46: 11.004475543757550, 43 47: 11.064541647783571, 48: 11.231219875286985, 49: 11.319222637391441, 50: 11.485478165340824, 51: 11.607522494435521, 52: 11.700268836069840, 44 53: 11.831245255954073, 54: 11.918975893263905 }

45 46 -class FragmentMatch(object):

47 """ 48 Base class, representing a match between a fragment and its target. 49 """ 50

51 - def __init__(self, id, qstart, qend, probability, rmsd, tm_score, qlength):

52 53 self._id = id 54 self._qstart = qstart 55 self._qend = qend 56 self._probability = probability 57 self._rmsd = rmsd 58 self._tm_score = tm_score 59 self._qlength = qlength

60 61 @property

62 - def id(self):

63 return self._id

64 65 @property

66 - def qstart(self):

67 return self._qstart

68 69 @property

70 - def qend(self):

71 return self._qend

72 73 @property

74 - def qlength(self):

75 return self._qlength

76 77 @property

78 - def rmsd(self):

79 return self._rmsd

80 81 @property

82 - def tm_score(self):

83 return self._tm_score

84 85 @property

86 - def probability(self):

87 return self._probability

88 89 @property

90 - def length(self):

91 return self.qend - self.qstart + 1

92 93 @property

94 - def source_id(self):

95 raise NotImplementedError()

96 97 @property

98 - def start(self):

99 raise NotImplementedError()

100 101 @property

102 - def end(self):

103 raise NotImplementedError()

104

105 106 -class TorsionAnglePredictor(object):

107 """ 108 Fragment-based phi/psi angles predictor. 109 110 @param target: target protein, containing fragment assignments 111 @type target: L{Target} 112 @param threshold: RMSD distance threshold for L{FragmentCluster}-based filtering 113 @type threshold: float 114 @param extend: pick alternative, longer cluster reps, if possible 115 @type extend: bool 116 @param init: populate all L{FragmentCluster}s on instantiation. If False, this step 117 will be performed on demand (the first time C{predictor.compute()} is invoked) 118 119 @note: if C{init} is False, the first call to C{predictor.compute()} might take a long 120 time. Subsequent calls will be very fast. 121 """ 122

123 - def __init__(self, target, threshold=1.5, extend=False, init=False):

124 125 if not isinstance(target, Target): 126 raise TypeError(target) 127 if target.matches.length == 0: 128 raise ValueError('This target has no fragment assignments') 129 130 self._target = target 131 self._threshold = float(threshold) 132 self._extend = bool(extend) 133 134 self._initialized = False 135 self._reps = {} 136 self._clusters = {} 137 138 if init: 139 self.init()

140 141 @property

142 - def target(self):

143 return self._target

144 145 @property

146 - def threshold(self):

147 return self._threshold

148 149 @property

150 - def extend(self):

151 return self._extend

152

153 - def init(self):

154 """ 155 Compute and cache all L{FragmentCluster}s. 156 """ 157 158 self._reps = {} 159 self._clusters = {} 160 161 for residue in self.target.residues: 162 cluster = self._filter(residue) 163 164 if cluster is not None: 165 rep = cluster.centroid() 166 if rep.has_alternative: 167 rep.exchange() 168 169 self._reps[residue.native.rank] = rep 170 self._clusters[residue.native.rank] = cluster.items 171 172 self._initialized = True

173

174 - def _filter(self, residue):

175 176 try: 177 nodes = [] 178 for ai in residue.assignments: 179 node = ClusterNode.create(ai.fragment) 180 nodes.append(node) 181 182 cluster = FragmentCluster(nodes, threshold=self.threshold) 183 cluster.shrink(minitems=0) 184 185 return cluster 186 187 except (ClusterExhaustedError, ClusterDivergingError): 188 return None

189

190 - def _residue(self, rank):

191 192 for r in self._target.residues: 193 if r.native.rank == rank: 194 return r 195 196 raise ValueError('Rank {0} is out of range'.format(rank))

197

198 - def compute_single(self, rank):

199 """ 200 Extract torsion angles from the L{ClusterRep} at residue C{#rank}. 201 202 @param rank: target residue rank 203 @type rank: int 204 205 @rtype: L{TorsionPredictionInfo} 206 """ 207 208 residue = self._residue(rank) 209 rep = residue.filter(threshold=self.threshold, extend=self.extend) 210 211 if rep is None: 212 return None 213 214 else: 215 fragment = rep.centroid 216 torsion = fragment.torsion_at(rank, rank)[0] 217 ss = fragment.sec_structure_at(rank, rank)[0] 218 219 return TorsionPredictionInfo(rank, rep.confidence, torsion, ss, primary=True)

220

221 - def compute(self, rank):

222 """ 223 Extract torsion angles from all L{ClusterRep}s, covering residue C{#rank}. 224 225 @param rank: target residue rank 226 @type rank: int 227 228 @return: L{TorsionPredictionInfo} instances, sorted by confidence 229 @rtype: tuple of L{TorsionPredictionInfo} 230 """ 231 232 if not self._initialized: 233 self.init() 234 235 prediction = [] 236 237 for rep in self._reps.values(): 238 239 if rep.centroid.qstart <= rank <= rep.centroid.qend: 240 241 fragment = rep.centroid 242 torsion = fragment.torsion_at(rank, rank)[0] 243 ss = fragment.sec_structure_at(rank, rank)[0] 244 info = TorsionPredictionInfo(rank, rep.confidence, torsion, ss) 245 246 if rep is self._reps.get(rank, None): 247 info.primary = True 248 249 prediction.append(info) 250 251 prediction.sort(reverse=True) 252 return tuple(prediction)

253

254 - def flat_torsion_map(self):

255 """ 256 Filter the current fragment map and create a new, completely flat, 257 non-overlapping map built from centroids, assigned iteratively by 258 decreasing confidence. Centroids with lower confidence which overlap 259 with previously assigned centroids will be trimmed to fill existing 260 gaps only. 261 262 @return: L{TorsionPredictionInfo} instances, one for each target residue 263 @rtype: tuple of L{TorsionPredictionInfo} 264 """ 265 266 if not self._initialized: 267 self.init() 268 269 prediction = [] 270 slots = set(range(1, self.target.length + 1)) 271 272 reps = list(self._reps.values()) 273 reps.sort(key=lambda i: i.confidence, reverse=True) 274 275 for rep in reps: 276 277 for rank in range(rep.centroid.qstart, rep.centroid.qend + 1): 278 if rank in slots: 279 torsion = rep.centroid.torsion_at(rank, rank)[0] 280 ss = rep.centroid.sec_structure_at(rank, rank)[0] 281 info = TorsionPredictionInfo(rank, rep.confidence, torsion, ss, primary=True) 282 283 prediction.append(info) 284 slots.remove(rank) 285 286 for rank in slots: 287 prediction.append(TorsionPredictionInfo(rank, 0, None)) 288 289 prediction.sort(key=lambda i: i.rank) 290 return tuple(prediction)

291

292 - def get_angles(self, rank):

293 """ 294 Extract all torsion angles coming from all fragments, which had survived 295 the filtering and cover residue C{#rank}. 296 297 @param rank: target residue rank 298 @type rank: int 299 300 @return: all L{TorsionAngles} for a cluster at the specified residue 301 @rtype: tuple of L{TorsionAngles} 302 """ 303 304 if not self._initialized: 305 self.init() 306 if rank not in self._clusters: 307 return tuple() 308 309 angles = [] 310 311 for node in self._clusters[rank]: 312 fragment = node.fragment 313 torsion = fragment.torsion_at(rank, rank)[0] 314 angles.append(torsion) 315 316 return tuple(angles)

317

318 319 -class TorsionPredictionInfo(object):

320 """ 321 Struct container for a single torsion angle prediction. 322 323 @param rank: target residue rank 324 @type rank: int 325 @param confidence: confidence of prediction 326 @type confidence: float 327 @param torsion: assigned phi/psi/omega angles 328 @type torsion: L{TorsionAngles} 329 @param dssp: assigned secondary structure 330 @type dssp: L{SecondaryStructureElement} 331 @param primary: if True, designates that the assigned angles are extracted 332 from the L{ClusterRep} at residue C{#rank}; otherwise: the 333 angles are coming from another, overlapping L{ClusterRep} 334 335 """ 336

337 - def __init__(self, rank, confidence, torsion, dssp, primary=False):

338 339 self.rank = rank 340 self.confidence = confidence 341 self.torsion = torsion 342 self.primary = primary 343 self.dssp = dssp

344

345 - def as_tuple(self):

346 """ 347 @return: convert this prediction to a tuple: (confidence, phi, psi, omega) 348 @rtype: tuple 349 """ 350 return tuple([self.confidence, self.torsion.phi, self.torsion.psi, self.torsion.omega])

351

352 - def __str__(self):

353 return '<TorsionPredictionInfo: {0.confidence:6.3f} at #{0.rank}>'.format(self)

354

355 - def __lt__(self, other):

356 return self.confidence < other.confidence

357

358 359 -class AssignmentFactory(object):

360

361 - def target(self, *a, **k):

362 return Target(*a, **k)

363

364 - def residue(self, *a, **k):

365 return TargetResidue(*a, **k)

366

367 - def assignment(self, *a, **k):

368 return Assignment(*a, **k)

369

370 -class ChemShiftAssignmentFactory(object):

371

372 - def target(self, *a, **k):

373 return ChemShiftTarget(*a, **k)

374

375 - def residue(self, *a, **k):

376 return ChemShiftTargetResidue(*a, **k)

377

378 - def assignment(self, *a, **k):

379 return ChemShiftAssignment(*a, **k)

380

381 -class Target(csb.core.AbstractNIContainer):

382 """ 383 Represents a protein structure prediction target. 384 385 @param id: target sequence ID, in PDB accnC format 386 @type id: str 387 @param length: total target sequence length 388 @type length: int 389 @param residues: a list, containing target's residues. See also 390 L{Target.from_sequence} 391 @type residues: iterable of L{csb.bio.structure.ProteinResidue}s 392 """ 393

394 - def __init__(self, id, length, residues, overlap=None, factory=AssignmentFactory()):

395 396 self._id = id 397 self._accession = id[:-1] 398 self._chain_id = id[-1] 399 self._length = length 400 self._overlap = overlap 401 self._factory = factory 402 403 self._assignments = csb.core.ReadOnlyCollectionContainer(type=Assignment) 404 self._errors = csb.core.CollectionContainer() 405 406 resi = [factory.residue(native) for native in residues] 407 self._residues = csb.core.ReadOnlyCollectionContainer(items=resi, 408 type=TargetResidue, start_index=1)

409 410 @staticmethod

411 - def from_sequence(id, sequence):

412 """ 413 Factory, which builds L{Target} objects from a bare sequence. 414 415 @param sequence: target's sequence 416 @type sequence: L{csb.bio.sequence.AbstractSequence}, str or iterable 417 418 @rtype: L{Target} 419 """ 420 421 if isinstance(sequence, csb.bio.sequence.Sequence): 422 sequence = sequence.sequence 423 424 residues = [] 425 426 for rn, aa in enumerate(sequence, start=1): 427 residue = csb.bio.structure.ProteinResidue(rank=rn, type=aa) 428 residues.append(residue) 429 430 return Target(id, len(residues), residues)

431 432 @staticmethod

433 - def from_profile(hmm):

434 """ 435 Factory, which builds L{Target} objects from an HMM profile. 436 437 @param hmm: target's HMM 438 @type hmm: L{csb.bio.hmm.ProfileHMM} 439 440 @rtype: L{Target} 441 """ 442 443 residues = [ r.clone() for r in hmm.residues ] 444 return Target(hmm.id, hmm.layers.length, residues)

445 446 @staticmethod

447 - def deserialize(pickle):

448 449 with open(pickle) as stream: 450 return csb.io.Pickle.load(stream)

451 452 @property

453 - def _children(self):

454 return self._residues

455 456 @property

457 - def errors(self):

458 return self._errors

459 460 @property

461 - def id(self):

462 return self._id

463 464 @property

465 - def accession(self):

466 return self._accession

467 468 @property

469 - def chain_id(self):

470 return self._chain_id

471 472 @property

473 - def max_overlap(self):

474 return self._overlap

475 476 @property

477 - def length(self):

478 return self._length

479 480 @property

481 - def sequence(self):

482 return ''.join(str(r.native.type) for r in self)

483 484 @property

485 - def matches(self):

486 return self._assignments

487 488 @property

489 - def residues(self):

490 return self._residues

491

492 - def assign(self, fragment):

493 """ 494 Add a new fragment match. 495 @param fragment: fragment to assign 496 @type fragment: L{Assignment} 497 """ 498 499 if not 1 <= fragment.qstart <= fragment.qend <= len(self._residues): 500 raise ValueError("Fragment out of range") 501 502 self._assignments._append_item(fragment) 503 504 for rank in range(fragment.qstart, fragment.qend + 1): 505 ai = ResidueAssignmentInfo(fragment, rank) 506 self._residues[rank].assign(ai)

507

508 - def assignall(self, fragments):

509 """ 510 Assign a bunch of fragments at once. 511 @type fragments: iterable of L{Assignment}s 512 """ 513 for frag in fragments: 514 self.assign(frag)

515

516 - def filter(self, threshold=1.5, extend=False):

517 """ 518 Filter the current fragment map using a L{FragmentCluster}. 519 520 @param threshold: cluster RMSD threshold (see L{FragmentCluster}) 521 @type threshold: float 522 @param extend: pick extended alternatives where possible (default=False) 523 @type extend: bool 524 525 @return: a new target, containing only cluster centroids/reps 526 @rtype: L{Target} 527 """ 528 529 target = self.clone() 530 531 for residue in self.residues: 532 rep = residue.filter(threshold=threshold, extend=extend) 533 534 if rep is not None: 535 target.assign(rep.centroid) 536 537 return target

538

539 - def clone(self):

540 """ 541 @return: a deep copy of the target 542 @rtype: L{Target} 543 """ 544 residues = [r.native for r in self.residues] 545 target = self._factory.target(self.id, self.length, residues, 546 overlap=self._overlap) 547 return target

548

549 -class ChemShiftTarget(Target):

550

551 - def __init__(self, id, length, residues, overlap=None):

552 553 super(ChemShiftTarget, self).__init__(id, length, residues, overlap=overlap, 554 factory=ChemShiftAssignmentFactory())

555

556 - def assign(self, fragment):

557 558 if not 1 <= fragment.qstart <= fragment.qend <= len(self._residues): 559 raise ValueError("Fragment out of range") 560 561 self._assignments._append_item(fragment) 562 563 rank = fragment.qstart 564 ai = ResidueAssignmentInfo(fragment, rank) 565 self._residues[rank].assign(ai)

566

567 - def clone(self):

568 return self._factory.target(self.id, self.length, 569 [r.native for r in self.residues], 570 overlap=self._overlap)

571

572 -class TargetResidue(object):

573 """ 574 Wrapper around L{Target}'s native residues. Decorates them with additional, 575 fragment-related methods. 576 577 @type native_residue: L{csb.bio.structure.ProteinResidue} 578 """ 579

580 - def __init__(self, native_residue):

581 582 self._type = native_residue.type 583 self._native = native_residue.clone() 584 self._assignments = csb.core.ReadOnlyCollectionContainer(type=ResidueAssignmentInfo)

585 586 @property

587 - def type(self):

588 return self._type

589 590 @property

591 - def native(self):

592 return self._native

593 594 @property

595 - def assignments(self):

596 return self._assignments

597

598 - def assign(self, assignment_info):

599 self._assignments._append_item(assignment_info)

600

601 - def filter(self, method=Metrics.RMSD, threshold=1.5, extend=False):

602 """ 603 Filter all fragments, covering this position in the L{Target} using a 604 L{FragmentCluster}. 605 606 @param method: one of the L{Metrics} members (default=L{Metrics.RMSD}) 607 @type method: str 608 @param threshold: cluster RMSD threshold (see L{FragmentCluster}) 609 @type threshold: float 610 @param extend: pick extended alternative where possible (default=False) 611 @type extend: bool 612 613 @return: cluster's representative (if converged) or None 614 @rtype: L{ClusterRep} or None 615 """ 616 617 try: 618 nodes = [] 619 for ai in self.assignments: 620 node = ClusterNode.create(ai.fragment, method, extend) 621 nodes.append(node) 622 623 cluster = FragmentCluster(nodes, threshold=threshold) 624 625 center = cluster.shrink(minitems=0) 626 if center.has_alternative: 627 center.exchange() 628 629 return center 630 631 except (ClusterExhaustedError, ClusterDivergingError): 632 return None

633

634 - def closest(self):

635 """ 636 @return: the fragment with the lowest RMSD at this position in the L{Target} 637 @rtype: L{Assignment} 638 """ 639 640 best = None 641 642 for ai in self.assignments: 643 a = ai.fragment 644 if a.length < FragmentCluster.MIN_LENGTH: 645 continue 646 if best is None or a.rmsd < best.rmsd: 647 best = a 648 elif a.rmsd == best.rmsd and a.length > best.length: 649 best = a 650 651 return best

652

653 - def longest(self):

654 """ 655 @return: the longest fragment, covering the current position 656 @rtype: L{Assignment} 657 """ 658 best = None 659 660 for q in self.assignments: 661 if best is None or (q.fragment.length > best.length): 662 best = q.fragment 663 664 return best

665

666 - def precision(self, threshold=1.5):

667 """ 668 @return: the residue-wise precision of the fragment library at the 669 current position (percentage). 670 671 @param threshold: true-positive RMSD cutoff (default=1.5) 672 @type threshold: float 673 @rtype: float 674 """ 675 676 if self.assignments.length < 1: 677 return None 678 else: 679 positive = [a for a in self.assignments if a.fragment.rmsd <= threshold] 680 pos = len(positive) * 100.0 / self.assignments.length 681 682 return pos

683

684 -class ChemShiftTargetResidue(TargetResidue):

685

686 - def closest(self):

687 688 best = None 689 690 for ai in self.assignments: 691 a = ai.fragment 692 693 if a.score < ChemShiftAssignment.BIT_SCORE_THRESHOLD * a.window: 694 continue 695 696 if best is None or a.score > best.score: 697 best = a 698 elif a.score == best.score and a.length > best.length: 699 best = a 700 701 return best

702

703 704 -class ResidueAssignmentInfo(object):

705

706 - def __init__(self, assignment, rank):

707 708 if not assignment.qstart <= rank <= assignment.qend: 709 raise ValueError('Rank {0} is not matched by this assignment') 710 711 self._assignment = assignment 712 self._rank = rank 713 self._relrank = rank - assignment.qstart

714 715 @property

716 - def c_alpha(self):

717 return self._assignment.backbone[self._relrank]

718 719 @property

720 - def fragment(self):

721 return self._assignment

722

723 -class Assignment(FragmentMatch):

724 """ 725 Represents a match between a fragment and its target. 726 727 @param source: source structure (must have torsion angles precomputed) 728 @type source: L{csb.bio.structure.Chain} 729 @param start: start position in C{source} (rank) 730 @type start: int 731 @param end: end position in C{source} (rank) 732 @type end: int 733 @param id: fragment ID 734 @type id: str 735 @param qstart: start position in target (rank) 736 @type qstart: int 737 @param qend: end position in target (rank) 738 @type qend: int 739 @param probability: probability of assignment 740 @type probability: float 741 @param rmsd: RMSD of the fragment, compared to target's native structure 742 @type rmsd: float 743 """ 744

745 - def __init__(self, source, start, end, qstart, qend, id=None, probability=None, rmsd=None, 746 tm_score=None, score=None, neff=None, internal_id=None):

747 748 assert source.has_torsion 749 sub = source.subregion(start, end, clone=True) 750 try: 751 calpha = [r.atoms['CA'].vector.copy() for r in sub.residues] 752 except csb.core.ItemNotFoundError: 753 raise csb.bio.structure.Broken3DStructureError() 754 torsion = [r.torsion.copy() for r in sub.residues] 755 756 self._calpha = csb.core.ReadOnlyCollectionContainer(items=calpha, type=numpy.ndarray) 757 self._torsion = torsion 758 self._sequence = sub.sequence 759 760 self._source_id = source.accession[:4] + source.id 761 self._start = start 762 self._end = end 763 764 self._score = score 765 self._neff = neff 766 self._ss = None 767 768 self.internal_id = internal_id 769 770 if id is None: 771 id = "{0}:{1}-{2}".format(self.source_id, self.start, self.end) 772 773 super(Assignment, self).__init__(id, qstart, qend, probability, rmsd, tm_score, None) 774 775 self._ss = SecondaryStructure('-' * self.length)

776 777 @staticmethod

778 - def from_fragment(fragment, provider):

779 """ 780 Create a new L{Assignment} given a source rosetta fragment. 781 782 @param fragment: rosetta fragment 783 @type fragment: L{RosettaFragment} 784 @param provider: PDB database provider 785 @type provider: L{StructureProvider} 786 787 @rtype: L{Assignment} 788 """ 789 try: 790 structure = provider.get(fragment.accession) 791 except KeyError: 792 structure = provider.get(fragment.source_id) 793 source = structure.chains[fragment.chain] 794 source.compute_torsion() 795 796 id = "{0}:{1}-{2}".format(fragment.source_id, fragment.start, fragment.end) 797 798 return Assignment(source, fragment.start, fragment.end, 799 fragment.qstart, fragment.qend, id, 0, 0)

800 801 @property

802 - def backbone(self):

803 return self._calpha

804 805 @property

806 - def sequence(self):

807 return self._sequence

808 809 @property

810 - def torsion(self):

811 return self._torsion

812 813 @property

814 - def source_id(self):

815 return self._source_id

816 817 @property

818 - def start(self):

819 return self._start

820 821 @property

822 - def end(self):

823 return self._end

824 825 @property

826 - def score(self):

827 return self._score

828 829 @property

830 - def neff(self):

831 return self._neff

832 833 @property

834 - def secondary_structure(self):

835 return self._ss

836 @secondary_structure.setter

837 - def secondary_structure(self, value):

838 839 if isinstance(value, csb.core.string): 840 value = csb.bio.structure.SecondaryStructure(value) 841 if len(str(value)) != self.length:#(value.end - value.start + 1) != self.length: 842 raise ValueError("Invalid secondary structure length", len(str(value)), self.length ) 843 844 self._ss = value

845

846 - def transform(self, rotation, translation):

847 """ 848 Apply rotation/translation to fragment's coordinates in place 849 """ 850 851 for ca in self.backbone: 852 newca = numpy.dot(ca, numpy.transpose(rotation)) + translation 853 for i in range(3): 854 ca[i] = newca[i]

855

856 - def _check_range(self, qstart, qend):

857 858 if not (self.qstart <= qstart <= qend <= self.qend): 859 raise ValueError('Region {0}..{1} is out of range {2.qstart}..{2.qend}'.format(qstart, qend, self))

860

861 - def anchored_around(self, rank):

862 """ 863 @return: True if the fragment is centered around position=C{rank} 864 @rtype: bool 865 """ 866 867 if self.qstart < rank < self.qend: 868 if (rank - self.qstart + 1) > 0.4 * (self.qend - self.qstart + 1): 869 return True 870 871 return False

872

873 - def backbone_at(self, qstart, qend):

874 """ 875 @return: the CA coordinates of the fragment at the specified subregion. 876 @rtype: list 877 """ 878 879 self._check_range(qstart, qend) 880 881 relstart = qstart - self.qstart 882 relend = qend - self.qstart + 1 883 884 return self.backbone[relstart : relend]

885

886 - def torsion_at(self, qstart, qend):

887 """ 888 @return: torsion angles of the fragment at the specified subregion 889 @rtype: list 890 """ 891 self._check_range(qstart, qend) 892 893 relstart = qstart - self.qstart 894 relend = qend - self.qstart + 1 895 896 return self.torsion[relstart : relend]

897

898 - def sec_structure_at(self, qstart, qend):

899 """ 900 @return: secondary structure of the fragment at the specified subregion 901 @rtype: list 902 """ 903 904 self._check_range(qstart, qend) 905 start = qstart - self.qstart + 1 906 end = qend - self.qstart + 1 907 908 return self.secondary_structure.scan(start, end, loose=True, cut=True)

909

910 - def overlap(self, other):

911 """ 912 @type other: L{Assignment} 913 @return: target positions, covered by both C{self} and C{other} 914 @rtype: set of int 915 """ 916 917 qranks = set(range(self.qstart, self.qend + 1)) 918 sranks = set(range(other.qstart, other.qend + 1)) 919 920 return qranks.intersection(sranks)

921

922 - def rmsd_to(self, other, min_overlap=5):

923 """ 924 @return: the CA RMSD between C{self} and C{other}. 925 926 @param other: another fragment 927 @type other: L{Assignment} 928 @param min_overlap: require at least that number of overlapping residues 929 (return None if not satisfied) 930 @type min_overlap: int 931 932 @rtype: float 933 """ 934 if self is other: 935 return 0 936 937 common = self.overlap(other) 938 939 if len(common) >= min_overlap: 940 941 qstart, qend = min(common), max(common) 942 943 q = self.backbone_at(qstart, qend) 944 s = other.backbone_at(qstart, qend) 945 946 if len(q) > 0 and len(s) > 0: 947 return csb.bio.utils.rmsd(numpy.array(q), numpy.array(s)) 948 949 return None

950

951 - def nrmsd_to(self, other, min_overlap=5):

952 """ 953 @return: the normalized CA RMSD between C{self} and C{other}. 954 955 @param other: another fragment 956 @type other: L{Assignment} 957 @param min_overlap: require at least that number of overlapping residues 958 (return None if not satisfied) 959 @type min_overlap: int 960 961 @rtype: float 962 """ 963 964 common = self.overlap(other) 965 966 if len(common) >= min_overlap: 967 968 qstart, qend = min(common), max(common) 969 970 q = self.backbone_at(qstart, qend) 971 s = other.backbone_at(qstart, qend) 972 973 if len(q) > 0 and len(s) > 0: 974 return csb.bio.utils.rmsd(q, s) / RANDOM_RMSD[ len(common) ] 975 976 return None

977

978 - def mda_to(self, other, min_overlap=5):

979 """ 980 @return: the MDA (maximum deviation in torsion angles) between 981 C{self} and C{other}. 982 983 @param other: another fragment 984 @type other: L{Assignment} 985 @param min_overlap: require at least that number of overlapping residues 986 (return None if not satisfied) 987 @type min_overlap: int 988 989 @rtype: float 990 """ 991 common = self.overlap(other) 992 993 if len(common) >= min_overlap: 994 995 qstart, qend = min(common), max(common) 996 997 q = self.torsion_at(qstart, qend) 998 s = other.torsion_at(qstart, qend) 999 1000 if len(q) > 0 and len(s) > 0: 1001 1002 maxphi = max(numpy.abs(i.phi - j.phi) for i, j in zip(q, s)[1:]) # phi: 2 .. L 1003 maxpsi = max(numpy.abs(i.psi - j.psi) for i, j in zip(q, s)[:-1]) # psi: 1 .. L-1 1004 1005 return max(maxphi, maxpsi) 1006 1007 return None

1008

1009 1010 -class ChemShiftAssignment(Assignment):

1011 1012 BIT_SCORE_THRESHOLD = 1.1 1013

1014 - def __init__(self, source, start, end, qstart, qend, window, score, rmsd):

1015 1016 self._window = window 1017 1018 super(ChemShiftAssignment, self).__init__( 1019 source, start, end, qstart, qend, id=None, probability=1.0, 1020 rmsd=rmsd, tm_score=None, score=score, neff=None, internal_id=None)

1021 1022 @property

1023 - def window(self):

1024 return self._window

1025

1026 -class ClusterExhaustedError(ValueError):

1027 pass

1028

1029 -class ClusterEmptyError(ClusterExhaustedError):

1030 pass

1031

1032 -class ClusterDivergingError(RuntimeError):

1033 pass

1034

1035 -class FragmentCluster(object):

1036 """ 1037 Provides clustering/filtering of the fragments, covering a common residue 1038 in the target. Clustering is done via iterative shrinking of the cluster. 1039 At each iteration, node rejection (deletion) is attempted for each node. The 1040 node rejection, causing the most significant drop in the average pairwise 1041 distance (RMSD) in the cluster, is retained. This procedure is repeated 1042 until: 1) the average pairwise RMSD drops below the C{threshold} (converged), 1043 2) the cluster gets exhausted or 3) node rejection no longer 1044 causes a drop in the average distance (not converging). 1045 1046 @param items: cluster members 1047 @type items: iterable of L{ClusterNode}s 1048 @param threshold: RMSD threshold; continue shrinking until the mean distance 1049 drops below this value (default=1.5) 1050 @type threshold: float 1051 @param connectedness: when calculating centroids, consider only nodes 1052 connected to at least c% of all surviving vertices 1053 (default=0.5) 1054 @type connectedness: float 1055 """ 1056 1057 MIN_LENGTH = 6 1058

1059 - def __init__(self, items, threshold=1.5, connectedness=0.5):

1060 1061 items = set(i for i in items if i.fragment.length >= FragmentCluster.MIN_LENGTH) 1062 1063 self._matrix = {} 1064 self._threshold = float(threshold) 1065 self._connectedness = float(connectedness) 1066 self._weight = 0 1067 self._edges = 0 1068 1069 visited = set() 1070 1071 for i in items: 1072 self._matrix.setdefault(i, {}) 1073 1074 for j in items: 1075 self._matrix.setdefault(j, {}) 1076 1077 if (j, i) not in visited: 1078 visited.add((i, j)) 1079 distance = i.distance(j) 1080 1081 if distance is not None: 1082 self._matrix[i][j] = distance 1083 self._matrix[j][i] = distance 1084 i.weight += distance 1085 j.weight += distance 1086 1087 self._weight += distance 1088 self._edges += 1 1089 1090 self._items = set(self._matrix.keys()) 1091 1092 if len(self._items) < 1: 1093 raise ClusterEmptyError() 1094 1095 self._initcount = self.count

1096 1097 @property

1098 - def count(self):

1099 return len(self._items)

1100 1101 @property

1102 - def items(self):

1103 return tuple(self._items)

1104 1105 @property

1106 - def fragments(self):

1107 return tuple(i.fragment for i in self._items)

1108 1109 @property

1110 - def threshold(self):

1111 return self._threshold

1112 @threshold.setter

1113 - def threshold(self, value):

1114 self._threshold = float(value)

1115 1116 @property

1117 - def connectedness(self):

1118 return self._connectedness

1119

1120 - def _distances(self, skip=None):

1121 1122 d = [] 1123 1124 for i in self._matrix: 1125 if skip is i: 1126 continue 1127 1128 for j in self._matrix[i]: 1129 if skip is not j: 1130 d.append(self._matrix[i][j]) 1131 1132 return d

1133

1134 - def _distance(self, i, j):

1135 1136 if j in self._matrix[i]: 1137 return self._matrix[i][j] 1138 else: 1139 return None

1140

1141 - def mean(self, skip=None):

1142 """ 1143 @return: the current mean distance in the cluster 1144 @rtype: float 1145 """ 1146 if self._edges == 0: 1147 raise ClusterExhaustedError() 1148 1149 if not skip: 1150 return float(self._weight) / self._edges 1151 1152 else: 1153 weight = self._weight - skip.weight 1154 edges = self._edges - len(self._matrix[skip]) 1155 1156 if edges < 1: 1157 return 0 1158 else: 1159 return float(weight) / edges

1160

1161 - def centroid(self):

1162 """ 1163 @return: the current representative fragment 1164 @rtype: L{ClusterRep} 1165 1166 @note: the cluster rep is the node with the lowest average distance 1167 to all other nodes. If a fixed fragment exists, structurally similar 1168 to the rep, but longer, this fragment may be suggested as an alternative 1169 (see also L{ClusterRep}). 1170 """ 1171 1172 alt = None 1173 cen = None 1174 avg = None 1175 1176 for i in self._matrix: 1177 edges = len(self._matrix[i]) or (1.0 / self.count) 1178 curravg = float(i.weight) / edges 1179 conn = len(self._matrix[i]) / float(self.count) 1180 1181 if avg is None or (curravg < avg and conn >= self.connectedness): 1182 avg = curravg 1183 cen = i 1184 elif curravg == avg: 1185 if i.fragment.length > cen.fragment.length: 1186 cen = i 1187 1188 d = self._distances() 1189 mean = numpy.mean(d) 1190 cons = sum(1.0 for i in d if i <= self.threshold) / len(d) 1191 1192 for i in self._matrix: 1193 if i is not cen and i.fixed and i.fragment.length > cen.fragment.length: 1194 distance = self._distance(i, cen) 1195 if distance is not None and distance < 0.5 * self.threshold: 1196 if alt is None or alt.fragment.length < i.fragment.length: 1197 alt = i 1198 1199 return ClusterRep(cen, mean, cons, len(self._matrix[cen]), alternative=alt, 1200 rejections=(self._initcount - self.count))

1201

1202 - def reject(self, item):

1203 """ 1204 Remove C{item} from the cluster. 1205 1206 @type item: L{ClusterNode} 1207 @raise ClusterExhaustedError: if this is the last remaining item 1208 """ 1209 if self.count == 1: 1210 raise ClusterExhaustedError() 1211 1212 assert not item.fixed 1213 1214 for i in self._matrix: 1215 if item in self._matrix[i]: 1216 distance = self._matrix[i][item] 1217 self._weight -= distance 1218 i.weight -= distance 1219 1220 del self._matrix[i][item] 1221 self._edges -= 1 1222 1223 del self._matrix[item] 1224 self._items.remove(item)

1225

1226 - def shrinkone(self):

1227 """ 1228 Shrink the cluster by a single node. 1229 1230 @return: True on successful shrink, False otherwise (e.g. if 1231 already converged) 1232 @rtype: bool 1233 @raise ClusterExhaustedError: if exhausted 1234 @raise ClusterDivergingError: if not converging 1235 """ 1236 1237 mean = self.mean() 1238 if mean <= self.threshold or self.count == 1: 1239 return False # already shrunk enough 1240 1241 m = {} 1242 1243 for i in self._matrix: 1244 if not i.fixed: 1245 newmean = self.mean(skip=i) 1246 m[newmean] = i 1247 1248 if len(m) == 0: # only fixed items remaining 1249 raise ClusterExhaustedError() 1250 1251 newmean = min(m) 1252 1253 if newmean > mean: 1254 raise ClusterDivergingError() # can't converge, usually when fixed items are too far away from the average 1255 elif newmean < mean: 1256 junk = m[newmean] 1257 self.reject(junk) 1258 return True # successful shrink 1259 else: 1260 return False # converged

1261

1262 - def shrink(self, minitems=2):

1263 """ 1264 Start automatic shrinking. 1265 1266 @param minitems: absolute minimum of the number of nodes in the cluster 1267 @type minitems: int 1268 1269 @return: cluster's representative: the node with the lowest average 1270 distance to all other nodes in the cluster 1271 @rtype: L{ClusterRep} 1272 1273 @raise ClusterExhaustedError: if C{self.count} < C{minitems} and 1274 still not converged 1275 """ 1276 1277 if self.count > minitems: 1278 1279 while self.shrinkone(): 1280 if self.count <= minitems: 1281 raise ClusterExhaustedError() 1282 else: 1283 raise ClusterExhaustedError() 1284 1285 return self.centroid()

1286

1287 -class ClusterNode(object):

1288 """ 1289 Cluster node. 1290 1291 @param fragment: fragment 1292 @type fragment: L{Assignment} 1293 @param distance: distance metric (a L{Metrics} member, default is RMSD) 1294 @type distance: str 1295 @param fixed: mark this node as fixed (cannot be rejected) 1296 @type fixed: bool 1297 """ 1298 1299 FIXED = 0.7 1300 1301 @staticmethod

1302 - def create(fragment, method=Metrics.RMSD, extend=False):

1303 """ 1304 Create a new L{ClusterNode} given a specified C{Assignment}. If this 1305 assignment is a high probability match, define it as a fixed fragment. 1306 1307 @rtype: L{ClusterNode} 1308 """ 1309 if fragment.probability > ClusterNode.FIXED and fragment.length >= FragmentCluster.MIN_LENGTH: 1310 return ClusterNode(fragment, distance=method, fixed=extend) 1311 else: 1312 return ClusterNode(fragment, distance=method, fixed=False)

1313

1314 - def __init__(self, fragment, distance=Metrics.RMSD, fixed=False):

1315 1316 if fixed and fragment.length < FragmentCluster.MIN_LENGTH: 1317 raise ValueError("Can't fix a short fragment") 1318 1319 self.fragment = fragment 1320 self.fixed = bool(fixed) 1321 self.weight = 0 1322 1323 self._distance = getattr(self.fragment, distance)

1324

1325 - def distance(self, other):

1326 """ 1327 @return: the distance between self and another node 1328 @type other: L{ClusterNode} 1329 @rtype: float 1330 """ 1331 return self._distance(other.fragment)

1332

1333 -class ClusterRep(object):

1334 """ 1335 Cluster's representative (centroid) node. This object carries the 1336 result of shrinking itself. 1337 1338 @param centroid: rep node 1339 @type centroid: L{ClusterNode} 1340 @param mean: current mean distance in the cluster 1341 @type mean: float 1342 @param consistency: percentage of pairwise distances below the RMSD C{threshold} 1343 @type consistency: float 1344 @param count: current number of nodes in the cluster 1345 @type count: int 1346 @param rejections: total number of rejections 1347 @type rejections: int 1348 @param alternative: suggested cluster rep alternative (e.g. structurally 1349 similar to the centroid, but longer) 1350 @type param: 1351 """ 1352

1353 - def __init__(self, centroid, mean, consistency, count, rejections=0, alternative=None):

1354 1355 if isinstance(centroid, ClusterNode): 1356 centroid = centroid.fragment 1357 if isinstance(alternative, ClusterNode): 1358 alternative = alternative.fragment 1359 1360 self._centroid = centroid 1361 self._alternative = alternative 1362 self._mean = mean 1363 self._consistency = consistency 1364 self._count = count 1365 self._rejections = rejections

1366 1367 @property

1368 - def confidence(self):

1369 """ 1370 Confidence of assignment: log10(count) * consistency 1371 """ 1372 if self.count <= 0 or self.count is None or self.consistency is None: 1373 return 0 1374 else: 1375 return numpy.log10(self.count) * self.consistency

1376 1377 @property

1378 - def centroid(self):

1379 return self._centroid

1380 1381 @property

1382 - def alternative(self):

1383 return self._alternative

1384 1385 @property

1386 - def has_alternative(self):

1387 return self._alternative is not None

1388 1389 @property

1390 - def mean(self):

1391 return self._mean

1392 1393 @property

1394 - def consistency(self):

1395 return self._consistency

1396 1397 @property

1398 - def count(self):

1399 return self._count

1400 1401 @property

1402 - def rejections(self):

1403 return self._rejections

1404

1405 - def exchange(self):

1406 """ 1407 If an alternative is available, swap the centroid and the alternative. 1408 """ 1409 1410 if self._alternative is not None: 1411 1412 centroid = self._centroid 1413 self._centroid = self._alternative 1414 self._alternative = centroid

1415

1416 1417 -class ResidueEventInfo(object):

1418

1419 - def __init__(self, residue, confidence=0, count=0, confident=True, gap=False, rep=None):

1420 1421 self.residue = residue 1422 self.confidence = confidence 1423 self.confident = confident 1424 self.gap = gap 1425 self.count = count 1426 self.rep = rep

1427 1428 @property

1429 - def rank(self):

1430 return self.residue.rank

1431 1432 @property

1433 - def type(self):

1434 return self.residue.type

1435 1436 @property

1437 - def torsion(self):

1438 if self.rep: 1439 return self.rep.torsion_at(self.rank, self.rank)[0] 1440 else: 1441 return None

1442

1443 1444 -class RosettaFragsetFactory(object):

1445 """ 1446 Simplifies the construction of fragment libraries. 1447 """ 1448

1449 - def __init__(self):

1450 import csb.bio.fragments.rosetta as rosetta 1451 self.rosetta = rosetta

1452

1453 - def make_fragset(self, target):

1454 """ 1455 Build a fragment library given a L{Target} and its L{Assignment}s. 1456 1457 @param target: target protein 1458 @type target: L{Target} 1459 1460 @rtype: L{RosettaFragmentMap} 1461 """ 1462 1463 frag_factory = self.rosetta.RosettaFragment 1464 fragments = list(map(frag_factory.from_object, target.matches)) 1465 #fragments = [ frag_factory.from_object(f) for f in target.matches if f.length >= 6 ] 1466 fragments.sort() 1467 1468 return self.rosetta.RosettaFragmentMap(fragments, target.length)

1469

1470 - def make_chopped(self, fragments, window):

1471 """ 1472 Build a fixed-length fragment library from a list of 1473 variable-length L{Assignment}s. 1474 1475 @param fragments: source fragments 1476 @type fragments: iterable of L{RosettaFragment}s 1477 @param window: fixed-length fragment size (for classic Rosetta: choose 9) 1478 @type window: int 1479 1480 @return: fixed-length fragment library 1481 @rtype: L{RosettaFragmentMap} 1482 """ 1483 1484 frags = [] 1485 1486 for f in fragments: 1487 for qs in range(f.qstart, f.qend - window + 1): 1488 frags.append(f.subregion(qs, qs + window - 1)) 1489 1490 return self.rosetta.RosettaFragmentMap(frags)

1491

1492 - def make_combined(self, target, filling, threshold=0.5, callback=None):

1493 """ 1494 Complement C{target}'s assignments with C{filling} (e.g. rosetta fragments). 1495 The regions to be complemented are determined by calculating the confidence 1496 at each residue (by filtering). 1497 1498 1499 @param target: target protein 1500 @type target: L{Target} 1501 @param filling: additional fragments to place in the low-conf regions 1502 @type filling: L{RosettaFragmentMap} or iterable of L{RosettaFragment} 1503 @param threshold: confidence threshold 1504 @type threshold: float 1505 1506 @return: complemented fragment library 1507 @rtype: L{RosettaFragmentMap} 1508 """ 1509 1510 fragmap = self.make_fragset(target) 1511 covered = set() 1512 1513 for r in target.residues: 1514 1515 if r.assignments.length == 0: 1516 if callback: 1517 callback(ResidueEventInfo(r.native, gap=True)) 1518 continue 1519 1520 cluster = r.filter() 1521 if cluster is None: 1522 if callback: 1523 callback(ResidueEventInfo(r.native, 0, 0, confident=False)) 1524 continue 1525 1526 if cluster.confidence >= threshold: 1527 covered.add(r.native.rank) 1528 confident = True 1529 else: 1530 confident = False 1531 1532 if callback: 1533 callback(ResidueEventInfo(r.native, cluster.confidence, cluster.count, confident)) 1534 1535 for r in target.residues: 1536 if r.native.rank not in covered: # true for gaps and low-conf residues 1537 fragmap.mark_unconfident(r.native.rank) 1538 1539 for frag in filling: 1540 fragmap.complement(frag) 1541 1542 return fragmap

1543

1544 - def make_filtered(self, target, extend=False, callback=None):

1545 """ 1546 Builed a filtered fragment library (by clustering), containing only 1547 representative fragments (cluster centroids). 1548 1549 @param target: target protein 1550 @type target: L{Target} 1551 @param extend: if True, pick alternative reps if available 1552 @type extend: bool 1553 1554 @return: filtered fragment library 1555 @rtype: L{RosettaFragmentMap} 1556 """ 1557 1558 fragments = [] 1559 1560 for r in target.residues: 1561 if r.assignments.length == 0: 1562 if callback: 1563 callback(ResidueEventInfo(r.native, gap=True)) 1564 continue 1565 1566 cluster = r.filter(extend=extend) 1567 if cluster is None: 1568 if callback: 1569 callback(ResidueEventInfo(r.native, 0, 0, confident=False)) 1570 continue 1571 1572 if extend and cluster.has_alternative: 1573 best = cluster.alternative 1574 else: 1575 best = cluster.centroid 1576 1577 fragment = self.rosetta.RosettaFragment.from_object(best) 1578 fragments.append(fragment) 1579 if callback: 1580 callback(ResidueEventInfo(r.native, cluster.confidence, cluster.count, rep=cluster.centroid)) 1581 1582 fragments.sort() 1583 return self.rosetta.RosettaFragmentMap(fragments, target.length)

1584

1585 - def mix(self, *fragsets):

1586 """ 1587 Mix fragments from multiple libraries. 1588 1589 @type fragsets: L{RosettaFragmentMap} 1590 @return: mixed fragment library 1591 @rtype: L{RosettaFragmentMap} 1592 """ 1593 1594 fragments = [] 1595 length = 0 1596 1597 for fragset in fragsets: 1598 if fragset._length > length: 1599 length = fragset._length 1600 1601 for fragment in fragset: 1602 fragments.append(fragment) 1603 1604 return self.rosetta.RosettaFragmentMap(fragments, length)

1605

1606 1607 -class BenchmarkAdapter(object):

1608

1609 - class Connection(object):

1610 1611 FACTORY = None 1612 DSN = None 1613

1614 - def __init__(self, factory=None, dsn=None):

1615 1616 self.factory = factory or self.__class__.FACTORY 1617 self.cs = dsn or self.__class__.DSN 1618 self.connection = None 1619 self.cursor = None

1620

1621 - def __enter__(self):

1622 1623 self.connection = self.factory(self.cs) 1624 try: 1625 self.cursor = self.connection.cursor() 1626 except: 1627 self.connection.close() 1628 raise 1629 return self

1630

1631 - def __exit__(self, *args):

1632 try: 1633 if not self.cursor.closed: 1634 self.cursor.close() 1635 finally: 1636 if not self.connection.closed: 1637 self.connection.close()

1638

1639 - def __init__(self, pdb_paths, connection_string=None, factory=AssignmentFactory()):

1640 1641 self._connection = None 1642 1643 self._parser = StructureParser 1644 self._pdb = FileSystemStructureProvider(pdb_paths) 1645 self._factory = factory 1646 1647 try: 1648 import psycopg2.extras 1649 except ImportError: 1650 raise RuntimeError('Please install the psycopg2 module first') 1651 1652 if connection_string is None: 1653 connection_string = self.connection_string() 1654 1655 BenchmarkAdapter.Connection.FACTORY = psycopg2.extras.DictConnection 1656 BenchmarkAdapter.Connection.DSN = connection_string

1657 1658 @staticmethod

1659 - def connection_string(database='FragmentBenchmarks', host='', username='', password=''):

1660 1661 fields = ['dbname={0}'.format(database)] 1662 1663 if host: 1664 fields.append('host={0}'.format(host)) 1665 if username: 1666 fields.append('user={0}'.format(username)) 1667 fields.append('password={0}'.format(password)) 1668 1669 return ' '.join(fields)

1670

1671 - def targets(self, benchmark_id):

1672 1673 with BenchmarkAdapter.Connection() as db: 1674 1675 db.cursor.callproc('reporting."GetTargets"', (benchmark_id,)) 1676 return db.cursor.fetchall()

1677

1678 - def target_details(self, target_id):

1679 1680 with BenchmarkAdapter.Connection() as db: 1681 1682 db.cursor.callproc('reporting."GetTargetDetails"', (target_id,)) 1683 return db.cursor.fetchall()

1684

1685 - def assignments(self, target_id, type):

1686 1687 with BenchmarkAdapter.Connection() as db: 1688 1689 db.cursor.callproc('reporting."GetAssignments"', (target_id, type)) 1690 return db.cursor.fetchall()

1691

1692 - def assignments_sec_structure(self, target_id, type):

1693 1694 with BenchmarkAdapter.Connection() as db: 1695 1696 db.cursor.callproc('reporting."GetTargetSecStructureAssignments2"', (target_id, type)) 1697 return db.cursor.fetchall()

1698

1699 - def scores(self, benchmark_id, type):

1700 1701 with BenchmarkAdapter.Connection() as db: 1702 1703 db.cursor.callproc('reporting."GetScores"', (benchmark_id, type)) 1704 return db.cursor.fetchall()

1705

1706 - def centroids(self, benchmark_id):

1707 1708 with BenchmarkAdapter.Connection() as db: 1709 1710 db.cursor.callproc('reporting."GetCentroids"', (benchmark_id,)) 1711 return db.cursor.fetchall()

1712

1713 - def structure(self, accession, chain=None):

1714 1715 pdbfile = self._pdb.find(accession) 1716 1717 if not pdbfile and chain: 1718 pdbfile = self._pdb.find(accession + chain) 1719 1720 if not pdbfile: 1721 raise IOError('{0} not found here: {1}'.format(accession, self._pdb)) 1722 1723 return self._parser(pdbfile).parse_structure()

1724

1725 - def prediction(self, target_id, type, ss=False):

1726 1727 info = self.target_details(target_id) 1728 if not info: 1729 raise ValueError('No such Target ID in the database: {0}'.format(target_id)) 1730 row = info[0] 1731 1732 id = row["Accession"] 1733 length = float(row["Length"]) 1734 overlap = float(row["MaxOverlap"]) / (length or 1.) 1735 1736 native = self.structure(id[:4], id[4]).chains[id[4]] 1737 target = self._factory.target(id, length, native.residues, overlap) 1738 1739 source = None 1740 1741 for row in self.assignments(target_id, type): 1742 1743 src_accession = row['Source'][:4] 1744 src_chain = row['Source'][4] 1745 1746 if source is None or source.accession != src_accession: 1747 try: 1748 source = self.structure(src_accession, src_chain) 1749 except (IOError, ValueError) as ex: 1750 target.errors.append(ex) 1751 continue 1752 1753 if src_chain == '_': 1754 frag_chain = source.first_chain 1755 else: 1756 frag_chain = source.chains[src_chain] 1757 if not frag_chain.has_torsion: 1758 frag_chain.compute_torsion() 1759 1760 fragment = self._factory.assignment( 1761 source=frag_chain, 1762 start=row['SourceStart'], 1763 end=row['SourceEnd'], 1764 id=row['FragmentName'], 1765 qstart=row['Start'], 1766 qend=row['End'], 1767 probability=row['Probability'], 1768 score=row['Score'], 1769 neff=row['Neff'], 1770 rmsd=row['RMSD'], 1771 tm_score=row['TMScore'], 1772 internal_id=row['InternalID']) 1773 1774 target.assign(fragment) 1775 1776 if ss: 1777 self._attach_sec_structure(target, target_id, type) 1778 1779 return target

1780

1781 - def _attach_sec_structure(self, target, target_id, type):

1782 1783 ss = {} 1784 1785 for row in self.assignments_sec_structure(target_id, type): 1786 frag_id, state = row["AssignmentID"], row["DSSP"] 1787 if row[frag_id] not in ss: 1788 ss[frag_id] = [] 1789 1790 ss[frag_id].append(state) 1791 1792 for a in target.matches: 1793 if a.internal_id in ss: 1794 dssp = ''.join(ss[a.internal_id]) 1795 a.secondary_structure = dssp

1796

Source Code for Package csb.bio.fragments