def __init__(self, old_bp=None, new_bp=None, cutoff=1.0, orientation="cis", force=False):
"""
Arguments:
- old_bp - single tuple/list: (moderna_residue1, moderna_residue2)
where moderna_residue is ModernaResidue object from model
- new_bp - new base pair description in format 'BP'
where BP is base pair shortcut
example: 'AC' - 'Adenine-Cytosine'
- cutoff - maximum allowed RMSD
- orientation - cis or trans
- force - change base pair even if there is no interaction between old_bp
Starts immediately if finds input data
"""
self.old_bp = old_bp
self.new_bp = new_bp
self.cutoff = cutoff
self.orientation = orientation[0].lower()
self.force = force
self.interaction = ''
self.rmsd = None
self.matrices = IsostericityMatrices()
self.superimposer = ModernaSuperimposer()
#self.pyrimidine_atoms = ["C5'", "C4'", "O4'", "C3'", "O3'", "C2'", "O2'", "N1"]
# self.purine_atoms = ["C5'", "C4'", "O4'", "C3'", "O3'", "C2'", "O2'", "N9"]
#self.pyrimidine_atoms = ["C5'", "C4'", "O4'", "C3'", "O3'", "C2'", "N*"]
#self.purine_atoms = ["C5'", "C4'", "O4'", "C3'", "O3'", "C2'", "N*"]
#self.pyrimidine_atoms = ["P", "O3'"]
#self.purine_atoms = ["P", "O3'"]
#self.pyrimidine_atoms = ["P", "O5'", "C5'", "C4'", "C3'", "O3'"]
#self.purine_atoms = ["P", "O5'", "C5'", "C4'", "C3'", "O3'"]
self.pyrimidine_atoms = ["C1'", "N*"]
self.purine_atoms = ["C1'", "N*"]
self.result_bp = None #contains result base pair after modelling
if None not in (self.old_bp, self.new_bp): self.check_input_data()
def merge_region(self):
"""Merges the optimized residues with the memorized ones."""
residues = [r for r in self.model]
if self.model_passive:
# apply old residue numbers
print '\nRestoring original numeration in the optimized region.'
for num, resi in zip(self.model_resnumbers, residues):
#print resi, num
#self.model.renumber_residue(resi.identifier, num)
resi.change_number(num)
self.model = ModernaStructure('residues',residues)
# do the superposition
print '\nSuperimposing the optimized part onto the rest of the model.'
all_atoms = self.model.get_all_atoms()
sup = ModernaSuperimposer(moved_atoms = all_atoms)
sup.get_atoms([self.stem5, self.stem3], BACKBONE_ATOMS, 'fixed')
resi5, resi3 = self.model[self.residues[0]], self.model[self.residues[1]]
sup.get_atoms([resi5, resi3], BACKBONE_ATOMS, 'moved')
sup.superimpose()
# merge residues
print '\nMerging the optimized part with the rest of the model.'
resi = [r for r in self.model]
for r in self.model_passive:
if r.identifier not in self.residues:
resi.append(r)
self.model = RnaModel(None, None, self.options.chain_name, 'residues', resi)
def force_superimpose(self, old_bp, new_bp):
"""
Superimposes base pairs if there is no interaction between old_bp and force mode is True
"""
min_rmsd = 100.0
pdb_name = ''
base_pair = None
path = DATA_PATH+'base_pairs/'
for pdb in os.listdir(path):
if new_bp in pdb:
moved_residues = ModernaStructure('file', path+pdb).moderna_residues
moved, fixed, to_move = self.create_atoms_lists(moved_residues)
rmsd = ModernaSuperimposer(fixed, moved, to_move).rmsd
if rmsd < min_rmsd:
pdb_name = pdb
min_rmsd = rmsd
base_pair = moved_residues
log.write_message("The best RMSD ("+str(min_rmsd)+") with structure: "+pdb_name)
if min_rmsd <= self.cutoff:
log.write_message("RMSD <= cutoff (" + str(self.cutoff) + ")")
self.assign_residue_numbers(base_pair['1'], base_pair['2'])
else:
log.write_message("RMSD > cutoff (" + str(self.cutoff) + ") - starting backbone builder")
self.run_backbone_builder()
def test_superimposition(self):
"""
"""
a = PDBParser().get_structure('A',BASE_PATH+'A.ent')[0]['C'][(' ',54,' ')]
c = PDBParser().get_structure('C',BASE_PATH+'C.ent')[0]['C'][(' ',54,' ')]
original_coord = a['N6'].coord[1]
ModernaSuperimposer([c['N1'],c['C2'],c['C6']],[a['N9'],a['C4'],a['C8']],a.child_list)
self.failIfEqual(a['N6'].coord[1],original_coord)
def __init__(self, struc, new_sequence=None, \
keep=keep_nothing, strict=True):
self.struc = struc
self.new_sequence = new_sequence
self.sup = ModernaSuperimposer()
self.rmsd = None
self._keep_func = keep
if strict:
self.check()
self._prepared_anchors = []
def add_op12(self):
"""Adds OP1 OP2 atoms"""
self.remove_op1_op2()
phos = RNAChain('file', DATA_PATH + 'phosphate_group.pdb')['1']
#TODO: replace by Bio.PDB --> faster
mobile = [phos['OP3'], phos['P'], phos["O5'"]]
fixed = [self.r1["O3'"], self.r2['P'], self.r2["O5'"]]
s = ModernaSuperimposer(fixed, mobile, phos.child_list)
self.r2.add(phos['OP1'])
self.r2.add(phos['OP2'])
def test_rmsd(self):
"""The RMS of the superposition should be close to manual superimp. in PyMOL."""
a = PDBParser().get_structure('A',
BASE_PATH + 'A.ent')[0]['C'][(' ', 54,
' ')]
g = PDBParser().get_structure('G',
BASE_PATH + 'G.ent')[0]['C'][(' ', 54,
' ')]
m = ModernaSuperimposer([a['C4'], a['N9'], a['C8']],
[g['C4'], g['N9'], g['C8']], a.child_list)
self.assertTrue(m.rmsd < 0.004)
def test_superimposition2(self):
"""
"""
a = PDBParser().get_structure('A',BASE_PATH+'A.ent')[0]['C'][(' ',54,' ')]
c = PDBParser().get_structure('C',BASE_PATH+'C.ent')[0]['C'][(' ',54,' ')]
#original_coord = a['N6'].coord[1]
ModernaSuperimposer([c['N1'],c['C2'],c['C6']],[a['N9'],a['C4'],a['C8']],a.child_list)
for at in a:
self.assertAlmostEqual(at.coord[0], A_SUPERIMPOSED_ON_C[at.id.strip()][0],5)
self.assertAlmostEqual(at.coord[1], A_SUPERIMPOSED_ON_C[at.id.strip()][1],5)
self.assertAlmostEqual(at.coord[2], A_SUPERIMPOSED_ON_C[at.id.strip()][2],5)
class ResidueEditor:
"""
Deals with residue objects.
Supplements RNAResidue object with functions to
- exchange bases
- add modifications
- remove modifications
- rotat chi angle
The type of each ModernaResidue is automatically recognized, and has a couple
of long and short names as attributes:
- long_abbrev
- short_abbrev (one letter abbreviation)
- original_base
- full_name
- modified (True/False)
"""
parse = PDBParser()
superimpose = ModernaSuperimposer()
def add_single_fragment(self, resi, rule):
"""
Adds a fragment to a residue.
Arguments:
- an adding rule dict (prepared by get_modification_rules())
"""
try:
fragment = self.parse.get_structure(
'fragment', MODIFICATION_FRAGMENTS_PATH +
rule['fragment_file_name'])[0]['A'][('H_UNK', 1, ' ')]
except IOError:
raise ModernaResidueError('File does not exist: %s' %
MODIFICATION_FRAGMENTS_PATH)
self.superimpose.get_atoms([resi], rule['fixed_link_atoms'], 'fixed')
self.superimpose.get_atoms([fragment], rule['moved_link_atoms'],
'moved')
self.superimpose.moved_atoms = fragment.child_list
self.superimpose.superimpose()
if rule['remove']:
delete_atoms = rule['remove'].split(',') + rule['moved_link_atoms']
else:
delete_atoms = rule['moved_link_atoms']
try:
for atom_name in delete_atoms:
resi.detach_child(atom_name)
for atom in fragment:
resi.add(atom)
except ModernaResidueError, e:
raise e
except:
def test_insert_in_helix(self):
"""Evaluates how a helical single strand is handled by LIR"""
helix = load_model(SINGLE_STRAND, 'A')
m = load_model(SINGLE_STRAND, 'A')
lc = find_fragment(m, '1475', '1485', Sequence('GCCCGUGAC'), 10)
# calculate all-atom-rmsds
result = []
i = 1
for cand in lc:
insert_fragment(m, cand)
fixed = self.get_atoms(helix)
moved = self.get_atoms(m)
s = ModernaSuperimposer(fixed, moved, m.get_all_atoms())
result.append(s.rmsd)
i += 1
self.assertAlmostEqual(result[0], 0.000, 3)
avg_rms = sum(result) / (1.0 * len(result))
self.assertTrue(avg_rms < 3.25)
def superimpose_bp(self):
"""
Superimpose two base pairs
Uses self.moved_atoms and self.standard_atoms
"""
filename = self.interaction+'_'+self.new_bp+'.pdb'
log.write_message("File used for superposition: "+filename)
moved_residues = ModernaStructure('file', DATA_PATH+'base_pairs/'+filename).moderna_residues
moved, fixed, to_move = self.create_atoms_lists(moved_residues)
self.rmsd = ModernaSuperimposer(fixed, moved, to_move).rmsd
log.write_message("Moved atoms: "+str(moved))
log.write_message("Fixed atoms: "+str(fixed))
log.write_message("RMSD: "+str(self.rmsd))
if self.rmsd <= self.cutoff:
log.write_message("\nRMSD: " + str(self.rmsd) + "\n")
self.assign_residue_numbers(moved_residues['1'], moved_residues['2'])
else:
log.write_message("\nRMSD bigger than offset " + str(self.rmsd) + ">" + str(self.cutoff) + " - starting backbone builder\n")
self.run_backbone_builder()
def __init__(self,
template=None,
alignment=None,
model_chain_name='A',
data_type=None,
data=None,
seq=None):
ModernaStructure.__init__(self,
data_type=data_type,
data=data,
chain_name=model_chain_name,
seq=seq)
#TODO: order of arguments is inconsistent.
#TODO: template + alignment should be obligatory
#TODO: replace alignment by recipe
#TODO: rename to SingleTemplateModeling and/or refactor classes for tasks out.
self.template = template
if template:
self.template.set_template_numeration()
if alignment:
self.recipe = RecipeMaker(alignment).recipe
self.alignment = alignment
self.s = ModernaSuperimposer()
class ResidueEditor:
"""
Deals with residue objects.
Supplements RNAResidue object with functions to
- exchange bases
- add modifications
- remove modifications
- rotat chi angle
The type of each ModernaResidue is automatically recognized, and has a couple
of long and short names as attributes:
- long_abbrev
- short_abbrev (one letter abbreviation)
- original_base
- full_name
- modified (True/False)
"""
parse = PDBParser()
superimpose = ModernaSuperimposer()
def add_single_fragment(self, resi, rule):
"""
Adds a fragment to a residue.
Arguments:
- an adding rule dict (prepared by get_modification_rules())
"""
try:
fragment = self.parse.get_structure(
'fragment', MODIFICATION_FRAGMENTS_PATH +
rule['fragment_file_name'])[0]['A'][('H_UNK', 1, ' ')]
except IOError:
raise ModernaResidueError('File does not exist: %s' %
MODIFICATION_FRAGMENTS_PATH)
self.superimpose.get_atoms([resi], rule['fixed_link_atoms'], 'fixed')
self.superimpose.get_atoms([fragment], rule['moved_link_atoms'],
'moved')
self.superimpose.moved_atoms = fragment.child_list
self.superimpose.superimpose()
if rule['remove']:
delete_atoms = rule['remove'].split(',') + rule['moved_link_atoms']
else:
delete_atoms = rule['moved_link_atoms']
try:
for atom_name in delete_atoms:
resi.detach_child(atom_name)
for atom in fragment:
resi.add(atom)
except ModernaResidueError as e:
raise e
except:
raise ModernaResidueError(
'Residue %s: could not remove unnecessary and add proper atoms'
% resi.identifier)
#TODO: remove except:
def mutate_unknown_residue(self, resi):
"""
Makes a Cytosine out of unknown residue (X, .) on ribose and N* (N9,N1) atoms.
When ribose and N* are nor present raises an error.
C can be then changed into any modification / standard residues.
"""
for x in RIBOSE:
if not resi.has_id(x):
raise ModernaResidueError(
'Residue %s: cannot mutate unknown residue. Missing ribose atom %s'
% (resi.identifier, x))
if not resi.has_id('N9') and not resi.has_id('N1'):
raise ModernaResidueError(
'Residue %s: cannot mutate unknown residue. Missing ribose atom N* (N1 or N9)'
% (resi.identifier))
try:
fragment = self.parse.get_structure(
'fragment',
MODIFICATION_FRAGMENTS_PATH + 'ribose_C.pdb')[0]['A'][(' ', 1,
' ')]
except IOError:
raise ModernaResidueError('File does not exist: %s' %
MODIFICATION_FRAGMENTS_PATH +
'ribose_C.pdb')
self.superimpose.get_atoms([resi], ["O4'", "C1'", "C2'"], 'fixed')
self.superimpose.fixed.append(resi["N*"])
self.superimpose.get_atoms([fragment], ["O4'", "C1'", "C2'", 'N1'],
'moved')
self.superimpose.moved_atoms = fragment.child_list
self.superimpose.superimpose()
for x in list(resi): # must copy items before deleting.
if x.name not in BACKBONE_RIBOSE_ATOMS:
resi.detach_child(x.name)
for x in fragment:
if x.name not in ["O4'", "C1'", "C2'"]:
resi.add(x)
resi.change_name('C')
log.write_message(
'Residue %s: patched to construct base atoms from scratch.' %
(resi.identifier))
def set_bfactor(self, resi, b_value):
"""Sets the same b factor for all atoms in the residue"""
for atom in resi:
atom.set_bfactor(b_value)