def refine(self, atmsel, actions):
"""Refine the optimized model with MD and CG"""
# Save the current model:
if self.fit_in_refine != 'NO_FIT':
self.write(file='TO_BE_REFINED.TMP')
# Possibly skip selecting hot atoms only and optimize all atoms:
if self.refine_hot_only:
self.initial_refine_hot(atmsel)
# Do simulated annealing MD:
if self.md_level:
self.md_level(atmsel, actions)
# Possibly skip 'HOT CG' after MD:
if self.refine_hot_only:
self.final_refine_hot(atmsel)
# Get a final conjugate gradients refined structure:
cg = conjugate_gradients()
cg.optimize(atmsel,
max_iterations=200,
output=self.optimize_output,
actions=actions)
# Evaluate gross changes between the initial and final refined model:
if 'NO_FIT' not in self.fit_in_refine:
aln = alignment(self.env)
mdl2 = read_model(file='TO_BE_REFINED.TMP')
casel = selection(self).only_atom_types('CA')
casel.superpose(mdl2, aln)
casel = selection(self)
casel.superpose(mdl2, aln)
modfile.delete('TO_BE_REFINED.TMP')
def get_normalized_dope_profile(self):
"""Return a normalized DOPE per-residue profile"""
from modeller.selection import selection
from modeller import normalized_dope, physical
profile = selection(self).get_dope_profile()
scorer = normalized_dope.DOPEScorer(self)
return scorer.get_profile(profile)
def het_std_restraints(self, aln, selhet, ca_distance, bond_distance,
rsrgrp):
"""Constrain each atom in a HETATM or BLK residue by its distance to all
protein atoms within C{bond_distance} (these interactions are also
removed from the nonbonded list) and also to all protein CA atoms
that are within C{ca_distance}. The former maintains any
protein-HETATM bonding, and the latter maintains the residue in
roughly the right position."""
rsr = self.restraints
selstd = selection(self).only_std_residues()
selca = selstd.only_atom_types('CA')
print "%d atoms in HETATM/BLK residues constrained\n" % len(selhet) \
+ "to protein atoms within %.2f angstroms\n" % bond_distance \
+ "and protein CA atoms within %.2f angstroms" % ca_distance
# Build the bonds first; this avoids duplicated CA-ligand bonds since
# make_distance() will not build restraints that are already on the
# nonbond exclusion list
for (sel, dist, excl) in ((selstd, bond_distance, bond_distance),
(selca, ca_distance, 0.0)):
rsr.make_distance(sel,
selhet,
aln=aln,
distance_rsr_model=7,
maximal_distance=dist,
spline_on_site=self.spline_on_site,
restraint_group=rsrgrp,
restraint_stdev=(0.2, 0.0),
residue_span_range=(1, 99999),
residue_span_sign=False,
exclude_distance=excl)
def homcsr(self, exit_stage):
"""Construct the initial model and restraints"""
# Check the alignment
aln = self.read_alignment()
# Since in general we do not want to loose the original alignment file
# (which is usually not a temporary scratch file):
if self.accelrys:
# Accelrys code here (Azat, you may want to add the .tmp.ali part
# so that you do not change the input alignment file, unless you
# want to have it changed here for some other use elsewhere):
aln.write(file=self.alnfile) # file='.tmp.ali'
codes = [seq.code for seq in aln]
aln.read(file=self.alnfile, align_codes=codes)
# modfile.delete(file='.tmp.ali')
self.check_alignment(aln)
# make topology and build/read the atom coordinates:
self.make_initial_model(aln)
# exit early?
if exit_stage == 2:
return
# make and write the stereochemical, homology, and special restraints?
if self.create_restraints:
self.mkhomcsr(selection(self), aln)
self.restraints.condense()
self.restraints.write(self.csrfile)
def _unbuild_ring(r, atoms):
s = selection()
for a in atoms:
try:
s.add(r.atoms[a])
except KeyError:
continue
s.unbuild()
def _check_model_hetatm_water(self):
"""Check to see if env.io.hetatm or water are set if we're using
HETATMs or waters"""
if not self.env.io.hetatm or not self.env.io.water:
water = selection(self).only_water_residues()
# Note that het is always a superset of water
het = selection(self).only_het_residues() - water
warn = """You have at least one %s residue in your model, but
io_data.%s is False. (This means that Modeller will not read
any %s data from your templates, which is usually not what
you want. To fix this, set env.io.%s = True before creating
the automodel or loopmodel object.)"""
if len(water) > 0 and not self.env.io.water:
log.warning("_check_model_hetatm_water",
warn % ('water', 'water', 'water', 'water'))
if len(het) > 0 and not self.env.io.hetatm:
log.warning("_check_model_hetatm_water",
warn % ('HETATM', 'hetatm', 'HETATM', 'hetatm'))
def assess_normalized_dopehr(self):
"""Assess the model, and return a normalized DOPE-HR score (z score)"""
from modeller.selection import selection
import normalized_dope
sel = selection(self)
dope_score = sel.assess_dopehr()
scorer = normalized_dope.DOPEHRScorer(self)
z_score = scorer.get_z_score(dope_score)
print ">> Normalized DOPE-HR z score: %.3f" % z_score
return z_score
def nonstd_restraints(self, aln):
"""Create restraints on HETATM and BLK residues."""
# Select all HETATM residues plus any ATOM residues that have
# no defined topology (generally speaking, BLK residues)
allatoms = selection(self)
selhet = allatoms.only_het_residues() | allatoms.only_no_topology()
rsrgrp = physical.xy_distance
self.het_std_restraints(aln, selhet, 10.0, 2.3, rsrgrp)
self.het_het_restraints(aln, selhet, 7.0, 2.3, rsrgrp)
self.het_internal_restraints(aln, selhet, rsrgrp)
def fit(env, model, code, model2, code2, alnfile, model2_fit):
"""Superposes model2 on model, and writes out a file with model2 superposed
on model."""
m1 = modelobj(env, file=model)
m2 = modelobj(env, file=model2)
aln = alignment(env, file=alnfile, align_codes=(code, code2))
atmsel = selection(m1).only_atom_types('CA')
atmsel.superpose(m2, aln)
m2.write(file=model2_fit)
def get_normalized_dope_profile(self):
"""Return a normalized DOPE per-residue profile"""
from modeller.selection import selection
import normalized_dope
import physical
sel = selection(self)
edat = sel.get_dope_energy_data()
oldgprsr = self.group_restraints
self.group_restraints = sel.get_dope_potential()
try:
profile = sel.get_energy_profile(edat, physical.nonbond_spline)
finally:
self.group_restraints = oldgprsr
scorer = normalized_dope.DOPEScorer(self)
return scorer.get_profile(profile)
def select_sphere(self, radius):
"""Returns a selection of all atoms within the given distance"""
inds = _modeller.mod_selection_sphere(self.mdl.modpt, self.x, self.y,
self.z, radius)
return selection.selection(AtomIndices(inds, self.mdl))
def select_atoms(self):
"""Select atoms to be optimized in the model building procedure. By
default, this selects all atoms, but you can redefine this routine
to select a subset instead."""
return selection(self)