def COpseudodihedrals(protein):
for resid2 in protein:
res2 = protein[resid2] #residue n
gotall = False
if res2.prevres:
res1 = res2.prevres # n-1
if res2.nextres:
res3 = res2.nextres # n+1
if res3.nextres:
res4 = res3.nextres # n+2
gotall = True
if not gotall:
continue
CA_1, O_1 = res1.getatomxyz('CA'), res1.getatomxyz('O')
CA_2, O_2 = res2.getatomxyz('CA'), res2.getatomxyz('O')
CA_3, O_3 = res3.getatomxyz('CA'), res3.getatomxyz('O')
CA_4 = res4.getatomxyz('CA')
if None in [CA_1, CA_2, CA_3, CA_4, O_1, O_2, O_3]:
continue
pseudoC_1 = perptersect(CA_1, CA_2, O_1)
pseudoC_2 = perptersect(CA_2, CA_3, O_2)
pseudoC_3 = perptersect(CA_3, CA_4, O_3)
d_in = geometry_restraints.dihedral(
sites=[O_1, pseudoC_1, pseudoC_2, O_2], angle_ideal=-40, weight=1)
d_out = geometry_restraints.dihedral(
sites=[O_2, pseudoC_2, pseudoC_3, O_3], angle_ideal=-40, weight=1)
res2.measures['CO_d_in'] = d_in.angle_model
res2.measures['CO_d_out'] = d_out.angle_model
def ca_measures(protein):
for resid2 in protein:
res2 = protein[resid2] #residue n
gotall = False
if res2.prevres:
res1 = res2.prevres # n-1
if res1.prevres:
res0 = res1.prevres # n-2
if res2.nextres:
res3 = res2.nextres # n+1
if res3.nextres:
res4 = res3.nextres # n+2
gotall = True
if not gotall:
continue
CA_0 = res0.getatomxyz('CA')
CA_1 = res1.getatomxyz('CA')
CA_2 = res2.getatomxyz('CA')
CA_3 = res3.getatomxyz('CA')
CA_4 = res4.getatomxyz('CA')
if None in [CA_0,CA_1,CA_2,CA_3,CA_4]:
#getatomxyz returns either an xyz list (tuple?) or None
continue
d_in = geometry_restraints.dihedral(sites=[CA_0,CA_1,CA_2,CA_3],
angle_ideal=-40, weight=1)
d_out = geometry_restraints.dihedral(sites=[CA_1,CA_2,CA_3,CA_4],
angle_ideal=-40, weight=1)
a = geometry_restraints.angle(sites=[CA_1,CA_2,CA_3],
angle_ideal=120, weight=1)
res2.measures['CA_d_in'] = d_in.angle_model
res2.measures['CA_d_out'] = d_out.angle_model
res2.measures['CA_a'] = a.angle_model
def phipsi(protein):
for resid2 in protein:
res2 = protein[resid2] #residue n
gotall = False
if res2.prevres:
res1 = res2.prevres # n-1
if res2.nextres:
res3 = res2.nextres # n+1
gotall = True
if not gotall:
continue
CO_1 = res1.getatomxyz('C')
N_2 = res2.getatomxyz('N')
CA_2,C_2 = res2.getatomxyz('CA'),res2.getatomxyz('C')
N_3 = res3.getatomxyz('N')
if None in [CO_1,N_2,CA_2,C_2,N_3]:
continue
phi = geometry_restraints.dihedral(sites=[CO_1, N_2, CA_2, C_2],
angle_ideal=-40, weight=1)
psi = geometry_restraints.dihedral(sites=[N_2, CA_2, C_2, N_3],
angle_ideal=-40, weight=1)
res2.measures['phi'] = phi.angle_model
res2.measures['psi'] = psi.angle_model
res1.measures['phi+1'] = phi.angle_model
res3.measures['psi-1'] = psi.angle_model
def phipsi(protein):
for resid2 in protein:
res2 = protein[resid2] #residue n
gotall = False
if res2.prevres:
res1 = res2.prevres # n-1
if res2.nextres:
res3 = res2.nextres # n+1
gotall = True
if not gotall:
continue
CO_1 = res1.getatomxyz('C')
N_2 = res2.getatomxyz('N')
CA_2, C_2 = res2.getatomxyz('CA'), res2.getatomxyz('C')
N_3 = res3.getatomxyz('N')
if None in [CO_1, N_2, CA_2, C_2, N_3]:
continue
phi = geometry_restraints.dihedral(sites=[CO_1, N_2, CA_2, C_2],
angle_ideal=-40,
weight=1)
psi = geometry_restraints.dihedral(sites=[N_2, CA_2, C_2, N_3],
angle_ideal=-40,
weight=1)
res2.measures['phi'] = phi.angle_model
res2.measures['psi'] = psi.angle_model
res1.measures['phi+1'] = phi.angle_model
res3.measures['psi-1'] = psi.angle_model
def COpseudodihedrals(protein):
for resid2 in protein:
res2 = protein[resid2] #residue n
gotall = False
if res2.prevres:
res1 = res2.prevres # n-1
if res2.nextres:
res3 = res2.nextres # n+1
if res3.nextres:
res4 = res3.nextres # n+2
gotall = True
if not gotall:
continue
CA_1, O_1 = res1.getatomxyz('CA'),res1.getatomxyz('O')
CA_2, O_2 = res2.getatomxyz('CA'),res2.getatomxyz('O')
CA_3, O_3 = res3.getatomxyz('CA'),res3.getatomxyz('O')
CA_4 = res4.getatomxyz('CA')
if None in [CA_1,CA_2,CA_3,CA_4,O_1,O_2,O_3]:
continue
pseudoC_1 = perptersect(CA_1,CA_2,O_1)
pseudoC_2 = perptersect(CA_2,CA_3,O_2)
pseudoC_3 = perptersect(CA_3,CA_4,O_3)
d_in = geometry_restraints.dihedral(sites=[O_1, pseudoC_1, pseudoC_2, O_2],
angle_ideal=-40, weight=1)
d_out = geometry_restraints.dihedral(sites=[O_2, pseudoC_2, pseudoC_3, O_3],
angle_ideal=-40, weight=1)
res2.measures['CO_d_in'] = d_in.angle_model
res2.measures['CO_d_out'] = d_out.angle_model
def exercise_dihedral():
sites = [col(site) for site in [
(1,0,0), (0,0,0), (0,1,0), (1,0,1)]]
angle_ideal = -45
for flip in xrange(2):
if (flip != 0):
sites = [sites[i] for i in [0,2,1,3]]
angle_ideal *= -1
dih = geometry_restraints.dihedral(
sites=sites,
angle_ideal=angle_ideal,
weight=1)
assert approx_equal(dih.angle_ideal, angle_ideal)
assert approx_equal(dih.angle_model, angle_ideal)
assert approx_equal(dih.delta, 0)
for i_trial in xrange(20):
sites_mod = []
for site in sites:
shift = col([random.uniform(-.1,.1) for i in xrange(3)])
sites_mod.append(site+shift)
exercise_dihedral_core(
sites_mod, angle_ideal, angle_esd=1, periodicity=1, angle_model=None)
for sites,angle_ideal,angle_esd,period,angle_model in dihedral_test_data:
sites = [col(site) for site in sites]
exercise_dihedral_core(
sites, angle_ideal, angle_esd, period, angle_model)
def _get_dihedral(sites_cart, dihedral_proxies, i_proxy):
if i_proxy is not None:
# compute dihedral
dihedral = geometry_restraints.dihedral(
sites_cart=sites_cart, proxy=dihedral_proxies[i_proxy])
return dihedral
return None
def exercise_dihedral():
sites = [
col(site) for site in [(1, 0, 0), (0, 0, 0), (0, 1, 0), (1, 0, 1)]
]
angle_ideal = -45
for flip in range(2):
if (flip != 0):
sites = [sites[i] for i in [0, 2, 1, 3]]
angle_ideal *= -1
dih = geometry_restraints.dihedral(sites=sites,
angle_ideal=angle_ideal,
weight=1)
assert approx_equal(dih.angle_ideal, angle_ideal)
assert approx_equal(dih.angle_model, angle_ideal)
assert approx_equal(dih.delta, 0)
for i_trial in range(20):
sites_mod = []
for site in sites:
shift = col([random.uniform(-.1, .1) for i in range(3)])
sites_mod.append(site + shift)
exercise_dihedral_core(sites_mod,
angle_ideal,
angle_esd=1,
periodicity=1,
angle_model=None)
for sites, angle_ideal, angle_esd, period, angle_model in dihedral_test_data:
sites = [col(site) for site in sites]
exercise_dihedral_core(sites, angle_ideal, angle_esd, period,
angle_model)
def sample_density (self, i_res, verbose=False) :
import iotbx.pdb
get_class = iotbx.pdb.common_residue_names_get_class
residue_group = self.residue_groups[i_res]
conformers = residue_group.conformers()
results = []
for i_conf, conformer in enumerate(residue_group.conformers()) :
if (i_conf > 0) and (self.params.skip_alt_confs) :
continue
residue = conformer.only_residue()
if (get_class(residue.resname) == "common_amino_acid") :
n_chi = int(self.angle_lookup.chisPerAA.get(residue.resname.lower(),0))
if (n_chi == 0) : continue
res_out = ringer_residue(
#residue_id_str=residue.id_str(),
resname=residue.resname,
chain_id=residue_group.parent().id,
resid=residue.resid(),
altloc=conformer.altloc,
n_chi=n_chi)
if (verbose) :
print >> self.log, " %s:" % residue.id_str()
for i in range(1, n_chi+1) :
try :
atoms = self.angle_lookup.extract_chi_atoms("chi%d" % i, residue)
except AttributeError :
print >> "AttributeError"
pass
else :
# Skip a chi angle if it doesn't work.
try:
i_seqs = [ atom.i_seq for atom in atoms ]
sites_chi = [ self.sites_cart[i_seq] for i_seq in i_seqs ]
from cctbx.geometry_restraints import dihedral
chi = dihedral(
sites=sites_chi,
angle_ideal=0,
weight=0)
if (verbose) :
print >> self.log, " chi%d = %.1f" % (i, chi.angle_model)
densities = sample_angle(
i_seqs=i_seqs,
sites_cart=sites_chi,
map_coeffs=self.map_coeffs,
real_map=self.real_map,
unit_cell=self.unit_cell,
angle_start=chi.angle_model,
sigma=self.sigma,
params=self.params)
if (verbose) : pass
res_out.add_angle(
id=i,
angle_current=chi.angle_model,
densities=densities,
sampling=self.params.sampling_angle)
# This is a pretty bad way to deal with it but I don't want to stop
# the whole program because of a problem such as a missing atom...
except: print "Problem with ringing"
results.append(res_out)
return results
def CApseudos(protein, dodihedrals=True, doangles=True):
for resid2 in protein:
res2 = protein[resid2] #residue n
gotall = False
if res2.prevres:
res1 = res2.prevres # n-1
if res1.prevres:
res0 = res1.prevres # n-2
if res2.nextres:
res3 = res2.nextres # n+1
if res3.nextres:
res4 = res3.nextres # n+2
gotall = True
if not gotall:
continue
CA_0 = res0.getatomxyz('CA')
CA_1 = res1.getatomxyz('CA')
CA_2 = res2.getatomxyz('CA')
CA_3 = res3.getatomxyz('CA')
CA_4 = res4.getatomxyz('CA')
if None in [CA_0, CA_1, CA_2, CA_3, CA_4]:
continue
if dodihedrals:
d_in = geometry_restraints.dihedral(sites=[CA_0, CA_1, CA_2, CA_3],
angle_ideal=-40,
weight=1)
d_out = geometry_restraints.dihedral(
sites=[CA_1, CA_2, CA_3, CA_4], angle_ideal=-40, weight=1)
res2.measures['CA_d_in'] = d_in.angle_model
res2.measures['CA_d_out'] = d_out.angle_model
if doangles:
a_in = geometry_restraints.angle(sites=[CA_0, CA_1, CA_2],
angle_ideal=120,
weight=1)
a = geometry_restraints.angle(sites=[CA_1, CA_2, CA_3],
angle_ideal=120,
weight=1)
a_out = geometry_restraints.angle(sites=[CA_2, CA_3, CA_4],
angle_ideal=120,
weight=1)
res2.measures['CA_a_in'] = a_in.angle_model
res2.measures['CA_a'] = a.angle_model
res2.measures['CA_a_out'] = a_out.angle_model
def get_dihedral(four_atom_list):
from cctbx import geometry_restraints
if None in four_atom_list:
return None
return geometry_restraints.dihedral(
sites=[atom.xyz for atom in four_atom_list],
angle_ideal=-40,
weight=1).angle_model
def get_dihedral(four_atom_list):
from cctbx import geometry_restraints
if None in four_atom_list:
return None
return geometry_restraints.dihedral(
sites=[atom.xyz for atom in four_atom_list],
angle_ideal=-40,
weight=1).angle_model
def psi_from_sites(resN, resCA, resC, nextN):
from cctbx import geometry_restraints
b = geometry_restraints.bond(sites=[resC, nextN],
distance_ideal=1,
weight=1)
if (b.distance_model > 4): return None
d = geometry_restraints.dihedral(sites=[resN, resCA, resC, nextN],
angle_ideal=-40,
weight=1)
return d.angle_model
def CApseudos(protein, dodihedrals = True, doangles = True):
for resid2 in protein:
res2 = protein[resid2] #residue n
gotall = False
if res2.prevres:
res1 = res2.prevres # n-1
if res1.prevres:
res0 = res1.prevres # n-2
if res2.nextres:
res3 = res2.nextres # n+1
if res3.nextres:
res4 = res3.nextres # n+2
gotall = True
if not gotall:
continue
CA_0 = res0.getatomxyz('CA')
CA_1 = res1.getatomxyz('CA')
CA_2 = res2.getatomxyz('CA')
CA_3 = res3.getatomxyz('CA')
CA_4 = res4.getatomxyz('CA')
if None in [CA_0,CA_1,CA_2,CA_3,CA_4]:
continue
if dodihedrals:
d_in = geometry_restraints.dihedral(sites=[CA_0,CA_1,CA_2,CA_3],
angle_ideal=-40, weight=1)
d_out = geometry_restraints.dihedral(sites=[CA_1,CA_2,CA_3,CA_4],
angle_ideal=-40, weight=1)
res2.measures['CA_d_in'] = d_in.angle_model
res2.measures['CA_d_out'] = d_out.angle_model
if doangles:
a_in = geometry_restraints.angle(sites=[CA_0,CA_1,CA_2],
angle_ideal=120, weight=1)
a = geometry_restraints.angle(sites=[CA_1,CA_2,CA_3],
angle_ideal=120, weight=1)
a_out = geometry_restraints.angle(sites=[CA_2,CA_3,CA_4],
angle_ideal=120, weight=1)
res2.measures['CA_a_in'] = a_in.angle_model
res2.measures['CA_a'] = a.angle_model
res2.measures['CA_a_out'] = a_out.angle_model
def cablam_measures(protein):
for resid2 in protein:
res2 = protein[resid2] #residue n
gotall = False
if res2.prevres:
res1 = res2.prevres # n-1
if res1.prevres:
res0 = res1.prevres # n-2
if res2.nextres:
res3 = res2.nextres # n+1
if res3.nextres:
res4 = res3.nextres # n+2
gotall = True
if not gotall:
continue
CA_0 = res0.getatomxyz('CA')
CA_1, O_1 = res1.getatomxyz('CA'), res1.getatomxyz('O')
CA_2, O_2 = res2.getatomxyz('CA'), res2.getatomxyz('O')
CA_3 = res3.getatomxyz('CA')
CA_4 = res4.getatomxyz('CA')
if None in [CA_0, CA_1, CA_2, CA_3, CA_4, O_1, O_2]:
#getatomxyz returns either an xyz list (tuple?) or None
continue
d_in = geometry_restraints.dihedral(sites=[CA_0, CA_1, CA_2, CA_3],
angle_ideal=-40,
weight=1)
d_out = geometry_restraints.dihedral(sites=[CA_1, CA_2, CA_3, CA_4],
angle_ideal=-40,
weight=1)
pseudoC_1 = perptersect(CA_1, CA_2, O_1)
pseudoC_2 = perptersect(CA_2, CA_3, O_2)
co_in = geometry_restraints.dihedral(
sites=[O_1, pseudoC_1, pseudoC_2, O_2], angle_ideal=-40, weight=1)
ca_a = geometry_restraints.angle(sites=[CA_1, CA_2, CA_3],
angle_ideal=120,
weight=1)
res2.measures['CA_d_in'] = d_in.angle_model
res2.measures['CA_d_out'] = d_out.angle_model
res2.measures['CO_d_in'] = co_in.angle_model
res2.measures['CA_a'] = ca_a.angle_model
def phi_from_sites(prevC, resN, resCA, resC):
from cctbx import geometry_restraints
b = geometry_restraints.bond(sites=[prevC, resN],
distance_ideal=1,
weight=1)
# check to see if residues are actually bonded.
if (b.distance_model > 4): return None
d = geometry_restraints.dihedral(sites=[prevC, resN, resCA, resC],
angle_ideal=-40,
weight=1)
return d.angle_model
def psi_from_sites (resN, resCA, resC, nextN) :
from cctbx import geometry_restraints
b = geometry_restraints.bond(
sites=[resC,nextN],
distance_ideal=1,
weight=1)
if (b.distance_model > 4): return None
d = geometry_restraints.dihedral(
sites=[resN,resCA,resC,nextN],
angle_ideal=-40,
weight=1)
return d.angle_model
def sample_density (self, i_res, verbose=False) :
import iotbx.pdb
get_class = iotbx.pdb.common_residue_names_get_class
residue_group = self.residue_groups[i_res]
conformers = residue_group.conformers()
results = []
for i_conf, conformer in enumerate(residue_group.conformers()) :
if (i_conf > 0) and (self.params.skip_alt_confs) :
continue
residue = conformer.only_residue()
if (get_class(residue.resname) == "common_amino_acid") :
n_chi = int(self.angle_lookup.chisPerAA.get(residue.resname.lower(),0))
if (n_chi == 0) : continue
res_out = ringer_residue(
#residue_id_str=residue.id_str(),
resname=residue.resname,
chain_id=residue_group.parent().id,
resid=residue.resid(),
altloc=conformer.altloc,
n_chi=n_chi)
if (verbose) :
print >> self.log, " %s:" % residue.id_str()
for i in range(1, n_chi+1) :
try :
atoms = self.angle_lookup.extract_chi_atoms("chi%d" % i, residue)
except AttributeError :
pass
else :
i_seqs = [ atom.i_seq for atom in atoms ]
sites_chi = [ self.sites_cart[i_seq] for i_seq in i_seqs ]
from cctbx.geometry_restraints import dihedral
chi = dihedral(
sites=sites_chi,
angle_ideal=0,
weight=0)
if (verbose) :
print >> self.log, " chi%d = %.1f" % (i, chi.angle_model)
densities = sample_angle(
i_seqs=i_seqs,
sites_cart=sites_chi,
map_coeffs=self.map_coeffs,
real_map=self.real_map,
angle_start=chi.angle_model,
sigma=self.sigma,
params=self.params)
if (verbose) : pass
res_out.add_angle(
id=i,
angle_current=chi.angle_model,
densities=densities,
sampling=self.params.sampling_angle)
results.append(res_out)
return results
def phi_from_sites (prevC, resN, resCA, resC) :
from cctbx import geometry_restraints
b = geometry_restraints.bond(
sites=[prevC,resN],
distance_ideal=1,
weight=1)
# check to see if residues are actually bonded.
if (b.distance_model > 4): return None
d = geometry_restraints.dihedral(
sites=[prevC,resN,resCA,resC],
angle_ideal=-40,
weight=1)
return d.angle_model
def generate_torsion_restraints(
pdb_hierarchy,
sites_cart,
selection=None,
sigma=2.5,
limit=15.0,
chi_angles_only=False,
top_out_potential=False,
origin_id=None):
torsion_proxies = geometry_restraints.shared_dihedral_proxy()
if pdb_hierarchy.atoms_size() < 4:
return torsion_proxies
assert not pdb_hierarchy.atoms().extract_i_seq().all_eq(0)
bool_pdbh_selection = flex.bool(pdb_hierarchy.atoms_size(), False)
if (selection is not None):
if (isinstance(selection, flex.bool)):
bool_pdbh_selection = selection
elif (isinstance(selection, flex.size_t)):
bool_pdbh_selection.set_selected(selection, True)
if selection is None:
bool_pdbh_selection = flex.bool(pdb_hierarchy.atoms_size(), True)
actual_selection = bool_pdbh_selection.iselection()
assert len(sites_cart) == len(actual_selection)
weight = 1.0 / (sigma**2)
selection_to_sites_map = get_selection_to_sites_map(
sites_cart=sites_cart,
selection=actual_selection)
residue_torsions = collect_residue_torsion_angles(
pdb_hierarchy=pdb_hierarchy,
atom_selection=bool_pdbh_selection,
chi_angles_only=chi_angles_only)
for residue_info in residue_torsions:
for chi in residue_info.chis:
i_seqs = chi.i_seqs
sites = []
for i_seq in i_seqs:
sites.append(selection_to_sites_map[i_seq])
di = geometry_restraints.dihedral(
sites=sites, angle_ideal=0.0, weight=weight)
angle_ideal = di.angle_model
dp = geometry_restraints.dihedral_proxy(
i_seqs=i_seqs,
angle_ideal=angle_ideal,
weight=weight,
limit=limit,
top_out=top_out_potential,
origin_id=origin_id)
torsion_proxies.append(dp)
return torsion_proxies
def generate_torsion_restraints(
pdb_hierarchy,
sites_cart,
selection=None,
sigma=2.5,
limit=15.0,
chi_angles_only=False,
top_out_potential=False,
origin_id=2):
torsion_proxies = geometry_restraints.shared_dihedral_proxy()
if pdb_hierarchy.atoms().size() < 4:
return torsion_proxies
assert not pdb_hierarchy.atoms().extract_i_seq().all_eq(0)
bool_pdbh_selection = flex.bool(pdb_hierarchy.atoms_size(), False)
if (selection is not None):
if (isinstance(selection, flex.bool)):
bool_pdbh_selection = selection
elif (isinstance(selection, flex.size_t)):
bool_pdbh_selection.set_selected(selection, True)
if selection is None:
bool_pdbh_selection = flex.bool(pdb_hierarchy.atoms_size(), True)
actual_selection = bool_pdbh_selection.iselection()
assert len(sites_cart) == len(actual_selection)
weight = 1.0 / (sigma**2)
selection_to_sites_map = get_selection_to_sites_map(
sites_cart=sites_cart,
selection=actual_selection)
residue_torsions = collect_residue_torsion_angles(
pdb_hierarchy=pdb_hierarchy,
atom_selection=bool_pdbh_selection,
chi_angles_only=chi_angles_only)
for residue_info in residue_torsions:
for chi in residue_info.chis:
i_seqs = chi.i_seqs
sites = []
for i_seq in i_seqs:
sites.append(selection_to_sites_map[i_seq])
di = geometry_restraints.dihedral(
sites=sites, angle_ideal=0.0, weight=weight)
angle_ideal = di.angle_model
dp = geometry_restraints.dihedral_proxy(
i_seqs=i_seqs,
angle_ideal=angle_ideal,
weight=weight,
limit=limit,
top_out=top_out_potential,
origin_id=origin_id)
torsion_proxies.append(dp)
return torsion_proxies
def exercise_dihedral_core(sites, angle_ideal, angle_esd, periodicity,
angle_model):
assert periodicity > 0
for signed_periodicity in [periodicity, -periodicity]:
dih = geometry_restraints.dihedral(sites=sites,
angle_ideal=angle_ideal,
weight=1. / angle_esd**2,
periodicity=signed_periodicity)
if (angle_model is not None):
assert approx_equal(angle_model, dih.angle_model)
ag = flex.vec3_double(dih.gradients())
residual_obj = residual_functor(
restraint_type=geometry_restraints.dihedral,
angle_ideal=dih.angle_ideal,
weight=dih.weight,
periodicity=signed_periodicity)
fg = flex.vec3_double(finite_differences(sites,
residual_obj)).as_double()
ag = ag.as_double()
scale = max(1, flex.mean(flex.abs(fg)))
assert approx_equal(ag / scale, fg / scale)
def exercise_dihedral_core(sites, angle_ideal, angle_esd, periodicity,
angle_model):
assert periodicity > 0
for signed_periodicity in [periodicity, -periodicity]:
dih = geometry_restraints.dihedral(
sites=sites,
angle_ideal=angle_ideal,
weight=1./angle_esd**2,
periodicity=signed_periodicity)
if (angle_model is not None):
assert approx_equal(angle_model, dih.angle_model)
ag = flex.vec3_double(dih.gradients())
residual_obj = residual_functor(
restraint_type=geometry_restraints.dihedral,
angle_ideal=dih.angle_ideal,
weight=dih.weight,
periodicity=signed_periodicity)
fg = flex.vec3_double(finite_differences(sites, residual_obj)).as_double()
ag = ag.as_double()
scale = max(1, flex.mean(flex.abs(fg)))
assert approx_equal(ag/scale, fg/scale)
def dihedrals_as_cif_loop(xray_structure, proxies):
space_group_info = sgtbx.space_group_info(group=xray_structure.space_group())
unit_cell = xray_structure.unit_cell()
sites_cart = xray_structure.sites_cart()
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_torsion_atom_site_label_1",
"_restr_torsion_atom_site_label_2",
"_restr_torsion_atom_site_label_3",
"_restr_torsion_atom_site_label_4",
"_restr_torsion_site_symmetry_1",
"_restr_torsion_site_symmetry_2",
"_restr_torsion_site_symmetry_3",
"_restr_torsion_site_symmetry_4",
"_restr_torsion_angle_target",
"_restr_torsion_weight_param",
"_restr_torsion_diff",
))
unit_mxs = [sgtbx.rt_mx()]*4
for proxy in proxies:
restraint = geometry_restraints.dihedral(
unit_cell=unit_cell,
sites_cart=sites_cart,
proxy=proxy)
sym_ops = proxy.sym_ops
if sym_ops is None: sym_ops = unit_mxs
i_seqs = proxy.i_seqs
loop.add_row((site_labels[i_seqs[0]],
site_labels[i_seqs[1]],
site_labels[i_seqs[2]],
site_labels[i_seqs[3]],
space_group_info.cif_symmetry_code(sym_ops[0]),
space_group_info.cif_symmetry_code(sym_ops[1]),
space_group_info.cif_symmetry_code(sym_ops[2]),
space_group_info.cif_symmetry_code(sym_ops[3]),
fmt % restraint.angle_ideal,
fmt % math.sqrt(1/restraint.weight),
fmt % restraint.delta))
return loop
def dihedrals_as_cif_loop(xray_structure, proxies):
space_group_info = sgtbx.space_group_info(group=xray_structure.space_group())
unit_cell = xray_structure.unit_cell()
sites_cart = xray_structure.sites_cart()
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_torsion_atom_site_label_1",
"_restr_torsion_atom_site_label_2",
"_restr_torsion_atom_site_label_3",
"_restr_torsion_atom_site_label_4",
"_restr_torsion_site_symmetry_1",
"_restr_torsion_site_symmetry_2",
"_restr_torsion_site_symmetry_3",
"_restr_torsion_site_symmetry_4",
"_restr_torsion_angle_target",
"_restr_torsion_weight_param",
"_restr_torsion_diff",
))
unit_mxs = [sgtbx.rt_mx()]*4
for proxy in proxies:
restraint = geometry_restraints.dihedral(
unit_cell=unit_cell,
sites_cart=sites_cart,
proxy=proxy)
sym_ops = proxy.sym_ops
if sym_ops is None: sym_ops = unit_mxs
i_seqs = proxy.i_seqs
loop.add_row((site_labels[i_seqs[0]],
site_labels[i_seqs[1]],
site_labels[i_seqs[2]],
site_labels[i_seqs[3]],
space_group_info.cif_symmetry_code(sym_ops[0]),
space_group_info.cif_symmetry_code(sym_ops[1]),
space_group_info.cif_symmetry_code(sym_ops[2]),
space_group_info.cif_symmetry_code(sym_ops[3]),
fmt % restraint.angle_ideal,
fmt % math.sqrt(1/restraint.weight),
fmt % restraint.delta))
return loop
def omegacalc(protein):
for resid2 in protein:
res2 = protein[resid2]
gotall = False
if res2.prevres:
res1 = res2.prevres #n+1
gotall = True
if not gotall:
continue
CA = res1.getatomxyz('CA')
C = res1.getatomxyz('C')
N_2 = res2.getatomxyz('N')
CA_2= res2.getatomxyz('CA')
if None in [CA, C, N_2, CA_2]:
#print res2.resnum, CA, C, N_2, CA_2
continue
omega = geometry_restraints.dihedral(sites=[CA,C,N_2,CA_2],
angle_ideal=-40, weight=1)
res2.measures['omega'] = omega.angle_model
def omegacalc(protein):
for resid2 in protein:
res2 = protein[resid2]
gotall = False
if res2.prevres:
res1 = res2.prevres #n+1
gotall = True
if not gotall:
continue
CA = res1.getatomxyz('CA')
C = res1.getatomxyz('C')
N_2 = res2.getatomxyz('N')
CA_2 = res2.getatomxyz('CA')
if None in [CA, C, N_2, CA_2]:
#print res2.resnum, CA, C, N_2, CA_2
continue
omega = geometry_restraints.dihedral(sites=[CA, C, N_2, CA_2],
angle_ideal=-40,
weight=1)
res2.measures['omega'] = omega.angle_model
def __sample_density (self, i_res, verbose=False) :
import iotbx.pdb
get_class = iotbx.pdb.common_residue_names_get_class
residue_group = self.residue_groups[i_res]
conformers = residue_group.conformers()
results = []
for i_conf, conformer in enumerate(residue_group.conformers()) :
if (i_conf > 0) and (self.params.skip_alt_confs) :
continue
residue = conformer.only_residue()
if (get_class(residue.resname) == "common_amino_acid") :
n_chi = int(self.angle_lookup.chisPerAA.get(residue.resname.lower(),0))
if (n_chi == 0) : continue
xyz = None
for atom in residue.atoms() :
if (atom.name.strip() == "CA") :
xyz = atom.xyz
break
res_out = ringer_residue(
resname=residue.resname,
chain_id=residue_group.parent().id,
# resid=residue.resid(),
resid=residue.resseq_as_int(),
altloc=conformer.altloc,
n_chi=n_chi,
xyz=xyz)
if (verbose) :
print >> self.log, " %s:" % residue.id_str()
for i in range(1, min(self.n_chi_max+1, n_chi+1)) :
try :
atoms = self.angle_lookup.extract_chi_atoms("chi%d" % i, residue)
except AttributeError as e :
pass
else :
try :
if (atoms is None) :
break
i_seqs = [ atom.i_seq for atom in atoms ]
sites_chi = [ self.sites_cart[i_seq] for i_seq in i_seqs ]
from cctbx.geometry_restraints import dihedral
chi = dihedral(
sites=sites_chi,
angle_ideal=0,
weight=0)
if (verbose) :
print >> self.log, " chi%d = %.1f" % (i, chi.angle_model)
densities, fofc_densities = sample_angle(
i_seqs=i_seqs,
sites_cart=sites_chi,
map_coeffs=self.map_coeffs,
real_map=self.real_map,
difference_map=self.difference_map,
unit_cell=self.unit_cell,
angle_start=chi.angle_model,
sigma=self.sigma,
params=self.params,
sampling_method=self.sampling_method)
if (len(fofc_densities) == 0) :
fofc_densities = None
else :
assert (len(fofc_densities) == len(densities))
if (verbose) : pass
res_out.add_angle(
id=i,
angle_current=chi.angle_model,
densities=densities,
fofc_densities=fofc_densities,
sampling=self.params.sampling_angle)
except Exception as e :
pass
results.append(res_out)
return results
def exercise_chirality(verbose=0):
# monomer library: CA N CB C
sites = [
col(site)
for site in [(27.660, 9.903,
2.078), (28.049, 9.675,
3.486), (28.183, 11.269,
1.625), (28.085, 8.759, 1.165)]
]
chir = geometry_restraints.chirality(sites=sites,
volume_ideal=-2.48,
both_signs=False,
weight=1)
assert approx_equal(chir.volume_model, -2.411548478)
assert approx_equal(chir.residual(), 0.00468561086412)
dih = geometry_restraints.dihedral(sites=improper_permutation(sites),
angle_ideal=35.26439,
weight=1)
assert approx_equal(dih.angle_model, 32.2587249641)
assert approx_equal(dih.residual(), 9.03402230782)
if (verbose):
dump_pdb("sites.pdb", sites)
print("volume_ideal:", chir.volume_ideal)
print("volume_model:", chir.volume_model)
print("angle_ideal:", dih.angle_ideal)
print("angle model:", dih.angle_model)
for i_trial in range(50):
volume_ideal = chir.volume_ideal
for both_signs in [False, True]:
sites_mod = []
for site in sites:
shift = col([random.uniform(-.5, .5) for i in range(3)])
sites_mod.append(site + shift)
if (both_signs): volume_ideal = abs(volume_ideal)
c = geometry_restraints.chirality(sites=sites_mod,
volume_ideal=volume_ideal,
both_signs=both_signs,
weight=500 * 1 / 0.2**2)
residual_obj = residual_functor(
restraint_type=geometry_restraints.chirality,
volume_ideal=c.volume_ideal,
both_signs=c.both_signs,
weight=c.weight)
fg = flex.vec3_double(finite_differences(
sites_mod, residual_obj)).as_double()
ag = flex.vec3_double(c.gradients()).as_double()
scale = max(1, flex.mean(flex.abs(fg)))
assert approx_equal(ag / scale, fg / scale)
d = geometry_restraints.dihedral(
sites=improper_permutation(sites_mod),
angle_ideal=dih.angle_ideal,
weight=750)
ag_dih = dih.gradients()
if (verbose and i_trial == 0 and not both_signs):
dump_pdb("sites_mod.pdb", sites_mod)
max_g_len = 0
for g in ag_dih:
max_g_len = max(max_g_len, abs(col(g)))
for g in flex.vec3_double(fg):
max_g_len = max(max_g_len, abs(col(g)))
sticks = []
for site, g in zip(improper_permutation(sites_mod), ag_dih):
sticks.append(
pml_stick(begin=site,
end=site + col(g) / max_g_len,
colors=[[1, 0, 0]] * 2,
width=0.01))
pml_write(f=open("dih.pml", "w"), label="dih", sticks=sticks)
sticks = []
for site, g in zip(sites_mod, flex.vec3_double(fg)):
sticks.append(
pml_stick(begin=site,
end=site + col(g) / max_g_len,
colors=[[0, 1, 0]] * 2,
width=0.01))
pml_write(f=open("chir.pml", "w"), label="chir", sticks=sticks)
def ensemble_mean_geometry_stats(self,
restraints_manager,
xray_structure,
ensemble_xray_structures,
ignore_hd = True,
verbose = False,
out = None,
return_pdb_string = False):
if (out is None): out = sys.stdout
if verbose:
utils.print_header("Ensemble mean geometry statistics", out = out)
ensemble_size = len(ensemble_xray_structures)
print >> out, "Ensemble size : ", ensemble_size
# Dictionaries to store deltas
ensemble_bond_deltas = {}
ensemble_angle_deltas = {}
ensemble_chirality_deltas = {}
ensemble_planarity_deltas = {}
ensemble_dihedral_deltas = {}
# List to store rmsd of each model
structures_bond_rmsd = flex.double()
structures_angle_rmsd = flex.double()
structures_chirality_rmsd = flex.double()
structures_planarity_rmsd = flex.double()
structures_dihedral_rmsd = flex.double()
# Remove water and hd atoms from global restraints manager
selection = flex.bool()
for sc in xray_structure.scatterers():
if sc.label.find('HOH') > -1:
selection.append(True)
else:
selection.append(False)
if ignore_hd:
hd_selection = xray_structure.hd_selection()
assert hd_selection.size() == selection.size()
for n in xrange(hd_selection.size()):
if hd_selection[n] or selection[n]:
selection[n] = True
restraints_manager = restraints_manager.select(selection = ~selection)
# Get all deltas
for n, structure in enumerate(ensemble_xray_structures):
if verbose:
print >> out, "\nModel : ", n+1
sites_cart = structure.sites_cart()
# Remove water and hd atoms from individual structures sites cart
selection = flex.bool()
for sc in structure.scatterers():
if sc.label.find('HOH') > -1:
selection.append(True)
else:
selection.append(False)
if ignore_hd:
hd_selection = structure.hd_selection()
assert hd_selection.size() == selection.size()
for n in xrange(hd_selection.size()):
if hd_selection[n] or selection[n]:
selection[n] = True
sites_cart = sites_cart.select(~selection)
assert sites_cart is not None
site_labels = None
energies_sites = restraints_manager.energies_sites(
sites_cart = sites_cart,
compute_gradients = False)
# Rmsd of individual model
bond_rmsd = energies_sites.geometry.bond_deviations()[2]
angle_rmsd = energies_sites.geometry.angle_deviations()[2]
chirality_rmsd = energies_sites.geometry.chirality_deviations()[2]
planarity_rmsd = energies_sites.geometry.planarity_deviations()[2]
dihedral_rmsd = energies_sites.geometry.dihedral_deviations()[2]
structures_bond_rmsd.append(bond_rmsd)
structures_angle_rmsd.append(angle_rmsd)
structures_chirality_rmsd.append(chirality_rmsd)
structures_planarity_rmsd.append(planarity_rmsd)
structures_dihedral_rmsd.append(dihedral_rmsd)
if verbose:
print >> out, " Model RMSD"
print >> out, " bond : %.6g" % bond_rmsd
print >> out, " angle : %.6g" % angle_rmsd
print >> out, " chirality : %.6g" % chirality_rmsd
print >> out, " planarity : %.6g" % planarity_rmsd
print >> out, " dihedral : %.6g" % dihedral_rmsd
# Bond
pair_proxies = restraints_manager.geometry.pair_proxies(flags=None, sites_cart=sites_cart)
assert pair_proxies is not None
if verbose:
pair_proxies.bond_proxies.show_histogram_of_deltas(
sites_cart = sites_cart,
n_slots = 10,
f = out)
for proxy in pair_proxies.bond_proxies.simple:
bond_simple_proxy = geometry_restraints.bond(
sites_cart = sites_cart,
proxy = proxy)
if proxy.i_seqs in ensemble_bond_deltas:
ensemble_bond_deltas[proxy.i_seqs][0]+=bond_simple_proxy.delta
ensemble_bond_deltas[proxy.i_seqs][1]+=1
else:
ensemble_bond_deltas[proxy.i_seqs] = [bond_simple_proxy.delta, 1]
if verbose:
print >> out, "bond simple :", proxy.i_seqs
print >> out, " distance_ideal : %.6g" % proxy.distance_ideal
print >> out, " distance_model : %.6g" % bond_simple_proxy.distance_model
print >> out, " detla : %.6g" % bond_simple_proxy.delta
if (pair_proxies.bond_proxies.asu.size() > 0):
asu_mappings = pair_proxies.bond_proxies.asu_mappings()
for proxy in pair_proxies.bond_proxies.asu:
rt_mx = asu_mappings.get_rt_mx_ji(pair=proxy)
bond_asu_proxy = geometry_restraints.bond(
sites_cart = sites_cart,
asu_mappings = asu_mappings,
proxy = proxy)
proxy_i_seqs = (proxy.i_seq, proxy.j_seq)
if proxy_i_seqs in ensemble_bond_deltas:
ensemble_bond_deltas[proxy_i_seqs][0]+=bond_asu_proxy.delta
ensemble_bond_deltas[proxy_i_seqs][1]+=1
else:
ensemble_bond_deltas[proxy_i_seqs] = [bond_asu_proxy.delta, 1]
if verbose:
print >> out, "bond asu :", (proxy.i_seq, proxy.j_seq), rt_mx
print >> out, " distance_ideal : %.6g" % proxy.distance_ideal
print >> out, " distance_model : %.6g" % bond_asu_proxy.distance_model
print >> out, " delta : %.6g" % bond_asu_proxy.delta
# Angle
if verbose:
restraints_manager.geometry.angle_proxies.show_histogram_of_deltas(
sites_cart = sites_cart,
n_slots = 10,
f = out)
for proxy in restraints_manager.geometry.angle_proxies:
angle_proxy = geometry_restraints.angle(
sites_cart = sites_cart,
proxy = proxy)
if proxy.i_seqs in ensemble_angle_deltas:
ensemble_angle_deltas[proxy.i_seqs][0]+=angle_proxy.delta
ensemble_angle_deltas[proxy.i_seqs][1]+=1
else:
ensemble_angle_deltas[proxy.i_seqs] = [angle_proxy.delta, 1]
if verbose:
print >> out, "angle : ", proxy.i_seqs
print >> out, " angle_ideal : %.6g" % proxy.angle_ideal
print >> out, " angle_model : %.6g" % angle_proxy.angle_model
print >> out, " delta : %.6g" % angle_proxy.delta
# Chirality
if verbose:
restraints_manager.geometry.chirality_proxies.show_histogram_of_deltas(
sites_cart = sites_cart,
n_slots = 10,
f = out)
for proxy in restraints_manager.geometry.chirality_proxies:
chirality_proxy = geometry_restraints.chirality(
sites_cart = sites_cart,
proxy = proxy)
if proxy.i_seqs in ensemble_chirality_deltas:
ensemble_chirality_deltas[proxy.i_seqs][0]+=chirality_proxy.delta
ensemble_chirality_deltas[proxy.i_seqs][1]+=1
else:
ensemble_chirality_deltas[proxy.i_seqs] = [chirality_proxy.delta, 1]
if verbose:
print >> out, "chirality : ", proxy.i_seqs
print >> out, " chirality_ideal : %.6g" % proxy.volume_ideal
print >> out, " chirality_model : %.6g" % chirality_proxy.volume_model
print >> out, " chirality : %.6g" % chirality_proxy.delta
# Planarity
for proxy in restraints_manager.geometry.planarity_proxies:
planarity_proxy = geometry_restraints.planarity(
sites_cart = sites_cart,
proxy = proxy)
proxy_i_seqs = []
for i_seq in proxy.i_seqs:
proxy_i_seqs.append(i_seq)
proxy_i_seqs = tuple(proxy_i_seqs)
if proxy_i_seqs in ensemble_planarity_deltas:
ensemble_planarity_deltas[proxy_i_seqs][0]+=planarity_proxy.rms_deltas()
ensemble_planarity_deltas[proxy_i_seqs][1]+=1
else:
ensemble_planarity_deltas[proxy_i_seqs] = [planarity_proxy.rms_deltas(), 1]
if verbose:
print >> out, "planarity : ", proxy_i_seqs
print >> out, " planarity rms_deltas : %.6g" % planarity_proxy.rms_deltas()
# Dihedral
if verbose:
restraints_manager.geometry.dihedral_proxies.show_histogram_of_deltas(
sites_cart = sites_cart,
n_slots = 10,
f = out)
for proxy in restraints_manager.geometry.dihedral_proxies:
dihedral_proxy = geometry_restraints.dihedral(
sites_cart = sites_cart,
proxy = proxy)
if proxy.i_seqs in ensemble_dihedral_deltas:
ensemble_dihedral_deltas[proxy.i_seqs][0]+=dihedral_proxy.delta
ensemble_dihedral_deltas[proxy.i_seqs][1]+=1
else:
ensemble_dihedral_deltas[proxy.i_seqs] = [dihedral_proxy.delta, 1]
if verbose:
print >> out, "dihedral : ", proxy.i_seqs
print >> out, " dihedral_ideal : %.6g" % proxy.angle_ideal
print >> out, " periodicity : %.6g" % proxy.periodicity
print >> out, " dihedral_model : %.6g" % dihedral_proxy.angle_model
print >> out, " delta : %.6g" % dihedral_proxy.delta
# Calculate RMSDs for ensemble model
# Bond
mean_bond_delta = flex.double()
for proxy, info in ensemble_bond_deltas.iteritems():
assert info[1] == ensemble_size
mean_delta = info[0] / info[1]
mean_bond_delta.append(mean_delta)
bond_delta_sq = mean_bond_delta * mean_bond_delta
ensemble_bond_rmsd = math.sqrt(flex.mean_default(bond_delta_sq, 0))
# Angle
mean_angle_delta = flex.double()
for proxy, info in ensemble_angle_deltas.iteritems():
assert info[1] == ensemble_size
mean_delta = info[0] / info[1]
mean_angle_delta.append(mean_delta)
angle_delta_sq = mean_angle_delta * mean_angle_delta
ensemble_angle_rmsd = math.sqrt(flex.mean_default(angle_delta_sq, 0))
# Chirality
mean_chirality_delta = flex.double()
for proxy, info in ensemble_chirality_deltas.iteritems():
assert info[1] == ensemble_size
mean_delta = info[0] / info[1]
mean_chirality_delta.append(mean_delta)
chirality_delta_sq = mean_chirality_delta * mean_chirality_delta
ensemble_chirality_rmsd = math.sqrt(flex.mean_default(chirality_delta_sq, 0))
# Planarity
mean_planarity_delta = flex.double()
for proxy, info in ensemble_planarity_deltas.iteritems():
assert info[1] == ensemble_size
mean_delta = info[0] / info[1]
mean_planarity_delta.append(mean_delta)
planarity_delta_sq = mean_planarity_delta * mean_planarity_delta
ensemble_planarity_rmsd = math.sqrt(flex.mean_default(planarity_delta_sq, 0))
# Dihedral
mean_dihedral_delta = flex.double()
for proxy, info in ensemble_dihedral_deltas.iteritems():
assert info[1] == ensemble_size
mean_delta = info[0] / info[1]
mean_dihedral_delta.append(mean_delta)
dihedral_delta_sq = mean_dihedral_delta * mean_dihedral_delta
ensemble_dihedral_rmsd = math.sqrt(flex.mean_default(dihedral_delta_sq, 0))
# Calculate <structure rmsd>
assert ensemble_size == structures_bond_rmsd
assert ensemble_size == structures_angle_rmsd
assert ensemble_size == structures_chirality_rmsd
assert ensemble_size == structures_planarity_rmsd
assert ensemble_size == structures_dihedral_rmsd
structure_bond_rmsd_mean = structures_bond_rmsd.min_max_mean().mean
structure_angle_rmsd_mean = structures_angle_rmsd.min_max_mean().mean
structure_chirality_rmsd_mean = structures_chirality_rmsd.min_max_mean().mean
structure_planarity_rmsd_mean = structures_planarity_rmsd.min_max_mean().mean
structure_dihedral_rmsd_mean = structures_dihedral_rmsd.min_max_mean().mean
# Show summary
utils.print_header("Ensemble RMSD summary", out = out)
print >> out, " RMSD (mean delta per restraint)"
print >> out, " bond : %.6g" % ensemble_bond_rmsd
print >> out, " angle : %.6g" % ensemble_angle_rmsd
print >> out, " chirality : %.6g" % ensemble_chirality_rmsd
print >> out, " planarity : %.6g" % ensemble_planarity_rmsd
print >> out, " dihedral : %.6g" % ensemble_dihedral_rmsd
print >> out, " RMSD (mean RMSD per structure)"
print >> out, " bond : %.6g" % structure_bond_rmsd_mean
print >> out, " angle : %.6g" % structure_angle_rmsd_mean
print >> out, " chirality : %.6g" % structure_chirality_rmsd_mean
print >> out, " planarity : %.6g" % structure_planarity_rmsd_mean
print >> out, " dihedral : %.6g" % structure_dihedral_rmsd_mean
if ignore_hd:
print >> out, "\n Calculated excluding H/D"
else:
print >> out, "\n Calculated including H/D"
if return_pdb_string:
ens_geo_pdb_string = "REMARK 3"
ens_geo_pdb_string += "\nREMARK 3 NUMBER STRUCTURES IN ENSEMBLE : {0:5d}".format(ensemble_size)
if ignore_hd:
ens_geo_pdb_string += "\nREMARK 3 RMS DEVIATIONS FROM IDEAL VALUES (EXCLUDING H/D)"
else:
ens_geo_pdb_string += "\nREMARK 3 RMS DEVIATIONS FROM IDEAL VALUES (INCLUDING H/D)"
ens_geo_pdb_string += "\nREMARK 3 RMSD (MEAN DELTA PER RESTRAINT)"
ens_geo_pdb_string += "\nREMARK 3 BOND : {0:5.3f}".format(ensemble_bond_rmsd)
ens_geo_pdb_string += "\nREMARK 3 ANGLE : {0:5.3f}".format(ensemble_angle_rmsd)
ens_geo_pdb_string += "\nREMARK 3 CHIRALITY : {0:5.3f}".format(ensemble_chirality_rmsd)
ens_geo_pdb_string += "\nREMARK 3 PLANARITY : {0:5.3f}".format(ensemble_planarity_rmsd)
ens_geo_pdb_string += "\nREMARK 3 DIHEDRAL : {0:5.2f}".format(ensemble_dihedral_rmsd)
ens_geo_pdb_string += "\nREMARK 3 RMSD (MEAN RMSD PER STRUCTURE)"
ens_geo_pdb_string += "\nREMARK 3 BOND : {0:5.3f}".format(structure_bond_rmsd_mean)
ens_geo_pdb_string += "\nREMARK 3 ANGLE : {0:5.3f}".format(structure_angle_rmsd_mean)
ens_geo_pdb_string += "\nREMARK 3 CHIRALITY : {0:5.3f}".format(structure_chirality_rmsd_mean)
ens_geo_pdb_string += "\nREMARK 3 PLANARITY : {0:5.3f}".format(structure_planarity_rmsd_mean)
ens_geo_pdb_string += "\nREMARK 3 DIHEDRAL : {0:5.2f}".format(structure_dihedral_rmsd_mean)
ens_geo_pdb_string += "\nREMARK 3"
return ens_geo_pdb_string
def get_rna_backbone_dihedrals (processed_pdb_file,
geometry=None, pdb_hierarchy=None):
# at present, this will only return measurements for angles arising from
# atoms with altloc ' ' or altloc 'A'
# TO-DO: extend to more alternates JJH 140108
from cctbx import geometry_restraints
bb_dihedrals = defaultdict(dict)
formatted_out = []
alt_tracker = {}
if (processed_pdb_file is not None) :
sites_cart = processed_pdb_file.all_chain_proxies.sites_cart
geometry = processed_pdb_file.geometry_restraints_manager()
pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy
else :
assert (not None in [geometry, pdb_hierarchy])
sites_cart = pdb_hierarchy.atoms().extract_xyz()
dihedral_proxies = geometry.dihedral_proxies
i_seq_name_hash = build_name_hash(pdb_hierarchy=pdb_hierarchy)
def is_blank_or_alt_a(proxy):
for i in proxy.i_seqs:
alt = i_seq_name_hash[i][4:5]
if alt not in [' ', 'A']:
return False
return True
for dp in dihedral_proxies:
atoms = []
debug_key = ""
invert_sign = False
dp.sort_i_seqs()
for i in dp.i_seqs:
atoms.append(i_seq_name_hash[i][0:4].strip())
debug_key = debug_key+i_seq_name_hash[i]
if len(atoms) != 4:
continue
name = match_dihedral_to_name(atoms=atoms)
#handle dihedral equivalences
if name == None:
inverted_atoms = get_inverted_atoms(atoms=atoms, improper=False)
name = match_dihedral_to_name(atoms=inverted_atoms)
if name == None:
inverted_atoms = get_inverted_atoms(atoms=atoms, improper=True)
name = match_dihedral_to_name(atoms=inverted_atoms)
if name is not None:
invert_sign = True
if (name is not None) and (is_blank_or_alt_a(dp)):
restraint = geometry_restraints.dihedral(
sites_cart=sites_cart,
proxy=dp)
key = i_seq_name_hash[dp.i_seqs[1]][4:]
if alt_tracker.get(key[1:]) is None:
alt_tracker[key[1:]] = []
if key[0:1] not in alt_tracker[key[1:]]:
alt_tracker[key[1:]].append(key[0:1])
bb_dihedrals[key][name] = restraint.angle_model
if invert_sign:
bb_dihedrals[key][name] = bb_dihedrals[key][name] * -1.0
for key in bb_dihedrals.keys():
altloc = key[0:1]
resname = key[1:4]
chainID = key[4:6]
resnum = key[6:10]
i_code = key[10:]
if 'A' in alt_tracker[key[1:]]:
if altloc != 'A':
continue
if bb_dihedrals[key].get('alpha') is not None:
alpha = "%.3f" % bb_dihedrals[key]['alpha']
# FIXME will the lookup below ever actually work?
elif altloc == 'A' and \
bb_dihedrals[' '+key[1:]].get('alpha') is not None:
alpha = "%.3f" % bb_dihedrals[' '+key[1:]]['alpha']
else:
alpha = '__?__'
if bb_dihedrals[key].get('beta') is not None:
beta = "%.3f" % bb_dihedrals[key]['beta']
elif altloc == 'A' and \
bb_dihedrals[' '+key[1:]].get('beta') is not None:
beta = "%.3f" % bb_dihedrals[' '+key[1:]]['beta']
else:
beta = '__?__'
if bb_dihedrals[key].get('gamma') is not None:
gamma = "%.3f" % bb_dihedrals[key]['gamma']
elif altloc == 'A' and \
bb_dihedrals[' '+key[1:]].get('gamma') is not None:
gamma = "%.3f" % bb_dihedrals[' '+key[1:]]['gamma']
else:
gamma = '__?__'
if bb_dihedrals[key].get('delta'):
delta = "%.3f" % bb_dihedrals[key]['delta']
elif altloc == 'A' and \
bb_dihedrals[' '+key[1:]].get('delta') is not None:
delta = "%.3f" % bb_dihedrals[' '+key[1:]]['delta']
else:
delta = '__?__'
if bb_dihedrals[key].get('epsilon'):
epsilon = "%.3f" % bb_dihedrals[key]['epsilon']
elif altloc == 'A' and \
bb_dihedrals[' '+key[1:]].get('epsilon') is not None:
epsilon = "%.3f" % bb_dihedrals[' '+key[1:]]['epsilon']
else:
epsilon = '__?__'
if bb_dihedrals[key].get('zeta'):
zeta = "%.3f" % bb_dihedrals[key]['zeta']
elif altloc == 'A' and \
bb_dihedrals[' '+key[1:]].get('zeta') is not None:
zeta = "%.3f" % bb_dihedrals[' '+key[1:]]['zeta']
else:
zeta = '__?__'
eval = "%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s" \
% (" ",
"1",
chainID,
resnum,
i_code,
altloc,
resname,
alpha,
beta,
gamma,
delta,
epsilon,
zeta)
formatted_out.append(eval)
formatted_out.sort()
backbone_dihedrals = ""
for line in formatted_out:
backbone_dihedrals += line+'\n'
return backbone_dihedrals
def adiabatic_mapping (pdb_hierarchy,
restraints_manager,
start_coords,
end_coords,
params,
nsteps=10,
verbose=False,
out=None) :
"""
Linear interpolation with energy minimization. The number of minimizer
cycles should be kept low to prevent each "frame" from snapping back to the
starting coordinates. Interpolating the dihedral restraint target angles
may help remediate this problem.
"""
from mmtbx.refinement import geometry_minimization
from cctbx import geometry_restraints
import scitbx.lbfgs
if (start_coords.size() != end_coords.size()) :
raise RuntimeError("Coordinate size mismatch: %d versus %d" %
(start_coords.size(), end_coords.size()))
grm = restraints_manager
include_dihedrals = (params.interpolate_dihedrals or
(not params.exclude_dihedrals))
grm_flags = geometry_restraints.flags.flags(
default=True,
dihedral=include_dihedrals)
term_params = scitbx.lbfgs.termination_parameters(
max_iterations=params.n_min_steps)
dihedral_steps = []
n = nsteps - 1
if (params.interpolate_dihedrals) :
# FIXME this needs work - should find the optimal path instead of the
# simplistic assumption currently made
for proxy in grm.dihedral_proxies :
sites1 = []
sites2 = []
for k in range(4) :
sites1.append(start_coords[proxy.i_seqs[k]])
sites2.append(end_coords[proxy.i_seqs[k]])
dihe_start = geometry_restraints.dihedral(
sites=sites1,
angle_ideal=0,
weight=1).angle_model
dihe_end = geometry_restraints.dihedral(
sites=sites2,
angle_ideal=0,
weight=1).angle_model
delta = (dihe_end - dihe_start) / n
dihedral_steps.append(delta)
proxy.weight = 0.1
m = morph(pdb_hierarchy)
m.add_frame(start_coords)
current_xyz = start_coords
final_xyz = end_coords
while n > 0 :
print >> out, "Interpolation step %d" % (nsteps - n)
if (verbose) :
print >> out, ""
new_xyz = current_xyz.deep_copy()
dxyz = (final_xyz - new_xyz) * (1. / n)
new_xyz += dxyz
if (params.minimize) :
if (params.interpolate_dihedrals) :
for k, proxy in enumerate(grm.dihedral_proxies) :
proxy.angle_ideal += dihedral_steps[k]
minimized = geometry_minimization.lbfgs(
sites_cart=new_xyz,
geometry_restraints_manager=grm,
geometry_restraints_flags=grm_flags,
lbfgs_termination_params=term_params)
if (verbose) :
n_iter = minimized.minimizer.iter()
print >> out, ""
print >> out, "Number of minimization iterations:", n_iter
print >> out, ""
print >> out, "Energies at end of minimization:"
minimized.final_target_result.show(f=out)
print >> out, "RMS coordinate change: %.3f" % current_xyz.rms_difference(new_xyz)
m.add_frame(new_xyz)
n -= 1
current_xyz = new_xyz
m.add_frame(final_xyz)
return m
def ensemble_mean_geometry_stats(self,
restraints_manager,
xray_structure,
ensemble_xray_structures,
ignore_hd = True,
verbose = False,
out = None,
return_pdb_string = False):
if (out is None): out = sys.stdout
if verbose:
utils.print_header("Ensemble mean geometry statistics", out = out)
ensemble_size = len(ensemble_xray_structures)
print("Ensemble size : ", ensemble_size, file=out)
# Dictionaries to store deltas
ensemble_bond_deltas = {}
ensemble_angle_deltas = {}
ensemble_chirality_deltas = {}
ensemble_planarity_deltas = {}
ensemble_dihedral_deltas = {}
# List to store rmsd of each model
structures_bond_rmsd = flex.double()
structures_angle_rmsd = flex.double()
structures_chirality_rmsd = flex.double()
structures_planarity_rmsd = flex.double()
structures_dihedral_rmsd = flex.double()
# Remove water and hd atoms from global restraints manager
selection = flex.bool()
for sc in xray_structure.scatterers():
if sc.label.find('HOH') > -1:
selection.append(True)
else:
selection.append(False)
if ignore_hd:
hd_selection = xray_structure.hd_selection()
assert hd_selection.size() == selection.size()
for n in range(hd_selection.size()):
if hd_selection[n] or selection[n]:
selection[n] = True
restraints_manager = restraints_manager.select(selection = ~selection)
# Get all deltas
for n, structure in enumerate(ensemble_xray_structures):
if verbose:
print("\nModel : ", n+1, file=out)
sites_cart = structure.sites_cart()
# Remove water and hd atoms from individual structures sites cart
selection = flex.bool()
for sc in structure.scatterers():
if sc.label.find('HOH') > -1:
selection.append(True)
else:
selection.append(False)
if ignore_hd:
hd_selection = structure.hd_selection()
assert hd_selection.size() == selection.size()
for n in range(hd_selection.size()):
if hd_selection[n] or selection[n]:
selection[n] = True
sites_cart = sites_cart.select(~selection)
assert sites_cart is not None
site_labels = None
energies_sites = restraints_manager.energies_sites(
sites_cart = sites_cart,
compute_gradients = False)
# Rmsd of individual model
bond_rmsd = energies_sites.geometry.bond_deviations()[2]
angle_rmsd = energies_sites.geometry.angle_deviations()[2]
chirality_rmsd = energies_sites.geometry.chirality_deviations()[2]
planarity_rmsd = energies_sites.geometry.planarity_deviations()[2]
dihedral_rmsd = energies_sites.geometry.dihedral_deviations()[2]
structures_bond_rmsd.append(bond_rmsd)
structures_angle_rmsd.append(angle_rmsd)
structures_chirality_rmsd.append(chirality_rmsd)
structures_planarity_rmsd.append(planarity_rmsd)
structures_dihedral_rmsd.append(dihedral_rmsd)
if verbose:
print(" Model RMSD", file=out)
print(" bond : %.6g" % bond_rmsd, file=out)
print(" angle : %.6g" % angle_rmsd, file=out)
print(" chirality : %.6g" % chirality_rmsd, file=out)
print(" planarity : %.6g" % planarity_rmsd, file=out)
print(" dihedral : %.6g" % dihedral_rmsd, file=out)
# Bond
pair_proxies = restraints_manager.geometry.pair_proxies(flags=None, sites_cart=sites_cart)
assert pair_proxies is not None
if verbose:
pair_proxies.bond_proxies.show_histogram_of_deltas(
sites_cart = sites_cart,
n_slots = 10,
f = out)
for proxy in pair_proxies.bond_proxies.simple:
bond_simple_proxy = geometry_restraints.bond(
sites_cart = sites_cart,
proxy = proxy)
if proxy.i_seqs in ensemble_bond_deltas:
ensemble_bond_deltas[proxy.i_seqs][0]+=bond_simple_proxy.delta
ensemble_bond_deltas[proxy.i_seqs][1]+=1
else:
ensemble_bond_deltas[proxy.i_seqs] = [bond_simple_proxy.delta, 1]
if verbose:
print("bond simple :", proxy.i_seqs, file=out)
print(" distance_ideal : %.6g" % proxy.distance_ideal, file=out)
print(" distance_model : %.6g" % bond_simple_proxy.distance_model, file=out)
print(" detla : %.6g" % bond_simple_proxy.delta, file=out)
if (pair_proxies.bond_proxies.asu.size() > 0):
asu_mappings = pair_proxies.bond_proxies.asu_mappings()
for proxy in pair_proxies.bond_proxies.asu:
rt_mx = asu_mappings.get_rt_mx_ji(pair=proxy)
bond_asu_proxy = geometry_restraints.bond(
sites_cart = sites_cart,
asu_mappings = asu_mappings,
proxy = proxy)
proxy_i_seqs = (proxy.i_seq, proxy.j_seq)
if proxy_i_seqs in ensemble_bond_deltas:
ensemble_bond_deltas[proxy_i_seqs][0]+=bond_asu_proxy.delta
ensemble_bond_deltas[proxy_i_seqs][1]+=1
else:
ensemble_bond_deltas[proxy_i_seqs] = [bond_asu_proxy.delta, 1]
if verbose:
print("bond asu :", (proxy.i_seq, proxy.j_seq), rt_mx, file=out)
print(" distance_ideal : %.6g" % proxy.distance_ideal, file=out)
print(" distance_model : %.6g" % bond_asu_proxy.distance_model, file=out)
print(" delta : %.6g" % bond_asu_proxy.delta, file=out)
# Angle
if verbose:
restraints_manager.geometry.angle_proxies.show_histogram_of_deltas(
sites_cart = sites_cart,
n_slots = 10,
f = out)
for proxy in restraints_manager.geometry.angle_proxies:
angle_proxy = geometry_restraints.angle(
sites_cart = sites_cart,
proxy = proxy)
if proxy.i_seqs in ensemble_angle_deltas:
ensemble_angle_deltas[proxy.i_seqs][0]+=angle_proxy.delta
ensemble_angle_deltas[proxy.i_seqs][1]+=1
else:
ensemble_angle_deltas[proxy.i_seqs] = [angle_proxy.delta, 1]
if verbose:
print("angle : ", proxy.i_seqs, file=out)
print(" angle_ideal : %.6g" % proxy.angle_ideal, file=out)
print(" angle_model : %.6g" % angle_proxy.angle_model, file=out)
print(" delta : %.6g" % angle_proxy.delta, file=out)
# Chirality
if verbose:
restraints_manager.geometry.chirality_proxies.show_histogram_of_deltas(
sites_cart = sites_cart,
n_slots = 10,
f = out)
for proxy in restraints_manager.geometry.chirality_proxies:
chirality_proxy = geometry_restraints.chirality(
sites_cart = sites_cart,
proxy = proxy)
if proxy.i_seqs in ensemble_chirality_deltas:
ensemble_chirality_deltas[proxy.i_seqs][0]+=chirality_proxy.delta
ensemble_chirality_deltas[proxy.i_seqs][1]+=1
else:
ensemble_chirality_deltas[proxy.i_seqs] = [chirality_proxy.delta, 1]
if verbose:
print("chirality : ", proxy.i_seqs, file=out)
print(" chirality_ideal : %.6g" % proxy.volume_ideal, file=out)
print(" chirality_model : %.6g" % chirality_proxy.volume_model, file=out)
print(" chirality : %.6g" % chirality_proxy.delta, file=out)
# Planarity
for proxy in restraints_manager.geometry.planarity_proxies:
planarity_proxy = geometry_restraints.planarity(
sites_cart = sites_cart,
proxy = proxy)
proxy_i_seqs = []
for i_seq in proxy.i_seqs:
proxy_i_seqs.append(i_seq)
proxy_i_seqs = tuple(proxy_i_seqs)
if proxy_i_seqs in ensemble_planarity_deltas:
ensemble_planarity_deltas[proxy_i_seqs][0]+=planarity_proxy.rms_deltas()
ensemble_planarity_deltas[proxy_i_seqs][1]+=1
else:
ensemble_planarity_deltas[proxy_i_seqs] = [planarity_proxy.rms_deltas(), 1]
if verbose:
print("planarity : ", proxy_i_seqs, file=out)
print(" planarity rms_deltas : %.6g" % planarity_proxy.rms_deltas(), file=out)
# Dihedral
if verbose:
restraints_manager.geometry.dihedral_proxies.show_histogram_of_deltas(
sites_cart = sites_cart,
n_slots = 10,
f = out)
for proxy in restraints_manager.geometry.dihedral_proxies:
dihedral_proxy = geometry_restraints.dihedral(
sites_cart = sites_cart,
proxy = proxy)
if proxy.i_seqs in ensemble_dihedral_deltas:
ensemble_dihedral_deltas[proxy.i_seqs][0]+=dihedral_proxy.delta
ensemble_dihedral_deltas[proxy.i_seqs][1]+=1
else:
ensemble_dihedral_deltas[proxy.i_seqs] = [dihedral_proxy.delta, 1]
if verbose:
print("dihedral : ", proxy.i_seqs, file=out)
print(" dihedral_ideal : %.6g" % proxy.angle_ideal, file=out)
print(" periodicity : %.6g" % proxy.periodicity, file=out)
print(" dihedral_model : %.6g" % dihedral_proxy.angle_model, file=out)
print(" delta : %.6g" % dihedral_proxy.delta, file=out)
# Calculate RMSDs for ensemble model
# Bond
mean_bond_delta = flex.double()
for proxy, info in six.iteritems(ensemble_bond_deltas):
# assert info[1] == ensemble_size
if info[1]!=ensemble_size:
print('skipping bond RMSD calns of ensemble %s' % info, file=out)
continue
mean_delta = info[0] / info[1]
mean_bond_delta.append(mean_delta)
bond_delta_sq = mean_bond_delta * mean_bond_delta
ensemble_bond_rmsd = math.sqrt(flex.mean_default(bond_delta_sq, 0))
# Angle
mean_angle_delta = flex.double()
for proxy, info in six.iteritems(ensemble_angle_deltas):
assert info[1] == ensemble_size
mean_delta = info[0] / info[1]
mean_angle_delta.append(mean_delta)
angle_delta_sq = mean_angle_delta * mean_angle_delta
ensemble_angle_rmsd = math.sqrt(flex.mean_default(angle_delta_sq, 0))
# Chirality
mean_chirality_delta = flex.double()
for proxy, info in six.iteritems(ensemble_chirality_deltas):
assert info[1] == ensemble_size
mean_delta = info[0] / info[1]
mean_chirality_delta.append(mean_delta)
chirality_delta_sq = mean_chirality_delta * mean_chirality_delta
ensemble_chirality_rmsd = math.sqrt(flex.mean_default(chirality_delta_sq, 0))
# Planarity
mean_planarity_delta = flex.double()
for proxy, info in six.iteritems(ensemble_planarity_deltas):
assert info[1] == ensemble_size
mean_delta = info[0] / info[1]
mean_planarity_delta.append(mean_delta)
planarity_delta_sq = mean_planarity_delta * mean_planarity_delta
ensemble_planarity_rmsd = math.sqrt(flex.mean_default(planarity_delta_sq, 0))
# Dihedral
mean_dihedral_delta = flex.double()
for proxy, info in six.iteritems(ensemble_dihedral_deltas):
assert info[1] == ensemble_size
mean_delta = info[0] / info[1]
mean_dihedral_delta.append(mean_delta)
dihedral_delta_sq = mean_dihedral_delta * mean_dihedral_delta
ensemble_dihedral_rmsd = math.sqrt(flex.mean_default(dihedral_delta_sq, 0))
# Calculate <structure rmsd>
assert ensemble_size == structures_bond_rmsd
assert ensemble_size == structures_angle_rmsd
assert ensemble_size == structures_chirality_rmsd
assert ensemble_size == structures_planarity_rmsd
assert ensemble_size == structures_dihedral_rmsd
structure_bond_rmsd_mean = structures_bond_rmsd.min_max_mean().mean
structure_angle_rmsd_mean = structures_angle_rmsd.min_max_mean().mean
structure_chirality_rmsd_mean = structures_chirality_rmsd.min_max_mean().mean
structure_planarity_rmsd_mean = structures_planarity_rmsd.min_max_mean().mean
structure_dihedral_rmsd_mean = structures_dihedral_rmsd.min_max_mean().mean
# Show summary
utils.print_header("Ensemble RMSD summary", out = out)
print(" RMSD (mean delta per restraint)", file=out)
print(" bond : %.6g" % ensemble_bond_rmsd, file=out)
print(" angle : %.6g" % ensemble_angle_rmsd, file=out)
print(" chirality : %.6g" % ensemble_chirality_rmsd, file=out)
print(" planarity : %.6g" % ensemble_planarity_rmsd, file=out)
print(" dihedral : %.6g" % ensemble_dihedral_rmsd, file=out)
print(" RMSD (mean RMSD per structure)", file=out)
print(" bond : %.6g" % structure_bond_rmsd_mean, file=out)
print(" angle : %.6g" % structure_angle_rmsd_mean, file=out)
print(" chirality : %.6g" % structure_chirality_rmsd_mean, file=out)
print(" planarity : %.6g" % structure_planarity_rmsd_mean, file=out)
print(" dihedral : %.6g" % structure_dihedral_rmsd_mean, file=out)
if ignore_hd:
print("\n Calculated excluding H/D", file=out)
else:
print("\n Calculated including H/D", file=out)
if return_pdb_string:
ens_geo_pdb_string = "REMARK 3"
ens_geo_pdb_string += "\nREMARK 3 NUMBER STRUCTURES IN ENSEMBLE : {0:5d}".format(ensemble_size)
if ignore_hd:
ens_geo_pdb_string += "\nREMARK 3 RMS DEVIATIONS FROM IDEAL VALUES (EXCLUDING H/D)"
else:
ens_geo_pdb_string += "\nREMARK 3 RMS DEVIATIONS FROM IDEAL VALUES (INCLUDING H/D)"
ens_geo_pdb_string += "\nREMARK 3 RMSD (MEAN DELTA PER RESTRAINT)"
ens_geo_pdb_string += "\nREMARK 3 BOND : {0:5.3f}".format(ensemble_bond_rmsd)
ens_geo_pdb_string += "\nREMARK 3 ANGLE : {0:5.3f}".format(ensemble_angle_rmsd)
ens_geo_pdb_string += "\nREMARK 3 CHIRALITY : {0:5.3f}".format(ensemble_chirality_rmsd)
ens_geo_pdb_string += "\nREMARK 3 PLANARITY : {0:5.3f}".format(ensemble_planarity_rmsd)
ens_geo_pdb_string += "\nREMARK 3 DIHEDRAL : {0:5.2f}".format(ensemble_dihedral_rmsd)
ens_geo_pdb_string += "\nREMARK 3 RMSD (MEAN RMSD PER STRUCTURE)"
ens_geo_pdb_string += "\nREMARK 3 BOND : {0:5.3f}".format(structure_bond_rmsd_mean)
ens_geo_pdb_string += "\nREMARK 3 ANGLE : {0:5.3f}".format(structure_angle_rmsd_mean)
ens_geo_pdb_string += "\nREMARK 3 CHIRALITY : {0:5.3f}".format(structure_chirality_rmsd_mean)
ens_geo_pdb_string += "\nREMARK 3 PLANARITY : {0:5.3f}".format(structure_planarity_rmsd_mean)
ens_geo_pdb_string += "\nREMARK 3 DIHEDRAL : {0:5.2f}".format(structure_dihedral_rmsd_mean)
ens_geo_pdb_string += "\nREMARK 3"
return ens_geo_pdb_string
def _get_dihedral(sites_cart, dihedral_proxies, i_proxy):
if i_proxy is not None:
# compute dihedral
dihedral = geometry_restraints.dihedral(sites_cart=sites_cart, proxy=dihedral_proxies[i_proxy])
return dihedral
return None
def get_rna_backbone_dihedrals(processed_pdb_file,
geometry=None,
pdb_hierarchy=None):
# at present, this will only return measurements for angles arising from
# atoms with altloc ' ' or altloc 'A'
# TO-DO: extend to more alternates JJH 140108
from cctbx import geometry_restraints
bb_dihedrals = defaultdict(dict)
formatted_out = []
alt_tracker = {}
if (processed_pdb_file is not None):
sites_cart = processed_pdb_file.all_chain_proxies.sites_cart
geometry = processed_pdb_file.geometry_restraints_manager()
pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy
else:
assert (not None in [geometry, pdb_hierarchy])
sites_cart = pdb_hierarchy.atoms().extract_xyz()
dihedral_proxies = geometry.dihedral_proxies
i_seq_name_hash = build_name_hash(pdb_hierarchy=pdb_hierarchy)
def is_blank_or_alt_a(proxy):
for i in proxy.i_seqs:
alt = i_seq_name_hash[i][4:5]
if alt not in [' ', 'A']:
return False
return True
for dp in dihedral_proxies:
atoms = []
debug_key = ""
invert_sign = False
dp.sort_i_seqs()
for i in dp.i_seqs:
atoms.append(i_seq_name_hash[i][0:4].strip())
debug_key = debug_key + i_seq_name_hash[i]
if len(atoms) != 4:
continue
name = match_dihedral_to_name(atoms=atoms)
#handle dihedral equivalences
if name == None:
inverted_atoms = get_inverted_atoms(atoms=atoms, improper=False)
name = match_dihedral_to_name(atoms=inverted_atoms)
if name == None:
inverted_atoms = get_inverted_atoms(atoms=atoms, improper=True)
name = match_dihedral_to_name(atoms=inverted_atoms)
if name is not None:
invert_sign = True
if (name is not None) and (is_blank_or_alt_a(dp)):
restraint = geometry_restraints.dihedral(sites_cart=sites_cart,
proxy=dp)
key = i_seq_name_hash[dp.i_seqs[1]][4:]
if alt_tracker.get(key[1:]) is None:
alt_tracker[key[1:]] = []
if key[0:1] not in alt_tracker[key[1:]]:
alt_tracker[key[1:]].append(key[0:1])
bb_dihedrals[key][name] = restraint.angle_model
if invert_sign:
bb_dihedrals[key][name] = bb_dihedrals[key][name] * -1.0
for key in list(bb_dihedrals.keys()):
altloc = key[0:1]
resname = key[1:4]
chainID = key[4:6]
resnum = key[6:10]
i_code = key[10:]
if 'A' in alt_tracker[key[1:]]:
if altloc != 'A':
continue
if bb_dihedrals[key].get('alpha') is not None:
alpha = "%.3f" % bb_dihedrals[key]['alpha']
# FIXME will the lookup below ever actually work?
elif altloc == 'A' and \
bb_dihedrals[' '+key[1:]].get('alpha') is not None:
alpha = "%.3f" % bb_dihedrals[' ' + key[1:]]['alpha']
else:
alpha = '__?__'
if bb_dihedrals[key].get('beta') is not None:
beta = "%.3f" % bb_dihedrals[key]['beta']
elif altloc == 'A' and \
bb_dihedrals[' '+key[1:]].get('beta') is not None:
beta = "%.3f" % bb_dihedrals[' ' + key[1:]]['beta']
else:
beta = '__?__'
if bb_dihedrals[key].get('gamma') is not None:
gamma = "%.3f" % bb_dihedrals[key]['gamma']
elif altloc == 'A' and \
bb_dihedrals[' '+key[1:]].get('gamma') is not None:
gamma = "%.3f" % bb_dihedrals[' ' + key[1:]]['gamma']
else:
gamma = '__?__'
if bb_dihedrals[key].get('delta'):
delta = "%.3f" % bb_dihedrals[key]['delta']
elif altloc == 'A' and \
bb_dihedrals[' '+key[1:]].get('delta') is not None:
delta = "%.3f" % bb_dihedrals[' ' + key[1:]]['delta']
else:
delta = '__?__'
if bb_dihedrals[key].get('epsilon'):
epsilon = "%.3f" % bb_dihedrals[key]['epsilon']
elif altloc == 'A' and \
bb_dihedrals[' '+key[1:]].get('epsilon') is not None:
epsilon = "%.3f" % bb_dihedrals[' ' + key[1:]]['epsilon']
else:
epsilon = '__?__'
if bb_dihedrals[key].get('zeta'):
zeta = "%.3f" % bb_dihedrals[key]['zeta']
elif altloc == 'A' and \
bb_dihedrals[' '+key[1:]].get('zeta') is not None:
zeta = "%.3f" % bb_dihedrals[' ' + key[1:]]['zeta']
else:
zeta = '__?__'
eval = "%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s" \
% (" ",
"1",
chainID,
resnum,
i_code,
altloc,
resname,
alpha,
beta,
gamma,
delta,
epsilon,
zeta)
formatted_out.append(eval)
formatted_out.sort()
backbone_dihedrals = ""
for line in formatted_out:
backbone_dihedrals += line + '\n'
return backbone_dihedrals
def ca_dock(move_coords, resnum_to_dock="0"):
#atoms_to_dock = get_atoms_to_flip(ag, resname, dock_atoms)
#move_coords = {}
#for atomname in dockatomlist:
# move_coords[atomname] = [all_atoms_to_dock[resnum_to_dock+atomname][0], all_atoms_to_dock[resnum_to_dock+atomname][1], all_atoms_to_dock[resnum_to_dock+atomname][2]]
#print("move_coords, pre: ")
#pprint.pprint(move_coords)
#move_coords, pre: {'CA': [3.859, 46.816, 9.877], 'C': [4.85, 45.995, 9.061], 'O': [5.738, 46.544, 8.4]}
translation_to_origin = move_coords[resnum_to_dock+dockatomlist[0]]
move_coords = translate(move_coords, translation_to_origin)
translation_to_origin = ref_coords_dock[dockatomlist[0]]
#translate(ref_coords_dock, translation_to_origin)
#print("move_coords, translated to origin: ")
#pprint.pprint(move_coords)
#return move_coords
#CAdock calculation
move_axis = [ move_coords[resnum_to_dock+dockatomlist[1]][0] - move_coords[resnum_to_dock+dockatomlist[0]][0],
move_coords[resnum_to_dock+dockatomlist[1]][1] - move_coords[resnum_to_dock+dockatomlist[0]][1],
move_coords[resnum_to_dock+dockatomlist[1]][2] - move_coords[resnum_to_dock+dockatomlist[0]][2] ]
ref_axis = [ ref_coords_dock[dockatomlist[2]][0] - ref_coords_dock[dockatomlist[0]][0],
ref_coords_dock[dockatomlist[2]][1] - ref_coords_dock[dockatomlist[0]][1],
ref_coords_dock[dockatomlist[2]][2] - ref_coords_dock[dockatomlist[0]][2] ]
#print("move_axis:"+str(move_axis))
#print("ref_axis:"+str(ref_axis))
alignaxis = numpy.cross(move_axis, ref_axis)
#may need safe handling of cmag here
# probably not due to guarantee of distance >>0
dotp = numpy.dot(move_axis,ref_axis)
normalize1 = numpy.sqrt( move_axis[0]**2 + move_axis[1]**2 + move_axis[2]**2 )
normalize2 = numpy.sqrt( ref_axis[0]**2 + ref_axis[1]**2 + ref_axis[2]**2 )
angle1 = numpy.arccos( dotp/(normalize1*normalize2) ) #in radians, of course
for atomname in move_coords:
move_coords[atomname] = nqh_dock.doaxisrot(move_coords[atomname], angle1, alignaxis)
#for atomname in all_atoms_to_dock:
# all_atoms_to_dock[atomname] = nqh_dock.doaxisrot(move_coords[atomname], angle1, alignaxis)
#First rotation of CA dock complete
#print("move_coords, after first rotation: ")
#pprint.pprint(move_coords)
#return move_coords
#start second rotation of CA dock
#get a dihedral
#m3,r1,r2,r3
angle2 = geometry_restraints.dihedral(sites=[move_coords[resnum_to_dock+dockatomlist[2]], ref_coords_dock[dockatomlist[0]], ref_coords_dock[dockatomlist[2]], ref_coords_dock[dockatomlist[1]]], angle_ideal=-40, weight=1).angle_model
#in degrees, convert to radians
angle2 = numpy.deg2rad(angle2)
##print >> sys.stderr, angle2
for atomname in move_coords:
move_coords[atomname] = nqh_dock.doaxisrot(move_coords[atomname], angle2, ref_axis)
#for atomname in all_atoms_to_dock:
# all_atoms_to_dock[atomname] = nqh_dock.doaxisrot(move_coords[atomname], angle1, alignaxis)
#translate from origin to original position
#translate(move_coords, [-translation_to_origin[0], -translation_to_origin[1], -translation_to_origin[2]])
#CA dock complete
#print("move_coords, post: ")
#pprint.pprint(move_coords)
return move_coords
def exercise_chirality(verbose=0):
# monomer library: CA N CB C
sites = [col(site) for site in [
(27.660, 9.903, 2.078),
(28.049, 9.675, 3.486),
(28.183, 11.269, 1.625),
(28.085, 8.759, 1.165)]]
chir = geometry_restraints.chirality(
sites=sites,
volume_ideal=-2.48,
both_signs=False,
weight=1)
assert approx_equal(chir.volume_model, -2.411548478)
assert approx_equal(chir.residual(), 0.00468561086412)
dih = geometry_restraints.dihedral(
sites=improper_permutation(sites),
angle_ideal=35.26439,
weight=1)
assert approx_equal(dih.angle_model, 32.2587249641)
assert approx_equal(dih.residual(), 9.03402230782)
if (verbose):
dump_pdb("sites.pdb", sites)
print "volume_ideal:", chir.volume_ideal
print "volume_model:", chir.volume_model
print "angle_ideal:", dih.angle_ideal
print "angle model:", dih.angle_model
for i_trial in xrange(50):
volume_ideal = chir.volume_ideal
for both_signs in [False, True]:
sites_mod = []
for site in sites:
shift = col([random.uniform(-.5,.5) for i in xrange(3)])
sites_mod.append(site+shift)
if (both_signs): volume_ideal = abs(volume_ideal)
c = geometry_restraints.chirality(
sites=sites_mod,
volume_ideal=volume_ideal,
both_signs=both_signs,
weight=500*1/0.2**2)
residual_obj = residual_functor(
restraint_type=geometry_restraints.chirality,
volume_ideal=c.volume_ideal,
both_signs=c.both_signs,
weight=c.weight)
fg = flex.vec3_double(
finite_differences(sites_mod, residual_obj)).as_double()
ag = flex.vec3_double(
c.gradients()).as_double()
scale = max(1, flex.mean(flex.abs(fg)))
assert approx_equal(ag/scale, fg/scale)
d = geometry_restraints.dihedral(
sites=improper_permutation(sites_mod),
angle_ideal=dih.angle_ideal,
weight=750)
ag_dih = dih.gradients()
if (verbose and i_trial == 0 and not both_signs):
dump_pdb("sites_mod.pdb", sites_mod)
max_g_len = 0
for g in ag_dih:
max_g_len = max(max_g_len, abs(col(g)))
for g in flex.vec3_double(fg):
max_g_len = max(max_g_len, abs(col(g)))
sticks = []
for site,g in zip(improper_permutation(sites_mod),ag_dih):
sticks.append(
pml_stick(
begin=site,
end=site+col(g)/max_g_len,
colors=[[1,0,0]]*2,
width=0.01))
pml_write(f=open("dih.pml", "w"), label="dih", sticks=sticks)
sticks = []
for site,g in zip(sites_mod,flex.vec3_double(fg)):
sticks.append(
pml_stick(
begin=site,
end=site+col(g)/max_g_len,
colors=[[0,1,0]]*2,
width=0.01))
pml_write(f=open("chir.pml", "w"), label="chir", sticks=sticks)
def __sample_density(self, i_res, verbose=False):
import iotbx.pdb
get_class = iotbx.pdb.common_residue_names_get_class
residue_group = self.residue_groups[i_res]
conformers = residue_group.conformers()
results = []
for i_conf, conformer in enumerate(residue_group.conformers()):
if (i_conf > 0) and (self.params.skip_alt_confs):
continue
residue = conformer.only_residue()
if (get_class(residue.resname) == "common_amino_acid"):
n_chi = int(
self.angle_lookup.chisPerAA.get(residue.resname.lower(),
0))
if (n_chi == 0): continue
xyz = None
for atom in residue.atoms():
if (atom.name.strip() == "CA"):
xyz = atom.xyz
break
res_out = ringer_residue(
resname=residue.resname,
chain_id=residue_group.parent().id,
# resid=residue.resid(),
resid=residue.resseq_as_int(),
altloc=conformer.altloc,
n_chi=n_chi,
xyz=xyz)
if (verbose):
print >> self.log, " %s:" % residue.id_str()
for i in range(1, min(self.n_chi_max + 1, n_chi + 1)):
try:
atoms = self.angle_lookup.extract_chi_atoms(
"chi%d" % i, residue)
except AttributeError as e:
pass
else:
try:
if (atoms is None):
break
i_seqs = [atom.i_seq for atom in atoms]
sites_chi = [
self.sites_cart[i_seq] for i_seq in i_seqs
]
from cctbx.geometry_restraints import dihedral
chi = dihedral(sites=sites_chi,
angle_ideal=0,
weight=0)
if (verbose):
print >> self.log, " chi%d = %.1f" % (
i, chi.angle_model)
densities, fofc_densities = sample_angle(
i_seqs=i_seqs,
sites_cart=sites_chi,
map_coeffs=self.map_coeffs,
real_map=self.real_map,
difference_map=self.difference_map,
unit_cell=self.unit_cell,
angle_start=chi.angle_model,
sigma=self.sigma,
params=self.params,
sampling_method=self.sampling_method)
if (len(fofc_densities) == 0):
fofc_densities = None
else:
assert (len(fofc_densities) == len(densities))
if (verbose): pass
res_out.add_angle(
id=i,
angle_current=chi.angle_model,
densities=densities,
fofc_densities=fofc_densities,
sampling=self.params.sampling_angle)
except Exception as e:
pass
results.append(res_out)
return results
def do_rot_then_flip(ag, rot_atoms=ROTATOMLIST, hinge_atoms=HINGEATOMLIST, dock_atoms=DOCKATOMLIST):
resname = ag.id_str()[1:4]
dockatomlist = dock_atoms[resname]
hingeatomlist = hinge_atoms[resname]
rotatomlist = rot_atoms[resname]
atoms_to_rot = get_atoms_to_flip(ag, resname, ROTATOMLIST)
atoms_to_hinge = get_atoms_to_flip(ag, resname, HINGEATOMLIST)
atoms_to_dock = get_atoms_to_flip(ag, resname, DOCKATOMLIST)
move_coords, ref_coords_hinge, ref_coords_dock = {}, {}, {}
for atomname in atoms_to_rot:
move_coords[atomname] = [atoms_to_rot[atomname].xyz[0], atoms_to_rot[atomname].xyz[1], atoms_to_rot[atomname].xyz[2]]
#reference coordinates for the original position are establiched now, since each step will update the model
for atomname in atoms_to_hinge:
ref_coords_hinge[atomname] = [atoms_to_hinge[atomname].xyz[0], atoms_to_hinge[atomname].xyz[1], atoms_to_hinge[atomname].xyz[2]]
for atomname in atoms_to_dock:
ref_coords_dock[atomname] = [atoms_to_dock[atomname].xyz[0], atoms_to_dock[atomname].xyz[1], atoms_to_dock[atomname].xyz[2]]
#start 180 degree rotation
#Each step starts with a translation to the origin
translation_to_origin = move_coords[rotatomlist[0]]
translate(move_coords, translation_to_origin)
#Align axis is the CB-CG vector (CG-CD for GLN)
alignaxis = [ move_coords[rotatomlist[1]][0] - move_coords[rotatomlist[0]][0],
move_coords[rotatomlist[1]][1] - move_coords[rotatomlist[0]][1],
move_coords[rotatomlist[1]][2] - move_coords[rotatomlist[0]][2] ]
for atomname in move_coords:
move_coords[atomname] = doaxisrot(move_coords[atomname], numpy.pi, alignaxis)
#translate from origin to original position
translate(move_coords, [-translation_to_origin[0], -translation_to_origin[1], -translation_to_origin[2]])
change_coords(atoms_to_rot, move_coords)
#180 degree rotation complete
#hinge motion setup
atoms_to_hinge = get_atoms_to_flip(ag, resname, hinge_atoms)
move_coords = {}
for atomname in atoms_to_hinge:
move_coords[atomname] = [atoms_to_hinge[atomname].xyz[0], atoms_to_hinge[atomname].xyz[1], atoms_to_hinge[atomname].xyz[2]]
translation_to_origin = ref_coords_hinge[hingeatomlist[0]]
translate(move_coords, translation_to_origin)
translate(ref_coords_hinge, translation_to_origin)
#hinge motion calculation
#lots of cross products, basically
#Calculate normal to the plane of the original sidechain and normal to the rotated sidechain
normplaneold = numpy.cross(vectorize(ref_coords_hinge[hingeatomlist[0]],ref_coords_hinge[hingeatomlist[1]]),vectorize(ref_coords_hinge[hingeatomlist[1]],ref_coords_hinge[hingeatomlist[2]]))
normplanenew = numpy.cross(vectorize(move_coords[hingeatomlist[1]],move_coords[hingeatomlist[2]]),vectorize(move_coords[hingeatomlist[0]],move_coords[hingeatomlist[1]]))
#axis of rotation is the line of intersection between the planes of the old and new sidechains
#due to translation to the origin, this is given by the cross product of the plane normals
hingeaxis = numpy.cross(normplaneold,normplanenew)
#angle of rotation alge between the planes of the old and new sidechains
#this is found using the dot product of the plane normals
hingeangle = -1*numpy.arccos(numpy.dot(normplaneold,normplanenew) / (veclen(normplaneold)*veclen(normplanenew)))
for atomname in move_coords:
move_coords[atomname] = doaxisrot(move_coords[atomname], hingeangle, hingeaxis)
#translate from origin to original position
translate(move_coords, [-translation_to_origin[0], -translation_to_origin[1], -translation_to_origin[2]])
change_coords(atoms_to_hinge, move_coords)
#hinge motion complete
#CAdock setup
atoms_to_dock = get_atoms_to_flip(ag, resname, dock_atoms)
move_coords = {}
for atomname in atoms_to_dock:
move_coords[atomname] = [atoms_to_dock[atomname].xyz[0], atoms_to_dock[atomname].xyz[1], atoms_to_dock[atomname].xyz[2]]
#move_coords and ref_coords are dicts with key atom_name -> value xyz coords in list form
print("move_coords:"+str(move_coords))
print("ref_coords_doc:"+str(ref_coords_dock))
print("docatomlist:"+str(dockatomlist))
translation_to_origin = ref_coords_dock[dockatomlist[0]]
translate(move_coords, translation_to_origin)
translate(ref_coords_dock, translation_to_origin)
print("move_coords, translate to origin: "+str(move_coords))
#CAdock calculation
move_axis = [ move_coords[dockatomlist[1]][0] - move_coords[dockatomlist[0]][0],
move_coords[dockatomlist[1]][1] - move_coords[dockatomlist[0]][1],
move_coords[dockatomlist[1]][2] - move_coords[dockatomlist[0]][2] ]
ref_axis = [ ref_coords_dock[dockatomlist[2]][0] - ref_coords_dock[dockatomlist[0]][0],
ref_coords_dock[dockatomlist[2]][1] - ref_coords_dock[dockatomlist[0]][1],
ref_coords_dock[dockatomlist[2]][2] - ref_coords_dock[dockatomlist[0]][2] ]
print("move_axis:"+str(move_axis))
print("ref_axis:"+str(ref_axis))
alignaxis = numpy.cross(move_axis, ref_axis)
#may need safe handling of cmag here
# probably not due to guarantee of distance >>0
dotp = numpy.dot(move_axis,ref_axis)
normalize1 = numpy.sqrt( move_axis[0]**2 + move_axis[1]**2 + move_axis[2]**2 )
normalize2 = numpy.sqrt( ref_axis[0]**2 + ref_axis[1]**2 + ref_axis[2]**2 )
angle1 = numpy.arccos( dotp/(normalize1*normalize2) ) #in radians, of course
for atomname in move_coords:
move_coords[atomname] = doaxisrot(move_coords[atomname], angle1, alignaxis)
#First rotation of CA dock complete
#start second rotation of CA dock
#get a dihedral
#m3,r1,r2,r3
angle2 = geometry_restraints.dihedral(sites=[move_coords[dockatomlist[2]], ref_coords_dock[dockatomlist[0]], ref_coords_dock[dockatomlist[2]], ref_coords_dock[dockatomlist[1]]], angle_ideal=-40, weight=1).angle_model
#in degrees, convert to radians
angle2 = numpy.deg2rad(angle2)
##print >> sys.stderr, angle2
for atomname in move_coords:
move_coords[atomname] = doaxisrot(move_coords[atomname], angle2, ref_axis)
#translate from origin to original position
translate(move_coords, [-translation_to_origin[0], -translation_to_origin[1], -translation_to_origin[2]])
#update hierarchy with new coordinates
change_coords(atoms_to_dock, move_coords)
