def regularized_seq(aseq, chain):
mmap = aseq.match_maps[chain]
from .common import modeller_copy
rseq = modeller_copy(aseq)
rseq.description = "structure:" + chain_save_name(chain)
seq_chars = list(rseq.characters)
from chimerax.atomic import Sequence
from chimerax.pdb import standard_polymeric_res_names as std_res_names
in_seq_hets = []
num_res = 0
for ungapped in range(len(aseq.ungapped())):
gapped = aseq.ungapped_to_gapped(ungapped)
if ungapped not in mmap:
seq_chars[gapped] = '-'
else:
r = mmap[ungapped]
num_res += 1
if r.name not in std_res_names:
in_seq_hets.append(r.name)
seq_chars[gapped] = '.'
else:
seq_chars[gapped] = Sequence.rname3to1(mmap[ungapped].name)
s = chain.structure
het_set = getattr(s, 'in_seq_hets', set())
# may want to preserve all-HET chains, so don't auto-exclude them
if num_res != len(in_seq_hets):
het_set.update(in_seq_hets)
s.in_seq_hets = het_set
rseq.characters = "".join(seq_chars)
return rseq
def find_affixes(chains, chain_info):
from chimerax.pdb import standard_polymeric_res_names as std_res_names
in_seq_hets = []
prefixes = []
suffixes = []
from chimerax.atomic import Sequence
for chain in chains:
try:
aseq, target = chain_info[chain]
except KeyError:
prefixes.append('')
suffixes.append('')
continue
match_map = aseq.match_maps[chain]
prefix = ''
for r in chain.existing_residues:
if r in match_map:
break
if r.name not in std_res_names:
in_seq_hets.append(r.name)
prefix += '.'
else:
prefix += Sequence.rname3to1(r.name)
prefixes.append(prefix)
suffix = ''
for r in reversed(chain.existing_residues):
if r in match_map:
break
if r.name not in std_res_names:
in_seq_hets.append(r.name)
suffix = '.' + suffix
else:
suffix = Sequence.rname3to1(r.name) + suffix
suffixes.append(suffix)
s = chain.structure
het_set = getattr(s, 'in_seq_hets', set())
het_set.update(in_seq_hets)
s.in_seq_hets = het_set
return prefixes, suffixes
def _update_errors_gaps(self, aseq):
if not self.settings.error_region_shown and not self.settings.gap_region_shown:
return
a_ref_seq = getattr(aseq, 'residue_sequence', aseq.ungapped())
errors = [0] * len(a_ref_seq)
gaps = [0] * len(a_ref_seq)
from chimerax.atomic import Sequence
for chain, match_map in aseq.match_maps.items():
for i, char in enumerate(a_ref_seq):
try:
res = match_map[i]
except KeyError:
gaps[i] += 1
else:
if Sequence.rname3to1(res.name) != char.upper():
errors[i] += 1
partial_error_blocks, full_error_blocks = [], []
partial_gap_blocks, full_gap_blocks = [], []
num_assocs = len(aseq.match_maps)
if num_assocs > 0:
for partial, full, check in [
(partial_error_blocks, full_error_blocks, errors),
(partial_gap_blocks, full_gap_blocks, gaps)
]:
cur_partial_block = cur_full_block = None
for i, check_num in enumerate(check):
gapped_i = aseq.ungapped_to_gapped(i)
if check_num == num_assocs:
if cur_full_block:
cur_full_block[-1] = gapped_i
else:
cur_full_block = [aseq, aseq, gapped_i, gapped_i]
full.append(cur_full_block)
if cur_partial_block:
cur_partial_block = None
else:
if cur_full_block:
cur_full_block = None
if check_num > 0:
if cur_partial_block:
cur_partial_block[-1] = gapped_i
else:
cur_partial_block = [
aseq, aseq, gapped_i, gapped_i
]
partial.append(cur_partial_block)
elif cur_partial_block:
cur_partial_block = None
for shown, region_name_part, partial_blocks, full_blocks, fills, outlines in [
(self.settings.error_region_shown, self.ERROR_REGION_STRING,
partial_error_blocks, full_error_blocks,
self.settings.error_region_interiors,
self.settings.error_region_borders),
(self.settings.gap_region_shown, self.GAP_REGION_STRING,
partial_gap_blocks, full_gap_blocks,
self.settings.gap_region_interiors,
self.settings.gap_region_borders)
]:
if not shown:
continue
full_fill, partial_fill = fills
full_outline, partial_outline = outlines
for region_name_start, blocks, fill, outline in [
(region_name_part, full_blocks, full_fill, full_outline),
("partial " + region_name_part, partial_blocks, partial_fill,
partial_outline)
]:
region_name = "%s of %s" % (region_name_start, aseq.name)
old_reg = self.region_browser.get_region(region_name,
create=False)
if old_reg:
self.region_browser.delete_region(old_reg)
if blocks:
self.region_browser.new_region(region_name,
blocks=blocks,
fill=fill,
outline=outline,
sequence=aseq,
cover_gaps=False)