def setupMDL(env,name):
from modeller.scripts import complete_pdb
mdl = complete_pdb(env, name)
mdl.patch_ss()
name = name.split(".pdb")[0]+"m.pdb"
mdl.write(file=name)
return name,mdl
def evaluate_single_model(pdb):
env.libs.topology.read(file='$(LIB)/top_heav.lib')
env.libs.parameters.read(file='$(LIB)/par.lib')
mdl = complete_pdb(env, pdb)
s = selection(mdl)
s.assess_dope(output='ENERGY_PROFILE NO_REPORT',
file='TvLDH.profile',
normalize_profile=True, smoothing_window=15)
def completePDB(pdbin,pdbout):
'''
Given a PDB, clean/complete the PDB using
Modeller's complete_pdb function.
'''
# Squelch stdout.
save_ = sys.stdout
sys.stdout = cStringIO.StringIO()
# Perform PDB completion.
env = environ()
env.libs.topology.read('${LIB}/top_heav.lib')
env.libs.parameters.read('${LIB}/par.lib')
m = complete_pdb(env,pdbin)
m.write(file=pdbout)
# Reclaim stdout.
sys.stdout = save_
def soap_score():
import modeller
from modeller.scripts import complete_pdb
from modeller import soap_protein_od
env = modeller.environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib')
env.libs.parameters.read(file='$(LIB)/par.lib')
# Set up SOAP-Protein-OD scoring (we create the scorer once and keep it
# around, since reading in the potential from disk can take a long time).
sp = soap_protein_od.Scorer()
out = open('SnapList.txt','w')
cnt = 0
files = [i for i in glob.glob('pm.pdb*.pdb')
if 'pm.pdb.B10010002.pdb' not in i]
for fil in files:
try:
cnt += 1
# Read a model previously generated by Modeller's automodel class
mdl = complete_pdb(env, fil)
# Select all atoms
atmsel = modeller.selection(mdl)
# Assess with the above Scorer
try:
score = atmsel.assess(sp)
out.write(fil+'\t'+str(score)+'\n')
except modeller.ModellerError:
print("The SOAP-Protein-OD library file is not included "
"with MODELLER.")
print("Please get it from https://salilab.org/SOAP/.")
# Was 'except: pass' but this will hide genuine errors. Replace with
# a more specific list of exceptions (and test)
except: raise
out.close()
def compute_profile(pdb_file, profile_file):
"""Compute the profile of each model
"""
env = get_environment([pdb_file])
# env and pdbfile
pdb = complete_pdb(env, pdb_file)
# all atom selection
s = selection(pdb)
# profile result
normal_result = s.assess_dope()
# output='ENERGY_PROFILE NO_REPORT',
# normalize_profile=False
# get_profile(profile_file)
profile = s.get_dope_profile()
# profile = s.get_dopehr_profile()
# profile.write_to_file(profile_file)
# val = []
# with open(profile_file, "rt") as test:
# for i in test:
# # print(i.split())
# val += [float(i.split()[1])]
# for i in profile:
# print(i)
return [i.energy for i in profile], normal_result
# This will enforce cis conformation for Pro-56.
# Make a model and stereochemical restraints:
from modeller import *
from modeller.scripts import complete_pdb, cispeptide
log.level(output=1, notes=1, warnings=1, errors=1, memory=0)
env = environ()
env.io.atom_files_directory = ['../atom_files']
env.libs.topology.read(file='$(LIB)/top_heav.lib')
env.libs.parameters.read(file='$(LIB)/par.lib')
code = '1fas'
mdl = complete_pdb(env, code)
rsr = mdl.restraints
atmsel = selection(mdl)
rsr.make(atmsel, restraint_type='stereo', spline_on_site=False)
# Change the Pro-56 restraint from trans to cis:
a = mdl.chains[0].atoms
cispeptide(rsr, atom_ids1=(a['O:56'], a['C:56'], a['N:57'], a['CA:57']),
atom_ids2=(a['CA:56'], a['C:56'], a['N:57'], a['CA:57']))
# Constrain the distance between alpha carbons in residues 5 and 15 to
# be less than 10 angstroms:
rsr.add(forms.upper_bound(group=physical.xy_distance,
feature=features.distance(a['CA:5'], a['CA:15']),
mean=10., stdev=0.1))
def Optimizemodel(pdb_file):
"""
It creates a PDB file with the optimized model from the input pdb,
with its energies and restraint contributions. Also it will create pdbs on
every step of the Molecular Dynamics optimization. The energy is returned as
the total value of Modeller's objective function, molpdf.
It also shows the topt 10 contributors to the molpdf before and after optimization
"""
# Setting up
env = environ()
env.io.atom_files_directory = ['../atom_files']
env.edat.dynamic_sphere = True
env.libs.topology.read(file='$(LIB)/top_heav.lib')
env.libs.parameters.read(file='$(LIB)/par.lib')
code, ext = pdb_file.split('.')
# Complete the pdb and make a model
mdl = complete_pdb(env, pdb_file)
mdl.write(file=code + '.ini')
# Select all atoms from the model, make restraints and save them in a file
atmsel = selection(mdl)
mdl.restraints.make(atmsel, restraint_type='stereo', spline_on_site=False)
mdl.restraints.write(file=code + '.rsr')
# Check the energy before optimization and save it in a var
initial_mpdf = atmsel.energy()
# Create optimizer objects
cg = conjugate_gradients(output='REPORT')
md = molecular_dynamics(output='REPORT')
# Open a file to get basic stats on each optimization
stats_file = open(code + '_opt.stats', 'w')
# Run MD. Write out a PDB structure every 10 steps during the run.
# Write stats every 10 steps
md.optimize(atmsel,
temperature=300,
max_iterations=50,
actions=[
actions.write_structure(10, code + '.MD%04d.pdb'),
actions.trace(10, stats_file)
])
# Run CG, and write stats every 5 steps
cg.optimize(atmsel,
max_iterations=50,
actions=[actions.trace(5, stats_file)])
# Final energy
final_mpdf = atmsel.energy()
# Assess DOPE
atmsel.assess_dope(output='ENERGY_PROFILE NO_REPORT',
file='TvLDH.profile',
normalize_profile=True,
smoothing_window=15)
# Print the energies and the contributions
initial_cont_all = dict(initial_mpdf[1])
top_init_conts = dict(
sorted(initial_cont_all.items(), key=itemgetter(1), reverse=True)[:5])
l.info("\n\nThe initial energy of " + code + " is " + str(initial_mpdf[0]))
print("\n\nThe initial energy of " + code + " is " + str(initial_mpdf[0]))
print("The top 10 initial contributions the restraints are:\n")
for keys, values in top_init_conts.items():
print(keys, ":", values)
final_cont_all = dict(final_mpdf[1])
top_final_conts = dict(
sorted(final_cont_all.items(), key=itemgetter(1), reverse=True)[:5])
l.info("\n\nThe final energy of " + code + " is " + str(final_mpdf[0]))
print("\n\nThe final energy of " + code + " is " + str(final_mpdf[0]))
print("Final contributions the restraints are:\n")
for keys, values in top_final_conts.items():
print(keys, ":", values)
mdl.write(file=code + '_optimized.pdb')
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# read model file
mdl = complete_pdb(env, 'Q9VYG2.B99990003.pdb')
# Assess with DOPE:
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT',
file='Q9VYG2.profile',
normalize_profile=True,
smoothing_window=15)
import os
from MDAnalysis import *
from MDAnalysis.analysis.align import *
import numpy
import numpy.linalg
from modeller import *
from modeller.scripts import complete_pdb
env = environ()
env.edat.radii_factor = 0.92
env.edat.dynamic_sphere= True
env.libs.topology.read('${LIB}/top_heav.lib')
env.libs.parameters.read('${LIB}/par.lib') #load parameters
env.io.atom_files_directory = ['.', '${LIB}/atom_files/']
log.verbose()
table = open('analysis.txt', 'w')
for x in os.listdir('.'):
if x.endswith('.pdb'):
new_mod = complete_pdb(env, x)
dope = new_mod.assess_normalized_dope()
bcat = MDAnalysis.Universe(x)
bcat_sel = bcat.selectAtoms('name CA or backbone')
bcat_RG = bcat_sel.radiusOfGyration()
table.write(str(x)+'\t'+str(dope)+'\t'+str(bcat_RG)+'\n')
table.close()
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# read model file
mdl = complete_pdb(env, 'lrrk2.B99990002.pdb')
# Assess with DOPE:
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT', file='lrrk2.profile',
normalize_profile=True, smoothing_window=15)
def calc(version, configfile, atomfile, inputsequencefile, outputfile):
#a list, where the helical residues should be
#TODO read out configfile
try:
global log
helixrange = []
config = open(configfile, 'r')
for line in config:
line = line.strip()
values = line.split(',')
pdbname = values[0]
proteinname = values[1]
residuename = values[2]
startlinker = values[3]
endlinker = values[4]
if (len(values)-3)%2 == 0:
for helixbase in range(3, len(values)-1, 2):
helixrange.append((int(values[helixbase]), int(values[helixbase+1])))
else:
log.error("calc", "wrong number of parameters in configfile")
config.close()
return -2
config.close()
except:
log.error("calc", "reading config file")
return -3
try:
modelsegments = ('FIRST:' + residuename,'LAST:' + residuename) #from where to where in the PDB, default is first to last aa
aligncodespdb = pdbname + residuename
alnfile = proteinname + "-" + aligncodespdb + ".ali"
log.minimal()
env = environ()
env.libs.topology.read('${MODINSTALL9v14}/'+version+'/modlib/top_heav.lib')
env.libs.parameters.read('${MODINSTALL9v14}/'+version+'/modlib/par.lib')
except:
log.error("calc", "unable to setup environment")
return -4
try:
aln = alignment(env)
mdl = model(env, file= atomfile, model_segment=modelsegments) #the PDB file
aln.append_model(mdl, align_codes=aligncodespdb, atom_files=atomfile)
aln.append(file=inputsequencefile, align_codes=proteinname) #in here the sequence has been.
aln.align2d()
aln.write(file=alnfile, alignment_format='PIR')
except:
log.error("calc", "unable to write alignment file")
return -5
class cycModel(dopehr_loopmodel):
def special_patches(self, aln):
# Link between last residue (-1) and first (0) to make chain cyclic:
self.patch(residue_type="LINK",
residues=(self.residues[-1], self.residues[0]))
class RestraintsModel(cycModel):
def special_restraints(self, aln):
for helix in helixrange:
self.restraints.add(secondary_structure.alpha(self.residue_range(str(helix[0]), str(helix[1]))))
class MyLoop(RestraintsModel):
def select_loop_atoms(self):
return selection(self.residue_range(startlinker, endlinker))
# Disable default NTER and CTER patching
env.patch_default = False
try:
a = MyLoop(env, alnfile=alnfile,
knowns=pdbname + residuename, sequence=proteinname,
loop_assess_methods=(assess.DOPE,
assess.normalized_dope,
assess.DOPEHR,
assess.GA341))
# generate 10 models
a.starting_model = 1
a.ending_model = 2
a.library_schedule = autosched.slow
a.max_var_iterations = 5000
a.md_level = refine.slow
a.repeat_optimization = 5
a.max_molpdf = 1e6
a.final_malign3d = True
# generate 10*5 loopmodels
a.loop.starting_model = 1
a.loop.ending_model = 4
a.loop.library_schedule = autosched.slow
a.loop.max_var_iterations = 5000
a.loop.md_level = refine.slow
a.loop.repeat_optimization = 5
a.loop.max_molpdf = 1e6
a.loop.final_malign3d = True
except:
log.error("calc", "setting up loopmodal")
return -6
try:
a.make()
except:
log.error("calc", "making loopmodal")
return -7
try:
ok_models = [x for x in a.outputs if x['failure'] is None]
# Rank the models by Energy Score
ok_models.sort(key=lambda a: a['DOPE-HR score'])
# Get top model
bestmodel = ok_models[0]
print "BEGIN***************************************************************************"
print str(bestmodel['DOPE-HR score']) + ";" + str(bestmodel['Normalized DOPE score'])
print "END*****************************************************************************"
refmodel = complete_pdb(env, bestmodel["name"])
refmodel_atms = selection(refmodel)
refmodel.restraints.unpick_all()
refmodel.restraints.condense()
except:
log.error("calc", "setting up refmodal")
return -8
try:
refmodel.restraints.make(refmodel_atms, restraint_type='STEREO', spline_on_site=False)
except:
log.error("calc", "making refmodal")
return -9
try:
for helix in helixrange:
refmodel.restraints.add(secondary_structure.alpha(refmodel.residue_range(str(helix[0]), str(helix[1]))))
sel = selection(refmodel)
except:
log.error("calc", "adding helixranges to restraints")
return -10
try:
thefile = open("cg_mod_out.dat", "w")
except:
log.error("calc", "opening file cg_mod_out.dat")
return -11
try:
cg_mod = conjugate_gradients()
cg_mod.optimize(refmodel, min_atom_shift=0.0001, max_iterations=10000, actions=[actions.trace(5,thefile)])
except:
log.error("calc", "cg_mod.optimize")
return -12
try:
refmodel.write(file=outputfile)
except:
log.error("calc", "writing outputfile %s" % outputfile)
return -13
return 0
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# read model file
mdl = complete_pdb(env, 'TvLDH.B99990004.pdb')
# Assess with DOPE:
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT',
file='TvLDH.profile',
normalize_profile=True,
smoothing_window=15)
def model_protein(SEQ, tmplts):
"""
align query sequence to sequence of template PDB structure
"""
best_model = haspdb
best_score = 0
best_rmsd = 0
best_seqid = 100
for template in tmplts:
PDB = template[0:5]
identifier = SEQ + '_' + PDB
seqfile = SEQ + '.pir'
chain = PDB[-1]
coords = PDB + '.pdb'
model_dir = '../data/homology/' + SEQ + '_' + PDB
if not os.path.exists(model_dir):
os.makedirs(model_dir)
shutil.copy2('../data/pdb/templates/' + coords, model_dir)
os.chdir(model_dir)
parse_pir(yeast_seqs[SEQ], seqfile)
env = environ()
aln = alignment(env)
mdl = model(env,
file=PDB,
model_segment=('FIRST:' + chain, 'LAST:' + chain))
aln.append_model(mdl, align_codes=PDB, atom_files=coords)
aln.append(file=seqfile, align_codes=SEQ)
aln.align2d()
aln.write(identifier + '.ali', alignment_format='PIR')
aln.write(identifier + '.pap', alignment_format='PAP')
env = environ()
a = automodel(env,
identifier + '.ali',
knowns=PDB,
sequence=SEQ,
assess_methods=(assess.DOPE, assess.GA341))
a.starting_model = 1
a.ending_model = 5
a.make()
homology_models = glob.glob(SEQ + '*.pdb')
for homology_model in homology_models:
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
mdl = complete_pdb(env, homology_model)
s = selection(mdl)
score = s.assess_dope()
rmsd, seqid = compute_rmds(homology_model, template)
if score < best_score:
best_score = np.copy(score)
best_rmsd = np.copy(rmsd)
best_seqid = np.copy(seqid)
best_model = model_dir + '/' + homology_model
os.chdir('../../../code/')
return best_model, best_score, best_rmsd, best_seqid
def refine_model(pdb, seqid):
"""
refine and complete exisiting PDB
"""
pdbcode = pdb.split('.')[0]
coords = pdb + '.pdb'
best_model = 'none'
best_score = 0
model_dir = '../data/homology/' + seqid + '_' + pdbcode
if not os.path.exists(model_dir):
os.makedirs(model_dir)
shutil.copy2('../data/pdb/templates/' + coords, model_dir)
os.chdir(model_dir)
#write reference sequence to file
parse_pir(yeast_seqs[seqid], seqid + '.seq')
# Get the sequence of PDB file, and write to an alignment file
e = environ()
m = model(e, file=pdbcode)
aln = alignment(e)
aln.append_model(m, align_codes=pdbcode)
aln.append(file=seqid + '.seq', align_codes=seqid)
aln.salign()
aln.write(file=seqid + '.ali')
# check that there are actually gaps in PDB to model
g = []
for record in SeqIO.parse(seqid + '.ali', "pir"):
g.append(record.seq.count('-'))
# if PDB complete, no need to model
if np.max(np.array(g)) < 1:
best_model = model_dir + '/' + coords
best_score = -100000
else:
# Load the automodel class
log.verbose()
env = environ()
a = automodel(env,
seqid + '.ali',
knowns=pdbcode,
sequence=seqid,
assess_methods=(assess.DOPE, assess.GA341))
a.starting_model = 1
a.ending_model = 3
a.make()
refined_models = glob.glob(seqid + '*.pdb')
for refined_model in refined_models:
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
mdl = complete_pdb(env, refined_model)
s = selection(mdl)
score = s.assess_dope()
if score < best_score:
best_score = np.copy(score)
best_model = model_dir + '/' + refined_model
os.chdir('../../../code/')
return best_model, best_score
#!/usr/bin/env python import os, sys from sys import argv script, filename, start_pos, end_pos = argv chainid = 'A' from modeller import * from modeller.scripts import complete_pdb from modeller import soap_loop #from modeller import soap_protein_od env = environ() env.libs.topology.read(file='$(LIB)/top_heav.lib') env.libs.parameters.read(file='$(LIB)/par.lib') env.edat.contact_shell = -999 sp = soap_loop.Scorer() #sp = soap_protein_od.Scorer() mdl = complete_pdb(env, filename) #atmsel = selection(mdl.chains[0]) atmsel = selection(mdl.residue_range(str(start_pos)+":"+chainid, str(end_pos)+":"+chainid)) score = atmsel.assess(sp) print "GRGR", score, filename
sp = soap_protein_od.Scorer()
# only calculate for single chains, because ga341 and dope only calculate first chains
models = [
'model_dimer.pdb', 'model_locked_dimer.pdb', 'model_fragment_dimer.pdb'
]
templates = ['template_dimer_all.pdb', 'template_fragment_dimer_all.pdb']
files = models + templates
for f in files:
if (not os.path.isfile(f)):
continue
print("; FILE " + f)
# read model file
mdl = complete_pdb(env, f)
if mdl.seq_id < 0 or mdl.seq_id > 100:
mdl.seq_id = 100
# Assess all atoms with DOPE:
#s = selection(mdl)
#print("calling assess_ga341 mdl")
#score_ga341 = mdl.assess_ga341()
#print("; ENERGY assess_ga341 " + str(score_ga341))
#print("calling assess_normalized_dope mdl")
#score_normalized_dope = mdl.assess_normalized_dope()
#print("; ENERGY assess_normalized_dope " + str(score_normalized_dope))
for c in mdl.chains:
# fornisce il modello migliore
m = ok_models[0]
print "Top model: %s (DOPE score %.3f)" % (m['name'], m[key])
from modeller.scripts import complete_pdb
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
num_file = ['01', '02', '03', '04', '05', '06', '07', '08', '09', '10']
nome_file_input = 'snd0405.B999900%s.pdb'
nome_file_output = 'modello%s.profile'
for ciclo in num_file:
mdl = complete_pdb(env, nome_file_input % ciclo) # read model file
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT', file=nome_file_output % ciclo,
normalize_profile=True, smoothing_window=15) # Assess with DOPE:
mdl = complete_pdb(env, '1CVS-c_149-359.pdb') # read model file
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT', file='templato.profile',
normalize_profile=True, smoothing_window=15) # Assess with DOPE:
def main(argv):
parser = argparse.ArgumentParser(description="Perform a substitution and find the best generated model of the chain, using Modeller")
parser.add_argument('pdbfile', help='input file (PDB)')
parser.add_argument('chain', help='chain')
parser.add_argument('subs', help='substitutions (residue, number, ..)')
parser.add_argument('overlap', help='number of overlap residues to remodel either side of substitutions')
parser.add_argument('models', help='number of models to build')
parser.add_argument('outfile', help='output file (PDB)')
parser.add_argument('-l', '--loopmodels', help='run DOPE-HR loop model refinement, generating LOOPMODELS refined models')
parser.add_argument('-r', '--restore_res', help='restore Amber residue names to PDB defaults before running Modeller', action='store_true')
parser.add_argument('-v', '--verbose', help='verbose output', action='store_true')
args = parser.parse_args()
if len(args.chain) > 1:
print 'Error: chain must be a single letter'
quit()
if args.loopmodels:
loopmodels = int(args.loopmodels)
else:
loopmodels = 0
subs = {}
insertions = {}
deletions = {}
for sub in args.subs.split(','):
try:
orig_res = sub[0]
rep_res = sub[-1:]
def pdb_num(s): # put residue number, insertion code into a standardised format
res_num = s
res_letter = ' '
if not res_num[-1:].isdigit():
res_letter = res_num[-1:]
res_num = res_num[:-1]
res_num = '%-4d%s' % (int(res_num), res_letter)
return res_num
if '.' not in sub:
res_num = pdb_num(sub[1:-1])
subs[res_num] = [orig_res, rep_res, -1, sub]
if args.restore_res and rep_res == 'H':
print 'Warning: the histidine substitution in %s will require adjustment to reflect its protonation.' % sub
elif orig_res == '-':
(res_num, rep_res) = sub[1:].split('.')
res_num = pdb_num(res_num)
if res_num in insertions:
insertions[res_num][1] += rep_res
else:
insertions[res_num] = [orig_res, rep_res, -1, sub]
if 'H' in rep_res:
print 'Warning: the histidine insertion in %s will require adjustment to reflect its protonation.' % sub
else:
(res_num, rep_res) = sub[1:].split('.')
res_num = pdb_num(res_num)
if res_num in deletions:
deletions[res_num][1] += rep_res
else:
deletions[res_num] = [orig_res, rep_res, -1, sub]
if 'H' in rep_res:
print 'Warning: the histidine substitution in %s will require adjustment to reflect its protonation.' % sub
except:
print 'Format error in substitution %s' % sub
quit()
if args.restore_res:
print 'Restoring standard residue names.'
changes = {}
changes['HIE'] = 'HIS'
changes['HID'] = 'HIS'
changes['HIP'] = 'HIS'
changes['CYX'] = 'CYS'
reported = ''
index = -1
prev_chain = ''
prev_res = ''
sub_seq = ''
with open(args.pdbfile, "r") as f, open('restored.pdb', "w") as of:
for line in f:
if len(line) > 26 and line[:6] == 'ATOM ':
resnum = '%-4d%s' % (int(line[22:26]), line[26])
resname = line[17:20]
chain = line[21]
if chain != prev_chain and chain == args.chain:
index = 0
prev_chain = chain
if args.restore_res and resname in changes:
line = line.replace(resname, changes[resname])
if reported != resnum + chain:
print '%s %s %s -> %s' % (resnum, chain, resname, changes[resname])
reported = resnum + chain
if chain == args.chain and resnum != prev_res:
index += 1 # first residue has index 1
prev_res = resnum
if resnum in subs and subs[resnum][2] < 0:
if res_codes[resname] != subs[resnum][0]:
print 'Error: original residue %s does not match substitution code %s' % (resname, subs[resnum][3])
quit()
else:
sub_seq += subs[resnum][1]
subs[resnum][2] = index
else:
sub_seq += res_codes[resname]
if resnum in insertions:
insertions[resnum][2] = index
elif resnum in deletions:
deletions[resnum][2] = index
if res_codes[resname] != deletions[resnum][0]:
print 'Error: original residue %s does not match substitution code %s' % (resname, deletions[resnum][3])
quit()
of.write(line)
error = False
lowest_sub = 9999
highest_sub = 0
for s in(subs, insertions, deletions):
for k, sub in s.iteritems():
if sub[2] < 0:
print 'Residue %s:%s (required for substitution %s) was not found in the PDB file' % (args.chain, k, sub[3])
error = True
else:
lowest_sub = min(lowest_sub, sub[2])
highest_sub = max(highest_sub, sub[2])
if error:
quit()
e = environ()
e.libs.topology.read(file='$(LIB)/top_heav.lib')
e.libs.parameters.read(file='$(LIB)/par.lib')
m = complete_pdb(e, 'restored.pdb')
# If we don't save and re-read the model, the residue numbering does not get saved properly in the alignment file.
m.write('completed.pdb')
m = model(e, file=args.pdbfile, model_segment=('FIRST:' + args.chain, 'LAST:' + args.chain))
aln = alignment(e)
aln.append_model(m, align_codes='restored.pdb')
aln.append_sequence(sub_seq)
aln[1].code = 'sub'
aln.write(file='alignment.ali')
# Before we read things back in, fix up the alignment file for any insertions or deletions
if len(insertions) > 0 or len(deletions) > 0:
al_seqs = get_sequences('alignment.ali')
if len(deletions) > 0:
l = list(al_seqs[1])
for k,d in deletions.iteritems():
for i in range(len(d[1])):
l[d[2]-1+i] = d[1][i]
al_seqs[1] = "".join(l)
if len(insertions) > 0:
# Sort the insertions so that we start with the highest index - that way the indeces
# stay valid as the sequence length increases
sorted(insertions, key=lambda k: k[2])
# Insert the specified residue at the specified position in the sequence, return the updated sequence
def insert_seq(s, r, p):
seq = s[:p] + r + s[p:]
return seq
if len(al_seqs) != 2:
print 'Internal error: wrong number of sequences in alignment.ali'
quit()
for k,ins in insertions.iteritems():
al_seqs[0] = insert_seq(al_seqs[0], '-'*len(ins[1]), ins[2])
al_seqs[1] = insert_seq(al_seqs[1], ins[1], ins[2])
rep_sequences('alignment.ali', al_seqs)
startpos = max(lowest_sub - int(args.overlap), 0)
endpos = highest_sub + int(args.overlap)
if args.verbose:
log.verbose()
else:
log.minimal()
class MyModel(automodel):
def select_atoms(self):
s = selection(self.residue_range(startpos, min(endpos, len(self.residues) - 1)))
return s
class MyLoopModel(dopehr_loopmodel):
def select_atoms(self):
s = selection(self.residue_range(startpos, min(endpos, len(self.residues) - 1)))
return s
if loopmodels > 0:
a = MyLoopModel(e, alnfile='alignment.ali', knowns='restored.pdb', sequence='sub')
a.md_level = None
a.loop.starting_model = 1
a.loop.ending_model = loopmodels
else:
a = MyModel(e, alnfile='alignment.ali', knowns='restored.pdb', sequence='sub')
a.starting_model = 1
a.ending_model = int(args.models)
a.make()
bestmolpdf = 999999
bestpdfname = ''
outputs = a.outputs if loopmodels == 0 else a.loop.outputs
for output in outputs:
if output['failure'] is None:
if output['molpdf'] < bestmolpdf:
bestmolpdf = output['molpdf']
bestpdfname = output['name']
if bestpdfname == '':
print 'Error in modelling run: no modelled files produced.'
quit()
print 'Best modelled file is %s: objective function value %f' % (bestpdfname, bestmolpdf)
copyfile(bestpdfname, args.outfile)
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# read model file
mdl = complete_pdb(env, 'WTGFP.B99990005.pdb')
# Assess with DOPE:
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT',
file='WTGFP.profile',
normalize_profile=True,
smoothing_window=15)
import matplotlib.pyplot as plt
from modeller import *
from modeller.scripts import complete_pdb
template_pdb_id = '2a31'
pdb_lyst = (template_pdb_id, 'TMPRSS2_254.B99990001', 'TMPRSS2_254.B99990002',
'TMPRSS2_254.B99990003')
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
for fileName in pdb_lyst:
# read model file
mdl = complete_pdb(env, fileName + '.pdb')
# Assess with DOPE:
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT',
file=fileName + '.profile',
normalize_profile=True,
smoothing_window=15)
def r_enumerate(seq):
"""Enumerate a sequence in reverse order"""
# Note that we don't use reversed() since Python 2.3 doesn't have it
num = len(seq) - 1
while num >= 0:
yield num, seq[num]
num -= 1
## NON-BONDED ENERGY TERMS
#soft sphere potential
env.edat.dynamic_sphere=False #turn off the soft-sphere
#lennard-jones potential (more accurate)
env.edat.dynamic_lennard=True
env.edat.contact_shell = 4.0
env.edat.update_dynamic = 0.39
env.io.atom_files_directory = work_dir
env.libs.parameters.read(file='$(LIB)/par.lib')
env.libs.topology.read(file='$(LIB)/top_heav.lib')
mdl1= complete_pdb(env, './' + model_name + str(i) +'.pdb')
mdl=complete_pdb(env, './' + receptor + '.pdb')
print(mdl1.residues[0])
## DIHEDRAL ANGLES PREDICTED BY USE OF KNOWN TEMPLATE STRUCTURE (PREPARE ALIGNMENT FILE)
ali = alignment(env)
ali.append(file = alig,align_codes = 'all')
modelname = model_name + str(i) + '.pdb'
ali.append_model(mdl1, atom_files = modelname, align_codes = modelname)
## copy
ali.append_model(mdl1, align_codes = modelname)
## DIHEDRAL ANGLE RESTRAINTS (USE HOMOLOGS AND DIHEDRAL LIBRARY)
mdl1.env.edat.nonbonded_sel_atoms = 1 # selected region "feels" the rest of system through the non-bonded terms
sched = autosched.loop.make_for_model(mdl1)
env = environ()
env.io.atom_files_directory = ['../atom_files']
env.libs.topology.read(file='$(LIB)/top_heav.lib')
env.libs.parameters.read(file='$(LIB)/par.lib')
def patch_disulfides(mdl):
# Must patch disulfides here to calculate the non-bonded
# energy properly. Also, when you use hydrogens, disulfides
# must always be patched so that sulfhydril hydrogens are
# removed from the model.
for ids in [ ('17', '39'),
( '3', '22'),
('53', '59'),
('41', '52') ]:
mdl.patch(residue_type='DISU', residues=[mdl.residues[r] for r in ids])
mdl = complete_pdb(env, "1fas", patch_disulfides)
# Select all atoms
atmsel = selection(mdl)
mdl.restraints.make(atmsel, restraint_type='stereo', spline_on_site=False)
# Actually calculate the energy
(molpdf, terms) = atmsel.energy(edat=energy_data(dynamic_sphere=True))
# molpdf is the total 'energy', and terms contains the contributions from
# each physical type. Here we print out the bond length contribution:
print "Bond energy is %.3f" % terms[physical.bond]
def main(argv):
parser = argparse.ArgumentParser(description="Perform a substitution and find the best generated model of the chain, using Modeller")
parser.add_argument('pdbfile', help='input file (PDB)')
parser.add_argument('chain', help='chain')
parser.add_argument('subs', help='substitutions (residue, number, ..)')
parser.add_argument('overlap', help='number of overlap residues to remodel either side of substitutions')
parser.add_argument('models', help='number of models to build')
parser.add_argument('outfile', help='output file (PDB)')
parser.add_argument('-r', '--restore_res', help='restore Amber residue names to PDB defaults before running Modeller', action='store_true')
parser.add_argument('-v', '--verbose', help='verbose output', action='store_true')
args = parser.parse_args()
if len(args.chain) > 1:
print 'Error: chain must be a single letter'
quit()
subs = {}
for sub in args.subs.split(','):
try:
orig_res = sub[0]
rep_res = sub[-1:]
res_num = sub[1:-1]
res_letter = ' '
if not res_num[-1:].isdigit():
res_letter = res_num[-1:]
res_num = res_num[:-1]
res_num = '%-4d%s' % (int(res_num), res_letter)
subs[res_num] = [orig_res, rep_res, -1, sub]
if args.restore_res and rep_res == 'H':
print 'Warning: the histidine substitution in %s will require adjustment to reflect its protonation.' % sub
except:
print 'Format error in substitution %s' % sub
quit()
if args.restore_res:
print 'Restoring standard residue names.'
changes = {}
changes['HIE'] = 'HIS'
changes['HID'] = 'HIS'
changes['HIP'] = 'HIS'
changes['CYX'] = 'CYS'
reported = ''
index = -1
prev_chain = ''
prev_res = ''
sub_seq = ''
with open(args.pdbfile, "r") as f, open('restored.pdb', "w") as of:
for line in f:
if len(line) > 26 and line[:6] == 'ATOM ':
resnum = '%-4d%s' % (int(line[22:26]), line[26])
resname = line[17:20]
chain = line[21]
if chain != prev_chain and chain == args.chain:
index = 0
prev_chain = chain
if args.restore_res and resname in changes:
line = line.replace(resname, changes[resname])
if reported != resnum + chain:
print '%s %s %s -> %s' % (resnum, chain, resname, changes[resname])
reported = resnum + chain
if chain == args.chain and resnum != prev_res:
index += 1
prev_res = resnum
if resnum in subs and subs[resnum][2] < 0:
if res_codes[resname] != subs[resnum][0]:
print 'Error: original residue %s does not match substitution code %s' % (resname, subs[resnum][3])
sub_seq += res_codes[resname]
else:
sub_seq += subs[resnum][1]
subs[resnum][2] = index
else:
sub_seq += res_codes[resname]
of.write(line)
error = False
lowest_sub = 9999
highest_sub = 0
for k, sub in subs.iteritems():
if sub[2] < 0:
print 'Residue %s:%s (required for substitution %s) was not found in the PDB file' % (args.chain, k, sub[3])
error = True
else:
lowest_sub = min(lowest_sub, sub[2])
highest_sub = max(highest_sub, sub[2])
if error:
quit()
e = environ()
e.libs.topology.read(file='$(LIB)/top_heav.lib')
e.libs.parameters.read(file='$(LIB)/par.lib')
m = complete_pdb(e, 'restored.pdb')
# If we don't save and re-read the model, the residue numbering does not get saved properly in the alignment file.
m.write('completed.pdb')
m = model(e, file=args.pdbfile, model_segment=('FIRST:' + args.chain, 'LAST:' + args.chain))
aln = alignment(e)
aln.append_model(m, align_codes='restored.pdb')
aln.append_sequence(sub_seq)
aln[1].code = 'sub'
aln.write(file='alignment.ali')
startpos = max(lowest_sub - int(args.overlap), 0)
endpos = highest_sub + int(args.overlap)
if args.verbose:
log.verbose()
else:
log.minimal()
class MyModel(automodel):
def select_atoms(self):
s = selection(self.residue_range(startpos, min(endpos, len(self.residues) - 1)))
return s
a = MyModel(e, alnfile='alignment.ali', knowns='restored.pdb', sequence='sub')
a.starting_model = 1
a.ending_model = int(args.models)
a.make()
bestmolpdf = 999999
bestpdfname = ''
for output in a.outputs:
if output['failure'] is None:
if output['molpdf'] < bestmolpdf:
bestmolpdf = output['molpdf']
bestpdfname = output['name']
if bestpdfname == '':
print 'Error in modelling run: no modelled files produced.'
quit()
print 'Best modelled file is %s: objective function value %f' % (bestpdfname, bestmolpdf)
copyfile(bestpdfname, args.outfile)
"""
Produces a per-residue energy evaluation of the model(s).
"""
from __future__ import print_function
import argparse
import os
import sys
ap = argparse.ArgumentParser(description=__doc__)
ap.add_argument('pdb_f', nargs='+',
help='PDB file names')
cmd = ap.parse_args()
from modeller import *
from modeller.scripts import complete_pdb
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
for pdb in cmd.pdb_f:
# read model file
mdl = complete_pdb(env, pdb)
# Assess with DOPE:
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT', file=pdb[:-4]+'.dope_profile',
normalize_profile=True, smoothing_window=15)
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# read model file
mdl = complete_pdb(env, 'sequence.B99990001.pdb')
# Assess with DOPE:
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT', file='TvLDH.profile',
normalize_profile=True, smoothing_window=15)
from modeller import * from modeller.scripts import complete_pdb import sys #programa para gerar o valor de ga341 e dope a partir de arquivos.pdb gerados pela modelagem arqpdb = sys.argv[1] env = environ() env.libs.topology.read(file='$(LIB)/top_heav.lib') env.libs.parameters.read(file='$(LIB)/par.lib') # Read a model previously generated by Modeller's automodel class mdl = complete_pdb(env, arqpdb) # Set template-model sequence identity. (Not needed in this case, since # this is written by Modeller into the .pdb file.) mdl.seq_id = 37.037 score = mdl.assess_ga341() env = environ() env.libs.topology.read(file='$(LIB)/top_heav.lib') env.libs.parameters.read(file='$(LIB)/par.lib') # Read a model previously generated by Modeller's automodel class mdl = complete_pdb(env, arqpdb) zscore = mdl.assess_normalized_dope()
# This script illustrates the use of the swap_atoms_in_res # argument to the selection.superpose() command: # Need to make sure that the topologies of the two molecules # superposed are exactly the same: from modeller import * from modeller.scripts import complete_pdb env = environ() env.libs.topology.read(file='$(LIB)/top_heav.lib') env.libs.parameters.read(file='$(LIB)/par.lib') atfil = '../atom_files/pdb1fdn.ent' mdl = complete_pdb(env, atfil) aln = alignment(env) aln.append_model(mdl, align_codes='orig') mdl2 = model(env, file='1fdn.swap.atm') aln.append_model(mdl2, align_codes='swap') atmsel = selection(mdl) atmsel.superpose(mdl2, aln, swap_atoms_in_res='') atmsel.superpose(mdl2, aln, swap_atoms_in_res='DEFHLNQRVY', fit=False) atmsel.superpose(mdl2, aln, swap_atoms_in_res='', fit=True)
# Example for 'chain' objects
from modeller import *
from modeller.scripts import complete_pdb
env = environ()
env.io.atom_files_directory = ['../atom_files']
env.libs.topology.read(file='$(LIB)/top_heav.lib')
env.libs.parameters.read(file='$(LIB)/par.lib')
mdl = complete_pdb(env, "1b3q")
# Print existing chain IDs and lengths:
print "Chain IDs and lengths: ", [(c.name, len(c.residues))
for c in mdl.chains]
# Set new chain IDs:
mdl.chains['A'].name = 'X'
mdl.chains['B'].name = 'Y'
# Write out chain sequences:
for c in mdl.chains:
c.write(file='1b3q%s.chn' % c.name,
atom_file='1b3q',
align_code='1b3q%s' % c.name)
# best to create 'sp' just once and keep it around, since reading in the
# potential from disk can take a long time).
sp = soap_protein_od.Scorer()
# only calculate for single chains, because ga341 and dope only calculate first chains
models = ['model_dimer.pdb', 'model_locked_dimer.pdb', 'model_fragment_dimer.pdb']
templates = ['template_dimer_all.pdb', 'template_fragment_dimer_all.pdb']
files = models + templates
for f in files:
if (not os.path.isfile(f)):
continue
print("; FILE " + f)
# read model file
mdl = complete_pdb(env, f)
if mdl.seq_id < 0 or mdl.seq_id > 100:
mdl.seq_id = 100
# Assess all atoms with DOPE:
#s = selection(mdl)
#print("calling assess_ga341 mdl")
#score_ga341 = mdl.assess_ga341()
#print("; ENERGY assess_ga341 " + str(score_ga341))
#print("calling assess_normalized_dope mdl")
#score_normalized_dope = mdl.assess_normalized_dope()
#print("; ENERGY assess_normalized_dope " + str(score_normalized_dope))
for c in mdl.chains:
def main(argv):
#Get Inputs
if (len(argv) < 2):
print(
"Error! DOPE.py requires 2 arguments: <Output_File> , <IDs_File>")
sys.exit(2)
#Get the Results File Name
try:
input_file = os.environ.get(
'TOOLHOME') + "/Results/Step_" + argv[1] + ".txt"
output_file = os.environ.get('TOOLHOME') + "/Results/" + argv[0]
except TypeError:
print("TOOLHOME Environment not Set. Are you running Main.py?")
sys.exit(2)
#Get IDs & Models Folder Locations
try:
ids = open(input_file).read().split()
models_folder = ids[0]
ids = ids[1:]
except:
print("Specified <IDs_File> could not be located or is invalid")
sys.exit(2)
#Setup DOPE Environment
try:
#Setup Log
log.level(output=0, notes=0, warnings=0, errors=1, memory=0)
#Setup Environment
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib')
env.libs.parameters.read(file='$(LIB)/par.lib')
except:
print("Could not setup DOPE environment")
sys.exit(2)
#Open Output File
output = open(output_file, "w+")
output.write(models_folder + "\n")
#Save Previous Working Directory
previious_dir = os.getcwd()
#Change Current Working Directory
os.chdir(os.path.dirname(__file__))
#Display Progress
print("Extracting DOPE from \"" + "Step_" + argv[1] + ".txt\"")
#Iterate IDs
for id_num in ids:
#Get Model File
model_file = models_folder + "ID_" + id_num + ".pdb"
# Read a model previously generated by Modeller's automodel class
mdl = complete_pdb(env, model_file)
# Select all atoms in the first chain
atmsel = selection(mdl.chains[0])
#Calculate Dope Score
score = atmsel.assess_dope()
# Write Results
output.write(id_num + "\t" + str(score) + "\n")
# Finally...
output.close
#Return to Previous Working Directory
os.chdir(previious_dir)
# Example for: selection.rotate_dihedrals() from modeller import * from modeller.scripts import complete_pdb # This will optimize and randomize dihedrals in a MODEL env = environ() env.io.atom_files_directory = ['../atom_files'] env.libs.topology.read(file='$(LIB)/top_heav.lib') env.libs.parameters.read(file='$(LIB)/par.lib') # Select dihedral angle types for optimization and randomization: dih = 'phi psi omega chi1 chi2 chi3 chi4 chi5' # Read the sequence, get its topology and coordinates: mdl = complete_pdb(env, '1fas') # Select all atoms atmsel = selection(mdl) atmsel.rotate_dihedrals(change='RANDOMIZE', deviation=90.0, dihedrals=dih) mdl.write(file='1fas.ini1') # Get restraints from somewhere and optimize dihedrals: mdl.restraints.make(atmsel, restraint_type='stereo', spline_on_site=False) atmsel.rotate_dihedrals(change='OPTIMIZE', deviation=90.0, dihedrals=dih) mdl.write(file='1fas.ini2')
def modeller_funcs(pdb_file, options):
"""
This functions optimizes a protein structure saved in a pdb file.
It optimizes the stereochemistry of the given model including non-bonded contacts.
:param pdb_file: pdb file with the structure we want to optimize.
:return: returns a pdb file with optimized structure.
"""
env = environ()
env.io.atom_files_directory = ['../atom_files']
env.edat.dynamic_sphere = True
env.libs.topology.read(file='$(LIB)/top_heav.lib')
env.libs.parameters.read(file='$(LIB)/par.lib')
path, ext = pdb_file.split('.')
dir, code = path.split('/')
mdl = complete_pdb(env, pdb_file)
# mdl.write(file=code + '.ini')
# Select all atoms:
atmsel = selection(mdl)
# Calculate initial energy and energy profile for the built structure
mpdf_ini = atmsel.energy()
z_score_ini = mdl.assess_normalized_dope()
mdl_ep_ini = atmsel.get_dope_profile()
mdl_ep_ini_smoothed = mdl_ep_ini.get_smoothed(window=50)
energy_profile_txt_path = dir + '/' + code + '_DOPE_EnergyProfile.txt'
mdl_ep_ini_smoothed.write_to_file(energy_profile_txt_path)
print("\nModel energy")
print("The unoptimized model energy of " + code + " is: " + str(mpdf_ini[0]))
print("\nZ-score")
print("The unoptimized Z-score of " + code + " is: " + str(z_score_ini))
if options.optimize is None:
energy_profile_plot(options, path, energy_profile_txt_path)
else:
# Create optimizer objects and set defaults for all further optimizations
cg = conjugate_gradients(output='NO_REPORT')
# Open a file to get basic stats on each optimization
trcfil = open(dir + '/optimization_stats_' + code + '.txt', 'w')
# Run CG on the all-atom selection; write stats every 5 steps
cg.optimize(atmsel, max_iterations=20, actions=actions.trace(5, trcfil))
# Finish off with some more CG, and write stats every 5 steps
cg.optimize(atmsel, max_iterations=20,
actions=[actions.trace(5, trcfil)])
mpdf = atmsel.energy()
# Calculate the normalized Z-score for the model after optimization
z_score = mdl.assess_normalized_dope()
print("\nModel energy")
print("The final energy of " + code + " is: " + str(mpdf[0]))
print("\nZ-score")
print("The final z-score of " + code + " is: " + str(z_score))
# Getting the energy profile of our optimized model
mdl_ep_fin = atmsel.get_dope_profile()
# Smooth the energy profile by applying a smoothing window of 50
mdl_ep_fin_smoothed = mdl_ep_fin.get_smoothed(window=50)
energy_profile_txt_path_opt = path + '_optimized_DOPE_EnergyProfile.txt'
mdl_ep_fin_smoothed.write_to_file(energy_profile_txt_path_opt)
mdl.write(file=path + '_optimized.pdb')
energy_profile_plot(options, path, energy_profile_txt_path, energy_profile_txt_path_opt)
from modeller import *
from modeller.scripts import complete_pdb
from modeller.optimizers import molecular_dynamics, conjugate_gradients
from modeller.automodel import autosched
log.none()
env = environ()
env.libs.topology.read('${LIB}/top_heav.lib')
env.libs.parameters.read('${LIB}/par.lib')
env.edat.dynamic_sphere=False
env.edat.dynamic_lennard=True
env.edat.contact_shell = 4.0
env.edat.update_dynamic = 0.39
m = complete_pdb(env, inputs.pdbfile)
wildtype_dope_score = m.assess_normalized_dope()
headerline = str('Protein,DOPE Score\n')
wildtype_score = str('WT,') + str(wildtype_dope_score) + str('\n')
dopefile = open(dirname+'/DOPE_scores.txt',"w")
line = dopefile.write(str(headerline))
line = dopefile.write(str(wildtype_score))
dopefile.close()
m.write(file=dirname+'/'+PDB_FILE.replace('.pdb','_receptor.pdb'))
f = open(dirname+'/'+PDB_FILE.replace('.pdb','_receptor.pdb'))
lines = f.readlines()
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# read model file
mdl = complete_pdb(env, '1qg8_fill.BL00230001.pdb')
# Assess all atoms with DOPE:
s = selection(mdl)
s.assess_dope(output='ENERGY_PROFILE NO_REPORT', file='model23.profile',
normalize_profile=True, smoothing_window=15)
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# directories for input atom files
env.io.atom_files_directory = './:../atom_files'
# read model file
mdl = complete_pdb(env, 'qseq1_2.BL00090001.pdb')
s = selection(mdl)
s.assess_dope(output='ENERGY_PROFILE NO_REPORT',
file='qseq1_2.profile',
normalize_profile=True,
smoothing_window=15)
knowns='1iok', sequence='P0A6F5',
assess_methods=assess.DOPE)
a.starting_model = 1
a.ending_model = 10
a.make()
# Get a list of all successfully built models from a.outputs
ok_models = filter(lambda x: x['failure'] is None, a.outputs)
#truncated the models, as residues 524-548 were not covered by the template
truncated_models_fn=[]
full_model_norm_dope_scores=[]
for ok_model in ok_models:
mdl_fn=ok_model['name']
mdl = complete_pdb(env, mdl_fn)
full_model_norm_dope_scores.append(mdl.assess_normalized_dope())
sel=selection(mdl.residue_range(1,524))
truncated_fn=mdl_fn.split(".pdb")[0]+".truncated.pdb"
sel.write(truncated_fn)
truncated_models_fn.append(truncated_fn)
norm_dope_scores=[]
fitting_scores=[]
# score models by normalized dope
for mdl_fn in truncated_models_fn:
# Read a model previously generated by Modeller's automodel class
mdl = complete_pdb(env, mdl_fn)
norm_dope_scores.append(mdl.assess_normalized_dope())
# score models by em
a.starting_model = 1
a.ending_model = 5
a.make()
###################################################################################################
# Evaluate_Model.py
print(
"###################################################################################################"
)
print("# Evaluate_Model.py")
print(
"###################################################################################################"
)
from modeller import *
from modeller.scripts import complete_pdb
#log.verbose() # request verbose output
#env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# read model file
mdl = complete_pdb(env, selected_PDB + '.B99990002.pdb')
# Assess with DOPE:
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT',
file=selected_PDB + '.profile',
normalize_profile=True,
smoothing_window=15)
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = Environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# directories for input atom files
env.io.atom_files_directory = './:../atom_files'
# read model file
mdl = complete_pdb(env, '1bdm.pdb', model_segment=('FIRST:A', 'LAST:A'))
s = Selection(mdl)
s.assess_dope(output='ENERGY_PROFILE NO_REPORT',
file='1bdmA.profile',
normalize_profile=True,
smoothing_window=15)
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# directories for input atom files
env.io.atom_files_directory = './:../atom_files'
# read model file
mdl = complete_pdb(env, 'template1.pdb', model_segment=('FIRST:A', 'LAST:A'))
s = selection(mdl)
s.assess_dope(output='ENERGY_PROFILE NO_REPORT', file='template1.profile',
normalize_profile=True, smoothing_window=15)
if not os.path.isdir('models/'):
os.makedirs('models/')
env = environ()
env.edat.radii_factor = 0.95 # if having clashing problems increase this number at risk of bad angles
env.edat.dynamic_sphere= True
env.libs.topology.read('${LIB}/top_heav.lib')
env.libs.parameters.read('${LIB}/par.lib') #load parameters
env.io.atom_files_directory = ['.', '${LIB}/atom_files/']
log.none()
x = 0 # a counter that will be used for naming the models later
for mod in os.listdir(ctd_loc):
if mod.endswith(".pdb"):
mdl_n = complete_pdb(env, ctd_loc+mod)
mdl_n.write(file='CTD.pdb') # write a temporary pdb file to be used for modelling and aligment
mdl_ori = model(env)
aln_ori = alignment(env)
mdl_ori.build_sequence(BCAT_seq)
aln_ori.append_sequence(BCAT_seq) # original model with sequence of beta-catenin
aln_ori[0].code = 'BCAT'
aln_ori.write(file='alignments/BCAT.ali')
aln_final = alignment(env, file='alignments/BCAT.ali')
mdl_arm = model(env)
mdl_arm.read(file= known_mod)
aln_final.append_model(mdl_arm, align_codes=known_mod, atom_files=known_mod)
aln_final.salign(
gap_function=False,
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# read model file
mdl = complete_pdb(env, '6eqe.pdb')
# Assess with DOPE:
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT', file='templateDOPE.txt',
normalize_profile=True, smoothing_window=15)
from modeller import *
from modeller.scripts import complete_pdb
log.verbose()
env = environ()
env.libs.topology.read(file="$(LIB)/top_heav.lib")
env.libs.parameters.read(file="$(LIB)/par.lib")
aln = alignment(env)
mdl = model(env, file="1bdm", model_segment=("FIRST:A", "LAST:A"))
aln.append_model(mdl, align_codes="1bdmA", atom_files="1bdm.pdb")
for code in (("TvLDH.BL00080001"), ("TvLDH.B99990001")):
mdl = complete_pdb(env, code)
aln.append_model(mdl, atom_files=code, align_codes=code)
aln.align2d()
aln.write(file="TvLDH.BL00080001-1bdmA.ali", alignment_format="PIR")
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# read model file
mdl = complete_pdb(env, 'qseq1.B99990005.pdb')
# Assess with DOPE:
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT',
file='qseq1.profile',
normalize_profile=True,
smoothing_window=15)
from modeller import *
from modeller.scripts import complete_pdb
from modeller.optimizers import conjugate_gradients
env = environ()
env.io.atom_files_directory = ['../atom_files']
log.verbose()
env.libs.topology.read(file='$(LIB)/top_heav.lib')
env.libs.parameters.read(file='$(LIB)/par.lib')
# Read in the model
mdl = complete_pdb(env, "1fdn")
rsr = mdl.restraints
# Select all C-alpha atoms
allat = selection(mdl)
allca = allat.only_atom_types('CA')
# Create a pseudo atom that is the center of all C-alphas, and activate it
center = pseudo_atom.gravity_center(allca)
rsr.pseudo_atoms.append(center)
# Constrain every C-alpha to be no more than 10 angstroms from the center
for at in allca:
r = forms.upper_bound(group=physical.xy_distance,
feature=features.distance(at, center),
mean=10.0,
stdev=0.1)
rsr.add(r)
# Example for: model.assess_ga341() from modeller import * from modeller.scripts import complete_pdb env = environ() env.libs.topology.read(file='$(LIB)/top_heav.lib') env.libs.parameters.read(file='$(LIB)/par.lib') # Read a model previously generated by Modeller's automodel class mdl = complete_pdb(env, '../atom_files/1fdx.B99990001.pdb') # Set template-model sequence identity. (Not needed in this case, since # this is written by Modeller into the .pdb file.) mdl.seq_id = 37.037 score = mdl.assess_ga341()
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# directories for input atom files
env.io.atom_files_directory = './:../atom_files'
# read model file
mdl = complete_pdb(env, '1bdm.pdb', model_segment=('FIRST:A', 'LAST:A'))
s = selection(mdl)
s.assess_dope(output='ENERGY_PROFILE NO_REPORT', file='1bdmA.profile',
normalize_profile=True, smoothing_window=15)
def analyze_seq(description, seq):
"""Simple 'analysis' of a sequence of residues, from a model or alignment"""
numcys = 0
for res in seq:
if res.pdb_name == 'CYS':
numcys += 1
print "%s contains %d residues, of which %d are CYS" \
% (description, len(seq), numcys)
env = environ()
env.io.atom_files_directory = ['../atom_files']
env.libs.topology.read(file='$(LIB)/top_heav.lib')
env.libs.parameters.read(file='$(LIB)/par.lib')
mdl = complete_pdb(env, "1fas")
# 'mdl.residues' is a list of all residues in the model
print "1-letter code of 1st residue: ", mdl.residues[0].code
print "PDB name of residue '10': ", mdl.residues['10:'].pdb_name
# Get the first aligned sequence from a file
aln = alignment(env, file='../commands/toxin.ali')
firstseq = aln[0]
# Analyze all residues in the model, a subset, and all residues in the
# alignment sequence
analyze_seq("Model 1fas", mdl.residues)
analyze_seq("First 10 residues of 1fas", mdl.residue_range('1:', '10:'))
analyze_seq("Aligned sequence %s" % firstseq.code, firstseq.residues)
from modeller import *
from modeller.scripts import complete_pdb
log.verbose() # request verbose output
env = environ()
env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology
env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters
# read model file
mdl = complete_pdb(env, 'TvLDH.B99990002.pdb')
# Assess with DOPE:
s = selection(mdl) # all atom selection
s.assess_dope(output='ENERGY_PROFILE NO_REPORT', file='TvLDH.profile',
normalize_profile=True, smoothing_window=15)
gap_penalties_2d=(0.35, 1.2, 0.9, 1.2, 0.6, 8.6, 1.2, 0., 0.), similarity_flag=True) aln.write(file=protein_name+'-mult.ali', alignment_format='PIR') aln.write(file=protein_name+'-mult.pap', alignment_format='PAP') #model_mult.py env = environ() a = automodel(env, alnfile=protein_name+'-mult.ali', knowns=(next_best_name), sequence=protein_name) a.starting_model = 1 a.ending_model = 5 a.make() #evaluate_model.py log.verbose() # request verbose output env = environ() env.libs.topology.read(file='$(LIB)/top_heav.lib') # read topology env.libs.parameters.read(file='$(LIB)/par.lib') # read parameters # read model file mdl = complete_pdb(env, protein_name+'.B99990001.pdb') # Assess all atoms with DOPE: s = selection(mdl) s.assess_dope(output='ENERGY_PROFILE NO_REPORT', file=protein_name+'.profile', normalize_profile=True, smoothing_window=15) elif inact_struc != protein_name: continue else: continue
