def exercise_isotropic_adp():
i_seqs = (0,)
weight = 2
u_cart = ((1,2,3,5,2,8),)
u_iso = (0,)
use_u_aniso = (True,)
p = adp_restraints.isotropic_adp_proxy(
i_seqs=i_seqs,
weight=weight)
assert p.i_seqs == i_seqs
assert approx_equal(p.weight, weight)
i = adp_restraints.isotropic_adp(u_cart=u_cart[0], weight=weight)
expected_deltas = (-1, 0, 1, 5, 2, 8)
expected_gradients = (-4, 0, 4, 40, 16, 64)
assert approx_equal(i.weight, weight)
assert approx_equal(i.deltas(), expected_deltas)
assert approx_equal(i.rms_deltas(), 4.5704364002673632)
assert approx_equal(i.residual(), 376.0)
assert approx_equal(i.gradients(), expected_gradients)
gradients_aniso_cart = flex.sym_mat3_double(1, (0,0,0,0,0,0))
gradients_iso = flex.double(1,0)
proxies = adp_restraints.shared_isotropic_adp_proxy([p,p])
u_cart = flex.sym_mat3_double(u_cart)
u_iso = flex.double(u_iso)
use_u_aniso = flex.bool(use_u_aniso)
params = adp_restraint_params(u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso)
residuals = adp_restraints.isotropic_adp_residuals(params, proxies=proxies)
assert approx_equal(residuals, (i.residual(),i.residual()))
deltas_rms = adp_restraints.isotropic_adp_deltas_rms(params, proxies=proxies)
assert approx_equal(deltas_rms, (i.rms_deltas(),i.rms_deltas()))
residual_sum = adp_restraints.isotropic_adp_residual_sum(
params,
proxies=proxies,
gradients_aniso_cart=gradients_aniso_cart
)
assert approx_equal(residual_sum, 752.0)
fd_grads_aniso, fd_grads_iso = finite_difference_gradients(
restraint_type=adp_restraints.isotropic_adp,
proxy=p,
u_cart=u_cart,
u_iso=u_iso,
use_u_aniso=use_u_aniso
)
for g,e in zip(gradients_aniso_cart, fd_grads_aniso):
assert approx_equal(g, matrix.col(e)*2)
#
# check frame invariance of residual
#
u_cart = matrix.sym(sym_mat3=(0.1,0.2,0.05,0.03,0.02,0.01))
a = adp_restraints.isotropic_adp(
u_cart=u_cart.as_sym_mat3(), weight=1)
expected_residual = a.residual()
gen = flex.mersenne_twister()
for i in range(20):
R = matrix.rec(gen.random_double_r3_rotation_matrix(),(3,3))
u_cart_rot = R * u_cart * R.transpose()
a = adp_restraints.isotropic_adp(
u_cart=u_cart_rot.as_sym_mat3(), weight=1)
assert approx_equal(a.residual(), expected_residual)
def exercise_isotropic_adp():
i_seqs = (0,)
weight = 2
u_cart = ((1,2,3,5,2,8),)
u_iso = (0,)
use_u_aniso = (True,)
p = adp_restraints.isotropic_adp_proxy(
i_seqs=i_seqs,
weight=weight)
assert p.i_seqs == i_seqs
assert approx_equal(p.weight, weight)
i = adp_restraints.isotropic_adp(u_cart=u_cart[0], weight=weight)
expected_deltas = (-1, 0, 1, 5, 2, 8)
expected_gradients = (-4, 0, 4, 40, 16, 64)
assert approx_equal(i.weight, weight)
assert approx_equal(i.deltas(), expected_deltas)
assert approx_equal(i.rms_deltas(), 4.5704364002673632)
assert approx_equal(i.residual(), 376.0)
assert approx_equal(i.gradients(), expected_gradients)
gradients_aniso_cart = flex.sym_mat3_double(1, (0,0,0,0,0,0))
gradients_iso = flex.double(1,0)
proxies = adp_restraints.shared_isotropic_adp_proxy([p,p])
u_cart = flex.sym_mat3_double(u_cart)
u_iso = flex.double(u_iso)
use_u_aniso = flex.bool(use_u_aniso)
params = adp_restraint_params(u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso)
residuals = adp_restraints.isotropic_adp_residuals(params, proxies=proxies)
assert approx_equal(residuals, (i.residual(),i.residual()))
deltas_rms = adp_restraints.isotropic_adp_deltas_rms(params, proxies=proxies)
assert approx_equal(deltas_rms, (i.rms_deltas(),i.rms_deltas()))
residual_sum = adp_restraints.isotropic_adp_residual_sum(
params,
proxies=proxies,
gradients_aniso_cart=gradients_aniso_cart
)
assert approx_equal(residual_sum, 752.0)
fd_grads_aniso, fd_grads_iso = finite_difference_gradients(
restraint_type=adp_restraints.isotropic_adp,
proxy=p,
u_cart=u_cart,
u_iso=u_iso,
use_u_aniso=use_u_aniso
)
for g,e in zip(gradients_aniso_cart, fd_grads_aniso):
assert approx_equal(g, matrix.col(e)*2)
#
# check frame invariance of residual
#
u_cart = matrix.sym(sym_mat3=(0.1,0.2,0.05,0.03,0.02,0.01))
a = adp_restraints.isotropic_adp(
u_cart=u_cart.as_sym_mat3(), weight=1)
expected_residual = a.residual()
gen = flex.mersenne_twister()
for i in range(20):
R = matrix.rec(gen.random_double_r3_rotation_matrix(),(3,3))
u_cart_rot = R * u_cart * R.transpose()
a = adp_restraints.isotropic_adp(
u_cart=u_cart_rot.as_sym_mat3(), weight=1)
assert approx_equal(a.residual(), expected_residual)
def inverse_transform_hierarchy(self, i, pdb_hierarchy): rt = self.get_inverse_matrix(i) atoms = pdb_hierarchy.atoms() sites_cart = atoms.extract_xyz() atoms.set_xyz(rt.r.elems * sites_cart + rt.t.elems) uij = flex.sym_mat3_double(sites_cart.size(),[-1,-1,-1,-1,-1,-1]) atoms.set_uij(uij)
def inverse_transform_hierarchy (self, i, pdb_hierarchy) : rt = self.get_inverse_matrix(i) atoms = pdb_hierarchy.atoms() sites_cart = atoms.extract_xyz() atoms.set_xyz(rt.r.elems * sites_cart + rt.t.elems) uij = flex.sym_mat3_double(sites_cart.size(),[-1,-1,-1,-1,-1,-1]) atoms.set_uij(uij)
def finite_differences_u_star(target_ftor, structure, delta=0.000001):
derivatives = flex.sym_mat3_double()
for i_scatterer in range(structure.scatterers().size()):
d_target_d_u_star = [0, 0, 0, 0, 0, 0]
if (structure.scatterers()[i_scatterer].flags.use_u_aniso()):
for iu in range(6):
target_values = []
for d_sign in (-1, 1):
modified_structure = structure.deep_copy_scatterers()
ms = modified_structure.scatterers()[i_scatterer]
u_star = list(ms.u_star)
u_star[iu] += d_sign * delta
ms.u_star = u_star
f_calc = target_ftor.f_obs(
).structure_factors_from_scatterers(
xray_structure=modified_structure,
algorithm="direct").f_calc()
target_result = target_ftor(f_calc,
compute_derivatives=False)
target_values.append(target_result.target())
derivative = (target_values[1] - target_values[0]) / (2 *
delta)
d_target_d_u_star[iu] = derivative
derivatives.append(d_target_d_u_star)
else:
derivatives.append(d_target_d_u_star)
return derivatives
def finite_differences_u_star(target_ftor, structure,
delta=0.000001):
derivatives = flex.sym_mat3_double()
for i_scatterer in xrange(structure.scatterers().size()):
d_target_d_u_star = [0,0,0,0,0,0]
if(structure.scatterers()[i_scatterer].flags.use_u_aniso()):
for iu in xrange(6):
target_values = []
for d_sign in (-1, 1):
modified_structure = structure.deep_copy_scatterers()
ms = modified_structure.scatterers()[i_scatterer]
u_star = list(ms.u_star)
u_star[iu] += d_sign * delta
ms.u_star = u_star
f_calc = target_ftor.f_obs().structure_factors_from_scatterers(
xray_structure=modified_structure,
algorithm="direct").f_calc()
target_result = target_ftor(f_calc, compute_derivatives=False)
target_values.append(target_result.target())
derivative = (target_values[1] - target_values[0]) / (2 * delta)
d_target_d_u_star[iu] = derivative
derivatives.append(d_target_d_u_star)
else:
derivatives.append(d_target_d_u_star)
return derivatives
def exercise_grad_u_transformations():
uc = uctbx.unit_cell((12.296512479074615, 15.985466222796999, 20.904071214426843, 83.0, 109.0, 129.0))
grad_u_star = (
1681615.347859645,
1740095.5140965185,
2212142.6517873215,
-2802250.0492254314,
-1934508.748421974,
1503834.0901063806,
)
grad_u_cart = adptbx.grad_u_star_as_u_cart(uc, grad_u_star)
assert approx_equal(
grad_u_cart,
(
11121.484290152286,
3713.1538936460488,
4293.4422553333607,
-332.12536958297818,
-340.3709419122527,
406.25522344235526,
),
)
assert approx_equal(grad_u_star, adptbx.grad_u_cart_as_u_star(uc, grad_u_cart))
grad_u_star_array = flex.sym_mat3_double([grad_u_star] * 3)
grad_u_cart_array = adptbx.grad_u_star_as_u_cart(uc, grad_u_star_array)
for g in grad_u_cart_array:
assert approx_equal(grad_u_cart, g)
grad_u_star_array = adptbx.grad_u_cart_as_u_star(uc, grad_u_cart_array)
for g in grad_u_star_array:
assert approx_equal(grad_u_star, g)
def u_cart_from_tls(sites_cart, selections, tlsos):
global time_u_cart_from_tls
t1 = time.time()
uanisos = flex.sym_mat3_double(sites_cart.size(), [0,0,0,0,0,0])
for selection, tlso in zip(selections, tlsos):
u = uaniso_from_tls_one_group(tlso = tlso,
sites_cart = sites_cart.select(selection))
uanisos.set_selected(selection, u)
t2 = time.time()
time_u_cart_from_tls += (t2 - t1)
return uanisos
def u_cart_from_tls(sites_cart, selections, tlsos):
global time_u_cart_from_tls
t1 = time.time()
uanisos = flex.sym_mat3_double(sites_cart.size(), [0, 0, 0, 0, 0, 0])
for selection, tlso in zip(selections, tlsos):
u = uaniso_from_tls_one_group(tlso=tlso,
sites_cart=sites_cart.select(selection),
zeroize_trace=True)
uanisos.set_selected(selection, u)
t2 = time.time()
time_u_cart_from_tls += (t2 - t1)
return uanisos
def u_cart_from_nm(adp_nmas, selections, xs, n_modes, total_size, zero_mode_flag = True):
global time_u_cart_from_nm
t1 = time.time()
uanisos = flex.sym_mat3_double(total_size, [0,0,0,0,0,0])
for adp_nma, selection, x in zip(adp_nmas, selections, xs):
uaniso_form_s_manager = uaniso_from_s(x = x,
adp_nma = adp_nma,
n_modes = n_modes,
zero_mode_flag = zero_mode_flag)
u = uaniso_form_s_manager.u_cart()
uanisos.set_selected(selection, u)
t2 = time.time()
time_u_cart_from_nm += (t2 - t1)
return uanisos
def u_cart_from_nm(adp_nmas, selections, xs, n_modes, total_size, zero_mode_flag = True):
global time_u_cart_from_nm
t1 = time.time()
uanisos = flex.sym_mat3_double(total_size, [0,0,0,0,0,0])
for adp_nma, selection, x in zip(adp_nmas, selections, xs):
uaniso_form_s_manager = uaniso_from_s(x = x,
adp_nma = adp_nma,
n_modes = n_modes,
zero_mode_flag = zero_mode_flag)
u = uaniso_form_s_manager.u_cart()
uanisos.set_selected(selection, u)
t2 = time.time()
time_u_cart_from_nm += (t2 - t1)
return uanisos
def u_cart_from_ensemble(models):
xyz_all = []
for m in models:
xyz_all.append(m.atoms().extract_xyz())
n_atoms = xyz_all[0].size()
xyz_atoms_all = []
for i in xrange(n_atoms):
xyz_atoms = flex.vec3_double()
for xyzs in xyz_all:
xyz_atoms.append(xyzs[i])
xyz_atoms_all.append(xyz_atoms)
result = flex.sym_mat3_double()
for i in xrange(n_atoms):
result.append(u_cart_from_xyz(sites_cart=xyz_atoms_all[i]))
return result
def u_cart_from_ensemble(models):
xyz_all = []
for m in models:
xyz_all.append(m.atoms().extract_xyz())
n_atoms = xyz_all[0].size()
xyz_atoms_all = []
for i in xrange(n_atoms):
xyz_atoms = flex.vec3_double()
for xyzs in xyz_all:
xyz_atoms.append(xyzs[i])
xyz_atoms_all.append(xyz_atoms)
result = flex.sym_mat3_double()
for i in xrange(n_atoms):
result.append(u_cart_from_xyz(sites_cart=xyz_atoms_all[i]))
return result
def exercise_grad_u_transformations():
uc = uctbx.unit_cell((12.296512479074615, 15.985466222796999,
20.904071214426843, 83.0, 109.0, 129.0))
grad_u_star = (1681615.347859645, 1740095.5140965185, 2212142.6517873215,
-2802250.0492254314, -1934508.748421974, 1503834.0901063806)
grad_u_cart = adptbx.grad_u_star_as_u_cart(uc, grad_u_star)
assert approx_equal(
grad_u_cart,
(11121.484290152286, 3713.1538936460488, 4293.4422553333607,
-332.12536958297818, -340.3709419122527, 406.25522344235526))
assert approx_equal(grad_u_star,
adptbx.grad_u_cart_as_u_star(uc, grad_u_cart))
grad_u_star_array = flex.sym_mat3_double([grad_u_star] * 3)
grad_u_cart_array = adptbx.grad_u_star_as_u_cart(uc, grad_u_star_array)
for g in grad_u_cart_array:
assert approx_equal(grad_u_cart, g)
grad_u_star_array = adptbx.grad_u_cart_as_u_star(uc, grad_u_cart_array)
for g in grad_u_star_array:
assert approx_equal(grad_u_star, g)
def run(args):
# if (len(args) == 0 ):
# raise RuntimeError("Please specify one or more pdb file names.")
mon_lib_srv = monomer_library.server.server()
ener_lib = monomer_library.server.ener_lib()
# pdb_file = libtbx.env.find_in_repositories(
# relative_path="phenix_regression/pdb/1A32.pdb",
# test=os.path.isfile)
pdb_file = "./4KI8.pdb"
# print pdb_file
processed_pdb_file = monomer_library.pdb_interpretation.process(
mon_lib_srv=mon_lib_srv,
ener_lib=ener_lib,
file_name=pdb_file,
raw_records=None,
force_symmetry=True)
xray_structure = processed_pdb_file.xray_structure()
pdb_inp = iotbx.pdb.input(file_name=pdb_file)
pdb_hierarchy = pdb_inp.construct_hierarchy()
# xray_structure.scattering_type_registry(table = "wk1995")
# reflection_file = reflection_file_reader.any_reflection_file(file_name = "./4ksc-sf.cif")
# miller_arrays = reflection_file.as_miller_arrays()
# for miller_array in miller_arrays:
# if (miller_array.is_xray_amplitude_array()):
# f_obs = miller_array
dummy = xray_structure.structure_factors(d_min=3.0).f_calc()
f_obs = abs(
dummy.structure_factors_from_scatterers(
xray_structure=xray_structure).f_calc())
flags = f_obs.generate_r_free_flags(fraction=0.01)
# f_calc = f_obs.structure_factors_from_scatterers(
# xray_structure = xray_structure).f_calc()
fmodel = mmtbx.f_model.manager(xray_structure=xray_structure,
f_obs=f_obs,
r_free_flags=flags)
# bulk_solvent_manager = bulk_solvent_and_scaling.bulk_solvent_and_scales(
# fmodel_kbu = fmodel.fmodel_kbu)
# f_bulk = bulk_solvent_manager.f_bulk()
# f_bulk.set_info("Bulk solvent structure factors")
# f_bulk.show_summary()
# xray_structure.convert_to_isotropic()
# u_iso_start = xray_structure.extract_u_iso_or_u_equiv()
# xray_structure.set_b_iso(value = 100.0)
# xray_structure.convert_to_anisotropic()
xray_structure.show_u_statistics(text="After set u_iso_start")
atoms = pdb_hierarchy.atoms()
atomsxyz = atoms.extract_xyz()
sites_cart = xray_structure.sites_cart()
atomic_weights = xray_structure.atomic_weights()
u_cart = xray_structure.scatterers().extract_u_cart(
xray_structure.unit_cell())
# nm_init_manager = nm_init(filename = "4ki8_evec.dat",
# n_modes = 50,
# atoms = atoms,
# zero_mode_input_flag = False,
# zero_mode_flag = True)
# eigenvector = nm_init_manager.return_modes(1)
selections = []
selection_strings = [
"chain A", "chain B", "chain C", "chain D", "chain E", "chain F",
"chain G"
]
# selection_strings = ["chain A"]
for string in selection_strings:
selections.append(
processed_pdb_file.all_chain_proxies.selection(string=string))
geometry = processed_pdb_file.geometry_restraints_manager(
show_energies=False, plain_pairs_radius=5.0)
restraints_manager = mmtbx.restraints.manager(geometry=geometry)
modes = tools.generate_evec(selections=selections,
xray_structure=xray_structure,
pdb_hierarchy=pdb_hierarchy,
filename="4ki8_evec.dat",
n_modes=20)
uanisos = flex.sym_mat3_double(xray_structure.sites_cart().size(),
[0, 0, 0, 0, 0, 0])
nmval = tools.read_nmval_file(evalin="4ki8_eval.dat",
n_modes=20,
zero_mode_input_flag=False,
zero_mode_flag=True)
xs_initial = []
adp_nmas = []
for selection in selections:
x = tools.init_nm_para(nmval=nmval, n_modes=20)
modes1d = tools.selected_modes_to_1D(modes=modes,
n_modes=20,
selection=selection)
weights_selected = xray_structure.atomic_weights().select(selection)
print "The number of selected atoms is %d." % len(weights_selected)
u_cart_selected = u_cart.select(selection)
adp_nma = init_nm_adp(modes=modes1d,
weights=weights_selected,
n_modes=20,
zero_mode_flag=True)
adp_nmas.append(adp_nma)
uaniso_from_s_manager = uaniso_from_s(x=x,
adp_nma=adp_nma,
n_modes=20,
zero_mode_flag=True)
u = uaniso_from_s_manager.u_cart()
x_scaled = scale_x(x=x,
uanisos=u_cart_selected,
adp_all=u,
n_modes=20,
zero_mode_flag=True)
xs_initial.append(x_scaled)
# t1 = time.time()
sfg_params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract()
sfg_params.cos_sin_table = False
tools.update_xray_structure_with_nm(xray_structure=xray_structure,
adp_nmas=adp_nmas,
selections=selections,
xs=xs_initial,
n_modes=20,
zero_mode_flag=True)
del adp_nmas
class refinement_flags:
pass
refinement_flags.adp_tls = selections
model = mmtbx.model.manager(refinement_flags=refinement_flags,
restraints_manager=restraints_manager,
xray_structure=xray_structure,
pdb_hierarchy=pdb_hierarchy)
fmodel.update_xray_structure(xray_structure=xray_structure,
update_f_calc=True)
fmodel_cp = fmodel.deep_copy()
nm_refinement_manager = tools.nm_refinement(
fmodel=fmodel_cp,
model=model,
selections=selections,
selections_1d=None,
n_modes=20,
number_of_macro_cycles=30,
max_number_of_iterations=10000,
evecin="4ki8_evec.dat",
evalin="4ki8_eval.dat",
start_xs_value=xs_initial,
run_finite_differences_test=False)
tools.show_time()
def exercise_proxy_show():
if sys.platform.startswith("win") and sys.version_info[:2] < (2,6):
# This appears to be a windows-specific bug with string formatting
# for python versions prior to 2.6, where the exponent is printed
# with 3 digits rather than 2.
print "Skipping exercise_proxy_show()"
return
sites_cart = flex.vec3_double((
(-3.1739,10.8317,7.5653),(-2.5419,9.7567,6.6306),
(-3.3369,8.8794,4.5191),(-3.4640,9.9882,5.3896)))
site_labels = ("C1", "C2", "O16", "N8")
u_cart = flex.sym_mat3_double((
(0.0153,0.0206,0.0234,0.0035,-0.0052,-0.0051),
(0.0185,0.0109,0.0206,0.0005,-0.0010,0.0002),
(0.0295,0.0203,0.0218,-0.0010,-0.0003,-0.0044),
(0.0159,0.0154,0.0206,-0.0003,0.0004,0.0036)))
u_iso = flex.double((-1,-1,-1,-1))
use_u_aniso = flex.bool((True,True,True,True))
#
proxies = adp_restraints.shared_adp_similarity_proxy()
sio = StringIO()
proxies.show_sorted(
by_value="residual",
u_cart=flex.sym_mat3_double(),
u_iso=flex.double(),
use_u_aniso=flex.bool(),
f=sio)
assert not show_diff(sio.getvalue(), """\
ADP similarity restraints: 0
""")
proxies = adp_restraints.shared_adp_similarity_proxy([
adp_restraints.adp_similarity_proxy(i_seqs=[0,1],weight=25),
adp_restraints.adp_similarity_proxy(i_seqs=[2,3],weight=0.3)])
sio = StringIO()
proxies.show_sorted(
by_value="residual",
u_cart=u_cart,
u_iso=u_iso,
use_u_aniso=use_u_aniso,
f=sio,
prefix=":")
assert not show_diff(sio.getvalue(), """\
:ADP similarity restraints: 2
:Sorted by residual:
:scatterers 0
: 1
: delta sigma weight rms_deltas residual
: U11 -3.20e-03 2.00e-01 2.50e+01 4.96e-03 5.54e-03
: U22 9.70e-03 2.00e-01 2.50e+01
: U33 2.80e-03 2.00e-01 2.50e+01
: U12 3.00e-03 2.00e-01 2.50e+01
: U13 -4.20e-03 2.00e-01 2.50e+01
: U23 -5.30e-03 2.00e-01 2.50e+01
:scatterers 2
: 3
: delta sigma weight rms_deltas residual
: U11 1.36e-02 1.83e+00 3.00e-01 6.15e-03 1.02e-04
: U22 4.90e-03 1.83e+00 3.00e-01
: U33 1.20e-03 1.83e+00 3.00e-01
: U12 -7.00e-04 1.83e+00 3.00e-01
: U13 -7.00e-04 1.83e+00 3.00e-01
: U23 -8.00e-03 1.83e+00 3.00e-01
""")
sio = StringIO()
proxies.show_sorted(
by_value="rms_deltas",
site_labels=site_labels,
u_cart=u_cart,
u_iso=flex.double((0.024,0.031,0.021,0.028)),
use_u_aniso=flex.bool((False,False,False,False)),
f=sio,
prefix="=")
assert not show_diff(sio.getvalue(), """\
=ADP similarity restraints: 2
=Sorted by rms_deltas:
=scatterers C1
= C2
= delta sigma weight residual
= Uiso -7.00e-03 2.00e-01 2.50e+01 1.22e-03
=scatterers O16
= N8
= delta sigma weight residual
= Uiso -7.00e-03 1.83e+00 3.00e-01 1.47e-05
""")
#
proxies = adp_restraints.shared_isotropic_adp_proxy()
sio = StringIO()
proxies.show_sorted(
by_value="residual",
u_cart=flex.sym_mat3_double(),
u_iso=u_iso,
use_u_aniso=use_u_aniso,
f=sio)
assert not show_diff(sio.getvalue(), """\
Isotropic ADP restraints: 0
""")
proxies = adp_restraints.shared_isotropic_adp_proxy([
adp_restraints.isotropic_adp_proxy(i_seqs=(0,),weight=25),
adp_restraints.isotropic_adp_proxy(i_seqs=(2,),weight=0.3)])
sio = StringIO()
proxies.show_sorted(
by_value="residual",
site_labels=site_labels,
u_cart=u_cart,
u_iso=u_iso,
use_u_aniso=use_u_aniso,
f=sio,
prefix=" ")
assert not show_diff(sio.getvalue(), """\
Isotropic ADP restraints: 2
Sorted by residual:
scatterer C1
delta sigma weight rms_deltas residual
U11 -4.47e-03 2.00e-01 2.50e+01 4.27e-03 4.11e-03
U22 8.33e-04 2.00e-01 2.50e+01
U33 3.63e-03 2.00e-01 2.50e+01
U12 3.50e-03 2.00e-01 2.50e+01
U13 -5.20e-03 2.00e-01 2.50e+01
U23 -5.10e-03 2.00e-01 2.50e+01
scatterer O16
delta sigma weight rms_deltas residual
U11 5.63e-03 1.83e+00 3.00e-01 3.16e-03 2.69e-05
U22 -3.57e-03 1.83e+00 3.00e-01
U33 -2.07e-03 1.83e+00 3.00e-01
U12 -1.00e-03 1.83e+00 3.00e-01
U13 -3.00e-04 1.83e+00 3.00e-01
U23 -4.40e-03 1.83e+00 3.00e-01
""")
sio = StringIO()
proxies.show_sorted(
by_value="rms_deltas",
u_cart=u_cart,
u_iso=u_iso,
use_u_aniso=use_u_aniso,
f=sio,
prefix="$")
assert not show_diff(sio.getvalue(), """\
$Isotropic ADP restraints: 2
$Sorted by rms_deltas:
$scatterer 0
$ delta sigma weight rms_deltas residual
$ U11 -4.47e-03 2.00e-01 2.50e+01 4.27e-03 4.11e-03
$ U22 8.33e-04 2.00e-01 2.50e+01
$ U33 3.63e-03 2.00e-01 2.50e+01
$ U12 3.50e-03 2.00e-01 2.50e+01
$ U13 -5.20e-03 2.00e-01 2.50e+01
$ U23 -5.10e-03 2.00e-01 2.50e+01
$scatterer 2
$ delta sigma weight rms_deltas residual
$ U11 5.63e-03 1.83e+00 3.00e-01 3.16e-03 2.69e-05
$ U22 -3.57e-03 1.83e+00 3.00e-01
$ U33 -2.07e-03 1.83e+00 3.00e-01
$ U12 -1.00e-03 1.83e+00 3.00e-01
$ U13 -3.00e-04 1.83e+00 3.00e-01
$ U23 -4.40e-03 1.83e+00 3.00e-01
""")
#
proxies = adp_restraints.shared_rigid_bond_proxy()
sio = StringIO()
proxies.show_sorted(
by_value="residual",
sites_cart=flex.vec3_double(),
u_cart=flex.sym_mat3_double(),
f=sio)
assert not show_diff(sio.getvalue(), """\
Rigid bond restraints: 0
""")
proxies = adp_restraints.shared_rigid_bond_proxy([
adp_restraints.rigid_bond_proxy(i_seqs=(0,1),weight=25),
adp_restraints.rigid_bond_proxy(i_seqs=(0,2),weight=15),
adp_restraints.rigid_bond_proxy(i_seqs=(2,3),weight=25),
adp_restraints.rigid_bond_proxy(i_seqs=(3,1),weight=30)])
sio = StringIO()
proxies.show_sorted(
by_value="residual",
sites_cart=sites_cart,
site_labels=site_labels,
u_cart=u_cart,
f=sio,
prefix="*")
assert not show_diff(sio.getvalue(), """\
*Rigid bond restraints: 4
*Sorted by residual:
*scatterers O16
* N8
* delta_z sigma weight residual
* -3.96e-03 2.00e-01 2.50e+01 3.92e-04
*scatterers C1
* C2
* delta_z sigma weight residual
* 1.08e-03 2.00e-01 2.50e+01 2.89e-05
*scatterers C1
* O16
* delta_z sigma weight residual
* 4.03e-04 2.58e-01 1.50e+01 2.44e-06
*scatterers N8
* C2
* delta_z sigma weight residual
* -1.54e-04 1.83e-01 3.00e+01 7.16e-07
""")
sio = StringIO()
proxies.show_sorted(
by_value="delta",
sites_cart=sites_cart,
u_cart=u_cart,
f=sio,
prefix="||",
max_items=2)
assert not show_diff(sio.getvalue(), """\
||Rigid bond restraints: 4
||Sorted by delta:
||scatterers 2
|| 3
|| delta_z sigma weight residual
|| -3.96e-03 2.00e-01 2.50e+01 3.92e-04
||scatterers 0
|| 1
|| delta_z sigma weight residual
|| 1.08e-03 2.00e-01 2.50e+01 2.89e-05
||... (remaining 2 not shown)
""")
def __init__(self,
u_cart,
u_iso=None,
use_u_aniso=None,
sites_cart=None,
adp_similarity_proxies=None,
rigid_bond_proxies=None,
isotropic_adp_proxies=None,
compute_gradients=True,
gradients_aniso_cart=None,
gradients_iso=None,
disable_asu_cache=False,
normalization=False):
adopt_init_args(self, locals())
self.number_of_restraints = 0
self.residual_sum = 0
self.normalization_factor = None
if (adp_similarity_proxies is not None):
assert u_iso is not None and use_u_aniso is not None
if (rigid_bond_proxies is not None): assert sites_cart is not None
if (sites_cart is not None): assert sites_cart.size() == u_cart.size()
if (u_iso is not None): assert u_iso.size() == u_cart.size()
if (use_u_aniso is not None):
assert use_u_aniso.size() == u_cart.size()
if (compute_gradients):
if (self.gradients_aniso_cart is None):
self.gradients_aniso_cart = flex.sym_mat3_double(
sites_cart.size(), [0, 0, 0, 0, 0, 0])
else:
assert self.gradients_aniso_cart.size() == sites_cart.size()
if (u_iso is not None and self.gradients_iso is None):
self.gradients_iso = flex.double(sites_cart.size(), 0)
elif (u_iso is not None):
assert self.gradients_iso.size() == sites_cart.size()
if (adp_similarity_proxies is None):
self.n_adp_similarity_proxies = None
self.adp_similarity_residual_sum = 0
else:
self.n_adp_similarity_proxies = len(adp_similarity_proxies)
self.adp_similarity_residual_sum = adp_restraints.adp_similarity_residual_sum(
u_cart=u_cart,
u_iso=u_iso,
use_u_aniso=use_u_aniso,
proxies=adp_similarity_proxies,
gradients_aniso_cart=self.gradients_aniso_cart,
gradients_iso=self.gradients_iso)
self.number_of_restraints += 6 * self.n_adp_similarity_proxies
self.residual_sum += self.adp_similarity_residual_sum
if (rigid_bond_proxies is None):
self.n_rigid_bond_proxies = None
self.rigid_bond_residual_sum = 0
else:
self.n_rigid_bond_proxies = len(rigid_bond_proxies)
self.rigid_bond_residual_sum = adp_restraints.rigid_bond_residual_sum(
sites_cart=sites_cart,
u_cart=u_cart,
proxies=rigid_bond_proxies,
gradients_aniso_cart=self.gradients_aniso_cart)
self.number_of_restraints += self.n_rigid_bond_proxies
self.residual_sum += self.rigid_bond_residual_sum
if (isotropic_adp_proxies is None):
self.n_isotropic_adp_proxies = None
self.isotropic_adp_residual_sum = 0
else:
self.n_isotropic_adp_proxies = len(isotropic_adp_proxies)
self.isotropic_adp_residual_sum = adp_restraints.isotropic_adp_residual_sum(
u_cart=u_cart,
proxies=isotropic_adp_proxies,
gradients_aniso_cart=self.gradients_aniso_cart)
self.number_of_restraints += self.n_isotropic_adp_proxies
self.residual_sum += self.isotropic_adp_residual_sum
self.finalize_target_and_gradients()
def __init__(self, cif_block):
crystal_symmetry_builder.__init__(self, cif_block)
self.hierarchy = hierarchy.root()
# These items are mandatory for the _atom_site loop, all others are optional
type_symbol = self._wrap_loop_if_needed(cif_block,
"_atom_site.type_symbol")
atom_labels = self._wrap_loop_if_needed(cif_block,
"_atom_site.auth_atom_id")
if atom_labels is None:
atom_labels = self._wrap_loop_if_needed(
cif_block, "_atom_site.label_atom_id"
) # corresponds to chem comp atom name
alt_id = self._wrap_loop_if_needed(
cif_block, "_atom_site.label_alt_id") # alternate conformer id
label_asym_id = self._wrap_loop_if_needed(
cif_block, "_atom_site.label_asym_id") # chain id
auth_asym_id = self._wrap_loop_if_needed(cif_block,
"_atom_site.auth_asym_id")
if label_asym_id is None: label_asym_id = auth_asym_id
if auth_asym_id is None: auth_asym_id = label_asym_id
comp_id = self._wrap_loop_if_needed(cif_block,
"_atom_site.auth_comp_id")
if comp_id is None:
comp_id = self._wrap_loop_if_needed(
cif_block, "_atom_site.label_comp_id") # residue name
entity_id = self._wrap_loop_if_needed(cif_block,
"_atom_site.label_entity_id")
seq_id = self._wrap_loop_if_needed(cif_block, "_atom_site.auth_seq_id")
if seq_id is None:
seq_id = self._wrap_loop_if_needed(
cif_block, "_atom_site.label_seq_id") # residue number
assert [atom_labels, alt_id, auth_asym_id, comp_id, entity_id,
seq_id].count(None) == 0, "someting is not present"
assert type_symbol is not None
atom_site_fp = cif_block.get('_atom_site.phenix_scat_dispersion_real')
atom_site_fdp = cif_block.get('_atom_site.phenix_scat_dispersion_imag')
pdb_ins_code = cif_block.get(
"_atom_site.pdbx_PDB_ins_code") # insertion code
model_ids = cif_block.get("_atom_site.pdbx_PDB_model_num")
atom_site_id = cif_block.get("_atom_site.id")
# only permitted values are ATOM or HETATM
group_PDB = cif_block.get("_atom_site.group_PDB")
# TODO: read esds
B_iso_or_equiv = flex.double(
self._wrap_loop_if_needed(cif_block, "_atom_site.B_iso_or_equiv"))
cart_x = flex.double(
self._wrap_loop_if_needed(cif_block, "_atom_site.Cartn_x"))
cart_y = flex.double(
self._wrap_loop_if_needed(cif_block, "_atom_site.Cartn_y"))
cart_z = flex.double(
self._wrap_loop_if_needed(cif_block, "_atom_site.Cartn_z"))
occu = flex.double(
self._wrap_loop_if_needed(cif_block, "_atom_site.occupancy"))
formal_charge = self._wrap_loop_if_needed(
cif_block, "_atom_site.pdbx_formal_charge")
# anisotropic b-factors
# TODO: read esds
anisotrop_id = self._wrap_loop_if_needed(cif_block,
"_atom_site_anisotrop.id")
adps = None
if anisotrop_id is not None:
u_ij = [
self._wrap_loop_if_needed(
cif_block,
"_atom_site_anisotrop.U[%s][%s]" % (ij[0], ij[1]))
for ij in ("11", "22", "33", "12", "13", "23")
]
assert u_ij.count(None) in (0, 6)
if u_ij.count(None) == 0:
adps = u_ij
else:
assert u_ij.count(None) == 6
b_ij = [
self._wrap_loop_if_needed(
cif_block,
"_atom_site_anisotrop.B[%s][%s]" % (ij[0], ij[1]))
for ij in ("11", "22", "33", "12", "13", "23")
]
assert b_ij.count(None) in (0, 6)
if b_ij.count(None) == 0:
adps = adptbx.b_as_u(b_ij)
assert not (u_ij.count(None) and b_ij.count(None)
) # illegal for both to be present
if adps is not None:
try:
adps = [flex.double(adp) for adp in adps]
except ValueError as e:
raise CifBuilderError("Error interpreting ADPs: " + str(e))
adps = flex.sym_mat3_double(*adps)
py_adps = {}
if anisotrop_id is not None and adps is not None:
for an_id, adp in zip(list(anisotrop_id), list(adps)):
py_adps[an_id] = adp
current_model_id = None
current_label_asym_id = None
current_auth_asym_id = None
current_residue_id = None
current_ins_code = None
for i_atom in range(atom_labels.size()):
# model(s)
last_model_id = current_model_id
current_model_id = model_ids[i_atom]
assert current_model_id is not None
if current_model_id != last_model_id:
model = hierarchy.model(id=current_model_id)
self.hierarchy.append_model(model)
# chain(s)
last_label_asym_id = current_label_asym_id
current_label_asym_id = label_asym_id[i_atom]
assert current_label_asym_id is not None
last_auth_asym_id = current_auth_asym_id
current_auth_asym_id = auth_asym_id[i_atom]
assert current_auth_asym_id not in [".", "?", " "], "mmCIF file contains " + \
"record with empty auth_asym_id, which is wrong."
assert current_label_asym_id is not None
if (current_auth_asym_id != last_auth_asym_id
or current_model_id != last_model_id):
chain = hierarchy.chain(id=current_auth_asym_id)
model.append_chain(chain)
else:
assert current_auth_asym_id == last_auth_asym_id
# residue_group(s)
# defined by residue id and insertion code
last_residue_id = current_residue_id
current_residue_id = seq_id[i_atom]
assert current_residue_id is not None
last_ins_code = current_ins_code
if pdb_ins_code is not None:
current_ins_code = pdb_ins_code[i_atom]
if current_ins_code in ("?", ".", None): current_ins_code = " "
if (current_residue_id != last_residue_id
or current_ins_code != last_ins_code
or current_auth_asym_id != last_auth_asym_id
or current_model_id != last_model_id):
try:
resseq = hy36encode(width=4, value=int(current_residue_id))
except ValueError as e:
resseq = current_residue_id
assert len(resseq) == 4
residue_group = hierarchy.residue_group(resseq=resseq,
icode=current_ins_code)
chain.append_residue_group(residue_group)
atom_groups = OrderedDict() # reset atom_groups cache
# atom_group(s)
# defined by resname and altloc id
current_altloc = alt_id[i_atom]
if current_altloc == "." or current_altloc == "?":
current_altloc = "" # Main chain atoms
current_resname = comp_id[i_atom]
if (current_altloc, current_resname) not in atom_groups:
atom_group = hierarchy.atom_group(altloc=current_altloc,
resname=current_resname)
atom_groups[(current_altloc, current_resname)] = atom_group
if current_altloc == "":
residue_group.insert_atom_group(0, atom_group)
else:
residue_group.append_atom_group(atom_group)
else:
atom_group = atom_groups[(current_altloc, current_resname)]
# atom(s)
atom = hierarchy.atom()
atom_group.append_atom(atom)
atom.set_element(type_symbol[i_atom])
atom.set_name(
format_pdb_atom_name(atom_labels[i_atom], type_symbol[i_atom]))
atom.set_xyz(new_xyz=(cart_x[i_atom], cart_y[i_atom],
cart_z[i_atom]))
atom.set_b(B_iso_or_equiv[i_atom])
atom.set_occ(occu[i_atom])
# hy36encode should go once the pdb.hierarchy has been
# modified to no longer store fixed-width strings
atom.set_serial(
hy36encode(width=5, value=int(atom_site_id[i_atom])))
# some code relies on an empty segid being 4 spaces
atom.set_segid(" ")
if group_PDB is not None and group_PDB[i_atom] == "HETATM":
atom.hetero = True
if formal_charge is not None:
charge = formal_charge[i_atom]
if charge not in ("?", "."):
if charge.endswith("-") or charge.startswith("-"):
sign = "-"
else:
sign = "+"
charge = charge.strip(" -+")
charge = int(charge)
if charge == 0: sign = ""
atom.set_charge("%i%s" % (charge, sign))
if atom_site_fp is not None:
fp = atom_site_fp[i_atom]
if fp not in ("?", "."):
atom.set_fp(new_fp=float(fp))
if atom_site_fdp is not None:
fdp = atom_site_fdp[i_atom]
if fdp not in ("?", "."):
atom.set_fdp(new_fdp=float(fdp))
if anisotrop_id is not None and adps is not None:
py_u_ij = py_adps.get(atom.serial.strip(), None)
if py_u_ij is not None:
atom.set_uij(py_u_ij)
if len(self.hierarchy.models()) == 1:
# for compatibility with single-model PDB files
self.hierarchy.models()[0].id = ""
def __init__(self, cif_block):
crystal_symmetry_builder.__init__(self, cif_block)
self.hierarchy = hierarchy.root()
# These items are mandatory for the _atom_site loop, all others are optional
type_symbol = self._wrap_loop_if_needed(cif_block,
"_atom_site.type_symbol")
atom_labels = self._wrap_loop_if_needed(cif_block,
"_atom_site.auth_atom_id")
if atom_labels is None:
atom_labels = self._wrap_loop_if_needed(
cif_block, "_atom_site.label_atom_id"
) # corresponds to chem comp atom name
alt_id = self._wrap_loop_if_needed(
cif_block, "_atom_site.label_alt_id") # alternate conformer id
label_asym_id = self._wrap_loop_if_needed(
cif_block, "_atom_site.label_asym_id") # chain id
auth_asym_id = self._wrap_loop_if_needed(cif_block,
"_atom_site.auth_asym_id")
if label_asym_id is None: label_asym_id = auth_asym_id
if auth_asym_id is None: auth_asym_id = label_asym_id
comp_id = self._wrap_loop_if_needed(cif_block,
"_atom_site.auth_comp_id")
if comp_id is None:
comp_id = self._wrap_loop_if_needed(
cif_block, "_atom_site.label_comp_id") # residue name
entity_id = self._wrap_loop_if_needed(cif_block,
"_atom_site.label_entity_id")
seq_id = self._wrap_loop_if_needed(cif_block, "_atom_site.auth_seq_id")
if seq_id is None:
seq_id = self._wrap_loop_if_needed(
cif_block, "_atom_site.label_seq_id") # residue number
assert [atom_labels, alt_id, auth_asym_id, comp_id, entity_id,
seq_id].count(None) == 0, "someting is not present"
assert type_symbol is not None
atom_site_fp = cif_block.get('_atom_site.phenix_scat_dispersion_real')
atom_site_fdp = cif_block.get('_atom_site.phenix_scat_dispersion_imag')
pdb_ins_code = cif_block.get(
"_atom_site.pdbx_PDB_ins_code") # insertion code
model_ids = cif_block.get("_atom_site.pdbx_PDB_model_num")
atom_site_id = cif_block.get("_atom_site.id")
# only permitted values are ATOM or HETATM
group_PDB = cif_block.get("_atom_site.group_PDB")
# TODO: read esds
B_iso_or_equiv = flex.double(
self._wrap_loop_if_needed(cif_block, "_atom_site.B_iso_or_equiv"))
cart_x = flex.double(
self._wrap_loop_if_needed(cif_block, "_atom_site.Cartn_x"))
cart_y = flex.double(
self._wrap_loop_if_needed(cif_block, "_atom_site.Cartn_y"))
cart_z = flex.double(
self._wrap_loop_if_needed(cif_block, "_atom_site.Cartn_z"))
occu = flex.double(
self._wrap_loop_if_needed(cif_block, "_atom_site.occupancy"))
formal_charge = self._wrap_loop_if_needed(
cif_block, "_atom_site.pdbx_formal_charge")
# anisotropic b-factors
# TODO: read esds
anisotrop_id = self._wrap_loop_if_needed(cif_block,
"_atom_site_anisotrop.id")
adps = None
if anisotrop_id is not None:
u_ij = [
self._wrap_loop_if_needed(
cif_block,
"_atom_site_anisotrop.U[%s][%s]" % (ij[0], ij[1]))
for ij in ("11", "22", "33", "12", "13", "23")
]
assert u_ij.count(None) in (0, 6)
if u_ij.count(None) == 0:
adps = u_ij
else:
assert u_ij.count(None) == 6
b_ij = [
self._wrap_loop_if_needed(
cif_block,
"_atom_site_anisotrop.B[%s][%s]" % (ij[0], ij[1]))
for ij in ("11", "22", "33", "12", "13", "23")
]
assert b_ij.count(None) in (0, 6)
if b_ij.count(None) == 0:
adps = adptbx.b_as_u(b_ij)
assert not (u_ij.count(None) and b_ij.count(None)
) # illegal for both to be present
if adps is not None:
try:
adps = [flex.double(adp) for adp in adps]
except ValueError, e:
raise CifBuilderError("Error interpreting ADPs: " + str(e))
adps = flex.sym_mat3_double(*adps)
def fd_grads(self, proxy):
dynamic_restraint_proxy_classes = (
adp.adp_u_eq_similarity_proxy,
adp.adp_volume_similarity_proxy,
)
if isinstance(proxy, (dynamic_restraint_proxy_classes)):
n_restraints = len(proxy.i_seqs)
else:
n_restraints = rows_per_restraint.get(proxy.__class__, 1)
grads = [flex.double(self.param_map.n_parameters) for i in range(n_restraints)]
eps = 1e-8
uc = self.xray_structure.unit_cell()
xs = self.xray_structure
u_cart = xs.scatterers().extract_u_cart(uc).deep_copy()
u_star = xs.scatterers().extract_u_star().deep_copy()
u_iso = xs.scatterers().extract_u_iso().deep_copy()
single_delta_classes = (
adp.fixed_u_eq_adp,
)
for n in xrange(n_restraints):
for i in xrange(self.param_map.n_scatterers):
use_u_aniso = self.param_map[i].u_aniso > -1
use_u_iso = self.param_map[i].u_iso > -1
for j in range(6):
if use_u_aniso:
h = [0,0,0,0,0,0]
h[j] = eps
h = matrix.sym(sym_mat3=h)
u_star[i]=list((matrix.sym(sym_mat3=u_star[i]) + h).as_sym_mat3())
r = self.restraint(proxy, u_cart=flex.sym_mat3_double([
adptbx.u_star_as_u_cart(uc, u) for u in u_star]))
if isinstance(r, adp.rigid_bond):
d1 = r.delta_z()
elif isinstance(r, single_delta_classes):
d1 = r.delta()
else:
d1 = r.deltas()[n]
u_star[i]=list((matrix.sym(sym_mat3=u_star[i]) - 2*h).as_sym_mat3())
r = self.restraint(proxy, u_cart=flex.sym_mat3_double([
adptbx.u_star_as_u_cart(uc, u) for u in u_star]))
if isinstance(r, adp.rigid_bond):
d2 = r.delta_z()
elif isinstance(r, single_delta_classes):
d2 = r.delta()
else:
d2 = r.deltas()[n]
elif use_u_iso:
u_iso[i] += eps
r = self.restraint(proxy, u_iso=u_iso)
if isinstance(r, adp.rigid_bond):
d1 = r.delta_z()
elif isinstance(r, single_delta_classes):
d1 = r.delta()
else:
d1 = r.deltas()[n]
u_iso[i] -= 2*eps
r = self.restraint(proxy, u_iso=u_iso)
if isinstance(r, adp.rigid_bond):
d2 = r.delta_z()
elif isinstance(r, single_delta_classes):
d2 = r.delta()
else:
d2 = r.deltas()[n]
d_delta = (d1-d2)/(2*eps)
if not isinstance(r, adp.rigid_bond) and j > 2:
d_delta *= 2 # off diagonals count twice
if use_u_aniso:
grads[n][self.param_map[i].u_aniso+j] = d_delta
elif use_u_iso:
grads[n][self.param_map[i].u_iso] = d_delta
break
return grads
def run(args):
# if (len(args) == 0 ):
# raise RuntimeError("Please specify one or more pdb file names.")
mon_lib_srv = monomer_library.server.server()
ener_lib = monomer_library.server.ener_lib()
# pdb_file = libtbx.env.find_in_repositories(
# relative_path="phenix_regression/pdb/1A32.pdb",
# test=os.path.isfile)
pdb_file = "./4KI8.pdb"
# print pdb_file
processed_pdb_file = monomer_library.pdb_interpretation.process(
mon_lib_srv = mon_lib_srv,
ener_lib = ener_lib,
file_name = pdb_file,
raw_records = None,
force_symmetry = True)
xray_structure = processed_pdb_file.xray_structure()
pdb_inp = iotbx.pdb.input(file_name=pdb_file)
pdb_hierarchy = pdb_inp.construct_hierarchy()
xray_structure.scattering_type_registry(table = "wk1995")
xray_structure.convert_to_isotropic()
u_iso_start = xray_structure.extract_u_iso_or_u_equiv()
xray_structure.convert_to_anisotropic()
atoms = pdb_hierarchy.atoms()
atomsxyz = atoms.extract_xyz()
sites_cart = xray_structure.sites_cart()
atomic_weights = xray_structure.atomic_weights()
# nm_init_manager = nm_init(filename = "4ki8_evec.dat",
# n_modes = 50,
# atoms = atoms,
# zero_mode_input_flag = False,
# zero_mode_flag = True)
# eigenvector = nm_init_manager.return_modes(1)
selections = []
selection_strings = ["chain A", "chain B", "chain C", "chain D", "chain E", "chain F", "chain G"]
for string in selection_strings:
selections.append(processed_pdb_file.all_chain_proxies.selection(
string = string))
modes = tools.generate_evec(selections = selections,
xray_structure = xray_structure,
pdb_hierarchy = pdb_hierarchy,
filename = "4ki8_evec.dat",
n_modes = 50)
time_init_nm_adp = 0.0
uanisos = flex.sym_mat3_double(xray_structure.sites_cart().size(), [0,0,0,0,0,0])
for selection in selections:
modes1d = tools.selected_modes_to_1D(modes = modes, n_modes = 50, selection = selection)
weights_selected = xray_structure.atomic_weights().select(selection)
assert len(modes1d) % 50 == 0
nmval = tools.read_nmval_file(evalin = "4ki8_eval.dat",
n_modes = 50,
zero_mode_input_flag = False,
zero_mode_flag = True)
x = tools.init_nm_para(nmval = nmval,
n_modes = 50)
t1 = time.time()
# adp_nma = init_nm_adp(modes = modes1d,
# weights = weights_selected,
# n_modes = 50,
# zero_mode_flag = True)
# print len(adp_nma)
# s = unpack_x(x = x, n_modes = 50, zero_mode_flag = True)
uaniso_from_s_manager = uaniso_from_s(x = x, modes1d = modes1d, weights = weights_selected,
n_modes = 50,
zero_mode_flag = True)
u = uaniso_from_s_manager.u_cart()
uanisos.set_selected(selection, u)
len_mode = int(len(modes1d)/50)
t2 = time.time()
time_init_nm_adp += (t2 - t1)
print " time_init_nm_adp = %-7.2f"% time_init_nm_adp
# for i in range(50):
# modes_selected = modes[i].select(selection)
# for j in range(len_mode):
# assert modes1d[j+len_mode*i] == modes_selected[j]
# eigenA = eigenvector.select(selections[0])
# for selection in selections:
# sites_cart_selected = xray_structure.sites_cart().select(selection)
# atomic_weights_selected = xray_structure.atomic_weights().select(selection)
# nm_init_manager.gen_zero_modes(sites_cart_selected, atomic_weights_selected)
# zero_mode0 = nm_init_manager.return_zero_modes(0)
# print t2 - t1
tools.show_time()
def exercise_rigid_bond():
i_seqs = (1,2)
weight = 1
p = adp_restraints.rigid_bond_proxy(i_seqs=i_seqs,weight=weight)
assert p.i_seqs == i_seqs
assert p.weight == weight
sites = ((1,2,3),(2,3,4))
u_cart = ((1,2,3,4,5,6), (3,4,5,6,7,8))
expected_gradients = ((-4, -4, -4, -8, -8, -8), (4, 4, 4, 8, 8, 8))
r = adp_restraints.rigid_bond(sites=sites, u_cart=u_cart, weight=weight)
assert r.weight == weight
assert approx_equal(r.delta_z(), -6)
assert approx_equal(r.residual(), 36)
assert approx_equal(r.gradients(), expected_gradients)
sites_cart = flex.vec3_double(((1,2,3),(2,5,4),(3,4,5)))
u_cart = flex.sym_mat3_double(((1,2,3,4,5,6),
(2,3,3,5,7,7),
(3,4,5,3,7,8)))
r = adp_restraints.rigid_bond(
adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart),
proxy=p)
assert approx_equal(r.weight, weight)
unit_cell = uctbx.unit_cell([15,25,30,90,90,90])
sites_frac = unit_cell.fractionalize(sites_cart=sites_cart)
u_star = flex.sym_mat3_double([
adptbx.u_cart_as_u_star(unit_cell, u_cart_i)
for u_cart_i in u_cart])
pair = adp_restraints.rigid_bond_pair(sites_frac[1],
sites_frac[2],
u_star[1],
u_star[2],
unit_cell)
assert approx_equal(pair.delta_z(), abs(r.delta_z()))
assert approx_equal(pair.z_12(), r.z_12())
assert approx_equal(pair.z_21(), r.z_21())
#
gradients_aniso_cart = flex.sym_mat3_double(sites_cart.size(), (0,0,0,0,0,0))
gradients_iso = flex.double(sites_cart.size(), 0)
proxies = adp_restraints.shared_rigid_bond_proxy([p,p])
params = adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart)
residuals = adp_restraints.rigid_bond_residuals(params, proxies=proxies)
assert approx_equal(residuals, (r.residual(),r.residual()))
deltas = adp_restraints.rigid_bond_deltas(params, proxies=proxies)
assert approx_equal(deltas, (r.delta_z(),r.delta_z()))
residual_sum = adp_restraints.rigid_bond_residual_sum(
params=params,
proxies=proxies,
gradients_aniso_cart=gradients_aniso_cart)
assert approx_equal(residual_sum, 2 * r.residual())
for g,e in zip(gradients_aniso_cart[1:3], r.gradients()):
assert approx_equal(g, matrix.col(e)*2)
fd_grads_aniso, fd_grads_iso = finite_difference_gradients(
restraint_type=adp_restraints.rigid_bond,
proxy=p,
sites_cart=sites_cart,
u_cart=u_cart)
for g,e in zip(gradients_aniso_cart, fd_grads_aniso):
assert approx_equal(g, matrix.col(e)*2)
#
# check frame invariance of residual
#
u_cart_1 = matrix.sym(sym_mat3=(0.1,0.2,0.05,0.03,0.02,0.01))
u_cart_2 = matrix.sym(sym_mat3=(0.21,0.32,0.11,0.02,0.02,0.07))
u_cart = (u_cart_1.as_sym_mat3(),u_cart_2.as_sym_mat3())
site_cart_1 = matrix.col((1,2,3))
site_cart_2 = matrix.col((3,1,4.2))
sites = (tuple(site_cart_1),tuple(site_cart_2))
a = adp_restraints.rigid_bond(sites=sites, u_cart=u_cart, weight=1)
expected_residual = a.residual()
gen = flex.mersenne_twister()
for i in range(20):
R = matrix.rec(gen.random_double_r3_rotation_matrix(),(3,3))
u_cart_1_rot = R * u_cart_1 * R.transpose()
u_cart_2_rot = R * u_cart_2 * R.transpose()
u_cart = (u_cart_1_rot.as_sym_mat3(),u_cart_2_rot.as_sym_mat3())
site_cart_1_rot = R * site_cart_1
site_cart_2_rot = R * site_cart_2
sites = (tuple(site_cart_1_rot),tuple(site_cart_2_rot))
a = adp_restraints.rigid_bond(
sites=sites, u_cart=u_cart,
weight=1)
assert approx_equal(a.residual(), expected_residual)
def exercise_flex_xray_scatterer():
from cctbx import uctbx, sgtbx, xray
uc = uctbx.unit_cell((10,11,12))
sg = sgtbx.space_group_info("P 2")
a = flex.xray_scatterer()
assert a.size() == 0
a = flex.xray_scatterer((
xray.scatterer("Si1", (0.1,0.2,0.3)),
xray.scatterer("O1", (0.2,0.3,0.4), (1,2,3,-0.1,0.2,-0.3), 0.9),
xray.scatterer("K1", (0.3,0.4,0.5), (3,1,2,-0.2,0.3,-0.1), 0.8,
fp=5, fdp=7)))
assert a.size() == 3
assert a[1].multiplicity() == 0
a[1].apply_symmetry(uc, sg.group())
assert a[1].multiplicity() == 2
assert approx_equal(a[1].weight(), 0.9)
a.front().occupancy = 0.8
assert approx_equal(a[0].occupancy, 0.8)
a.back().occupancy = 0.7
assert approx_equal(a[-1].occupancy, 0.7)
a[0].flags.set_grad_site(state=True)
a[1].flags.set_grad_fp(state=True)
a[2].flags.param = -234
p = pickle.dumps(a)
b = pickle.loads(p)
a_ = a.deep_copy()
assert a_.n_grad_u_iso() == a_.n_grad_u_aniso() == 0
a_[0].flags.set_grad_u_iso(state=True)
a_[1].flags.set_grad_u_aniso(state=True)
a_[2].flags.set_grad_u_aniso(state=True)
assert a_.n_grad_u_iso() == 1
assert a_.n_grad_u_aniso() == 2
for i,ai in enumerate(a):
bi = b[i]
assert ai.label == bi.label
assert ai.scattering_type == bi.scattering_type
assert approx_equal(ai.fp, bi.fp)
assert approx_equal(ai.fdp, bi.fdp)
assert approx_equal(ai.site, bi.site)
assert ai.flags.use_u_aniso() == bi.flags.use_u_aniso()
assert ai.u_iso == bi.u_iso
assert ai.u_star == bi.u_star
assert ai.multiplicity() == bi.multiplicity()
assert approx_equal(ai.weight(), bi.weight())
assert ai.flags.bits == bi.flags.bits
assert ai.flags.param == bi.flags.param
assert b[0].flags.grad_site()
assert not b[0].flags.grad_fp()
assert not b[1].flags.grad_site()
assert b[1].flags.grad_fp()
assert b[2].flags.param == -234
assert list(a.extract_labels()) == ["Si1", "O1", "K1"]
assert list(a.extract_scattering_types()) == ["Si", "O", "K"]
assert approx_equal(a.extract_sites(),
((0.1,0.2,0.3),(0.2,0.3,0.4),(0.3,0.4,0.5)))
a.set_sites(sites=flex.vec3_double(
((-0.1,-0.2,-0.3),(-0.2,-0.3,-0.4),(-0.3,-0.4,-0.5))))
assert approx_equal(a.extract_sites(),
((-0.1,-0.2,-0.3),(-0.2,-0.3,-0.4),(-0.3,-0.4,-0.5)))
assert approx_equal(a[1].site, (-0.2,-0.3,-0.4))
assert approx_equal(a.extract_occupancies(), (0.8,0.9,0.7))
a.set_occupancies(occupancies=flex.double((0.1,0.2,0.3)))
assert approx_equal(a.extract_occupancies(), (0.1,0.2,0.3))
assert approx_equal(a[1].occupancy, 0.2)
assert approx_equal(a.extract_u_iso(), (0.0, -1.0, -1.0))
assert approx_equal(a.extract_u_iso_or_u_equiv(unit_cell=uc),
(0.0, 258, 236+1/3.))
a.set_u_iso(u_iso=flex.double((3,4,5)), selection=flex.bool(a.size(), True),
unit_cell = uc)
assert approx_equal(a.extract_u_iso(), (3,-1,-1))
assert approx_equal(a.extract_u_iso_or_u_equiv(unit_cell=uc),
(3, 4, 5))
assert approx_equal(a[1].u_iso, -1)
u_cart_answer = [(-1.0, -1.0, -1.0, -1.0, -1.0, -1.0),
(4, 4, 4, 0, 0, 0), (5, 5, 5, 0, 0, 0)]
assert approx_equal(a.extract_u_cart(uc), u_cart_answer)
a.set_u_star(u_star=flex.sym_mat3_double(
[(-1,-2,-1,-1,-1,-1),
(1,2,3,-0.6,0.2,-0.3),
(3,1,2,-0.2,0.5,-0.1)]))
assert approx_equal(a.extract_u_star(),
[(-1,-1,-1,-1,-1,-1),
(1,2,3,-0.6,0.2,-0.3),
(3,1,2,-0.2,0.5,-0.1)])
assert approx_equal(a[1].u_star, (1,2,3,-0.6,0.2,-0.3))
unit_cell = uctbx.unit_cell((1,1,1,90,90,90))
a.set_u_cart(
unit_cell=unit_cell,
u_cart=flex.sym_mat3_double(
[(-1,-2,-1,-1,-1,-1),
(1,2,3,-0.6,0.2,-0.3),
(3,1,2,-0.2,0.5,-0.1)]))
assert approx_equal(a.extract_u_cart(unit_cell=unit_cell),
[(-1,-1,-1,-1,-1,-1),
(1,2,3,-0.6,0.2,-0.3),
(3,1,2,-0.2,0.5,-0.1)])
#
a.set_u_cart(unit_cell = unit_cell,
u_cart = flex.sym_mat3_double([(1,2,3,4,5,6),
(0,0,0,1,2,3),
(1,2,3,0,0,0)]),
selection = flex.size_t([1,2]))
assert approx_equal(a.extract_u_cart(unit_cell=unit_cell),
[(-1,-1,-1,-1,-1,-1),
(0,0,0,1,2,3),
(1,2,3,0,0,0)])
#
unit_cell = uctbx.unit_cell((10,10,10,90,90,90))
a.set_u_cart(
unit_cell=unit_cell,
u_cart=flex.sym_mat3_double(
[(-1,-2,-1,-1,-1,-1),
(1,2,3,-0.6,0.2,-0.3),
(3,1,2,-0.2,0.5,-0.1)]))
assert approx_equal(a.extract_u_star(),
[(-1,-1,-1,-1,-1,-1),
(0.01, 0.02, 0.03, -0.006, 0.002, -0.003),
(0.03, 0.01, 0.02, -0.002, 0.005, -0.001)])
assert approx_equal(a.extract_u_iso(), [3,-1,-1])
a.scale_adps(2.0)
assert approx_equal(a.extract_u_star(),
[(-1,-1,-1,-1,-1,-1),
(0.02, 0.04, 0.06, -0.012, 0.004, -0.006),
(0.06, 0.02, 0.04, -0.004, 0.01, -0.002)])
assert approx_equal(a.extract_u_iso(), [6,-1,-1])
assert a.count_anisotropic() == 2
assert a.count_anomalous() == 1
a.convert_to_isotropic(unit_cell=unit_cell)
assert a.count_anisotropic() == 0
a.convert_to_anisotropic(unit_cell=unit_cell)
assert a.count_anisotropic() == 3
m = a.sites_mod_positive()
assert approx_equal(m.extract_sites(), [
(0.9,0.8,0.7),
(0.8,0.7,0.6),
(0.7,0.6,0.5)])
m[2].site = (0.7,0.6,1.4) # to avoid +-0.5 ambiguity
m = m.sites_mod_short()
assert approx_equal(m.extract_sites(), [
(-0.1,-0.2,-0.3),
(-0.2,-0.3,-0.4),
(-0.3,-0.4,0.4)])
#
assert a.extract_grad_u_iso().all_eq(False)
a[1].flags.set_grad_u_iso(state=True)
assert list(a.extract_grad_u_iso()) == [False, True, False]
def __init__(self, cif_block):
crystal_symmetry_builder.__init__(self, cif_block)
self.hierarchy = hierarchy.root()
# These items are mandatory for the _atom_site loop, all others are optional
type_symbol = cif_block.get("_atom_site.type_symbol")
atom_labels = cif_block.get("_atom_site.auth_atom_id")
if atom_labels is None:
atom_labels = cif_block.get("_atom_site.label_atom_id") # corresponds to chem comp atom name
alt_id = cif_block.get("_atom_site.label_alt_id") # alternate conformer id
label_asym_id = cif_block.get("_atom_site.label_asym_id") # chain id
auth_asym_id = cif_block.get("_atom_site.auth_asym_id")
if label_asym_id is None: label_asym_id = auth_asym_id
if auth_asym_id is None: auth_asym_id = label_asym_id
comp_id = cif_block.get("_atom_site.auth_comp_id")
if comp_id is None:
comp_id = cif_block.get("_atom_site.label_comp_id") # residue name
entity_id = cif_block.get("_atom_site.label_entity_id")
seq_id = cif_block.get("_atom_site.auth_seq_id")
if seq_id is None:
seq_id = cif_block.get("_atom_site.label_seq_id") # residue number
assert [atom_labels, alt_id, auth_asym_id, comp_id, entity_id, seq_id].count(None) == 0
assert type_symbol is not None
atom_site_fp = cif_block.get('_atom_site.phenix_scat_dispersion_real')
atom_site_fdp = cif_block.get('_atom_site.phenix_scat_dispersion_imag')
pdb_ins_code = cif_block.get("_atom_site.pdbx_PDB_ins_code") # insertion code
model_ids = cif_block.get("_atom_site.pdbx_PDB_model_num")
atom_site_id = cif_block.get("_atom_site.id")
# only permitted values are ATOM or HETATM
group_PDB = cif_block.get("_atom_site.group_PDB")
# TODO: read esds
B_iso_or_equiv = flex.double(cif_block.get("_atom_site.B_iso_or_equiv"))
cart_x = flex.double(cif_block.get("_atom_site.Cartn_x"))
cart_y = flex.double(cif_block.get("_atom_site.Cartn_y"))
cart_z = flex.double(cif_block.get("_atom_site.Cartn_z"))
occu = flex.double(cif_block.get("_atom_site.occupancy"))
formal_charge = cif_block.get("_atom_site.pdbx_formal_charge")
# anisotropic b-factors
# TODO: read esds
anisotrop_id = cif_block.get("_atom_site_anisotrop.id")
adps = None
if anisotrop_id is not None:
u_ij = [cif_block.get("_atom_site_anisotrop.U[%s][%s]" %(ij[0], ij[1]))
for ij in ("11", "22", "33", "12", "13", "23")]
assert u_ij.count(None) in (0, 6)
if u_ij.count(None) == 0:
adps = u_ij
else:
assert u_ij.count(None) == 6
b_ij = [cif_block.get("_atom_site_anisotrop.B[%s][%s]" %(ij[0], ij[1]))
for ij in ("11", "22", "33", "12", "13", "23")]
assert b_ij.count(None) in (0, 6)
if b_ij.count(None) == 0:
adps = adptbx.b_as_u(b_ij)
assert not (u_ij.count(None) and b_ij.count(None)) # illegal for both to be present
if adps is not None:
try:
adps = [flex.double(adp) for adp in adps]
except ValueError, e:
raise CifBuilderError("Error interpreting ADPs: " + str(e))
adps = flex.sym_mat3_double(*adps)
def exercise_adp_similarity():
u_cart = ((1,3,2,4,3,6),(2,4,2,6,5,1))
u_iso = (-1,-1)
use_u_aniso = (True, True)
weight = 1
a = adp_restraints.adp_similarity(
u_cart=u_cart,
weight=weight)
assert approx_equal(a.use_u_aniso, use_u_aniso)
assert a.weight == weight
assert approx_equal(a.residual(), 68)
assert approx_equal(a.gradients2(),
((-2.0, -2.0, 0.0, -8.0, -8.0, 20.0), (2.0, 2.0, -0.0, 8.0, 8.0, -20.0)))
assert approx_equal(a.deltas(), (-1.0, -1.0, 0.0, -2.0, -2.0, 5.0))
assert approx_equal(a.rms_deltas(), 2.7487370837451071)
#
u_cart = ((1,3,2,4,3,6),(-1,-1,-1,-1,-1,-1))
u_iso = (-1,2)
use_u_aniso = (True, False)
a = adp_restraints.adp_similarity(
u_cart[0], u_iso[1], weight=weight)
assert approx_equal(a.use_u_aniso, use_u_aniso)
assert a.weight == weight
assert approx_equal(a.residual(), 124)
assert approx_equal(a.gradients2(),
((-2, 2, 0, 16, 12, 24), (2, -2, 0, -16, -12, -24)))
assert approx_equal(a.deltas(), (-1, 1, 0, 4, 3, 6))
assert approx_equal(a.rms_deltas(), 3.711842908553348)
#
i_seqs_aa = (1,2) # () - ()
i_seqs_ai = (1,0) # () - o
i_seqs_ia = (3,2) # o - ()
i_seqs_ii = (0,3) # o - o
p_aa = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_aa,weight=weight)
p_ai = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_ai,weight=weight)
p_ia = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_ia,weight=weight)
p_ii = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_ii,weight=weight)
assert p_aa.i_seqs == i_seqs_aa
assert p_aa.weight == weight
u_cart = flex.sym_mat3_double(((-1,-1,-1,-1,-1,-1),
(1,2,2,4,3,6),
(2,4,2,6,5,1),
(-1,-1,-1,-1,-1,-1)))
u_iso = flex.double((1,-1,-1,2))
use_u_aniso = flex.bool((False, True,True,False))
for p in (p_aa,p_ai,p_ia,p_ii):
params = adp_restraint_params(u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso)
a = adp_restraints.adp_similarity(params, proxy=p)
assert approx_equal(a.weight, weight)
#
gradients_aniso_cart = flex.sym_mat3_double(u_cart.size(), (0,0,0,0,0,0))
gradients_iso = flex.double(u_cart.size(), 0)
proxies = adp_restraints.shared_adp_similarity_proxy([p,p])
residuals = adp_restraints.adp_similarity_residuals(params, proxies=proxies)
assert approx_equal(residuals, (a.residual(),a.residual()))
deltas_rms = adp_restraints.adp_similarity_deltas_rms(params, proxies=proxies)
assert approx_equal(deltas_rms, (a.rms_deltas(),a.rms_deltas()))
residual_sum = adp_restraints.adp_similarity_residual_sum(
params,
proxies=proxies,
gradients_aniso_cart=gradients_aniso_cart,
gradients_iso=gradients_iso)
assert approx_equal(residual_sum, 2 * a.residual())
fd_grads_aniso, fd_grads_iso = finite_difference_gradients(
restraint_type=adp_restraints.adp_similarity,
proxy=p,
u_cart=u_cart,
u_iso=u_iso,
use_u_aniso=use_u_aniso)
for g,e in zip(gradients_aniso_cart, fd_grads_aniso):
assert approx_equal(g, matrix.col(e)*2)
for g,e in zip(gradients_iso, fd_grads_iso):
assert approx_equal(g, e*2)
#
# check frame invariance of residual
#
u_cart_1 = matrix.sym(sym_mat3=(0.1,0.2,0.05,0.03,0.02,0.01))
u_cart_2 = matrix.sym(sym_mat3=(0.21,0.32,0.11,0.02,0.02,0.07))
u_cart = (u_cart_1.as_sym_mat3(),u_cart_2.as_sym_mat3())
u_iso = (-1, -1)
use_u_aniso = (True, True)
a = adp_restraints.adp_similarity(u_cart, weight=1)
expected_residual = a.residual()
gen = flex.mersenne_twister()
for i in range(20):
R = matrix.rec(gen.random_double_r3_rotation_matrix(),(3,3))
u_cart_1_rot = R * u_cart_1 * R.transpose()
u_cart_2_rot = R * u_cart_2 * R.transpose()
u_cart = (u_cart_1_rot.as_sym_mat3(),u_cart_2_rot.as_sym_mat3())
a = adp_restraints.adp_similarity(u_cart, weight=1)
assert approx_equal(a.residual(), expected_residual)
def __init__(self,
pdb_str,
dx=0,
dy=0,
dz=0,
sx=0,
sy=0,
sz=0,
lx=[1, 0, 0],
ly=[0, 1, 0],
lz=[0, 0, 1],
tx=0,
ty=0,
tz=0,
vx=[1, 0, 0],
vy=[0, 1, 0],
vz=[0, 0, 1],
w_M_lx=[0, 0, 0],
w_M_ly=[0, 0, 0],
w_M_lz=[0, 0, 0],
origin=None,
n_models=10000,
assert_similarity=True,
show=False,
log=sys.stdout,
write_pdb_files=False,
smear_eps=0):
from mmtbx.tls import analysis, tls_as_xyz
from scitbx import matrix
from libtbx.utils import null_out
if (show):
print >> log, "INPUTS:", "-" * 73
print >> log, "dx :", dx
print >> log, "dy :", dy
print >> log, "dz :", dz
print >> log, "sx :", sx
print >> log, "sy :", sy
print >> log, "sz :", sz
print >> log, "lx :", [i for i in lx]
print >> log, "ly :", [i for i in ly]
print >> log, "lz :", [i for i in lz]
print >> log, "tx :", tx
print >> log, "ty :", ty
print >> log, "tz :", tz
print >> log, "vx :", [i for i in vx]
print >> log, "vy :", [i for i in vy]
print >> log, "vz :", [i for i in vz]
print >> log, "w_M_lx:", [i for i in w_M_lx]
print >> log, "w_M_ly:", [i for i in w_M_ly]
print >> log, "w_M_lz:", [i for i in w_M_lz]
print >> log, "origin:", origin
print >> log, "-" * 79
#
pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_str)
ph = pdb_inp.construct_hierarchy()
xrs = ph.extract_xray_structure(
crystal_symmetry=pdb_inp.crystal_symmetry())
sites_cart = xrs.sites_cart()
ph.atoms().set_xyz(sites_cart)
if (origin is None):
origin = sites_cart.mean()
#
o_tfm = analysis.tls_from_motions(dx=dx,
dy=dy,
dz=dz,
l_x=matrix.col(lx),
l_y=matrix.col(ly),
l_z=matrix.col(lz),
sx=sx,
sy=sy,
sz=sz,
tx=tx,
ty=ty,
tz=tz,
v_x=matrix.col(vx),
v_y=matrix.col(vy),
v_z=matrix.col(vz),
w_M_lx=matrix.col(w_M_lx),
w_M_ly=matrix.col(w_M_ly),
w_M_lz=matrix.col(w_M_lz))
#
self.u_cart_tls = get_u_cart(o_tfm=o_tfm,
origin=origin,
sites_cart=sites_cart)
tlso_ = tlso(t=o_tfm.T_M.as_sym_mat3(),
l=o_tfm.L_M.as_sym_mat3(),
s=o_tfm.S_M.as_mat3(),
origin=origin)
if (assert_similarity):
T = matrix.sym(sym_mat3=tlso_.t)
L = matrix.sym(sym_mat3=tlso_.l)
S = matrix.sqr(tlso_.s)
o_tfm = analysis.run(T=T, L=L, S=S, log=null_out()).self_check()
#
r = tls_as_xyz.ensemble_generator(tls_from_motions_object=o_tfm,
pdb_hierarchy=ph,
xray_structure=xrs,
n_models=n_models,
origin=origin,
use_states=write_pdb_files,
log=null_out())
if (write_pdb_files):
r.write_pdb_file(file_name="ensemble_%s.pdb" % str(n_models))
#
xyz_all = r.sites_cart_ens
n_atoms = xyz_all[0].size()
###
xyz_atoms_all = all_vs_all(xyz_all=xyz_all)
###
self.u_cart_ens = flex.sym_mat3_double()
for i in xrange(n_atoms):
self.u_cart_ens.append(
u_cart_from_xyz(sites_cart=xyz_atoms_all[i]))
u1 = self.u_cart_tls.as_double()
u2 = self.u_cart_ens.as_double()
#self.r = flex.sum(flex.abs(u1-u2))/\
# flex.sum(flex.abs(flex.abs(u1)+flex.abs(u2)))*2
# LS
#diff = u1-u2
#self.rLS = math.sqrt(flex.sum(diff*diff)/(9.*diff.size()))
#
# Merritt / Murshudov
e = smear_eps
eps = matrix.sqr([e, 0, 0, 0, e, 0, 0, 0, e])
I = matrix.sqr([2, 0, 0, 0, 2, 0, 0, 0, 2])
def add_const(u):
es = eigensystem.real_symmetric(u)
vecs = es.vectors()
l_z = matrix.col((vecs[0], vecs[1], vecs[2]))
l_y = matrix.col((vecs[3], vecs[4], vecs[5]))
l_x = matrix.col((vecs[6], vecs[7], vecs[8]))
#l_x = l_y.cross(l_z)
u = matrix.sym(sym_mat3=u)
R = matrix.sqr([
l_x[0], l_y[0], l_z[0], l_x[1], l_y[1], l_z[1], l_x[2], l_y[2],
l_z[2]
])
uD = R.transpose() * u * R
result = R * (uD + eps) * R.transpose()
tmp = R * uD * R.transpose()
for i in xrange(6):
assert approx_equal(tmp[i], u[i])
return R * (uD + eps) * R.transpose()
self.KL = 0
self.CC = 0
n1, n2, d1, d2 = 0, 0, 0, 0
for u1, u2 in zip(self.u_cart_tls, self.u_cart_ens):
for i in xrange(6):
n1 += abs(u1[i] - u2[i])
d1 += (abs(u1[i]) + abs(u2[i]))
u1 = add_const(u=u1)
u2 = add_const(u=u2)
for i in xrange(6):
n2 += abs(u1[i] - u2[i])
d2 += (abs(u1[i]) + abs(u2[i]))
iu1 = u1.inverse()
iu2 = u2.inverse()
self.KL += (u1 * iu2 + u2 * iu1 - I).trace()
diu1 = iu1.determinant()
diu2 = iu2.determinant()
den = (iu1 + iu2).determinant()
self.CC += (diu1 * diu2)**0.25 / (den / 8)**0.5
self.KL = self.KL / self.u_cart_ens.size()
self.CC = self.CC / self.u_cart_ens.size()
self.R1 = n1 / d1 * 2
self.R2 = n2 / d2 * 2
self.r = self.R1
#
###
for i in xrange(n_atoms):
ut = ["%8.5f" % u for u in self.u_cart_tls[i]]
ue = ["%8.5f" % u for u in self.u_cart_ens[i]]
if (assert_similarity):
for j in xrange(6):
assert approx_equal(abs(float(ut[j])), abs(float(ue[j])),
1.e-3)
#
if (write_pdb_files):
ph.atoms().set_uij(self.u_cart_tls)
ph.write_pdb_file(file_name="u_from_tls.pdb",
crystal_symmetry=xrs.crystal_symmetry())
ph.atoms().set_uij(self.u_cart_ens)
ph.write_pdb_file(file_name="u_from_ens.pdb",
crystal_symmetry=xrs.crystal_symmetry())
def exercise_rigid_bond():
i_seqs = (1,2)
weight = 1
p = adp_restraints.rigid_bond_proxy(i_seqs=i_seqs,weight=weight)
assert p.i_seqs == i_seqs
assert p.weight == weight
sites = ((1,2,3),(2,3,4))
u_cart = ((1,2,3,4,5,6), (3,4,5,6,7,8))
expected_gradients = ((-4, -4, -4, -8, -8, -8), (4, 4, 4, 8, 8, 8))
r = adp_restraints.rigid_bond(sites=sites, u_cart=u_cart, weight=weight)
assert r.weight == weight
assert approx_equal(r.delta_z(), -6)
assert approx_equal(r.residual(), 36)
assert approx_equal(r.gradients(), expected_gradients)
sites_cart = flex.vec3_double(((1,2,3),(2,5,4),(3,4,5)))
u_cart = flex.sym_mat3_double(((1,2,3,4,5,6),
(2,3,3,5,7,7),
(3,4,5,3,7,8)))
r = adp_restraints.rigid_bond(
adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart),
proxy=p)
assert approx_equal(r.weight, weight)
unit_cell = uctbx.unit_cell([15,25,30,90,90,90])
sites_frac = unit_cell.fractionalize(sites_cart=sites_cart)
u_star = flex.sym_mat3_double([
adptbx.u_cart_as_u_star(unit_cell, u_cart_i)
for u_cart_i in u_cart])
pair = adp_restraints.rigid_bond_pair(sites_frac[1],
sites_frac[2],
u_star[1],
u_star[2],
unit_cell)
assert approx_equal(pair.delta_z(), abs(r.delta_z()))
assert approx_equal(pair.z_12(), r.z_12())
assert approx_equal(pair.z_21(), r.z_21())
#
gradients_aniso_cart = flex.sym_mat3_double(sites_cart.size(), (0,0,0,0,0,0))
gradients_iso = flex.double(sites_cart.size(), 0)
proxies = adp_restraints.shared_rigid_bond_proxy([p,p])
params = adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart)
residuals = adp_restraints.rigid_bond_residuals(params, proxies=proxies)
assert approx_equal(residuals, (r.residual(),r.residual()))
deltas = adp_restraints.rigid_bond_deltas(params, proxies=proxies)
assert approx_equal(deltas, (r.delta_z(),r.delta_z()))
residual_sum = adp_restraints.rigid_bond_residual_sum(
params=params,
proxies=proxies,
gradients_aniso_cart=gradients_aniso_cart)
assert approx_equal(residual_sum, 2 * r.residual())
for g,e in zip(gradients_aniso_cart[1:3], r.gradients()):
assert approx_equal(g, matrix.col(e)*2)
fd_grads_aniso, fd_grads_iso = finite_difference_gradients(
restraint_type=adp_restraints.rigid_bond,
proxy=p,
sites_cart=sites_cart,
u_cart=u_cart)
for g,e in zip(gradients_aniso_cart, fd_grads_aniso):
assert approx_equal(g, matrix.col(e)*2)
#
# check frame invariance of residual
#
u_cart_1 = matrix.sym(sym_mat3=(0.1,0.2,0.05,0.03,0.02,0.01))
u_cart_2 = matrix.sym(sym_mat3=(0.21,0.32,0.11,0.02,0.02,0.07))
u_cart = (u_cart_1.as_sym_mat3(),u_cart_2.as_sym_mat3())
site_cart_1 = matrix.col((1,2,3))
site_cart_2 = matrix.col((3,1,4.2))
sites = (tuple(site_cart_1),tuple(site_cart_2))
a = adp_restraints.rigid_bond(sites=sites, u_cart=u_cart, weight=1)
expected_residual = a.residual()
gen = flex.mersenne_twister()
for i in range(20):
R = matrix.rec(gen.random_double_r3_rotation_matrix(),(3,3))
u_cart_1_rot = R * u_cart_1 * R.transpose()
u_cart_2_rot = R * u_cart_2 * R.transpose()
u_cart = (u_cart_1_rot.as_sym_mat3(),u_cart_2_rot.as_sym_mat3())
site_cart_1_rot = R * site_cart_1
site_cart_2_rot = R * site_cart_2
sites = (tuple(site_cart_1_rot),tuple(site_cart_2_rot))
a = adp_restraints.rigid_bond(
sites=sites, u_cart=u_cart,
weight=1)
assert approx_equal(a.residual(), expected_residual)
def exercise_adp_similarity():
u_cart = ((1,3,2,4,3,6),(2,4,2,6,5,1))
u_iso = (-1,-1)
use_u_aniso = (True, True)
weight = 1
a = adp_restraints.adp_similarity(
u_cart=u_cart,
weight=weight)
assert approx_equal(a.use_u_aniso, use_u_aniso)
assert a.weight == weight
assert approx_equal(a.residual(), 68)
assert approx_equal(a.gradients2(),
((-2.0, -2.0, 0.0, -8.0, -8.0, 20.0), (2.0, 2.0, -0.0, 8.0, 8.0, -20.0)))
assert approx_equal(a.deltas(), (-1.0, -1.0, 0.0, -2.0, -2.0, 5.0))
assert approx_equal(a.rms_deltas(), 2.7487370837451071)
#
u_cart = ((1,3,2,4,3,6),(-1,-1,-1,-1,-1,-1))
u_iso = (-1,2)
use_u_aniso = (True, False)
a = adp_restraints.adp_similarity(
u_cart[0], u_iso[1], weight=weight)
assert approx_equal(a.use_u_aniso, use_u_aniso)
assert a.weight == weight
assert approx_equal(a.residual(), 124)
assert approx_equal(a.gradients2(),
((-2, 2, 0, 16, 12, 24), (2, -2, 0, -16, -12, -24)))
assert approx_equal(a.deltas(), (-1, 1, 0, 4, 3, 6))
assert approx_equal(a.rms_deltas(), 3.711842908553348)
#
i_seqs_aa = (1,2) # () - ()
i_seqs_ai = (1,0) # () - o
i_seqs_ia = (3,2) # o - ()
i_seqs_ii = (0,3) # o - o
p_aa = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_aa,weight=weight)
p_ai = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_ai,weight=weight)
p_ia = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_ia,weight=weight)
p_ii = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_ii,weight=weight)
assert p_aa.i_seqs == i_seqs_aa
assert p_aa.weight == weight
u_cart = flex.sym_mat3_double(((-1,-1,-1,-1,-1,-1),
(1,2,2,4,3,6),
(2,4,2,6,5,1),
(-1,-1,-1,-1,-1,-1)))
u_iso = flex.double((1,-1,-1,2))
use_u_aniso = flex.bool((False, True,True,False))
for p in (p_aa,p_ai,p_ia,p_ii):
params = adp_restraint_params(u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso)
a = adp_restraints.adp_similarity(params, proxy=p)
assert approx_equal(a.weight, weight)
#
gradients_aniso_cart = flex.sym_mat3_double(u_cart.size(), (0,0,0,0,0,0))
gradients_iso = flex.double(u_cart.size(), 0)
proxies = adp_restraints.shared_adp_similarity_proxy([p,p])
residuals = adp_restraints.adp_similarity_residuals(params, proxies=proxies)
assert approx_equal(residuals, (a.residual(),a.residual()))
deltas_rms = adp_restraints.adp_similarity_deltas_rms(params, proxies=proxies)
assert approx_equal(deltas_rms, (a.rms_deltas(),a.rms_deltas()))
residual_sum = adp_restraints.adp_similarity_residual_sum(
params,
proxies=proxies,
gradients_aniso_cart=gradients_aniso_cart,
gradients_iso=gradients_iso)
assert approx_equal(residual_sum, 2 * a.residual())
fd_grads_aniso, fd_grads_iso = finite_difference_gradients(
restraint_type=adp_restraints.adp_similarity,
proxy=p,
u_cart=u_cart,
u_iso=u_iso,
use_u_aniso=use_u_aniso)
for g,e in zip(gradients_aniso_cart, fd_grads_aniso):
assert approx_equal(g, matrix.col(e)*2)
for g,e in zip(gradients_iso, fd_grads_iso):
assert approx_equal(g, e*2)
#
# check frame invariance of residual
#
u_cart_1 = matrix.sym(sym_mat3=(0.1,0.2,0.05,0.03,0.02,0.01))
u_cart_2 = matrix.sym(sym_mat3=(0.21,0.32,0.11,0.02,0.02,0.07))
u_cart = (u_cart_1.as_sym_mat3(),u_cart_2.as_sym_mat3())
u_iso = (-1, -1)
use_u_aniso = (True, True)
a = adp_restraints.adp_similarity(u_cart, weight=1)
expected_residual = a.residual()
gen = flex.mersenne_twister()
for i in range(20):
R = matrix.rec(gen.random_double_r3_rotation_matrix(),(3,3))
u_cart_1_rot = R * u_cart_1 * R.transpose()
u_cart_2_rot = R * u_cart_2 * R.transpose()
u_cart = (u_cart_1_rot.as_sym_mat3(),u_cart_2_rot.as_sym_mat3())
a = adp_restraints.adp_similarity(u_cart, weight=1)
assert approx_equal(a.residual(), expected_residual)
def run(args):
# if (len(args) == 0 ):
# raise RuntimeError("Please specify one or more pdb file names.")
mon_lib_srv = monomer_library.server.server()
ener_lib = monomer_library.server.ener_lib()
# pdb_file = libtbx.env.find_in_repositories(
# relative_path="phenix_regression/pdb/1A32.pdb",
# test=os.path.isfile)
pdb_file = "./4KI8.pdb"
# print pdb_file
processed_pdb_file = monomer_library.pdb_interpretation.process(
mon_lib_srv=mon_lib_srv,
ener_lib=ener_lib,
file_name=pdb_file,
raw_records=None,
force_symmetry=True)
xray_structure = processed_pdb_file.xray_structure()
pdb_inp = iotbx.pdb.input(file_name=pdb_file)
pdb_hierarchy = pdb_inp.construct_hierarchy()
xray_structure.scattering_type_registry(table="wk1995")
xray_structure.convert_to_isotropic()
u_iso_start = xray_structure.extract_u_iso_or_u_equiv()
xray_structure.convert_to_anisotropic()
atoms = pdb_hierarchy.atoms()
atomsxyz = atoms.extract_xyz()
sites_cart = xray_structure.sites_cart()
atomic_weights = xray_structure.atomic_weights()
u_cart = xray_structure.scatterers().extract_u_cart(
xray_structure.unit_cell())
print atomic_weights.size()
# nm_init_manager = nm_init(filename = "4ki8_evec.dat",
# n_modes = 50,
# atoms = atoms,
# zero_mode_input_flag = False,
# zero_mode_flag = True)
# eigenvector = nm_init_manager.return_modes(1)
selections = []
selection_strings = [
"chain A", "chain B", "chain C", "chain D", "chain E", "chain F",
"chain G"
]
for string in selection_strings:
selections.append(
processed_pdb_file.all_chain_proxies.selection(string=string))
print selections[0]
print len(selections[0])
modes = tools.generate_evec(selections=selections,
xray_structure=xray_structure,
pdb_hierarchy=pdb_hierarchy,
filename="4ki8_evec.dat",
n_modes=50)
time_init_nm_adp = 0.0
uanisos = flex.sym_mat3_double(xray_structure.sites_cart().size(),
[0, 0, 0, 0, 0, 0])
nmval = tools.read_nmval_file(evalin="4ki8_eval.dat",
n_modes=50,
zero_mode_input_flag=False,
zero_mode_flag=True)
for selection in selections:
modes1d = tools.selected_modes_to_1D(modes=modes,
n_modes=50,
selection=selection)
# pprint(list(modes1d))
weights_selected = xray_structure.atomic_weights().select(selection)
u_cart_selected = u_cart.select(selection)
assert len(modes1d) % 50 == 0
x = tools.init_nm_para(nmval=nmval, n_modes=50)
# pprint(list(x))
t1 = time.time()
adp_nma = init_nm_adp(modes=modes1d,
weights=weights_selected,
n_modes=50,
zero_mode_flag=True)
# print len(adp_nma)
# s = unpack_x(x = x, n_modes = 50, zero_mode_flag = True)
uaniso_from_s_manager = uaniso_from_s(x=x,
adp_nma=adp_nma,
weights=weights_selected,
n_modes=50,
zero_mode_flag=True)
u = uaniso_from_s_manager.u_cart()
x_scaled = scale_x(x=x,
uanisos=u_cart_selected,
adp_all=u,
n_modes=50,
zero_mode_flag=True)
del uaniso_from_s_manager
uaniso_from_s_manager = uaniso_from_s(x=x_scaled,
adp_nma=adp_nma,
weights=weights_selected,
n_modes=50,
zero_mode_flag=True)
del u
u = uaniso_from_s_manager.u_cart()
uanisos.set_selected(selection, u)
len_mode = int(len(modes1d) / 50)
t2 = time.time()
time_init_nm_adp += (t2 - t1)
pprint(list(uanisos))
print " time_init_nm_adp = %-7.2f" % time_init_nm_adp
# for i in range(50):
# modes_selected = modes[i].select(selection)
# for j in range(len_mode):
# assert modes1d[j+len_mode*i] == modes_selected[j]
# eigenA = eigenvector.select(selections[0])
# for selection in selections:
# sites_cart_selected = xray_structure.sites_cart().select(selection)
# atomic_weights_selected = xray_structure.atomic_weights().select(selection)
# nm_init_manager.gen_zero_modes(sites_cart_selected, atomic_weights_selected)
# zero_mode0 = nm_init_manager.return_zero_modes(0)
# print t2 - t1
tools.show_time()
def exercise_proxy_show():
sites_cart = flex.vec3_double((
(-3.1739,10.8317,7.5653),(-2.5419,9.7567,6.6306),
(-3.3369,8.8794,4.5191),(-3.4640,9.9882,5.3896)))
site_labels = ("C1", "C2", "O16", "N8")
u_cart = flex.sym_mat3_double((
(0.0153,0.0206,0.0234,0.0035,-0.0052,-0.0051),
(0.0185,0.0109,0.0206,0.0005,-0.0010,0.0002),
(0.0295,0.0203,0.0218,-0.0010,-0.0003,-0.0044),
(0.0159,0.0154,0.0206,-0.0003,0.0004,0.0036)))
u_iso = flex.double((-1,-1,-1,-1))
use_u_aniso = flex.bool((True,True,True,True))
#
proxies = adp_restraints.shared_adp_similarity_proxy()
sio = StringIO()
proxies.show_sorted(
by_value="residual",
u_cart=flex.sym_mat3_double(),
u_iso=flex.double(),
use_u_aniso=flex.bool(),
f=sio)
assert not show_diff(sio.getvalue(), """\
ADP similarity restraints: 0
""")
proxies = adp_restraints.shared_adp_similarity_proxy([
adp_restraints.adp_similarity_proxy(i_seqs=[0,1],weight=25),
adp_restraints.adp_similarity_proxy(i_seqs=[2,3],weight=0.3)])
sio = StringIO()
proxies.show_sorted(
by_value="residual",
u_cart=u_cart,
u_iso=u_iso,
use_u_aniso=use_u_aniso,
f=sio,
prefix=":")
assert not show_diff(sio.getvalue(), """\
:ADP similarity restraints: 2
:Sorted by residual:
:scatterers 0
: 1
: delta sigma weight rms_deltas residual
: U11 -3.20e-03 2.00e-01 2.50e+01 4.96e-03 5.54e-03
: U22 9.70e-03 2.00e-01 2.50e+01
: U33 2.80e-03 2.00e-01 2.50e+01
: U12 3.00e-03 2.00e-01 2.50e+01
: U13 -4.20e-03 2.00e-01 2.50e+01
: U23 -5.30e-03 2.00e-01 2.50e+01
:scatterers 2
: 3
: delta sigma weight rms_deltas residual
: U11 1.36e-02 1.83e+00 3.00e-01 6.15e-03 1.02e-04
: U22 4.90e-03 1.83e+00 3.00e-01
: U33 1.20e-03 1.83e+00 3.00e-01
: U12 -7.00e-04 1.83e+00 3.00e-01
: U13 -7.00e-04 1.83e+00 3.00e-01
: U23 -8.00e-03 1.83e+00 3.00e-01
""")
sio = StringIO()
proxies.show_sorted(
by_value="rms_deltas",
site_labels=site_labels,
u_cart=u_cart,
u_iso=flex.double((0.024,0.031,0.021,0.028)),
use_u_aniso=flex.bool((False,False,False,False)),
f=sio,
prefix="=")
assert not show_diff(sio.getvalue(), """\
=ADP similarity restraints: 2
=Sorted by rms_deltas:
=scatterers C1
= C2
= delta sigma weight residual
= Uiso -7.00e-03 2.00e-01 2.50e+01 1.22e-03
=scatterers O16
= N8
= delta sigma weight residual
= Uiso -7.00e-03 1.83e+00 3.00e-01 1.47e-05
""")
#
proxies = adp_restraints.shared_isotropic_adp_proxy()
sio = StringIO()
proxies.show_sorted(
by_value="residual",
u_cart=flex.sym_mat3_double(),
u_iso=u_iso,
use_u_aniso=use_u_aniso,
f=sio)
assert not show_diff(sio.getvalue(), """\
Isotropic ADP restraints: 0
""")
proxies = adp_restraints.shared_isotropic_adp_proxy([
adp_restraints.isotropic_adp_proxy(i_seqs=(0,),weight=25),
adp_restraints.isotropic_adp_proxy(i_seqs=(2,),weight=0.3)])
sio = StringIO()
proxies.show_sorted(
by_value="residual",
site_labels=site_labels,
u_cart=u_cart,
u_iso=u_iso,
use_u_aniso=use_u_aniso,
f=sio,
prefix=" ")
assert not show_diff(sio.getvalue(), """\
Isotropic ADP restraints: 2
Sorted by residual:
scatterer C1
delta sigma weight rms_deltas residual
U11 -4.47e-03 2.00e-01 2.50e+01 4.27e-03 4.11e-03
U22 8.33e-04 2.00e-01 2.50e+01
U33 3.63e-03 2.00e-01 2.50e+01
U12 3.50e-03 2.00e-01 2.50e+01
U13 -5.20e-03 2.00e-01 2.50e+01
U23 -5.10e-03 2.00e-01 2.50e+01
scatterer O16
delta sigma weight rms_deltas residual
U11 5.63e-03 1.83e+00 3.00e-01 3.16e-03 2.69e-05
U22 -3.57e-03 1.83e+00 3.00e-01
U33 -2.07e-03 1.83e+00 3.00e-01
U12 -1.00e-03 1.83e+00 3.00e-01
U13 -3.00e-04 1.83e+00 3.00e-01
U23 -4.40e-03 1.83e+00 3.00e-01
""")
sio = StringIO()
proxies.show_sorted(
by_value="rms_deltas",
u_cart=u_cart,
u_iso=u_iso,
use_u_aniso=use_u_aniso,
f=sio,
prefix="$")
assert not show_diff(sio.getvalue(), """\
$Isotropic ADP restraints: 2
$Sorted by rms_deltas:
$scatterer 0
$ delta sigma weight rms_deltas residual
$ U11 -4.47e-03 2.00e-01 2.50e+01 4.27e-03 4.11e-03
$ U22 8.33e-04 2.00e-01 2.50e+01
$ U33 3.63e-03 2.00e-01 2.50e+01
$ U12 3.50e-03 2.00e-01 2.50e+01
$ U13 -5.20e-03 2.00e-01 2.50e+01
$ U23 -5.10e-03 2.00e-01 2.50e+01
$scatterer 2
$ delta sigma weight rms_deltas residual
$ U11 5.63e-03 1.83e+00 3.00e-01 3.16e-03 2.69e-05
$ U22 -3.57e-03 1.83e+00 3.00e-01
$ U33 -2.07e-03 1.83e+00 3.00e-01
$ U12 -1.00e-03 1.83e+00 3.00e-01
$ U13 -3.00e-04 1.83e+00 3.00e-01
$ U23 -4.40e-03 1.83e+00 3.00e-01
""")
#
proxies = adp_restraints.shared_rigid_bond_proxy()
sio = StringIO()
proxies.show_sorted(
by_value="residual",
sites_cart=flex.vec3_double(),
u_cart=flex.sym_mat3_double(),
f=sio)
assert not show_diff(sio.getvalue(), """\
Rigid bond restraints: 0
""")
proxies = adp_restraints.shared_rigid_bond_proxy([
adp_restraints.rigid_bond_proxy(i_seqs=(0,1),weight=25),
adp_restraints.rigid_bond_proxy(i_seqs=(0,2),weight=15),
adp_restraints.rigid_bond_proxy(i_seqs=(2,3),weight=25),
adp_restraints.rigid_bond_proxy(i_seqs=(3,1),weight=30)])
sio = StringIO()
proxies.show_sorted(
by_value="residual",
sites_cart=sites_cart,
site_labels=site_labels,
u_cart=u_cart,
f=sio,
prefix="*")
assert not show_diff(sio.getvalue(), """\
*Rigid bond restraints: 4
*Sorted by residual:
*scatterers O16
* N8
* delta_z sigma weight residual
* -3.96e-03 2.00e-01 2.50e+01 3.92e-04
*scatterers C1
* C2
* delta_z sigma weight residual
* 1.08e-03 2.00e-01 2.50e+01 2.89e-05
*scatterers C1
* O16
* delta_z sigma weight residual
* 4.03e-04 2.58e-01 1.50e+01 2.44e-06
*scatterers N8
* C2
* delta_z sigma weight residual
* -1.54e-04 1.83e-01 3.00e+01 7.16e-07
""")
sio = StringIO()
proxies.show_sorted(
by_value="delta",
sites_cart=sites_cart,
u_cart=u_cart,
f=sio,
prefix="||",
max_items=2)
assert not show_diff(sio.getvalue(), """\
||Rigid bond restraints: 4
||Sorted by delta:
||scatterers 2
|| 3
|| delta_z sigma weight residual
|| -3.96e-03 2.00e-01 2.50e+01 3.92e-04
||scatterers 0
|| 1
|| delta_z sigma weight residual
|| 1.08e-03 2.00e-01 2.50e+01 2.89e-05
||... (remaining 2 not shown)
""")
def run(args):
# if (len(args) == 0 ):
# raise RuntimeError("Please specify one or more pdb file names.")
mon_lib_srv = monomer_library.server.server()
ener_lib = monomer_library.server.ener_lib()
# pdb_file = libtbx.env.find_in_repositories(
# relative_path="phenix_regression/pdb/1A32.pdb",
# test=os.path.isfile)
pdb_file = "./4KSC.pdb"
# print pdb_file
processed_pdb_file = monomer_library.pdb_interpretation.process(
mon_lib_srv=mon_lib_srv,
ener_lib=ener_lib,
file_name=pdb_file,
raw_records=None,
force_symmetry=True)
xray_structure = processed_pdb_file.xray_structure()
pdb_inp = iotbx.pdb.input(file_name=pdb_file)
pdb_hierarchy = pdb_inp.construct_hierarchy()
xray_structure.scattering_type_registry(table="wk1995")
reflection_file = reflection_file_reader.any_reflection_file(
file_name="./4ksc-sf.cif")
miller_arrays = reflection_file.as_miller_arrays()
for miller_array in miller_arrays:
if (miller_array.is_xray_amplitude_array()):
f_obs = miller_array
# xray_structure.convert_to_isotropic()
# u_iso_start = xray_structure.extract_u_iso_or_u_equiv()
xray_structure.convert_to_anisotropic()
atoms = pdb_hierarchy.atoms()
atomsxyz = atoms.extract_xyz()
sites_cart = xray_structure.sites_cart()
atomic_weights = xray_structure.atomic_weights()
u_cart = xray_structure.scatterers().extract_u_cart(
xray_structure.unit_cell())
# nm_init_manager = nm_init(filename = "4ki8_evec.dat",
# n_modes = 50,
# atoms = atoms,
# zero_mode_input_flag = False,
# zero_mode_flag = True)
# eigenvector = nm_init_manager.return_modes(1)
selections = []
# selection_strings = ["chain A", "chain B", "chain C", "chain D", "chain E", "chain F", "chain G"]
selection_strings = ["chain A"]
for string in selection_strings:
selections.append(
processed_pdb_file.all_chain_proxies.selection(string=string))
modes = tools.generate_evec(selections=selections,
xray_structure=xray_structure,
pdb_hierarchy=pdb_hierarchy,
filename="eigenvectors.dat",
n_modes=20)
time_nm_from_uaniso = 0.0
uanisos = flex.sym_mat3_double(xray_structure.sites_cart().size(),
[0, 0, 0, 0, 0, 0])
nmval = tools.read_nmval_file(evalin="eigenvalues.dat",
n_modes=20,
zero_mode_input_flag=False,
zero_mode_flag=True)
xs_initial = []
adp_nmas = []
for selection in selections:
x = tools.init_nm_para(nmval=nmval, n_modes=20)
modes1d = tools.selected_modes_to_1D(modes=modes,
n_modes=20,
selection=selection)
weights_selected = xray_structure.atomic_weights().select(selection)
print "The number of selected atoms is %d." % len(weights_selected)
u_cart_selected = u_cart.select(selection)
adp_nma = init_nm_adp(modes=modes1d,
weights=weights_selected,
n_modes=20,
zero_mode_flag=True)
adp_nmas.append(adp_nma)
uaniso_from_s_manager = uaniso_from_s(
x=x,
adp_nma=adp_nma,
# weights = weights_selected,
n_modes=20,
zero_mode_flag=True)
u = uaniso_from_s_manager.u_cart()
x_scaled = scale_x(x=x,
uanisos=u_cart_selected,
adp_all=u,
n_modes=20,
zero_mode_flag=True)
xs_initial.append(x_scaled)
# t1 = time.time()
nm_from_uanisos = tools.nm_from_uanisos(xray_structure=xray_structure,
selections=selections,
modes=modes,
xs_initial=xs_initial,
n_modes=20,
number_of_macro_cycles=4,
verbose=1)
tools.update_xray_structure_with_nm(xray_structure=xray_structure,
adp_nmas=adp_nmas,
selections=selections,
xs=nm_from_uanisos,
n_modes=20,
zero_mode_flag=True)
# t2 = time.time()
# print t2 - t1
tools.show_time()
def fd_grads(self, proxy):
dynamic_restraint_proxy_classes = (
adp.adp_u_eq_similarity_proxy,
adp.adp_volume_similarity_proxy,
)
if isinstance(proxy, (dynamic_restraint_proxy_classes)):
n_restraints = len(proxy.i_seqs)
else:
n_restraints = rows_per_restraint.get(proxy.__class__, 1)
grads = [
flex.double(self.param_map.n_parameters)
for i in range(n_restraints)
]
eps = 1e-8
uc = self.xray_structure.unit_cell()
xs = self.xray_structure
u_cart = xs.scatterers().extract_u_cart(uc).deep_copy()
u_star = xs.scatterers().extract_u_star().deep_copy()
u_iso = xs.scatterers().extract_u_iso().deep_copy()
single_delta_classes = (adp.fixed_u_eq_adp, )
for n in xrange(n_restraints):
for i in xrange(self.param_map.n_scatterers):
use_u_aniso = self.param_map[i].u_aniso > -1
use_u_iso = self.param_map[i].u_iso > -1
for j in range(6):
if use_u_aniso:
h = [0, 0, 0, 0, 0, 0]
h[j] = eps
h = matrix.sym(sym_mat3=h)
u_star[i] = list(
(matrix.sym(sym_mat3=u_star[i]) + h).as_sym_mat3())
r = self.restraint(proxy,
u_cart=flex.sym_mat3_double([
adptbx.u_star_as_u_cart(uc, u)
for u in u_star
]))
if isinstance(r, adp.rigid_bond):
d1 = r.delta_z()
elif isinstance(r, single_delta_classes):
d1 = r.delta()
else:
d1 = r.deltas()[n]
u_star[i] = list((matrix.sym(sym_mat3=u_star[i]) -
2 * h).as_sym_mat3())
r = self.restraint(proxy,
u_cart=flex.sym_mat3_double([
adptbx.u_star_as_u_cart(uc, u)
for u in u_star
]))
if isinstance(r, adp.rigid_bond):
d2 = r.delta_z()
elif isinstance(r, single_delta_classes):
d2 = r.delta()
else:
d2 = r.deltas()[n]
elif use_u_iso:
u_iso[i] += eps
r = self.restraint(proxy, u_iso=u_iso)
if isinstance(r, adp.rigid_bond):
d1 = r.delta_z()
elif isinstance(r, single_delta_classes):
d1 = r.delta()
else:
d1 = r.deltas()[n]
u_iso[i] -= 2 * eps
r = self.restraint(proxy, u_iso=u_iso)
if isinstance(r, adp.rigid_bond):
d2 = r.delta_z()
elif isinstance(r, single_delta_classes):
d2 = r.delta()
else:
d2 = r.deltas()[n]
d_delta = (d1 - d2) / (2 * eps)
if not isinstance(r, adp.rigid_bond) and j > 2:
d_delta *= 2 # off diagonals count twice
if use_u_aniso:
grads[n][self.param_map[i].u_aniso + j] = d_delta
elif use_u_iso:
grads[n][self.param_map[i].u_iso] = d_delta
break
return grads
def __init__(self, cif_block):
# XXX To do: interpret _atom_site_refinement_flags
crystal_symmetry_builder.__init__(self, cif_block, strict=True)
atom_sites_frac = [
as_double_or_none_if_all_question_marks(
_, column_name='_atom_site_fract_%s' % axis)
for _, axis in [(cif_block.get('_atom_site_fract_%s' % axis), axis)
for axis in ('x', 'y', 'z')]
]
if atom_sites_frac.count(None) == 3:
atom_sites_cart = [
as_double_or_none_if_all_question_marks(
_, column_name='_atom_site_Cartn_%s' % axis) for _ in [
cif_block.get('_atom_site_Cartn_%s' % axis)
for axis in ('x', 'y', 'z')
]
]
if atom_sites_cart.count(None) != 0:
raise CifBuilderError("No atomic coordinates could be found")
atom_sites_cart = flex.vec3_double(*atom_sites_cart)
# XXX do we need to take account of _atom_sites_Cartn_tran_matrix_ ?
atom_sites_frac = self.crystal_symmetry.unit_cell().fractionalize(
atom_sites_cart)
else:
if atom_sites_frac.count(None) != 0:
raise CifBuilderError("No atomic coordinates could be found")
atom_sites_frac = flex.vec3_double(*atom_sites_frac)
labels = cif_block.get('_atom_site_label')
type_symbol = cif_block.get('_atom_site_type_symbol')
if type_symbol:
type_symbol = flex.std_string(
s.replace('0+', '').replace('0-', '') for s in type_symbol)
U_iso_or_equiv = flex_double_else_none(
cif_block.get('_atom_site_U_iso_or_equiv',
cif_block.get('_atom_site_U_equiv_geom_mean')))
if U_iso_or_equiv is None:
B_iso_or_equiv = flex_double_else_none(
cif_block.get('_atom_site_B_iso_or_equiv',
cif_block.get('_atom_site_B_equiv_geom_mean')))
adp_type = cif_block.get('_atom_site_adp_type')
occupancy = flex_double_else_none(
cif_block.get('_atom_site_occupancy'))
scatterers = flex.xray_scatterer()
atom_site_aniso_label = flex_std_string_else_none(
cif_block.get('_atom_site_aniso_label'))
if atom_site_aniso_label is not None:
atom_site_aniso_label = atom_site_aniso_label
adps = [
cif_block.get('_atom_site_aniso_U_%i' % i)
for i in (11, 22, 33, 12, 13, 23)
]
have_Bs = False
if adps.count(None) > 0:
adps = [
cif_block.get('_atom_site_aniso_B_%i' % i)
for i in (11, 22, 33, 12, 13, 23)
]
have_Bs = True
if adps.count(None) == 6:
adps = None
elif adps.count(None) > 0:
CifBuilderError("Some ADP items are missing")
else:
sel = None
for adp in adps:
f = (adp == "?")
if (sel is None): sel = f
else: sel &= f
sel = ~sel
atom_site_aniso_label = atom_site_aniso_label.select(sel)
try:
adps = [flex.double(adp.select(sel)) for adp in adps]
except ValueError as e:
raise CifBuilderError("Error interpreting ADPs: " + str(e))
adps = flex.sym_mat3_double(*adps)
for i in range(len(atom_sites_frac)):
kwds = {}
if labels is not None:
kwds.setdefault('label', str(labels[i]))
if type_symbol is not None:
kwds.setdefault('scattering_type', str(type_symbol[i]))
if (atom_site_aniso_label is not None and adps is not None
and labels is not None
and labels[i] in atom_site_aniso_label):
adp = adps[flex.first_index(atom_site_aniso_label, labels[i])]
if have_Bs: adp = adptbx.b_as_u(adp)
kwds.setdefault(
'u',
adptbx.u_cif_as_u_star(self.crystal_symmetry.unit_cell(),
adp))
elif U_iso_or_equiv is not None:
kwds.setdefault('u', float_from_string(U_iso_or_equiv[i]))
elif B_iso_or_equiv is not None:
kwds.setdefault('b', float_from_string(B_iso_or_equiv[i]))
if occupancy is not None:
kwds.setdefault('occupancy', float_from_string(occupancy[i]))
scatterers.append(xray.scatterer(**kwds))
scatterers.set_sites(atom_sites_frac)
self.structure = xray.structure(crystal_symmetry=self.crystal_symmetry,
scatterers=scatterers)
def __init__(self, u_cart,
u_iso=None,
use_u_aniso=None,
sites_cart=None,
adp_similarity_proxies=None,
rigid_bond_proxies=None,
isotropic_adp_proxies=None,
compute_gradients=True,
gradients_aniso_cart=None,
gradients_iso=None,
disable_asu_cache=False,
normalization=False):
adopt_init_args(self, locals())
self.number_of_restraints = 0
self.residual_sum = 0
self.normalization_factor = None
if (adp_similarity_proxies is not None):
assert u_iso is not None and use_u_aniso is not None
if (rigid_bond_proxies is not None): assert sites_cart is not None
if (sites_cart is not None): assert sites_cart.size() == u_cart.size()
if (u_iso is not None): assert u_iso.size() == u_cart.size()
if (use_u_aniso is not None): assert use_u_aniso.size() == u_cart.size()
if (compute_gradients):
if (self.gradients_aniso_cart is None):
self.gradients_aniso_cart = flex.sym_mat3_double(
sites_cart.size(), [0,0,0,0,0,0])
else:
assert self.gradients_aniso_cart.size() == sites_cart.size()
if (u_iso is not None and self.gradients_iso is None):
self.gradients_iso = flex.double(sites_cart.size(), 0)
elif (u_iso is not None):
assert self.gradients_iso.size() == sites_cart.size()
if (adp_similarity_proxies is None):
self.n_adp_similarity_proxies = None
self.adp_similarity_residual_sum = 0
else:
self.n_adp_similarity_proxies = len(adp_similarity_proxies)
self.adp_similarity_residual_sum = adp_restraints.adp_similarity_residual_sum(
u_cart=u_cart,
u_iso=u_iso,
use_u_aniso=use_u_aniso,
proxies=adp_similarity_proxies,
gradients_aniso_cart=self.gradients_aniso_cart,
gradients_iso=self.gradients_iso)
self.number_of_restraints += 6 * self.n_adp_similarity_proxies
self.residual_sum += self.adp_similarity_residual_sum
if (rigid_bond_proxies is None):
self.n_rigid_bond_proxies = None
self.rigid_bond_residual_sum = 0
else:
self.n_rigid_bond_proxies = len(rigid_bond_proxies)
self.rigid_bond_residual_sum = adp_restraints.rigid_bond_residual_sum(
sites_cart=sites_cart,
u_cart=u_cart,
proxies=rigid_bond_proxies,
gradients_aniso_cart=self.gradients_aniso_cart)
self.number_of_restraints += self.n_rigid_bond_proxies
self.residual_sum += self.rigid_bond_residual_sum
if (isotropic_adp_proxies is None):
self.n_isotropic_adp_proxies = None
self.isotropic_adp_residual_sum = 0
else:
self.n_isotropic_adp_proxies = len(isotropic_adp_proxies)
self.isotropic_adp_residual_sum = adp_restraints.isotropic_adp_residual_sum(
u_cart=u_cart,
proxies=isotropic_adp_proxies,
gradients_aniso_cart=self.gradients_aniso_cart)
self.number_of_restraints += self.n_isotropic_adp_proxies
self.residual_sum += self.isotropic_adp_residual_sum
self.finalize_target_and_gradients()
def __init__(self, cif_block):
# XXX To do: interpret _atom_site_refinement_flags
crystal_symmetry_builder.__init__(self, cif_block, strict=True)
atom_sites_frac = [
as_double_or_none_if_all_question_marks(
_, column_name='_atom_site_fract_%s' % axis) for _ in [
cif_block.get('_atom_site_fract_%s' % axis)
for axis in ('x', 'y', 'z')
]
]
if atom_sites_frac.count(None) == 3:
atom_sites_cart = [
as_double_or_none_if_all_question_marks(
_, column_name='_atom_site_Cartn_%s' % axis) for _ in [
cif_block.get('_atom_site_Cartn_%s' % axis)
for axis in ('x', 'y', 'z')
]
]
if atom_sites_cart.count(None) != 0:
raise CifBuilderError("No atomic coordinates could be found")
atom_sites_cart = flex.vec3_double(*atom_sites_cart)
# XXX do we need to take account of _atom_sites_Cartn_tran_matrix_ ?
atom_sites_frac = self.crystal_symmetry.unit_cell().fractionalize(
atom_sites_cart)
else:
if atom_sites_frac.count(None) != 0:
raise CifBuilderError("No atomic coordinates could be found")
atom_sites_frac = flex.vec3_double(*atom_sites_frac)
labels = cif_block.get('_atom_site_label')
type_symbol = cif_block.get('_atom_site_type_symbol')
U_iso_or_equiv = flex_double_else_none(
cif_block.get('_atom_site_U_iso_or_equiv',
cif_block.get('_atom_site_U_equiv_geom_mean')))
if U_iso_or_equiv is None:
B_iso_or_equiv = flex_double_else_none(
cif_block.get('_atom_site_B_iso_or_equiv',
cif_block.get('_atom_site_B_equiv_geom_mean')))
adp_type = cif_block.get('_atom_site_adp_type')
occupancy = flex_double_else_none(
cif_block.get('_atom_site_occupancy'))
scatterers = flex.xray_scatterer()
atom_site_aniso_label = flex_std_string_else_none(
cif_block.get('_atom_site_aniso_label'))
if atom_site_aniso_label is not None:
atom_site_aniso_label = atom_site_aniso_label
adps = [
cif_block.get('_atom_site_aniso_U_%i' % i)
for i in (11, 22, 33, 12, 13, 23)
]
have_Bs = False
if adps.count(None) > 0:
adps = [
cif_block.get('_atom_site_aniso_B_%i' % i)
for i in (11, 22, 33, 12, 13, 23)
]
have_Bs = True
if adps.count(None) == 6:
adps = None
elif adps.count(None) > 0:
CifBuilderError("Some ADP items are missing")
else:
sel = None
for adp in adps:
f = (adp == "?")
if (sel is None): sel = f
else: sel &= f
sel = ~sel
atom_site_aniso_label = atom_site_aniso_label.select(sel)
try:
adps = [flex.double(adp.select(sel)) for adp in adps]
except ValueError, e:
raise CifBuilderError("Error interpreting ADPs: " + str(e))
adps = flex.sym_mat3_double(*adps)
def __init__(self, cif_block):
# XXX To do: interpret _atom_site_refinement_flags
crystal_symmetry_builder.__init__(self, cif_block, strict=True)
atom_sites_frac = [as_double_or_none_if_all_question_marks(
_, column_name='_atom_site_fract_%s' %axis)
for _ in [cif_block.get('_atom_site_fract_%s' %axis)
for axis in ('x','y','z')]]
if atom_sites_frac.count(None) == 3:
atom_sites_cart = [as_double_or_none_if_all_question_marks(
_, column_name='_atom_site_Cartn_%s' %axis)
for _ in [cif_block.get('_atom_site_Cartn_%s' %axis)
for axis in ('x','y','z')]]
if atom_sites_cart.count(None) != 0:
raise CifBuilderError("No atomic coordinates could be found")
atom_sites_cart = flex.vec3_double(*atom_sites_cart)
# XXX do we need to take account of _atom_sites_Cartn_tran_matrix_ ?
atom_sites_frac = self.crystal_symmetry.unit_cell().fractionalize(
atom_sites_cart)
else:
if atom_sites_frac.count(None) != 0:
raise CifBuilderError("No atomic coordinates could be found")
atom_sites_frac = flex.vec3_double(*atom_sites_frac)
labels = cif_block.get('_atom_site_label')
type_symbol = cif_block.get('_atom_site_type_symbol')
if type_symbol:
type_symbol = flex.std_string(
s.replace('0+', '').replace('0-', '') for s in type_symbol)
U_iso_or_equiv = flex_double_else_none(
cif_block.get('_atom_site_U_iso_or_equiv',
cif_block.get('_atom_site_U_equiv_geom_mean')))
if U_iso_or_equiv is None:
B_iso_or_equiv = flex_double_else_none(
cif_block.get('_atom_site_B_iso_or_equiv',
cif_block.get('_atom_site_B_equiv_geom_mean')))
adp_type = cif_block.get('_atom_site_adp_type')
occupancy = flex_double_else_none(cif_block.get('_atom_site_occupancy'))
scatterers = flex.xray_scatterer()
atom_site_aniso_label = flex_std_string_else_none(
cif_block.get('_atom_site_aniso_label'))
if atom_site_aniso_label is not None:
atom_site_aniso_label = atom_site_aniso_label
adps = [cif_block.get('_atom_site_aniso_U_%i' %i)
for i in (11,22,33,12,13,23)]
have_Bs = False
if adps.count(None) > 0:
adps = [cif_block.get('_atom_site_aniso_B_%i' %i)
for i in (11,22,33,12,13,23)]
have_Bs = True
if adps.count(None) == 6:
adps = None
elif adps.count(None) > 0:
CifBuilderError("Some ADP items are missing")
else:
sel = None
for adp in adps:
f = (adp == "?")
if (sel is None): sel = f
else: sel &= f
sel = ~sel
atom_site_aniso_label = atom_site_aniso_label.select(sel)
try:
adps = [flex.double(adp.select(sel)) for adp in adps]
except ValueError, e:
raise CifBuilderError("Error interpreting ADPs: " + str(e))
adps = flex.sym_mat3_double(*adps)
def exercise_flex_xray_scatterer():
from cctbx import uctbx, sgtbx, xray
uc = uctbx.unit_cell((10, 11, 12))
sg = sgtbx.space_group_info("P 2")
a = flex.xray_scatterer()
assert a.size() == 0
a = flex.xray_scatterer((xray.scatterer("Si1", (0.1, 0.2, 0.3)),
xray.scatterer("O1", (0.2, 0.3, 0.4),
(1, 2, 3, -0.1, 0.2, -0.3), 0.9),
xray.scatterer("K1", (0.3, 0.4, 0.5),
(3, 1, 2, -0.2, 0.3, -0.1),
0.8,
fp=5,
fdp=7)))
assert a.size() == 3
assert a[1].multiplicity() == 0
a[1].apply_symmetry(uc, sg.group())
assert a[1].multiplicity() == 2
assert approx_equal(a[1].weight(), 0.9)
a.front().occupancy = 0.8
assert approx_equal(a[0].occupancy, 0.8)
a.back().occupancy = 0.7
assert approx_equal(a[-1].occupancy, 0.7)
a[0].flags.set_grad_site(state=True)
a[1].flags.set_grad_fp(state=True)
a[2].flags.param = -234
p = pickle.dumps(a)
b = pickle.loads(p)
a_ = a.deep_copy()
assert a_.n_grad_u_iso() == a_.n_grad_u_aniso() == 0
a_[0].flags.set_grad_u_iso(state=True)
a_[1].flags.set_grad_u_aniso(state=True)
a_[2].flags.set_grad_u_aniso(state=True)
assert a_.n_grad_u_iso() == 1
assert a_.n_grad_u_aniso() == 2
for i, ai in enumerate(a):
bi = b[i]
assert ai.label == bi.label
assert ai.scattering_type == bi.scattering_type
assert approx_equal(ai.fp, bi.fp)
assert approx_equal(ai.fdp, bi.fdp)
assert approx_equal(ai.site, bi.site)
assert ai.flags.use_u_aniso() == bi.flags.use_u_aniso()
assert ai.u_iso == bi.u_iso
assert ai.u_star == bi.u_star
assert ai.multiplicity() == bi.multiplicity()
assert approx_equal(ai.weight(), bi.weight())
assert ai.flags.bits == bi.flags.bits
assert ai.flags.param == bi.flags.param
assert b[0].flags.grad_site()
assert not b[0].flags.grad_fp()
assert not b[1].flags.grad_site()
assert b[1].flags.grad_fp()
assert b[2].flags.param == -234
assert list(a.extract_labels()) == ["Si1", "O1", "K1"]
assert list(a.extract_scattering_types()) == ["Si", "O", "K"]
assert approx_equal(a.extract_sites(),
((0.1, 0.2, 0.3), (0.2, 0.3, 0.4), (0.3, 0.4, 0.5)))
a.set_sites(sites=flex.vec3_double(((-0.1, -0.2, -0.3), (-0.2, -0.3, -0.4),
(-0.3, -0.4, -0.5))))
assert approx_equal(a.extract_sites(),
((-0.1, -0.2, -0.3), (-0.2, -0.3, -0.4),
(-0.3, -0.4, -0.5)))
assert approx_equal(a[1].site, (-0.2, -0.3, -0.4))
assert approx_equal(a.extract_occupancies(), (0.8, 0.9, 0.7))
a.set_occupancies(occupancies=flex.double((0.1, 0.2, 0.3)))
assert approx_equal(a.extract_occupancies(), (0.1, 0.2, 0.3))
assert approx_equal(a[1].occupancy, 0.2)
assert approx_equal(a.extract_u_iso(), (0.0, -1.0, -1.0))
assert approx_equal(a.extract_u_iso_or_u_equiv(unit_cell=uc),
(0.0, 258, 236 + 1 / 3.))
a.set_u_iso(u_iso=flex.double((3, 4, 5)),
selection=flex.bool(a.size(), True),
unit_cell=uc)
assert approx_equal(a.extract_u_iso(), (3, -1, -1))
assert approx_equal(a.extract_u_iso_or_u_equiv(unit_cell=uc), (3, 4, 5))
assert approx_equal(a[1].u_iso, -1)
u_cart_answer = [(-1.0, -1.0, -1.0, -1.0, -1.0, -1.0), (4, 4, 4, 0, 0, 0),
(5, 5, 5, 0, 0, 0)]
assert approx_equal(a.extract_u_cart(uc), u_cart_answer)
a.set_u_star(
u_star=flex.sym_mat3_double([(-1, -2, -1, -1, -1,
-1), (1, 2, 3, -0.6, 0.2,
-0.3), (3, 1, 2, -0.2, 0.5,
-0.1)]))
assert approx_equal(a.extract_u_star(), [(-1, -1, -1, -1, -1, -1),
(1, 2, 3, -0.6, 0.2, -0.3),
(3, 1, 2, -0.2, 0.5, -0.1)])
assert approx_equal(a[1].u_star, (1, 2, 3, -0.6, 0.2, -0.3))
unit_cell = uctbx.unit_cell((1, 1, 1, 90, 90, 90))
a.set_u_cart(unit_cell=unit_cell,
u_cart=flex.sym_mat3_double([(-1, -2, -1, -1, -1, -1),
(1, 2, 3, -0.6, 0.2, -0.3),
(3, 1, 2, -0.2, 0.5, -0.1)]))
assert approx_equal(a.extract_u_cart(unit_cell=unit_cell),
[(-1, -1, -1, -1, -1, -1), (1, 2, 3, -0.6, 0.2, -0.3),
(3, 1, 2, -0.2, 0.5, -0.1)])
#
a.set_u_cart(unit_cell=unit_cell,
u_cart=flex.sym_mat3_double([(1, 2, 3, 4, 5, 6),
(0, 0, 0, 1, 2, 3),
(1, 2, 3, 0, 0, 0)]),
selection=flex.size_t([1, 2]))
assert approx_equal(a.extract_u_cart(unit_cell=unit_cell),
[(-1, -1, -1, -1, -1, -1), (0, 0, 0, 1, 2, 3),
(1, 2, 3, 0, 0, 0)])
#
unit_cell = uctbx.unit_cell((10, 10, 10, 90, 90, 90))
a.set_u_cart(unit_cell=unit_cell,
u_cart=flex.sym_mat3_double([(-1, -2, -1, -1, -1, -1),
(1, 2, 3, -0.6, 0.2, -0.3),
(3, 1, 2, -0.2, 0.5, -0.1)]))
assert approx_equal(a.extract_u_star(),
[(-1, -1, -1, -1, -1, -1),
(0.01, 0.02, 0.03, -0.006, 0.002, -0.003),
(0.03, 0.01, 0.02, -0.002, 0.005, -0.001)])
assert approx_equal(a.extract_u_iso(), [3, -1, -1])
a.scale_adps(2.0)
assert approx_equal(a.extract_u_star(),
[(-1, -1, -1, -1, -1, -1),
(0.02, 0.04, 0.06, -0.012, 0.004, -0.006),
(0.06, 0.02, 0.04, -0.004, 0.01, -0.002)])
assert approx_equal(a.extract_u_iso(), [6, -1, -1])
assert a.count_anisotropic() == 2
assert a.count_anomalous() == 1
a.convert_to_isotropic(unit_cell=unit_cell)
assert a.count_anisotropic() == 0
a.convert_to_anisotropic(unit_cell=unit_cell)
assert a.count_anisotropic() == 3
m = a.sites_mod_positive()
assert approx_equal(m.extract_sites(), [(0.9, 0.8, 0.7), (0.8, 0.7, 0.6),
(0.7, 0.6, 0.5)])
m[2].site = (0.7, 0.6, 1.4) # to avoid +-0.5 ambiguity
m = m.sites_mod_short()
assert approx_equal(m.extract_sites(), [(-0.1, -0.2, -0.3),
(-0.2, -0.3, -0.4),
(-0.3, -0.4, 0.4)])
#
assert a.extract_grad_u_iso().all_eq(False)
a[1].flags.set_grad_u_iso(state=True)
assert list(a.extract_grad_u_iso()) == [False, True, False]
def run(args):
# if (len(args) == 0 ):
# raise RuntimeError("Please specify one or more pdb file names.")
mon_lib_srv = monomer_library.server.server()
ener_lib = monomer_library.server.ener_lib()
# pdb_file = libtbx.env.find_in_repositories(
# relative_path="phenix_regression/pdb/1A32.pdb",
# test=os.path.isfile)
pdb_file = "./4KSC.pdb"
# print pdb_file
processed_pdb_file = monomer_library.pdb_interpretation.process(
mon_lib_srv = mon_lib_srv,
ener_lib = ener_lib,
file_name = pdb_file,
raw_records = None,
force_symmetry = True)
xray_structure = processed_pdb_file.xray_structure()
pdb_inp = iotbx.pdb.input(file_name=pdb_file)
pdb_hierarchy = pdb_inp.construct_hierarchy()
# xray_structure.scattering_type_registry(table = "wk1995")
# reflection_file = reflection_file_reader.any_reflection_file(file_name = "./4ksc-sf.cif")
# miller_arrays = reflection_file.as_miller_arrays()
# for miller_array in miller_arrays:
# if (miller_array.is_xray_amplitude_array()):
# f_obs = miller_array
dummy = xray_structure.structure_factors(d_min = 2.0).f_calc()
f_obs = abs(dummy.structure_factors_from_scatterers(
xray_structure = xray_structure).f_calc())
flags = f_obs.generate_r_free_flags(fraction=0.01)
# f_calc = f_obs.structure_factors_from_scatterers(
# xray_structure = xray_structure).f_calc()
fmodel = mmtbx.f_model.manager(xray_structure = xray_structure,
f_obs = f_obs,
r_free_flags = flags)
# bulk_solvent_manager = bulk_solvent_and_scaling.bulk_solvent_and_scales(
# fmodel_kbu = fmodel.fmodel_kbu)
# f_bulk = bulk_solvent_manager.f_bulk()
# f_bulk.set_info("Bulk solvent structure factors")
# f_bulk.show_summary()
# xray_structure.convert_to_isotropic()
# u_iso_start = xray_structure.extract_u_iso_or_u_equiv()
xray_structure.set_b_iso(value = 25.0)
xray_structure.convert_to_anisotropic()
xray_structure.show_u_statistics(
text = "After set u_iso_start")
atoms = pdb_hierarchy.atoms()
atomsxyz = atoms.extract_xyz()
sites_cart = xray_structure.sites_cart()
atomic_weights = xray_structure.atomic_weights()
u_cart = xray_structure.scatterers().extract_u_cart(xray_structure.unit_cell())
# nm_init_manager = nm_init(filename = "4ki8_evec.dat",
# n_modes = 50,
# atoms = atoms,
# zero_mode_input_flag = False,
# zero_mode_flag = True)
# eigenvector = nm_init_manager.return_modes(1)
selections = []
# selection_strings = ["chain A", "chain B", "chain C", "chain D", "chain E", "chain F", "chain G"]
selection_strings = ["chain A"]
for string in selection_strings:
selections.append(processed_pdb_file.all_chain_proxies.selection(
string = string))
geometry = processed_pdb_file.geometry_restraints_manager(
show_energies = False,
plain_pairs_radius = 5.0)
restraints_manager = mmtbx.restraints.manager(geometry = geometry)
modes = tools.generate_evec(selections = selections,
xray_structure = xray_structure,
pdb_hierarchy = pdb_hierarchy,
filename = "eigenvectors.dat",
n_modes = 20)
time_nm_from_uaniso = 0.0
uanisos = flex.sym_mat3_double(xray_structure.sites_cart().size(), [0,0,0,0,0,0])
nmval = tools.read_nmval_file(evalin = "eigenvalues.dat",
n_modes = 20,
zero_mode_input_flag = False,
zero_mode_flag = True)
xs_initial = []
adp_nmas = []
for selection in selections:
x = tools.init_nm_para(nmval = nmval,
n_modes = 20)
modes1d = tools.selected_modes_to_1D(modes = modes, n_modes = 20, selection = selection)
weights_selected = xray_structure.atomic_weights().select(selection)
print "The number of selected atoms is %d." % len(weights_selected)
u_cart_selected = u_cart.select(selection)
adp_nma = init_nm_adp(modes = modes1d,
weights = weights_selected,
n_modes = 20,
zero_mode_flag = True)
adp_nmas.append(adp_nma)
uaniso_from_s_manager = uaniso_from_s(x = x,
adp_nma = adp_nma,
# weights = weights_selected,
n_modes = 20,
zero_mode_flag = True)
u = uaniso_from_s_manager.u_cart()
x_scaled = scale_x(x = x,
uanisos = u_cart_selected,
adp_all = u,
n_modes = 20,
zero_mode_flag = True)
xs_initial.append(x_scaled)
# t1 = time.time()
sfg_params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract()
sfg_params.cos_sin_table = False
tools.update_xray_structure_with_nm(xray_structure = xray_structure,
adp_nmas = adp_nmas,
selections = selections,
xs = xs_initial,
n_modes = 20,
zero_mode_flag = True)
class refinement_flags: pass
refinement_flags.adp_tls = selections
model = mmtbx.model.manager(
refinement_flags = refinement_flags,
restraints_manager = restraints_manager,
xray_structure = xray_structure,
pdb_hierarchy = pdb_hierarchy)
fmodel.update_xray_structure(xray_structure = xray_structure,
update_f_calc = True)
fmodel_cp = fmodel.deep_copy()
nm_refinement_manager = tools.nm_refinement(
fmodel = fmodel_cp,
model = model,
selections = selections,
selections_1d = None,
n_modes = 20,
number_of_macro_cycles = 50,
max_number_of_iterations = 10000,
start_xs_value = xs_initial,
run_finite_differences_test = False)
# t2 = time.time()
# print t2 - t1
tools.show_time()
def __init__(self,
pdb_str,
dx=0,
dy=0,
dz=0,
sx=0,
sy=0,
sz=0,
lx=[1, 0, 0],
ly=[0, 1, 0],
lz=[0, 0, 1],
tx=0,
ty=0,
tz=0,
vx=[1, 0, 0],
vy=[0, 1, 0],
vz=[0, 0, 1],
w_M_lx=[0, 0, 0],
w_M_ly=[0, 0, 0],
w_M_lz=[0, 0, 0],
origin=None,
n_models=10000,
assert_similarity=True,
show=False,
log=sys.stdout,
write_pdb_files=False):
from mmtbx.tls import analysis, tls_as_xyz
from scitbx import matrix
from libtbx.utils import null_out
if (show):
print >> log, "INPUTS:", "-" * 73
print >> log, "dx :", dx
print >> log, "dy :", dy
print >> log, "dz :", dz
print >> log, "sx :", sx
print >> log, "sy :", sy
print >> log, "sz :", sz
print >> log, "lx :", [i for i in lx]
print >> log, "ly :", [i for i in ly]
print >> log, "lz :", [i for i in lz]
print >> log, "tx :", tx
print >> log, "ty :", ty
print >> log, "tz :", tz
print >> log, "vx :", [i for i in vx]
print >> log, "vy :", [i for i in vy]
print >> log, "vz :", [i for i in vz]
print >> log, "w_M_lx:", [i for i in w_M_lx]
print >> log, "w_M_ly:", [i for i in w_M_ly]
print >> log, "w_M_lz:", [i for i in w_M_lz]
print >> log, "origin:", origin
print >> log, "-" * 79
#
pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_str)
ph = pdb_inp.construct_hierarchy()
xrs = ph.extract_xray_structure(
crystal_symmetry=pdb_inp.crystal_symmetry())
sites_cart = xrs.sites_cart()
ph.atoms().set_xyz(sites_cart)
if (origin is None):
origin = sites_cart.mean()
#
o_tfm = analysis.tls_from_motions(dx=dx,
dy=dy,
dz=dz,
l_x=matrix.col(lx),
l_y=matrix.col(ly),
l_z=matrix.col(lz),
sx=sx,
sy=sy,
sz=sz,
tx=tx,
ty=ty,
tz=tz,
v_x=matrix.col(vx),
v_y=matrix.col(vy),
v_z=matrix.col(vz),
w_M_lx=matrix.col(w_M_lx),
w_M_ly=matrix.col(w_M_ly),
w_M_lz=matrix.col(w_M_lz))
#
self.u_cart_tls = get_u_cart(o_tfm=o_tfm,
origin=origin,
sites_cart=sites_cart)
tlso_ = tlso(t=o_tfm.T_M.as_sym_mat3(),
l=o_tfm.L_M.as_sym_mat3(),
s=o_tfm.S_M.as_mat3(),
origin=origin)
if (assert_similarity):
T = matrix.sym(sym_mat3=tlso_.t)
L = matrix.sym(sym_mat3=tlso_.l)
S = matrix.sqr(tlso_.s)
o_tfm = analysis.run(T=T, L=L, S=S, log=null_out()).self_check()
#
r = tls_as_xyz.ensemble_generator(tls_from_motions_object=o_tfm,
pdb_hierarchy=ph,
xray_structure=xrs,
n_models=n_models,
origin=origin,
use_states=write_pdb_files,
log=null_out())
if (write_pdb_files):
r.write_pdb_file(file_name="ensemble_%s.pdb" % str(n_models))
#
xyz_all = r.sites_cart_ens
n_atoms = xyz_all[0].size()
###
xyz_atoms_all = all_vs_all(xyz_all=xyz_all)
###
self.u_cart_ens = flex.sym_mat3_double()
for i in xrange(n_atoms):
self.u_cart_ens.append(
u_cart_from_xyz(sites_cart=xyz_atoms_all[i]))
u1 = self.u_cart_tls.as_double()
u2 = self.u_cart_ens.as_double()
self.r = flex.sum(flex.abs(u1-u2))/\
flex.sum(flex.abs(flex.abs(u1)+flex.abs(u2)))*2
###
for i in xrange(n_atoms):
ut = ["%8.5f" % u for u in self.u_cart_tls[i]]
ue = ["%8.5f" % u for u in self.u_cart_ens[i]]
if (assert_similarity):
for j in xrange(6):
assert approx_equal(abs(float(ut[j])), abs(float(ue[j])),
1.e-3)
#
if (write_pdb_files):
ph.atoms().set_uij(self.u_cart_tls)
ph.write_pdb_file(file_name="u_from_tls.pdb",
crystal_symmetry=xrs.crystal_symmetry())
ph.atoms().set_uij(self.u_cart_ens)
ph.write_pdb_file(file_name="u_from_ens.pdb",
crystal_symmetry=xrs.crystal_symmetry())
