| 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 |
|