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 create_model(template=None, alignment=None, model_chain_name=None):
"""*create_model(template=None, alignment=None, model_chain_name=None)*
Creates a RNA structure model.
Produces a RnaModel object that can be saved
in a variable (see example).
If no arguments are given, an empty RNAModel is created.
If both a Template and an Alignment are given as arguments,
the complete model is built automatically.
The chain id that the model should have can be specified optionally.
:Arguments:
* Template object (optional)
* Alignment object (optional)
* chain id of the model to be built
"""
if template: template = validate_template(template)
if alignment: alignment = validate_alignment(alignment)
model = RnaModel(template=template, alignment=alignment, model_chain_name=model_chain_name, data_type=None, data=None)
if template and alignment:
if not match_template_with_alignment(template,alignment):
raise ModernaError("""Template and alignment sequences do not match!
The model cannot be built automatically.
Template : %s
Alignment: %s
"""%(template.get_sequence(),alignment.template_seq))
model.create_model()
match_alignment_with_model(alignment,model)
return model
def setUp(self):
"""
fragment attached at 5' end of model.
"""
self.m = RnaModel(data_type='file',data=MINI_TEMPLATE, seq=Sequence("GCGGAUUUALCUCAG"))
self.s1 = ModernaStructure('file', SMALL_FRAGMENT, seq=Sequence("GCGG"))
self.s2 = ModernaStructure('file',SMALL_FRAGMENT, seq=Sequence("GCGG"))
def test_insert_all_fragments_retain_template(self):
"""The template sequence should not change."""
m2 = RnaModel(template=self.t,
alignment=self.a,
model_chain_name='A',
data_type='file',
data=MINI_TEMPLATE)
m2.insert_all_fragments()
self.assertEqual(self.t.get_sequence(), self.seq_before)
def test_5p_extension(self):
a = read_alignment("""> target
AAAAAAAAAAGCGGAUUUALCUCAG
> template
----------GCGGAUUUALCUCAG
""")
m = RnaModel(None, a, data_type='file', data=MINI_TEMPLATE)
m.add_missing_5p()
self.assertEqual(m.get_sequence(), a.target_seq)
def test_model_with_5p3p_ends(self):
a = read_alignment('''> target
CAUGCGGAYYYALCUCAGGUA
> mini_template
---GCGGAUUUALCUCAG---
''')
m = RnaModel(self.t, a)
m.create_model()
self.assertEqual(m.get_sequence(), Sequence('CAUGCGGAYYYALCUCAGGUA'))
def setUp(self):
self.m = RnaModel(data_type='file',
data=MINI_TEMPLATE,
seq=Sequence("GCGGAUUUALCUCAG"))
self.s1 = ModernaStructure('file',
SMALL_FRAGMENT,
seq=Sequence("GCGG"))
self.s2 = ModernaStructure('file',
SMALL_FRAGMENT,
seq=Sequence("GCGG"))
def test_model_with_hydro_template(self):
"""If the template contains hydrogens, modifications should be added."""
t = Template(RNA_HYDRO, 'file', 'B')
a = read_alignment("""> 3tra_A.pdb Z73314.1/2358-2429
UPA
> 1qru_B.pdb X55374.1/1-72
CAA
""")
m = RnaModel(t, a)
m.create_model()
self.assertEqual(m.get_sequence(), Sequence('UPA'))
def test_model_with_alignment_adjustment(self):
"""Introduces small corrections on alignment."""
a = read_alignment("""> target
ACUGUGAYUA[UACCU#P-G
> template with small errors.
GCG7A----U.UAGCUCA_G
""")
t = Template(MINI_TEMPLATE, 'file')
match_template_with_alignment(t, a)
m = RnaModel(t, a)
m.create_model()
self.assertEqual(m.get_sequence(), Sequence("ACUGUGAYUA[UACCU#PG"))
def test_number_gap(self):
"""Builds model with numbering gap in the template."""
a = read_alignment("""> target
CCGACCUUCGGCCACCUGACAGUCCUGUGCGGGAAACCGCACAGGACUGUCAACCAGGUAAUAUAACCACCGGGAAACGGUGGUUAUAUUACCUGGUACGCCUUGACGUGGGGGAAACCCCACGUCAAGGCGUGGUGGCCGAAGGUCGG
> template
CCGACCUUCGGCCACCUGACAGUCCUGUGCGG----CCGCACAGGACUGUCAACCAGGUAAUAUAACCACCGG----CGGUGGUUAUAUUACCUGGUACGCCUUGACGUGGGG----CCCCACGUCAAGGCGUGGUGGCCGAAGGUCGG
""")
t = Template(JMB_TEMPLATE, 'file')
clean_structure(t)
m = RnaModel(t, a)
m.create_model()
self.assertEqual(m.get_sequence().seq_without_breaks, a.target_seq)
def test_fill_doublegap(self):
"""Should insert fragments into correct sites."""
# prepare model
t = Template(DOUBLEGAP, 'file', 'A')
m = RnaModel()
for r in t:
m.copy_residue(r)
# insert first fragment
struc = ModernaStructure('file', FRAGMENT1)
f1 = ModernaFragment53(struc, anchor5=m['20'], anchor3=m['24'], \
new_sequence=Sequence('AUA'), keep=keep_first_last)
m.insert_fragment(f1)
resids = [r.identifier for r in m]
expected_resids1 = [
'18', '19', '20', '21', '21A', '23', '24', '27', '28', '29', '30',
'31', '32', '33', '34', '35'
]
self.assertEqual(resids, expected_resids1)
# insert second fragment
struc = ModernaStructure('file', FRAGMENT2)
f2 = ModernaFragment53(struc, anchor5=m['23'], anchor3=m['28'], \
new_sequence=Sequence('AUUA'), keep=keep_first_last)
m.insert_fragment(f2)
resids = [r.identifier for r in m]
expected_resids2 = [
'18', '19', '20', '21', '21A', '23', '24', '24A', '24B', '27',
'28', '29', '30', '31', '32', '33', '34', '35'
]
self.assertEqual(resids, expected_resids2)
def load_model(data, chain_name='A',data_type='file',template=None,alignment=None):
"""*load_model(file_path, chain_name='A', data_type='file', template=None, alignment=None)*
Loads a structure model that has been built previously,
or any PDB struture that is then to be modified.
Produces a RnaModel object that can be saved in a variable.
Each model in ModeRNA contains only one chain.
Multi-chain structures can be modeled by using more than one
Template/Alignment/RNAModel at a time.
By default, RNAModels are created by reading files.
They can also be created from BioPython PDB objects
(precisely Bio.PDB.Structure.Structure and Bio.PDB.Chain.Chain objects)
:Arguments:
* path+filename of a PDB structure file; or a Structure or Chain object from BioPython.
* chain id (by default 'A')
* data type ('file' by default; if set to 'structure' or 'chain', Bio.PDB objects are read)
* Template object to be used for this model (optional)
* Alignment object to be used for this model (optional)
"""
if data_type == 'file': data = validate_filename(data)
elif data_type == 'residues': data = validate_resi_list(data)
if template: template = validate_template(template)
if alignment: alignment = validate_alignment(alignment)
return RnaModel(template=template, alignment=alignment, model_chain_name=chain_name, data_type=data_type, data=data)
def test_doublegap_model(self):
"""Should create a model filling two gaps"""
a = read_alignment('''> target
GGGAUAGUUCCAGABU#A
> template
GGGA-AG--CCAGABU#A
''')
t = Template(DOUBLEGAP, 'file', 'A')
m = RnaModel(t, a)
m.apply_alignment()
m.insert_all_fragments()
m.fix_backbone()
self.assertEqual(m.get_sequence(), Sequence('GGGAUAGUUCCAGABU#A'))
def setUp(self):
self.s = ModernaStructure('file', MINI_TEMPLATE)
self.t = Template(MINI_TEMPLATE, 'file')
self.m = RnaModel(None, None, 'A', 'file', MINI_TEMPLATE)
self.f = ModernaFragment53(self.s,
anchor5=self.m['1'],
anchor3=self.m['14'])
self.struc = PDBParser().get_structure('test_struc', MINI_TEMPLATE)
def extract_region(self):
self.model.renumber_chain()
"""Cuts out the residues for optimization and keeps the rest in memory."""
if self.residues:
print '\nExtracting the region to be optimized (%s-%s) from the model.'%(self.residues[0], self.residues[1])
print '\t.. total residues in model : %4i'%len(self.model)
self.model_passive = self.model.find_residues_not_in_range(self.residues[0], self.residues[1])
print '\t.. residues not participating in optimization : %4i (+2 for superposition afterwards)'%(len(self.model_passive)-2)
print '\t '+','.join([r.identifier for r in self.model_passive])
self.model = RnaModel(None, None, self.options.chain_name, 'residues', self.model[self.residues[0]:self.residues[1]])
# memorize residue numbers because MMTK screws them
self.model_resnumbers = [r.identifier for r in self.model]
print '\t.. residues participating in optimization : %4i'%len(self.model)
print '\t '+','.join([r.identifier for r in self.model])
# keeps duplicate versions of the residues indicated by self.residues,
# so they can be superimposed later
self.stem5, self.stem3 = self.model[self.residues[0]], self.model[self.residues[1]]
else:
self.struc_to_optimize = self.model
def test_gaps_in_target(self):
"""Moderna should model gaps in the target, too."""
a = read_alignment(ALIGN_TARGET_GAP)
m = RnaModel(self.t, a)
m.apply_alignment()
m.insert_all_fragments()
self.assertEqual(
m.get_sequence().seq_with_modifications.replace('_', ''),
'..CUGACCU#P')
class ModernaFragment5Tests(TestCase):
"""fragment attached at 3' end of model"""
def setUp(self):
self.m = RnaModel(data_type='file',
data=MINI_TEMPLATE,
seq=Sequence("GCGGAUUUALCUCAG"))
self.s1 = ModernaStructure('file',
SMALL_FRAGMENT,
seq=Sequence("GCGG"))
self.s2 = ModernaStructure('file',
SMALL_FRAGMENT,
seq=Sequence("GCGG"))
def test_attributes(self):
five = ModernaFragment5(self.s1, anchor5=self.m['15'])
self.assertEqual(len(five.anchor_residues), 1)
self.assertEqual(len(five.nonanchor_residues), 3)
self.assertTrue(str(five))
def test_add_on_3_end(self):
"""Model sequence should change accordingly."""
five = ModernaFragment5(self.s1, anchor5=self.m['15'])
self.m.insert_fragment(five)
self.assertEqual(self.m.get_sequence(), Sequence("GCGGAUUUALCUCAGCGG"))
self.assertTrue(five.rmsd <= 1.00)
def test_add_on_3_end_replace(self):
"""Model sequence should change accordingly."""
five_overwrite = ModernaFragment5(self.s2, anchor5=self.m['9'])
self.m.insert_fragment(five_overwrite)
self.assertEqual(self.m.get_sequence(), Sequence("GCGGAUUUACGG"))
self.assertTrue(five_overwrite.rmsd <= 1.00, 0)
class ModernaFragment3Tests(TestCase):
def setUp(self):
"""
fragment attached at 5' end of model.
"""
self.m = RnaModel(data_type='file',
data=MINI_TEMPLATE,
seq=Sequence("GCGGAUUUALCUCAG"))
self.s1 = ModernaStructure('file',
SMALL_FRAGMENT,
seq=Sequence("GCGG"))
self.s2 = ModernaStructure('file',
SMALL_FRAGMENT,
seq=Sequence("GCGG"))
def test_attributes(self):
"""Attributes of fragment are accessible."""
three = ModernaFragment3(self.s1, anchor3=self.m['1'])
self.assertEqual(len(three.anchor_residues), 1)
self.assertEqual(len(three.nonanchor_residues), 3)
self.assertTrue(str(three))
def test_add_on_5_end(self):
"""Model sequence should change accordingly."""
three = ModernaFragment3(self.s1, anchor3=self.m['1'])
self.m.insert_fragment(three)
self.assertEqual(self.m.get_sequence(), Sequence("GCGGCGGAUUUALCUCAG"))
self.assertTrue(three.rmsd <= 1.00)
def test_add_on_5_end_exact(self):
"""Model sequence should change accordingly."""
# exactly fitting example replacing original residues.
three_overwrite = ModernaFragment3(self.s2, anchor3=self.m['6'])
self.m.insert_fragment(three_overwrite)
self.assertEqual(self.m.get_sequence(), Sequence("GCGUUUALCUCAG"))
self.assertTrue(three_overwrite.rmsd <= 1.00)
def test_add_discontinuous(self):
"""Tries to add a helix to an end."""
helix = ModernaStructure('file', 'test_data/rna_structures/helix.pdb')
helix_frag = ModernaFragment3(helix, anchor3=self.m['1'], strict=False)
self.m.insert_fragment(helix_frag)
self.assertEqual(self.m.get_sequence(),
Sequence('CCGACCUUCGGCC_GGUGGCCGAAGGGCGGAUUUALCUCAG'))
def test_create_model_with_gaps(self):
"""Should create the model automatically."""
a = read_alignment(ALIGN_1B23_1QF6)
t = Template(RNA_1B23, 'file', 'R')
m = RnaModel(t, a)
m.apply_alignment()
m.insert_all_fragments()
self.assertEqual(
m.get_sequence().seq_with_modifications.replace('_', ''),
'GCCGAUAUAGCUCAGDDGGDAGAGCAGCGCAUUCGUEAUGCGAAG7UCGUAGGTPCGACUCCUAUUAUCGGCACCA'
)
def test_eliminate_middle(self):
"""Builds a fragment to shorten the connection between two anchor pairs"""
helix = ModernaStructure('file', HELIX, 'A')
helix = RnaModel(data_type='residues',
data=helix['1':'10'] + helix['71':'80'])
frag = ModernaFragment2D(self.motif, \
anchor5=helix['2'], anchor3=helix['79'], \
anchor5_upper=helix['8'], anchor3_upper=helix['73'], \
frag5_upper=self.motif['196'], frag3_upper=self.motif['217'], \
new_sequence=Sequence('C'), \
model=helix)
finsert = FragmentInserter()
finsert.prepare_fragment(frag, helix)
frag.fix_backbone()
self.assertEqual(frag.struc.get_sequence(), Sequence('AAAA_UUUCU'))
class FragmentInserterTests(TestCase):
"""
Tests for the FragmentInserter class
"""
def setUp(self):
self.m = RnaModel(data_type='file',data=MINI_TEMPLATE, seq=Sequence("GCGGAUUUALCUCAG"))
self.s1 = ModernaStructure('file', SMALL_FRAGMENT, seq=Sequence("GCGG"))
#self.s2 = ModernaStructure('file',SMALL_FRAGMENT, seq=Sequence("GCGG"))
#self.s3 = ModernaStructure('file', MINI_TEMPLATE, seq=Sequence("GCGGAUUUALCUCAG"))
def test_insert(self):
"""Inserts fragment into a model"""
f1 = ModernaFragment53(self.s1, anchor5=self.m['10'],anchor3=self.m['13'])
finsert = FragmentInserter()
finsert.insert_fragment(f1, self.m)
self.assertEqual(self.m.get_sequence(),Sequence("GCGGAUUUALCGCAG"))
def test_long_5p_extension(self):
a = read_alignment("""> target
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCGGAUUUALCUCAG
> template
----------------------------------------GCGGAUUUALCUCAG
""")
# first number == 1 should not work
m = RnaModel(None, a, data_type='file', data=MINI_TEMPLATE)
self.assertRaises(RenumeratorError, m.add_missing_5p)
# first number == 100 should work
m = RnaModel(None, a, data_type='file', data=MINI_TEMPLATE)
renumber_chain(m, 100)
m.add_missing_5p()
self.assertEqual(m.get_sequence(), a.target_seq)
def test_oppositegap_model(self):
"""Should create a model with close gaps in the other respective sequence"""
a = read_alignment('''> target
GGGAGAGCRUUAG-BU#A
> template
GGGAGAGCR--AGABU#A
''')
t = Template(OPPOSITEGAP, 'file', 'A')
m = RnaModel(t, a)
m.apply_alignment()
m.insert_all_fragments()
self.assertEqual(
m.get_sequence().seq_with_modifications.replace('_', ''),
'GGGAGAGCRUUAGBU#A')
def test_insert_eliminate(self):
"""Inserts a 2D fragment into a model."""
helix = load_model(HELIX, 'A')
helix = RnaModel(None, None, 'A', 'residues',
helix['1':'8'] + helix['73':'80'])
mf = ModernaFragment2D(self.motif, \
anchor5=helix['7'], anchor3=helix['74'], \
anchor5_upper=helix['8'], anchor3_upper=helix['73'], \
frag5_upper=self.motif['196'], frag3_upper=self.motif['217'], \
new_sequence=Sequence('C'), \
model=helix)
helix.insert_fragment(mf)
self.assertEqual(helix.get_sequence(), Sequence('AAAAAAAA_UCUUUUUUU'))
self.assertEqual(helix.get_secstruc(), '(((((((().)))))))')
def test_model_with_close_gaps(self):
t = Template('test_data/rna_structures/2du3_excerpt.ent', 'file', 'D')
a = read_alignment('''> 1qru_B.pdb X55374.1/1-72
GCA-UUCCG
> 2du3_D.pdb
CUUUA-CCC
''')
m = RnaModel()
copy_some_residues([t['944'], t['946'], t['947']], m)
lc = find_fragment(m, '946', '947', Sequence('U'))
insert_fragment(m, lc[0])
lc = find_fragment(m, '944', '946', Sequence(''))
insert_fragment(m, lc[0])
return #TODO: remove
# generate model
m = RnaModel(t, a)
m.create_model()
def test_fill_gap_numbering(self):
"""Should insert fragment with correct numbering."""
t = Template(DOUBLEGAP, 'file', 'A')
m = RnaModel()
for r in t:
m.copy_residue(r)
struc = ModernaStructure('file', FRAGMENT1)
f1 = ModernaFragment53(struc,
anchor5=m['20'],
anchor3=m['24'],
new_sequence=Sequence('AUA'))
m.insert_fragment(f1)
resids = [r.identifier for r in m]
expected_resids1 = [
'18', '19', '20', '20A', '20B', '20C', '24', '27', '28', '29',
'30', '31', '32', '33', '34', '35'
]
self.assertEqual(resids, expected_resids1)
class ModelMinimization:
"""
Main class for minimizing models
"""
def __init__(self, options, temp_path):
self.options = options
# structure
print 'Loading model from %s, chain %s'%(options.input_file, options.chain_name)
self.model = load_model(options.input_file, options.chain_name)
self.model_passive = None
self.stem5, self.stem3 = None, None
self.sequence_before = self.model.get_sequence()
self.model_resnumbers = []
# parameters
self.residues = None
if options.residues:
self.residues = options.residues.split('-')
self.cycles = int(options.cycles)
self.output_name = options.output_file
self.modifications = []
self.restraints = []
self.mmtk_output_file = 'mmtk_output.pdb'
self.temp_pdb_file = temp_path
def model_to_tempfile(self):
"""writes model to temporary file."""
self.model.write_pdb_file(self.temp_pdb_file)
self.model = None
def tempfile_to_model(self):
"""Reads model from temporary file."""
self.model = load_model(self.temp_pdb_file, self.options.chain_name)
def extract_region(self):
self.model.renumber_chain()
"""Cuts out the residues for optimization and keeps the rest in memory."""
if self.residues:
print '\nExtracting the region to be optimized (%s-%s) from the model.'%(self.residues[0], self.residues[1])
print '\t.. total residues in model : %4i'%len(self.model)
self.model_passive = self.model.find_residues_not_in_range(self.residues[0], self.residues[1])
print '\t.. residues not participating in optimization : %4i (+2 for superposition afterwards)'%(len(self.model_passive)-2)
print '\t '+','.join([r.identifier for r in self.model_passive])
self.model = RnaModel(None, None, self.options.chain_name, 'residues', self.model[self.residues[0]:self.residues[1]])
# memorize residue numbers because MMTK screws them
self.model_resnumbers = [r.identifier for r in self.model]
print '\t.. residues participating in optimization : %4i'%len(self.model)
print '\t '+','.join([r.identifier for r in self.model])
# keeps duplicate versions of the residues indicated by self.residues,
# so they can be superimposed later
self.stem5, self.stem3 = self.model[self.residues[0]], self.model[self.residues[1]]
else:
self.struc_to_optimize = self.model
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 remove_modifications(self):
"""Memorizes modified nucleotides for later, and then removes them."""
print '\nRemoving modified bases from the model.'
for resi in self.model.get_modified_residues():
resi=self.model[resi]
modi = (resi.identifier, resi.long_abbrev)
print '\t.. %s at position %s'%modi
self.modifications.append(modi)
self.model.remove_all_modifications()
# check for O3 atoms
for resi in self.model:
if resi.child_dict.has_key(' O3P'):
raise OptimizationError('O3P atoms cannot be handled by MMTK!')
def change_atom_names(self, forth=False, back=False):
"""Replaces atom and residue names so that MMTK can iterpret them."""
print '\nReplacing names in temporary PDB file (%s)'%((forth and 'ModeRNA->MMTK') or (back and 'MMTK->ModeRNA'))
if forth: nameset = FORTH_SET
elif back: nameset = BACK_SET
else: raise OptimizationError("Invalid options for changing atom names.")
# replace residue and atom names
out = []
for line in open(self.temp_pdb_file):
if line.startswith('ATOM') or line.startswith('HETATM'):
resiname = nameset.replace_residue_name(line[17:20])
atomname = nameset.replace_atom_name(line[12:16])
line = line[:12]+atomname+line[16:17]+resiname+line[20:]
if len(line)>13 and line[13]!='H': # discard hydrogens
out.append(line)
open(self.temp_pdb_file, 'w').writelines(out)
def create_restraints(self, chain):
"""If a residue range was specified, these residues are cut out, and """
if self.residues:
print '\t.. building restraints'
first_resi = chain[0]
last_resi = chain[-1]
# distances between the two terminal residues
dist_po = (self.stem5['P'] - self.stem3["O3'"])/10.0
restraints = HarmonicDistanceRestraint(first_resi.phosphate.P, last_resi.sugar.O_3, dist_po, 10000.)
dist_co = (self.stem5["O5'"] - self.stem3["O3'"])/10.0
restraints += HarmonicDistanceRestraint(first_resi.sugar.O_5, last_resi.sugar.C_3, dist_co, 10000.)
dist_cc = (self.stem5["C5'"] - self.stem3["C4'"])/10.0
restraints += HarmonicDistanceRestraint(first_resi.sugar.C_5, last_resi.sugar.C_4, dist_cc, 10000.)
# angles between the two terminal residues
angle_cpo = calc_angle(self.stem5["C4'"].get_vector(), self.stem3["P"].get_vector(), self.stem3["O3'"].get_vector())
#angle_cpo = calc_angle(self.stem3["P"].coord-self.stem5["C4'"].coord, self.stem3["P"].coord-self.stem3["O3'"].coord)
restraints += HarmonicAngleRestraint(first_resi.sugar.C_4, last_resi.phosphate.P, last_resi.sugar.O_3, angle_cpo, 100000.)
angle_pco1 = calc_angle(self.stem5["P"].get_vector(), self.stem3["C4'"].get_vector(), self.stem3["O3'"].get_vector())
restraints += HarmonicAngleRestraint(first_resi.phosphate.P, last_resi.sugar.C_4, last_resi.sugar.O_3, angle_pco1, 10000.)
angle_pco2 = calc_angle(self.stem5["P"].get_vector(), self.stem5["C4'"].get_vector(), self.stem3["O3'"].get_vector())
restraints += HarmonicAngleRestraint(first_resi.phosphate.P, first_resi.sugar.C_4, last_resi.sugar.O_3, angle_pco2, 10000.)
angle_pcc = calc_angle(self.stem5["P"].get_vector(), self.stem5["C4'"].get_vector(), self.stem3["C4'"].get_vector())
restraints += HarmonicAngleRestraint(first_resi.phosphate.P, first_resi.sugar.C_4, last_resi.sugar.C_4, angle_pcc, 10000.)
# torsion between the two terminal residues
# THESE PRODUCE SEGMENTATION FAULTS - THE OTHERS MUST SUFFICE
# restraints += HarmonicDihedralRestraint(first_resi.phosphate.P, first_resi.sugar.C_4, last_resi.phosphate.P, last_resi.sugar.C_4, 1.0, 10.)
#restraints += HarmonicDihedralRestraint(first_resi.phosphate.P, first_resi.sugar.C_4, last_resi.sugar.C_4, last_resi.sugar.O_3, 0.0, 100000.)
#restraints += HarmonicDihedralRestraint(first_resi.sugar.C_4, first_resi.sugar.O_3, last_resi.phosphate.P, last_resi.sugar.C_4, 0.0, 100000.)
#restraints += HarmonicDihedralRestraint(first_resi.sugar.C_4, first_resi.sugar.O_3, last_resi.sugar.C_4, last_resi.sugar.O_3, 0.0, 100000.)
return restraints
def optimize(self):
"""Run the optimization with MMTK"""
print '\n-------------------------------------------------------------------------------'
print '\n MMTK Optimization starts...'
print '\t.. building universe'
configuration = PDBConfiguration(self.temp_pdb_file)
# Construct the nucleotide chain object. This also constructs positions
# for the missing hydrogens, using geometrical criteria.
chain = configuration.createNucleotideChains()[0]
universe = InfiniteUniverse()
universe.addObject(chain)
restraints = self.create_restraints(chain)
# define force field
print '\t.. setting up force field'
if restraints:
ff = Amber94ForceField() + restraints
else:
ff = Amber94ForceField()
universe.setForceField(ff)
# do the minimization
print '\t.. starting minimization with %i cycles'%self.cycles
minimizer = ConjugateGradientMinimizer(universe)
minimizer(steps = self.cycles)
# write the intermediate output
print '\t.. writing MMTK output to %s'% self.temp_pdb_file
if self.model_passive:
print '\t (please note that MMTK applies a different numeration of residues.\n\t The original one will be restored in the final output).'
universe.writeToFile(self.mmtk_output_file)
open(self.temp_pdb_file, 'w').write(open(self.mmtk_output_file).read())
print '\n-------------------------------------------------------------------------------'
def add_modifications(self):
"""Restores modifications on the model."""
print "\nAdding modifications back to the model:"
for position, modif in self.modifications:
print "\t.. adding %s in position %s"%(modif, position)
self.model[position].add_modification(modif)
# check if sequence stayed the same
print '\nSequence before optimization'
print self.sequence_before
print 'Sequence after optimization'
print self.model.get_sequence()
def write_result(self):
"""Creates the output file."""
print "\nWriting final output to: %s"%self.output_name
self.model.write_pdb_file(self.output_name)
def test_load_model(self):
"""A model should be loadable from a file."""
m = RnaModel(None, None, 'A', 'file', MINI_TEMPLATE)
self.assertEqual(len(m), 15)
def setUp(self):
self.a = read_alignment(MINI_ALIGNMENT)
self.t = Template(MINI_TEMPLATE, seq=Sequence("GCGGAUUUALCUCAG"))
self.m = RnaModel(self.t, self.a)
self.seq_before = self.t.get_sequence()
self.br = BaseRecognizer()
def test_gap_optimization_example_2(self):
t = Template('test_data/gaps/mini_1h4s_T_gap2.pdb', 'file', 'T')
a = read_alignment('test_data/gaps/ali_gap2.fasta')
m = RnaModel(t, a)
m.create_model()
