def exercise_approx_equal():
assert approx_equal(1., 1. + 1e-11)
assert approx_equal(1+1j, 0.997+1.004j, eps=1e-2)
assert approx_equal(1, 0.997+0.004j, eps=1e-2)
assert approx_equal(1+0.003j, 0.997, eps=1e-2)
assert approx_equal([ 2.5, 3.4+5.8j, 7.89],
[ 2.4+0.1j, 3.5+5.9j, 7.90], eps=0.2)
def exercise_3():
missing = check_external_dependencies(['scipy', 'sklearn', 'networkx'])
if len(missing):
print ("Skipping exercise_3: missing dependencies" +
" %s" * len(missing)) %(tuple(missing))
return
# thaumatin
data_dir = os.path.join(dials_regression, "indexing_test_data", "i04_weak_data")
pickle_path = os.path.join(data_dir, "full.pickle")
sweep_path = os.path.join(data_dir, "datablock_orig.json")
extra_args = ["cluster_analysis_search=True",
"n_macro_cycles=3",
"bin_size_fraction=0.25",
"reciprocal_space_grid.d_min=4"]
expected_unit_cell = uctbx.unit_cell(
(58, 58, 150, 90, 90, 90))
expected_rmsds = (0.05, 0.041, 0.0004)
# now enforce symmetry
extra_args.append("known_symmetry.space_group=P4")
expected_hall_symbol = ' P 4'
result = run_one_indexing(pickle_path, sweep_path, extra_args, expected_unit_cell,
expected_rmsds, expected_hall_symbol)
a, b, c = result.crystal_model.get_real_space_vectors()
assert approx_equal(a.length(), b.length())
assert c.length() > b.length()
assert approx_equal(a.angle(b, deg=True), 90)
assert approx_equal(b.angle(c, deg=True), 90)
assert approx_equal(c.angle(a, deg=True), 90)
def exercise_00():
file = libtbx.env.find_in_repositories(relative_path=
"chem_data/polygon_data/all_mvd.pickle", test=os.path.isfile)
database_dict = easy_pickle.load(file)
#
i_1l2h = list(database_dict["pdb_code"]).index("1l2h")
found = 0
for key in database_dict.keys():
#print key, ": ",database_dict[key][i_1l2h]
#
value = database_dict[key][i_1l2h]
if(key == "unit_cell"):
assert "(53.89, 53.89, 77.36, 90, 90, 90)" == value.strip()
found += 1
if(key == "high_resolution"):
assert approx_equal(1.54, float(value))
found += 1
if(key == "pdb_header_tls"):
assert "false (n_groups: 0)" == value.strip()
found += 1
if(key == "test_set_size"):
assert approx_equal(0.0476, float(value),0002)
found += 1
if(key == "twinned"):
assert "h,-k,-l" == value.strip()
found += 1
#
assert found == 5
def test_fit():
x1_obs=[]
x2_obs=[]
x1m=1.0
x2m=3.0
a=1
b=2
c=-0.5
y_obs=[]
for ii in range(10):
for jj in range(10):
x1_obs.append(ii-5)
x2_obs.append(jj-5)
y_obs.append(
a*(( (ii-5.0)-x1m )**2.0) +
b*(( (jj-5.0)-x2m )**2.0) +
2.0*c*( (ii-5.0)-x1m )*( (jj-5.0)-x2m )
)
fit =fqf.fit_quadratic_function_2d_data( x1_obs, x2_obs, y_obs )
assert approx_equal( fit.x1m, x1m, eps=1e-5)
assert approx_equal( fit.x2m, x2m, eps=1e-5)
assert approx_equal( fit.a, a, eps=1e-5)
assert approx_equal( fit.b, b, eps=1e-5)
assert approx_equal( fit.c, c, eps=1e-5)
print 'OK'
def assert_equal_data_and_sigmas(array_1, array_2):
a, b = array_1.map_to_asu().common_sets(array_2.map_to_asu())
assert a.indices().all_eq(b.indices())
from libtbx.test_utils import approx_equal
assert approx_equal(a.data(), b.data())
if (not array_1.is_xray_reconstructed_amplitude_array()):
assert approx_equal(a.sigmas(), b.sigmas())
def check_adp_set_b_iso(
cmd, xrsp_init, output, selection, selection_str, verbose,
tolerance=1.e-3):
remove_files(output)
run_command(command=cmd, verbose=verbose)
xrsp = xray_structure_plus(file_name = output)
assert approx_equal(xrsp.occ, xrsp_init.occ,tolerance)
assert approx_equal(xrsp.sites_cart, xrsp_init.sites_cart,tolerance)
assert approx_equal(xrsp.use_u_iso, xrsp_init.use_u_iso,tolerance)
assert approx_equal(xrsp.use_u_aniso,xrsp_init.use_u_aniso,tolerance)
assert approx_equal(xrsp.u_iso_not_used, xrsp_init.u_iso_not_used,tolerance)
assert approx_equal(xrsp.u_cart_not_used,xrsp_init.u_cart_not_used,tolerance)
if(selection_str is None):
assert not_approx_equal(xrsp.u_iso_used, xrsp_init.u_iso_used,tolerance)
for ucart in xrsp.u_cart:
b_iso = adptbx.u_as_b(adptbx.u_cart_as_u_iso(ucart))
if b_iso > 0: assert approx_equal(b_iso, 10, 0.005)
else: assert approx_equal(b_iso, -78.956, 0.005)
else:
arg1 = xrsp.u_iso_used.select(selection.select(xrsp.use_u_iso))
arg2 = xrsp_init.u_iso_used.select(selection.select(xrsp_init.use_u_iso))
if(arg1.size() > 0): assert not_approx_equal(arg1, arg2,tolerance)
for ucart in xrsp.u_cart:
b_iso = adptbx.u_as_b(adptbx.u_cart_as_u_iso(ucart))
if b_iso > 0: assert approx_equal(b_iso, 10, 0.005)
else: assert approx_equal(b_iso, -78.956, 0.005)
def tst_import_beam_centre(self):
from glob import glob
import os
from libtbx import easy_run
from dxtbx.serialize import load
# Find the image files
image_files = glob(os.path.join(self.path, "centroid*.cbf"))
image_files = ' '.join(image_files)
# provide mosflm beam centre to dials.import
cmd = 'dials.import %s mosflm_beam_centre=100,200 output.datablock=mosflm_beam_centre.json' %image_files
easy_run.fully_buffered(cmd)
assert os.path.exists("mosflm_beam_centre.json")
datablock = load.datablock("mosflm_beam_centre.json")[0]
imgset = datablock.extract_imagesets()[0]
beam_centre = imgset.get_detector()[0].get_beam_centre(imgset.get_beam().get_s0())
assert approx_equal(beam_centre, (200,100))
# provide an alternative datablock.json to get geometry from
cmd = 'dials.import %s reference_geometry=mosflm_beam_centre.json output.datablock=mosflm_beam_centre2.json' %image_files
easy_run.fully_buffered(cmd)
assert os.path.exists("mosflm_beam_centre2.json")
datablock = load.datablock("mosflm_beam_centre2.json")[0]
imgset = datablock.extract_imagesets()[0]
beam_centre = imgset.get_detector()[0].get_beam_centre(imgset.get_beam().get_s0())
assert approx_equal(beam_centre, (200,100))
print 'OK'
def exercise_match_bijvoet_mates():
h0 = flex.miller_index(((1,2,3), (-1,-2,-3), (2,3,4), (-2,-3,-4), (3,4,5)))
d0 = flex.double((1,2,3,4,5))
bm = miller.match_bijvoet_mates(
sgtbx.space_group_type(),
h0)
bm = miller.match_bijvoet_mates(
sgtbx.reciprocal_space_asu(sgtbx.space_group_type()),
h0)
bm = miller.match_bijvoet_mates(
h0)
assert tuple(bm.pairs()) == ((0,1), (2,3))
assert tuple(bm.singles("+")) == (4,)
assert tuple(bm.singles("-")) == ()
assert bm.n_singles() != 0
assert tuple(bm.pairs_hemisphere_selection("+")) == (0, 2)
assert tuple(bm.pairs_hemisphere_selection("-")) == (1, 3)
assert tuple(bm.singles_hemisphere_selection("+")) == (4,)
assert tuple(bm.singles_hemisphere_selection("-")) == ()
assert tuple(bm.miller_indices_in_hemisphere("+")) == ((1,2,3), (2,3,4))
assert tuple(bm.miller_indices_in_hemisphere("-")) == ((-1,-2,-3),(-2,-3,-4))
assert approx_equal(tuple(bm.minus(d0)), (-1, -1))
assert approx_equal(tuple(bm.additive_sigmas(d0)),
[math.sqrt(x*x+y*y) for x,y in ((1,2), (3,4))])
assert approx_equal(tuple(bm.average(d0)), (3/2., 7/2.))
h0.append((1,2,3))
try: miller.match_bijvoet_mates(h0)
except Exception: pass
else: raise Exception_expected
def check_f_calc_derivs():
eps = 1e-6
g_fin = flex.complex_double()
c_fin = flex.vec3_double()
for ih in xrange(f_calc.size()):
c_orig = f_calc[ih]
g_fin_ab = []
c_fin_ab = []
for iab in [0, 1]:
fs = []
gs = []
for signed_eps in [eps, -eps]:
if iab == 0:
f_calc[ih] = complex(c_orig.real + signed_eps, c_orig.imag)
else:
f_calc[ih] = complex(c_orig.real, c_orig.imag + signed_eps)
trg_eps = r1.target(f_obs=f_obs, f_calc=f_calc)
fs.append(trg_eps.t)
gs.append(trg_eps.f_calc_gradients[ih])
g_fin_ab.append((fs[0] - fs[1]) / (2 * eps))
c_fin_ab.append((gs[0] - gs[1]) / (2 * eps))
g_fin.append(complex(*g_fin_ab))
assert approx_equal(c_fin_ab[0].imag, c_fin_ab[1].real)
c_fin.append((c_fin_ab[0].real, c_fin_ab[1].imag, c_fin_ab[0].imag))
f_calc[ih] = c_orig
for pn, f, a in zip(g_fin.part_names(), g_fin.parts(), trg.f_calc_gradients.parts()):
print >> log, "g fin %s:" % pn, numstr(f)
print >> log, " ana %s:" % pn, numstr(a)
assert approx_equal(trg.f_calc_gradients, g_fin)
for pn, f, a in zip(["aa", "bb", "ab"], c_fin.parts(), trg.f_calc_hessians.parts()):
print >> log, "c fin %s:" % pn, numstr(f)
print >> log, " ana %s:" % pn, numstr(a)
assert approx_equal(trg.f_calc_hessians, c_fin)
def exercise():
t = henke.table("SI")
assert t.label() == "Si"
assert t.atomic_number() == 14
f = t.at_angstrom(2)
assert f.is_valid_fp()
assert f.is_valid_fdp()
assert f.is_valid()
from cctbx import factor_kev_angstrom
assert approx_equal(f.fp(), t.at_kev(factor_kev_angstrom / 2).fp())
assert approx_equal(f.fdp(), t.at_kev(factor_kev_angstrom / 2).fdp())
assert approx_equal(f.fp(), t.at_ev(1000 * factor_kev_angstrom / 2).fp())
assert approx_equal(f.fdp(), t.at_ev(1000 * factor_kev_angstrom / 2).fdp())
c = f.as_complex()
assert c.real == f.fp()
assert c.imag == f.fdp()
verify(t, 10.0, -9999.00, 4.00688)
verify(t, 29.3, 4.04139-14, 0.371742)
verify(t, 30000.0, 14.0266-14, 0.0228459)
n = 0
for t in henke.table_iterator():
n += 1
if (n == 1):
assert t.label() == "H"
elif (n == 92):
assert t.label() == "U"
u = henke.table(t.label())
assert u.label() == t.label()
assert n == 92
def exercise_two_loop_recursion(fgh): x0 = flex.double([3.0, -4.0]) g0 = fgh.g(x0) h0 = flex.double([[1,0],[0,1]]) memory = [] hg0 = bfgs.hg_two_loop_recursion(memory, hk0=h0, gk=g0) assert approx_equal(hg0, h0.matrix_multiply(g0)) # x1 = x0 - 1/3 * hg0 g1 = fgh.g(x1) h1 = bfgs.h_update(hk=h0, sk=x1-x0, yk=g1-g0) memory.append(bfgs.memory_element(s=x1-x0, y=g1-g0)) hg1 = bfgs.hg_two_loop_recursion(memory, hk0=h0, gk=g1) assert approx_equal(hg1, h1.matrix_multiply(g1)) # x2 = x1 - 1/5 * hg1 g2 = fgh.g(x2) h2 = bfgs.h_update(hk=h1, sk=x2-x1, yk=g2-g1) memory.append(bfgs.memory_element(s=x2-x1, y=g2-g1)) hg2 = bfgs.hg_two_loop_recursion(memory, hk0=h0, gk=g2) assert approx_equal(hg2, h2.matrix_multiply(g2)) # x3 = x2 - 3/8 * hg2 g3 = fgh.g(x3) h3 = bfgs.h_update(hk=h2, sk=x3-x2, yk=g3-g2) memory.append(bfgs.memory_element(s=x3-x2, y=g3-g2)) hg3 = bfgs.hg_two_loop_recursion(memory, hk0=h0, gk=g3) assert approx_equal(hg3, h3.matrix_multiply(g3))
def exercise_d_metrical_matrix_d_params():
def finite_differences(unit_cell, eps=1e-6):
grads = []
for i in range(6):
params = list(unit_cell.parameters())
params[i] += eps
uc = uctbx.unit_cell(parameters=params)
qm = matrix.col(uc.metrical_matrix())
params[i] -= 2*eps
uc = uctbx.unit_cell(parameters=params)
qp = matrix.col(uc.metrical_matrix())
dq = (qm-qp)/(2*eps)
grads.extend(list(dq))
grads = flex.double(grads)
grads.resize(flex.grid((6,6)))
return grads.matrix_transpose()
from cctbx import sgtbx
p1 = sgtbx.space_group_info('P1')
uc = p1.any_compatible_unit_cell(27)
grads = uc.d_metrical_matrix_d_params()
fd_grads = finite_differences(uc)
assert approx_equal(grads, fd_grads)
sgi = sgtbx.space_group_info('I-4')
uc = sgi.any_compatible_unit_cell(volume=18000)
grads = uc.d_metrical_matrix_d_params()
fd_grads = finite_differences(uc)
assert approx_equal(grads, fd_grads)
def exercise_linear_normal_equations():
py_eqs = [ ( 1, (-1, 0, 0), 1),
( 2, ( 2, -1, 0), 3),
(-1, ( 0, 2, 1), 2),
(-2, ( 0, 1, 0), -2),
]
eqs_0 = normal_eqns.linear_ls(3)
for b, a, w in py_eqs:
eqs_0.add_equation(right_hand_side=b,
design_matrix_row=flex.double(a),
weight=w)
eqs_1 = normal_eqns.linear_ls(3)
b = flex.double()
w = flex.double()
a = sparse.matrix(len(py_eqs), 3)
for i, (b_, a_, w_) in enumerate(py_eqs):
b.append(b_)
w.append(w_)
for j in xrange(3):
if a_[j]: a[i, j] = a_[j]
eqs_1.add_equations(right_hand_side=b, design_matrix=a, weights=w)
assert approx_equal(
eqs_0.normal_matrix_packed_u(), eqs_1.normal_matrix_packed_u(), eps=1e-15)
assert approx_equal(
eqs_0.right_hand_side(), eqs_1.right_hand_side(), eps=1e-15)
assert approx_equal(
list(eqs_0.normal_matrix_packed_u()), [ 13, -6, 0, 9, 4, 2 ], eps=1e-15)
assert approx_equal(
list(eqs_0.right_hand_side()), [ 11, -6, -2 ], eps=1e-15)
def exercise_geo_reduce_for_tardy(mon_lib_srv, ener_lib, file_name, expected_bond_counts, expected_dihedral_counts):
file_path = libtbx.env.find_in_repositories(
relative_path="phenix_regression/tardy_action/" + file_name, test=os.path.isfile
)
if file_path is None:
print 'Skipping exercise_geo_reduce_for_tardy("%s"):' " input file not available" % file_name
return
log = StringIO()
processed_pdb_file = monomer_library.pdb_interpretation.process(
mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, file_name=file_path, log=log
)
geo = processed_pdb_file.geometry_restraints_manager()
sites_cart = processed_pdb_file.all_chain_proxies.sites_cart_exact()
tardy_tree = geo.construct_tardy_tree(sites_cart=sites_cart)
reduced_geo = geo.reduce_for_tardy(tardy_tree=tardy_tree)
bond_counts = (
geo.pair_proxies(sites_cart=sites_cart).bond_proxies.n_total(),
reduced_geo.pair_proxies(sites_cart=sites_cart).bond_proxies.n_total(),
)
dihedral_counts = (geo.get_dihedral_proxies().size(), reduced_geo.get_dihedral_proxies().size())
assert approx_equal(bond_counts, expected_bond_counts)
assert approx_equal(dihedral_counts, expected_dihedral_counts)
proxy_i_seqs_red = {}
for proxy in reduced_geo.dihedral_proxies:
proxy_i_seqs_red[proxy.i_seqs] = proxy
assert len(proxy_i_seqs_red) == dihedral_counts[1]
awl = list(processed_pdb_file.all_chain_proxies.pdb_hierarchy.atoms_with_labels())
for proxy in geo.get_dihedral_proxies():
if not proxy_i_seqs_red.has_key(proxy.i_seqs):
sigma = 1 / proxy.weight ** 0.5
if sigma > 10:
assert awl[proxy.i_seqs[0]].resname in ["PRO", "CYS"]
def exercise_fast_minimum_reduction():
mr = uctbx.fast_minimum_reduction(uctbx.unit_cell((1,1,1,90,90,90)))
assert mr.iteration_limit() == 100
assert mr.multiplier_significant_change_test() == 16
assert mr.min_n_no_significant_change() == 2
mr = uctbx.fast_minimum_reduction(uctbx.unit_cell((1,1,1,90,90,90)), 90)
assert mr.iteration_limit() == 90
assert mr.multiplier_significant_change_test() == 16
assert mr.min_n_no_significant_change() == 2
mr = uctbx.fast_minimum_reduction(uctbx.unit_cell((1,1,1,90,90,90)), 90,8)
assert mr.iteration_limit() == 90
assert mr.multiplier_significant_change_test() == 8
assert mr.min_n_no_significant_change() == 2
mr = uctbx.fast_minimum_reduction(uctbx.unit_cell((1,1,1,90,90,90)), 90,8,4)
assert mr.iteration_limit() == 90
assert mr.multiplier_significant_change_test() == 8
assert mr.min_n_no_significant_change() == 4
mr = uctbx.fast_minimum_reduction(uctbx.unit_cell((2,3,5,80,90,100)))
assert approx_equal(mr.as_gruber_matrix(),(4,9,25,-5.209445,0,-2.083778))
assert approx_equal(mr.as_niggli_matrix(),(4,9,25,-5.209445/2,0,-2.083778/2))
assert approx_equal(mr.as_sym_mat3(),(4,9,25,-2.083778/2,0,-5.209445/2))
assert mr.as_unit_cell().is_similar_to(uctbx.unit_cell((2,3,5,100,90,100)))
assert approx_equal(mr.r_inv(), (-1,0,0,0,-1,0,0,0,1))
assert mr.n_iterations() == 1
assert not mr.termination_due_to_significant_change_test()
assert mr.type() == 2
mr = uctbx.fast_minimum_reduction(uctbx.unit_cell((5,3,2,50,120,130)), 8)
assert mr.n_iterations() == 8
assert not mr.termination_due_to_significant_change_test()
try:
uctbx.fast_minimum_reduction(uctbx.unit_cell((5,3,2,50,120,130)), 2, 7)
except RuntimeError, e:
assert str(e) == "cctbx Error: Iteration limit exceeded."
def exercise_f_model_no_scales(symbol = "C 2"):
random.seed(0)
flex.set_random_seed(0)
x = random_structure.xray_structure(
space_group_info = sgtbx.space_group_info(symbol=symbol),
elements =(("O","N","C")*5+("H",)*10),
volume_per_atom = 200,
min_distance = 1.5,
general_positions_only = True,
random_u_iso = True,
random_occupancy = False)
f_obs = abs(x.structure_factors(d_min = 1.5, algorithm="fft").f_calc())
x.shake_sites_in_place(mean_distance=1)
k_iso = flex.double(f_obs.data().size(), 2)
k_aniso = flex.double(f_obs.data().size(), 3)
fmodel = mmtbx.f_model.manager(
xray_structure = x,
k_isotropic = k_iso,
k_anisotropic = k_aniso,
f_obs = f_obs)
fc = abs(fmodel.f_calc()).data()
fm = abs(fmodel.f_model()).data()
fmns = abs(fmodel.f_model_no_scales()).data()
assert approx_equal(flex.mean(fm/fc), 6)
assert approx_equal(flex.mean(fmns/fc), 1)
def exercise(prefix="tst_models_to_from_chains"):
# inputs
expected_n = 5
xrs = iotbx.pdb.input(source_info=None, lines=pdb_str).xray_structure_simple()
input_file_name = "%s.pdb"%prefix
of = open(input_file_name,"w")
print >> of, pdb_str
of.close()
mi = flex.miller_index(((0,0,1), ))
ms = miller.set(xrs.crystal_symmetry(), mi, anomalous_flag=False)
complete_set = ms.complete_set(d_min=3)
fc = complete_set.structure_factors_from_scatterers(
xray_structure=xrs).f_calc()
# models -> chains
easy_run.call("phenix.models_as_chains %s"%input_file_name)
pdb_inp = iotbx.pdb.input(file_name="chains_"+input_file_name)
h = pdb_inp.construct_hierarchy()
assert len(list(h.chains()))==expected_n
assert len(list(h.models()))==1
xrs_c = pdb_inp.xray_structure_simple()
fc_c = complete_set.structure_factors_from_scatterers(
xray_structure=xrs_c).f_calc()
#
easy_run.call("phenix.chains_as_models chains_%s"%input_file_name)
pdb_inp = iotbx.pdb.input(file_name="models_chains_"+input_file_name)
h = pdb_inp.construct_hierarchy()
assert len(list(h.chains()))==expected_n
assert len(list(h.models()))==expected_n
xrs_m = pdb_inp.xray_structure_simple()
fc_m = complete_set.structure_factors_from_scatterers(
xray_structure=xrs_m).f_calc()
#
assert approx_equal(0, r(fc, fc_c) )
assert approx_equal(0, r(fc, fc_m) )
assert approx_equal(0, r(fc_c, fc_m))
def exercise():
""" Compare simple mask (mmtbx/utils.h) with classic mask. Does not account
for site multiplicity due to symmetry. Also, this is an alternative
exercise for asu mask.
"""
for i_pdb, pdb_str in enumerate([pdb_str_1, pdb_str_2, pdb_str_3]):
for solvent_radius in [0, 1.0]:
print "file %d solvent_raius: %3.1f"%(i_pdb, solvent_radius)
xrs = iotbx.pdb.input(source_info = None,
lines = pdb_str).xray_structure_simple()
mp = mmtbx.masks.mask_master_params.extract()
mp.solvent_radius=solvent_radius
mp.shrink_truncation_radius=0.0
mmtbx_masks_asu_mask_obj = mmtbx.masks.asu_mask(
xray_structure = xrs.expand_to_p1(sites_mod_positive=True), # Must be P1
d_min = 1,
mask_params = mp)
mask_data = mmtbx_masks_asu_mask_obj.mask_data_whole_uc()
c1o,c0o,s,csf = mask_data.count(1), mask_data.count(0), mask_data.size(),\
mmtbx_masks_asu_mask_obj.asu_mask.contact_surface_fraction
assert c1o+c0o==s
f1o, f0o = c1o*100./s, c0o*100./s
print " old", f1o, f0o, csf
mask_data = maptbx.mask(
xray_structure = xrs, # Expanded to P1 internally
n_real = mask_data.focus(),
solvent_radius = solvent_radius)
c1n, c0n, s = mask_data.count(1), mask_data.count(0), mask_data.size()
assert c1n+c0n==s
f1n, f0n = c1n*100./s, c0n*100./s
print " new:", f1n, f0n
assert approx_equal(f1o, f1n, 1)
assert approx_equal(f0o, f0n, 1)
assert approx_equal(f1o, csf*100, 1)
def exercise_ellipsoid(n_trials=100, n_sub_trials=10):
from gltbx import quadrics
rnd = random.Random(0)
for i in xrange(n_trials):
centre = matrix.col([ rnd.random() for k in xrange(3) ])
half_lengths = matrix.col([ 0.1 + rnd.random() for k in xrange(3) ])
r = scitbx.math.euler_angles_as_matrix(
[ rnd.uniform(0, 360) for i in xrange(3) ], deg=True)
metrics = r * matrix.diag([ x**2 for x in half_lengths ]) * r.transpose()
t = quadrics.ellipsoid_to_sphere_transform(centre, metrics.as_sym_mat3())
assert approx_equal(t.translation_part(), centre)
m = matrix.sqr(t.linear_part())
assert m.determinant() > 0
for j in xrange(n_sub_trials):
y = matrix.col([ rnd.random() for k in xrange(3) ])
c_y = y.transpose() * y
x = m*y
c_x = x.transpose() * metrics.inverse() * x
assert approx_equal(c_x, c_y)
r = scitbx.math.euler_angles_as_matrix((30, 115, 260), deg=True)
centre = matrix.col((-1, 2, 3))
metrics = r * matrix.diag((-1, 0.1, 1)) * r.transpose()
t = quadrics.ellipsoid_to_sphere_transform(centre, metrics.as_sym_mat3())
assert t.non_positive_definite()
x = r * matrix.col((1,0,0))
assert x.transpose() * metrics.inverse() * x > 0
def exercise () :
from libtbx.test_utils import approx_equal
try :
import numpy
except ImportError :
test_numpy = False
print "Numpy not installed, will skip array conversion."
else :
test_numpy = True
# ramachandran
z_data = get_rotarama_data(pos_type="general",
convert_to_numpy_array=test_numpy)
z_data = get_rotarama_data(pos_type="pre-proline",
convert_to_numpy_array=test_numpy)
# rotamer
z_data = get_rotarama_data(residue_type="arg",
db="rota",
convert_to_numpy_array=test_numpy)
z_data = get_rotarama_data(residue_type="phe",
db="rota",
convert_to_numpy_array=test_numpy)
atom_info = decode_atom_str(" OD2 ASP A 14L")
assert (atom_info.name == " OD2") and (atom_info.resname == "ASP")
assert (atom_info.altloc == " ") and (atom_info.chain_id == "A")
assert (atom_info.resid == " 14L") and (atom_info.resseq == "14")
mpscore = molprobity_score(48.0, 9.95, 86.44) # 2hr0
assert approx_equal(mpscore, 3.55, eps=0.01)
mpscore = molprobity_score(215.8, 17.99, 52.18) # 3mku
assert approx_equal(mpscore, 4.71, eps=0.01)
def exercise_tensor_constraints_core(crystal_symmetry):
from cctbx import crystal
from cctbx import adptbx
from scitbx import matrix
site_symmetry = crystal.special_position_settings(
crystal_symmetry).site_symmetry(site=(0,0,0))
unit_cell = crystal_symmetry.unit_cell()
group = crystal_symmetry.space_group()
assert site_symmetry.n_matrices() == group.order_p()
for reciprocal_space in [False, True]:
c_tensor_constraints = sgtbx.tensor_rank_2_constraints(
space_group=group,
reciprocal_space=reciprocal_space).row_echelon_form()
p_tensor_constraints = python_tensor_constraints(
self=group, reciprocal_space=reciprocal_space)
assert c_tensor_constraints.all_eq(p_tensor_constraints)
adp_constraints = group.adp_constraints()
u_cart_p1 = adptbx.random_u_cart()
u_star_p1 = adptbx.u_cart_as_u_star(unit_cell, u_cart_p1)
u_star = site_symmetry.average_u_star(u_star_p1)
f = unit_cell.volume()**(2/3.)
assert approx_equal(
list(matrix.col(group.average_u_star(u_star=u_star_p1))*f),
list(matrix.col(u_star)*f))
independent_params = adp_constraints.independent_params(u_star)
assert adp_constraints.n_independent_params() == len(independent_params)
assert adp_constraints.n_independent_params() \
+ adp_constraints.n_dependent_params() == 6
u_star_vfy = adp_constraints.all_params(independent_params)
u_cart = adptbx.u_star_as_u_cart(unit_cell, u_star)
u_cart_vfy = adptbx.u_star_as_u_cart(unit_cell, list(u_star_vfy))
assert approx_equal(u_cart_vfy, u_cart)
def __init__(self, xray_structure, k_anisotropic, k_masks, ss):
self.xray_structure = xray_structure
self.k_anisotropic = k_anisotropic
self.k_masks = k_masks
self.ss = ss
#
k_total = self.k_anisotropic
r = scitbx.math.gaussian_fit_1d_analytical(x=flex.sqrt(self.ss), y=k_total)
k,b = r.a, r.b
#
k,b,r = mmtbx.bulk_solvent.fit_k_exp_b_to_k_total(k_total, self.ss, k, b)
k_exp_overall, b_exp_overall = None,None
if(r<0.7): k_exp_overall, b_exp_overall = k,b
if(self.xray_structure is None): return None
b_adj = 0
if([k_exp_overall, b_exp_overall].count(None)==0 and k != 0):
bs1 = self.xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
def split(b_trace, xray_structure):
b_min = xray_structure.min_u_cart_eigenvalue()*adptbx.u_as_b(1.)
b_res = min(0, b_min + b_trace+1.e-6)
b_adj = b_trace-b_res
xray_structure.shift_us(b_shift = b_adj)
return b_adj, b_res
b_adj,b_res=split(b_trace=b_exp_overall,xray_structure=self.xray_structure)
k_new = k_exp_overall*flex.exp(-self.ss*b_adj)
bs2 = self.xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
diff = bs2-bs1
assert approx_equal(flex.min(diff), flex.max(diff))
assert approx_equal(flex.max(diff), b_adj)
self.k_anisotropic = self.k_anisotropic/k_new
self.k_masks = [m*flex.exp(-self.ss*b_adj) for m in self.k_masks]
def exercise_emringer_residue_scan():
pdb_file = libtbx.env.find_in_repositories(
relative_path="phenix_regression/mmtbx/em_ringer/tst_emringer_model.pdb",
test=os.path.isfile)
map_file = libtbx.env.find_in_repositories(
relative_path="phenix_regression/mmtbx/em_ringer/tst_emringer_map.ccp4",
test=os.path.isfile)
assert (not None in [pdb_file, map_file])
results, scoring, rolling = emringer.run([pdb_file, map_file], out=null_out())
# Make sure the right number of residues (22 out of 28) get scanned
assert len(results)==22
modelled_list = [290.742121792,192.844056257,45.4781110306,294.247825632,303.618891108,58.7694040824,331.70068496,46.7136045049,290.167261226,304.261231829,282.651244586,268.729721112,195.972333785,305.321933311,314.81066224,286.028424514,311.180807466,313.004918133,296.67781565,296.949191638,169.644245088,192.496265164]
peak_list = [270,180,260,75,305,30,310,90,265,270,270,240,280,260,310,285,295,100,260,165,155,200]
peak_rhos = [0.175600306502,0.351591946536,0.206238983746,0.3269057296,0.68375562882,0.251143527693,0.29106077218,0.199922124642,0.298461589197,0.563313760047,0.412696803251,0.511080434089,0.310001828446,0.228239176285,0.563148497472,0.490755919184,0.200978032127,0.274929619102,0.299229846335,0.179215798655,0.150783734124,0.210869945593]
for i in range(22):
# Make sure the modelled angle is correctly read
assert approx_equal(results[i]._angles[1].angle_current, modelled_list[i])
# Make sure the peak is chosen correctly
assert approx_equal(results[i]._angles[1].peak_chi, peak_list[i])
# Make sure the peak rhos are correct
assert approx_equal(results[i]._angles[1].peak_rho, peak_rhos[i])
results, scoring2, rolling2 = emringer.run([pdb_file, map_file, "rolling_window_threshold=0.5"], out=null_out())
assert rolling.threshold == 0
assert rolling2.threshold == 0.5
#print rolling.results_a[0]
#print rolling2.results_a[0]
# just making sure this doesn't break!
results, scoring2, rolling = emringer.run([pdb_file, map_file, "sampling_angle=2"], out=null_out())
def exercise_1(grid_step,
radius,
shell,
a,
b,
buffer_layer,
site_cart):
xray_structure = xray_structure_of_one_atom(site_cart = site_cart,
buffer_layer = buffer_layer,
a = a,
b = b)
sampled_density = mmtbx.real_space.sampled_model_density(
xray_structure = xray_structure,
grid_step = grid_step)
site_frac = xray_structure.unit_cell().fractionalization_matrix()*site_cart
assert approx_equal(flex.max(sampled_density.data()),
sampled_density.data().value_at_closest_grid_point(site_frac[0]))
around_atom_obj = mmtbx.real_space.around_atom(
unit_cell = xray_structure.unit_cell(),
map_data = sampled_density.data(),
radius = radius,
shell = shell,
site_frac = list(xray_structure.sites_frac())[0])
data_exact = around_atom_obj.data()
dist_exact = around_atom_obj.distances()
approx_obj = maptbx.one_gaussian_peak_approximation(
data_at_grid_points = data_exact,
distances = dist_exact,
use_weights = False,
optimize_cutoff_radius = True)
assert approx_equal(approx_obj.a_reciprocal_space(), 6.0, 1.e-3)
assert approx_equal(approx_obj.b_reciprocal_space(), 3.0, 1.e-3)
assert approx_obj.gof() < 0.3
assert approx_obj.cutoff_radius() < radius
def check_f_derivs():
g_ana = trg.f_gradients
c_ana = trg.f_hessians
eps = 1e-6
g_fin = flex.complex_double()
c_fin = flex.vec3_double()
for ih in xrange(i_calc.size()):
c_orig = f_calc[ih]
g_fin_ab = []
c_fin_ab = []
for iab in [0,1]:
fs = []
gs = []
for signed_eps in [eps, -eps]:
if (iab == 0):
f_calc[ih] = complex(c_orig.real + signed_eps, c_orig.imag)
else:
f_calc[ih] = complex(c_orig.real, c_orig.imag + signed_eps)
trg_eps = kwt2(
f_obs=f_obs, i_obs=i_obs, i_sig=i_sig,
f_calc=f_calc, i_calc=None, wa=wa, wb=wb)
fs.append(trg_eps.target)
gs.append(trg_eps.f_gradients[ih])
g_fin_ab.append((fs[0]-fs[1])/(2*eps))
c_fin_ab.append((gs[0]-gs[1])/(2*eps))
g_fin.append(complex(*g_fin_ab))
assert approx_equal(c_fin_ab[0].imag, c_fin_ab[1].real)
c_fin.append((c_fin_ab[0].real, c_fin_ab[1].imag, c_fin_ab[0].imag))
f_calc[ih] = c_orig
assert approx_equal(g_ana, g_fin)
assert approx_equal(c_ana, c_fin)
def step_h(self, V_L, b_o):
"""
Three uncorrelated translations.
"""
print_step("Step h:", self.log)
V_M = b_o.R_PL * V_L * b_o.R_PL.transpose()
self.show_matrix(x=V_M, title="V_M ")
es = self.eigen_system_default_handler(m=V_M)
v_x, v_y, v_z = es.x, es.y, es.z
lam_u,lam_v,lam_w = es.vals
self.show_vector(x=v_x, title="v_x")
self.show_vector(x=v_y, title="v_y")
self.show_vector(x=v_z, title="v_z")
assert approx_equal(v_x.dot(v_y), 0)
assert approx_equal(v_y.dot(v_z), 0)
assert approx_equal(v_z.dot(v_x), 0)
R_MV = matrix.sqr([
v_x[0], v_y[0], v_z[0],
v_x[1], v_y[1], v_z[1],
v_x[2], v_y[2], v_z[2]])
self.show_matrix(x=R_MV, title="R_MV")
V_V = matrix.sym(sym_mat3=[lam_u, lam_v, lam_w, 0,0,0])
self.show_matrix(x=V_V, title="V_V")
assert approx_equal(V_V, R_MV.transpose() * V_M * R_MV) # formula (20)
return group_args(
v_x = v_x,
v_y = v_y,
v_z = v_z,
V_M = V_M,
V_V = V_V,
R_MV = R_MV)
def exercise_pair_registry_adp_iso():
mersenne_twister = flex.mersenne_twister(seed=0)
for n_seq in xrange(2,20):
registry = ncs.restraints.pair_registry(n_seq=n_seq, n_ncs=n_seq)
for j_seq in xrange(1,n_seq):
assert registry.enter(i_seq=0, j_seq=j_seq, j_ncs=j_seq) == (0, 0)
selection_pairs = registry.selection_pairs()
for j in xrange(1,n_seq):
assert zip(*selection_pairs[j-1]) == [(0,j)]
weight = 2.134
average_power = 0.589
u_isos = mersenne_twister.random_double(size=n_seq) + 1.e-3
gradients_in = mersenne_twister.random_double(size=n_seq)
gradients = gradients_in.deep_copy()
registry_residual_sum = registry.adp_iso_residual_sum(
weight=weight,
average_power=average_power,
u_isos=u_isos,
u_average_min=1.e-6,
gradients=gradients)
gradients -= gradients_in
assert approx_equal(
registry_residual_sum,
adp_iso_residual_sum(
weight=weight, average_power=average_power, u_isos=u_isos))
assert approx_equal(
gradients,
adp_iso_analytical_gradients(
weight=weight, average_power=average_power, u_isos=u_isos))
def apply_back_trace_of_overall_exp_scale_matrix(self, xray_structure=None):
k,b=self.overall_isotropic_kb_estimate()
k_total = self.core.k_isotropic * self.core.k_anisotropic * \
self.core.k_isotropic_exp
k,b,r = mmtbx.bulk_solvent.fit_k_exp_b_to_k_total(k_total, self.ss, k, b)
if(r<0.7): self.k_exp_overall,self.b_exp_overall = k,b
if(xray_structure is None): return None
b_adj = 0
if([self.k_exp_overall,self.b_exp_overall].count(None)==0 and k != 0):
bs1 = xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
def split(b_trace, xray_structure):
b_min = xray_structure.min_u_cart_eigenvalue()*adptbx.u_as_b(1.)
b_res = min(0, b_min + b_trace+1.e-6)
b_adj = b_trace-b_res
xray_structure.shift_us(b_shift = b_adj)
return b_adj, b_res
b_adj,b_res=split(b_trace=self.b_exp_overall,xray_structure=xray_structure)
k_new = self.k_exp_overall*flex.exp(-self.ss*b_adj)
bs2 = xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
diff = bs2-bs1
assert approx_equal(flex.min(diff), flex.max(diff))
assert approx_equal(flex.max(diff), b_adj)
self.core = self.core.update(
k_isotropic = self.core.k_isotropic,
k_isotropic_exp = self.core.k_isotropic_exp/k_new,
k_masks = [m*flex.exp(-self.ss*b_adj) for m in self.core.k_masks])
return group_args(
xray_structure = xray_structure,
k_isotropic = self.k_isotropic(),
k_anisotropic = self.k_anisotropic(),
k_mask = self.k_masks(),
b_adj = b_adj)
def run_once():
buffers = easy_run.fully_buffered(command=run_cmd)
if (len(buffers.stderr_lines) != 3):
print "v"*79
print "\n".join(buffers.stderr_lines)
print "^"*79
raise RuntimeError(
"Unexpected number of output lines"
" (3 expected; acutal output see above).")
if (n_scatt == 0):
pass
elif (n_scatt <= 10 and n_refl <= 100):
assert len(buffers.stdout_lines) == n_scatt + n_refl
else:
assert len(buffers.stdout_lines) == 1
max_a, max_b = [float(s) for s in buffers.stdout_lines[0].split()]
if (check_max_a_b):
if (n_scatt == 2000 and n_refl == 20000):
assert approx_equal(max_a, 35.047157, eps=1e-4)
assert approx_equal(max_b, 25.212738, eps=1e-4)
elif (n_scatt == 100 and n_refl == 1000):
assert approx_equal(max_a, 4.493645, eps=1e-4)
assert approx_equal(max_b, 10.515532, eps=1e-4)
elif (n_scatt <= 10 and n_refl <= 100):
if (libtbx.env.has_module(name="cctbx")):
compare_with_cctbx_structure_factors(
n_scatt=n_scatt,
n_refl=n_refl,
output_lines=buffers.stdout_lines)
else:
raise RuntimeError, (max_a, max_b)
utime = float(buffers.stderr_lines[1].split()[1])
utimes.append(utime)
print "sample utime: %.2f" % utime
sys.stdout.flush()
def tst_gauss_hermite_engine():
# test with known values
ghe = sm.gauss_hermite_engine(4)
x_ams_55 = [0.524647623275290, 1.650680123885785]
w_ams_55 = [0.8049140900055 , 0.08131283544725]
wexs_ams_55 = [1.0599644828950 , 1.2402258176958]
x_this = ghe.x()[0:2]
w_this = ghe.w()[0:2]
for x,xx in zip( x_this, x_ams_55):
assert approx_equal( x, xx, eps=1e-8 )
for w,ww in zip( w_this, w_ams_55):
assert approx_equal( w, ww, eps=1e-8 )
# test a large order set of number
for n in range(2,29):
ghe = sm.gauss_hermite_engine(n)
x_this = ghe.x()
step = 0.5/math.sqrt(n*1.0)
for ix in range( x_this.size() ):
f = ghe.f( x_this[ix] )[0]
assert approx_equal(f,0,eps=1e-5)
# check the uniqueness of each point
for jj in range( x_this.size() ):
if jj != ix:
assert ( math.fabs(x_this[ix]-x_this[jj]) >= step )
for a_box, a_output, n_box, n_output in zip(box_abc, output_abc,
output_box.map_box.all(),
output_unit_cell_grid):
expected_output_abc.append(a_box * n_output / n_box)
box_spacing.append(a_box / n_box)
if output_crystal_symmetry:
output_spacing.append(a_output / n_output)
else:
output_spacing.append(a_box / n_box)
if output_crystal_symmetry: # make sure it is compatible...
r0 = expected_output_abc[0] / output_abc[0]
r1 = expected_output_abc[1] / output_abc[1]
r2 = expected_output_abc[2] / output_abc[2]
from libtbx.test_utils import approx_equal
if not approx_equal(r0, r1, eps=0.001) or not approx_equal(
r0, r2, eps=0.001):
print >>log,"WARNING: output_unit_cell and cell_grid will "+\
"change ratio of grid spacing.\nOld spacings: "+\
"(%.2f, %.2f, %.2f) A " %(tuple(box_spacing))+\
"\nNew spacings: (%.2f, %.2f, %.2f) A \n" %(tuple(output_spacing))
else:
output_abc = expected_output_abc
from cctbx import crystal
output_crystal_symmetry = crystal.symmetry(unit_cell=list(output_abc) +
[90, 90, 90],
space_group="P1")
print >>log, \
"Output unit cell will be: (%.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n"%(
tuple(output_crystal_symmetry.unit_cell().parameters()))
def verify(table, wave_length, fp, fdp):
fp_fdp = table.at_angstrom(wave_length)
assert approx_equal(fp_fdp.fp(), fp)
assert approx_equal(fp_fdp.fdp(), fdp)
def __init__(self,
refiner,
xray_structure,
start_trial_weight_value=50.,
weight_sample_rate=10,
rms_bonds_limit=0.03,
rms_angles_limit=3.0,
optimize_weight=True):
self.rms_angles_start = None
self.rms_bonds_start = None
self.refiner = refiner
self.weight_start = start_trial_weight_value
sites_cart_start = xray_structure.sites_cart()
self.rms_bonds_start, self.rms_angles_start = \
self.rmsds(sites_cart=xray_structure.sites_cart())
self.weight_sample_rate = weight_sample_rate
# results
self.weight_final = None
self.sites_cart_result = None
self.rms_bonds_final, self.rms_angles_final = None, None
#
pool = {}
bonds = flex.double()
angles = flex.double()
weights = flex.double()
#
weight = start_trial_weight_value
weight_last = weight
self.adjust_weight_sample_rate(weight=weight)
if (optimize_weight):
while True:
self.rmsds(sites_cart=sites_cart_start) # DUMMY
self.adjust_weight_sample_rate(weight=weight_last)
tmp = xray_structure.deep_copy_scatterers()
#tmp.shake_sites_in_place(
# rms_difference = None,
# mean_distance = 0.5)
refiner.refine(
xray_structure=
tmp, #xray_structure.deep_copy_scatterers(), # XXX
weight=weight)
sites_cart_result = refiner.sites_cart()
bd, ad = self.rmsds(sites_cart=sites_cart_result)
bonds.append(bd)
angles.append(ad)
weights.append(weight)
pool.setdefault(weight, []).append(
[sites_cart_result.deep_copy(), bd, ad])
if (refiner.geometry_restraints_manager is None): break
weight_last = weight
if (ad > rms_angles_limit or bd > rms_bonds_limit):
weight -= self.weight_sample_rate
else:
weight += self.weight_sample_rate
if (weight < 0 or abs(weight) < 1.e-6):
self.adjust_weight_sample_rate(weight=weight)
weight = weight_last
weight -= self.weight_sample_rate
#print ">>> ", "%8.4f %8.4f"%(weight, weight_last), "%6.4f %5.2f"%(bd, ad),\
# self.weight_sample_rate, " f (start/final):", refiner.refined.f_start, refiner.refined.f_final
if ((weight < 0 or weight > 1000) or weight in weights): break
l = bonds.size() - 1
if (bonds.size() > 5 and abs(bonds[l] - bonds[l - 1]) < 0.0005
and abs(bonds[l] - bonds[l - 2]) < 0.0005
and abs(bonds[l] - bonds[l - 3]) < 0.0005
and abs(bonds[l] - bonds[l - 4]) < 0.0005
and abs(bonds[l] - bonds[l - 5]) < 0.0005):
break
else:
refiner.refine(
xray_structure=xray_structure.deep_copy_scatterers(), # XXX
weight=weight)
sites_cart_result = refiner.sites_cart()
# select results
if (optimize_weight):
delta = bonds - rms_bonds_limit
ind = (delta == flex.max_default(delta.select(delta <= 0),
flex.min(delta))).iselection()[0]
self.weight_final = weights[ind]
self.sites_cart_result = pool[self.weight_final][0][0]
self.rms_bonds_final,self.rms_angles_final = \
self.rmsds(sites_cart=self.sites_cart_result)
assert approx_equal(pool[self.weight_final][0][2], angles[ind])
assert approx_equal(pool[self.weight_final][0][1], bonds[ind])
assert approx_equal(self.rms_angles_final, angles[ind])
assert approx_equal(self.rms_bonds_final, bonds[ind])
else:
self.weight_final = self.weight_start
self.sites_cart_result = sites_cart_result
def exercise(space_group_info,
const_gaussian,
negative_gaussian,
anomalous_flag,
allow_mix,
use_u_iso,
use_u_aniso,
d_min=1.,
resolution_factor=1. / 3,
max_prime=5,
quality_factor=100,
wing_cutoff=1.e-6,
exp_table_one_over_step_size=-100,
force_complex=False,
verbose=0):
if (const_gaussian):
elements = ["const"] * 8
elif (negative_gaussian):
elements = ["H"] * 8
else:
elements = ["N", "C", "C", "O", "N", "C", "C", "O"]
if (random.random() < 0.5):
random_f_prime_scale = 0.6
else:
random_f_prime_scale = 0
structure = random_structure.xray_structure(
space_group_info,
elements=elements,
random_f_prime_d_min=1,
random_f_prime_scale=random_f_prime_scale,
random_f_double_prime=anomalous_flag,
use_u_aniso=True,
use_u_iso=False,
random_u_cart_scale=0.3,
random_u_iso=True,
random_occupancy=True)
random_structure.random_modify_adp_and_adp_flags_2(
scatterers=structure.scatterers(),
use_u_iso=use_u_iso,
use_u_aniso=use_u_aniso,
allow_mix=allow_mix,
random_u_iso_scale=0.3,
random_u_iso_min=0.0)
sampled_density_must_be_positive = True
if (negative_gaussian):
reg = structure.scattering_type_registry(
custom_dict={"H": eltbx.xray_scattering.gaussian(-1)})
assert reg.gaussian("H").n_terms() == 0
assert reg.gaussian("H").c() == -1
sampled_density_must_be_positive = False
elif (not const_gaussian and random.random() < 0.5):
if (random.random() < 0.5):
sampled_density_must_be_positive = False
assign_custom_gaussians(
structure, negative_a=not sampled_density_must_be_positive)
f_direct = structure.structure_factors(anomalous_flag=anomalous_flag,
d_min=d_min,
algorithm="direct").f_calc()
crystal_gridding = f_direct.crystal_gridding(
resolution_factor=resolution_factor, d_min=d_min, max_prime=max_prime)
assert crystal_gridding.symmetry_flags() is None
rfft = fftpack.real_to_complex_3d(crystal_gridding.n_real())
u_base = xray.calc_u_base(d_min, resolution_factor, quality_factor)
omptbx.env.num_threads = libtbx.introspection.number_of_processors()
sampled_density = xray.sampled_model_density(
unit_cell=structure.unit_cell(),
scatterers=structure.scatterers(),
scattering_type_registry=structure.scattering_type_registry(),
fft_n_real=rfft.n_real(),
fft_m_real=rfft.m_real(),
u_base=u_base,
wing_cutoff=wing_cutoff,
exp_table_one_over_step_size=exp_table_one_over_step_size,
force_complex=force_complex,
sampled_density_must_be_positive=sampled_density_must_be_positive,
tolerance_positive_definite=1.e-5,
use_u_base_as_u_extra=False)
focus = sampled_density.real_map_unpadded().focus()
all = sampled_density.real_map_unpadded().all()
last = sampled_density.real_map_unpadded().last()
assert approx_equal(focus, last)
assert approx_equal(all, last)
assert sampled_density.anomalous_flag() == (anomalous_flag
or force_complex)
if (0 or verbose):
print "const_gaussian:", const_gaussian
print "negative_gaussian:", negative_gaussian
print "number of scatterers passed:", \
sampled_density.n_scatterers_passed()
print "number of contributing scatterers:", \
sampled_density.n_contributing_scatterers()
print "number of anomalous scatterers:", \
sampled_density.n_anomalous_scatterers()
print "wing_cutoff:", sampled_density.wing_cutoff()
print "exp_table_one_over_step_size:", \
sampled_density.exp_table_one_over_step_size()
print "exp_table_size:", sampled_density.exp_table_size()
print "max_sampling_box_edges:", sampled_density.max_sampling_box_edges(
),
print "(%.4f, %.4f, %.4f)" % sampled_density.max_sampling_box_edges_frac(
)
if (not sampled_density.anomalous_flag()):
print "map min:", flex.min(sampled_density.real_map())
print "map max:", flex.max(sampled_density.real_map())
else:
print "map min:", flex.min(flex.real(
sampled_density.complex_map())),
print flex.min(flex.imag(sampled_density.complex_map()))
print "map max:", flex.max(flex.real(
sampled_density.complex_map())),
print flex.max(flex.imag(sampled_density.complex_map()))
if (not sampled_density.anomalous_flag() and negative_gaussian):
assert flex.min(sampled_density.real_map()) < 0
assert flex.max(sampled_density.real_map()) == 0
if (not sampled_density.anomalous_flag()):
map = sampled_density.real_map()
assert map.all() == rfft.m_real()
assert map.focus() == rfft.n_real()
sf_map = rfft.forward(map)
assert sf_map.all() == rfft.n_complex()
assert sf_map.focus() == rfft.n_complex()
collect_conj = True
else:
cfft = fftpack.complex_to_complex_3d(rfft.n_real())
map = sampled_density.complex_map()
assert map.all() == cfft.n()
assert map.focus() == cfft.n()
sf_map = cfft.backward(map)
assert sf_map.all() == cfft.n()
assert sf_map.focus() == cfft.n()
collect_conj = False
f_fft_data = maptbx.structure_factors.from_map(
space_group=f_direct.space_group(),
anomalous_flag=sampled_density.anomalous_flag(),
miller_indices=f_direct.indices(),
complex_map=sf_map,
conjugate_flag=collect_conj).data()
sampled_density.eliminate_u_extra_and_normalize(f_direct.indices(),
f_fft_data)
structure_factor_utils.check_correlation("direct/fft_regression",
f_direct.indices(),
0,
f_direct.data(),
f_fft_data,
min_corr_ampl=1 * 0.99,
max_mean_w_phase_error=1 * 3.,
verbose=verbose)
f_fft = xray.structure_factors.from_scatterers(
miller_set=f_direct,
grid_resolution_factor=resolution_factor,
quality_factor=quality_factor,
wing_cutoff=wing_cutoff,
exp_table_one_over_step_size=exp_table_one_over_step_size,
sampled_density_must_be_positive=sampled_density_must_be_positive,
max_prime=max_prime)(xray_structure=structure,
miller_set=f_direct,
algorithm="fft").f_calc()
structure_factor_utils.check_correlation("direct/fft_xray",
f_direct.indices(),
0,
f_direct.data(),
f_fft.data(),
min_corr_ampl=1 * 0.99,
max_mean_w_phase_error=1 * 3.,
verbose=verbose)
def test_basics():
# construct a simple structure whose sites and u_iso's are to be refined
xs = xray.structure(crystal_symmetry=crystal.symmetry(
unit_cell=(10, 10, 10, 90, 90, 90), space_group_symbol='hall: P 1'),
scatterers=flex.xray_scatterer((
xray.scatterer('C0', site=(0, -1 / 2, 0), u=0.1),
xray.scatterer('C1', site=(0, 1 / 2, 0), u=0.2),
xray.scatterer('C0a', site=(1 / 2, 0, 0), u=0.1),
xray.scatterer('C1a', site=(-1 / 2, 0, 0), u=0.2),
)))
for sc in xs.scatterers():
sc.flags.set_grad_site(True)
sc.flags.set_grad_u_iso(True)
# copy the original structure as a reference to test against later
xs_ref = xs.deep_copy_scatterers()
# mess up the symmetries that the forthcoming constraints shall impose
c0, c1, c0a, c1a = xs.scatterers()
c0a.site = (0, 0, 0)
c1a.site = (1 / 2, 1 / 2, 1 / 2)
c0a.u_iso = 0.5
c1a.u_iso = 0.6
# construct a reparametrisation for the following constraints:
# (C0a, C1a) is the image of (C0, C1) through a rotation of 90 degrees
# about the z-axis
r = constraints.ext.reparametrisation(xs.unit_cell())
sc_params = constraints.shared_scatterer_parameters(xs.scatterers())
c0_site_param = r.add(constraints.independent_site_parameter, c0)
sc_params[0].site = c0_site_param
c1_site_param = r.add(constraints.independent_site_parameter, c1)
sc_params[1].site = c1_site_param
move_param = r.add(constraints.independent_small_6_vector_parameter,
(0, 0, 0, 0, 0, math.pi / 2))
c0a_c1a_site_param = r.add(constraints.same_group_xyz,
scatterers=(c0a, c1a),
sites=(c0_site_param, c1_site_param),
alignment_matrix=matrix.identity(3),
shifts_and_angles=move_param)
sc_params[2].site = sc_params[3].site = c0a_c1a_site_param
c0_u_iso_param = r.add(constraints.independent_u_iso_parameter, c0)
sc_params[0].u = c0_u_iso_param
c1_u_iso_param = r.add(constraints.independent_u_iso_parameter, c1)
sc_params[1].u = c1_u_iso_param
c0a_c1a_u_iso_param = r.add(constraints.same_group_u_iso,
scatterers=(c0a, c1a),
u_isos=(c0_u_iso_param, c1_u_iso_param))
sc_params[2].u = sc_params[3].u = c0a_c1a_u_iso_param
r.finalise()
# put the reparametrisation to work
r.linearise()
r.store()
c0_ref, c1_ref, c0a_ref, c1a_ref = xs_ref.scatterers()
assert approx_equal(c0a.site, c0a_ref.site, eps=1e-12)
assert approx_equal(c1a.site, c1a_ref.site, eps=1e-12)
assert approx_equal(c0a.u_iso, c0a_ref.u_iso, eps=1e-12)
assert approx_equal(c1a.u_iso, c1a_ref.u_iso, eps=1e-12)
# check that origin fixing restraints work in the presence of
# that reparametrisation
# this is a regression test as they used not to (bug reported by Oleg)
from smtbx.refinement.restraints import origin_fixing_restraints
from scitbx import lstbx
orig_fixing = origin_fixing_restraints.homogeneous_weighting(
xs.space_group())
normal_eqn = lstbx.normal_eqns.ext.linear_ls(n_parameters=(3 + 1) * 2 + 6)
jacobian_transpose_matching_grad_fc = r.jacobian_transpose_matching(
sc_params.mapping_to_grad_fc())
orig_fixing.add_to(normal_eqn, jacobian_transpose_matching_grad_fc,
sc_params)
def exercise_spotfinder():
if not libtbx.env.has_module("dials_regression"):
print "Skipping exercise_spotfinder: dials_regression not present"
return
data_dir = libtbx.env.find_in_repositories(
relative_path="dials_regression/centroid_test_data",
test=os.path.isdir)
template = glob(os.path.join(data_dir, "centroid*.cbf"))
args = [
"dials.find_spots", ' '.join(template),
"output.reflections=spotfinder.pickle", "output.shoeboxes=True"
]
result = easy_run.fully_buffered(command=" ".join(args)).raise_if_errors()
assert os.path.exists("spotfinder.pickle")
with open("spotfinder.pickle", "rb") as f:
reflections = pickle.load(f)
assert len(reflections) == 653, len(reflections)
refl = reflections[0]
assert approx_equal(refl['intensity.sum.value'], 42)
assert approx_equal(refl['bbox'], (1398, 1400, 513, 515, 0, 1))
assert approx_equal(refl['xyzobs.px.value'],
(1399.1190476190477, 514.2142857142857, 0.5))
assert "shoebox" in reflections
print 'OK'
# now with a resolution filter
args = [
"dials.find_spots", "filter.d_min=2", "filter.d_max=15",
' '.join(template), "output.reflections=spotfinder.pickle",
"output.shoeboxes=False"
]
result = easy_run.fully_buffered(command=" ".join(args)).raise_if_errors()
assert os.path.exists("spotfinder.pickle")
with open("spotfinder.pickle", "rb") as f:
reflections = pickle.load(f)
assert len(reflections) == 467, len(reflections)
assert "shoebox" not in reflections
print 'OK'
# now write a hot mask
args = [
"dials.find_spots", "write_hot_mask=True", ' '.join(template),
"output.reflections=spotfinder.pickle", "output.shoeboxes=False"
]
result = easy_run.fully_buffered(command=" ".join(args)).raise_if_errors()
assert os.path.exists("spotfinder.pickle")
with open("spotfinder.pickle", "rb") as f:
reflections = pickle.load(f)
assert len(reflections) == 653, len(reflections)
assert "shoebox" not in reflections
assert os.path.exists("hot_mask_0.pickle")
with open("hot_mask_0.pickle", "rb") as f:
mask = pickle.load(f)
assert len(mask) == 1, len(mask)
assert mask[0].count(False) == 12, mask[0].count(False)
print 'OK'
# now write a hot mask
args = [
"dials.find_spots", "write_hot_mask=True",
"hot_mask_prefix=my_hot_mask", ' '.join(template),
"output.reflections=spotfinder.pickle", "output.shoeboxes=False"
]
result = easy_run.fully_buffered(command=" ".join(args)).raise_if_errors()
assert os.path.exists("spotfinder.pickle")
with open("spotfinder.pickle", "rb") as f:
reflections = pickle.load(f)
assert len(reflections) == 653, len(reflections)
assert "shoebox" not in reflections
assert os.path.exists("my_hot_mask_0.pickle")
with open("my_hot_mask_0.pickle", "rb") as f:
mask = pickle.load(f)
assert len(mask) == 1, len(mask)
assert mask[0].count(False) == 12, mask[0].count(False)
print 'OK'
# now with more generous parameters
args = [
"dials.find_spots", "min_spot_size=3", "max_separation=3",
' '.join(template), "output.reflections=spotfinder.pickle"
]
result = easy_run.fully_buffered(command=" ".join(args)).raise_if_errors()
assert os.path.exists("spotfinder.pickle")
with open("spotfinder.pickle", "rb") as f:
reflections = pickle.load(f)
assert len(reflections) == 678, len(reflections)
print 'OK'
# Now with a user defined mask
template = glob(os.path.join(data_dir, "centroid*.cbf"))
args = [
"dials.find_spots", ' '.join(template),
"output.reflections=spotfinder.pickle", "output.shoeboxes=True",
"lookup.mask=%s" % os.path.join(data_dir, "mask.pickle")
]
result = easy_run.fully_buffered(command=" ".join(args)).raise_if_errors()
assert os.path.exists("spotfinder.pickle")
with open("spotfinder.pickle", "rb") as f:
reflections = pickle.load(f)
from dxtbx.datablock import DataBlockFactory
datablocks = DataBlockFactory.from_json_file(
os.path.join(data_dir, "datablock.json"))
assert (len(datablocks) == 1)
imageset = datablocks[0].extract_imagesets()[0]
detector = imageset.get_detector()
beam = imageset.get_beam()
for x, y, z in reflections['xyzobs.px.value']:
d = detector[0].get_resolution_at_pixel(beam.get_s0(), (x, y))
assert (d >= 3)
# Now with a user defined mask
template = glob(os.path.join(data_dir, "centroid*.cbf"))
args = [
"dials.find_spots", ' '.join(template),
"output.reflections=spotfinder.pickle", "output.shoeboxes=True",
"region_of_interest=800,1200,800,1200"
]
result = easy_run.fully_buffered(command=" ".join(args)).raise_if_errors()
assert os.path.exists("spotfinder.pickle")
with open("spotfinder.pickle", "rb") as f:
reflections = pickle.load(f)
x, y, z = reflections['xyzobs.px.value'].parts()
assert x.all_ge(800)
assert y.all_ge(800)
assert x.all_lt(1200)
assert y.all_lt(1200)
print 'OK'
# now with XFEL stills
data_dir = libtbx.env.find_in_repositories(
relative_path="dials_regression/spotfinding_test_data",
test=os.path.isdir)
template = os.path.join(data_dir, "idx-s00-20131106040302615.cbf")
args = [
"dials.find_spots", template, "output.reflections=spotfinder.pickle"
]
result = easy_run.fully_buffered(command=" ".join(args)).raise_if_errors()
assert os.path.exists("spotfinder.pickle")
with open("spotfinder.pickle", "rb") as f:
reflections = pickle.load(f)
assert len(reflections) == 2643, len(reflections)
print 'OK'
def as_remark_200(self, wavelength=None):
from libtbx.test_utils import approx_equal
synchrotron = wl = "NULL"
if (wavelength is not None):
out = StringIO()
# XXX somewhat risky...
if (not approx_equal(wavelength, 1.5418, eps=0.01, out=out) and
not approx_equal(wavelength, 0.7107, eps=0.01, out=out)):
synchrotron = "Y"
else:
synchrotron = "N"
wl = "%.4f" % wavelength
lines = []
lines.append("")
lines.append("EXPERIMENTAL DETAILS")
lines.append(" EXPERIMENT TYPE : X-RAY DIFFRACTION")
lines.append(" DATE OF DATA COLLECTION : NULL")
lines.append(" TEMPERATURE (KELVIN) : NULL")
lines.append(" PH : NULL")
lines.append(" NUMBER OF CRYSTALS USED : NULL")
lines.append("")
lines.append(" SYNCHROTRON (Y/N) : NULL")
lines.append(" RADIATION SOURCE : NULL")
lines.append(" BEAMLINE : NULL")
lines.append(" X-RAY GENERATOR MODEL : NULL")
lines.append(" MONOCHROMATIC OR LAUE (M/L) : M")
lines.append(" WAVELENGTH OR RANGE (A) : %s" % wl)
lines.append(" MONOCHROMATOR : NULL")
lines.append(" OPTICS : NULL")
lines.append("")
lines.append(" DETECTOR TYPE : NULL")
lines.append(" DETECTOR MANUFACTURER : NULL")
lines.append(" INTENSITY-INTEGRATION SOFTWARE : NULL")
lines.append(" DATA SCALING SOFTWARE : NULL")
lines.append("")
lines.append("OVERALL.")
comp_overall = format_value("%.1f", self.overall.completeness * 100)
mult_overall = format_value("%.1f", self.overall.mean_redundancy)
rmerg_overall = format_value("%.5f", self.overall.r_merge)
s2n_overall = format_value("%.4f", self.overall.i_over_sigma_mean)
lines.append(" COMPLETENESS FOR RANGE (%%) : %s" % comp_overall)
lines.append(" DATA REDUNDANCY : %s" % mult_overall)
lines.append(" R MERGE (I) : %s" % rmerg_overall)
lines.append(" R SYM (I) : NULL")
lines.append(" <I/SIGMA(I)> FOR THE DATA SET : %s" % s2n_overall)
lines.append("")
lines.append("IN THE HIGHEST RESOLUTION SHELL.")
bin_stats = self.bins[-1]
d_max = format_value("%.2f", bin_stats.d_max)
d_min = format_value("%.2f", bin_stats.d_min)
comp_lastbin = format_value("%.1f", bin_stats.completeness * 100)
mult_lastbin = format_value("%.1f", bin_stats.mean_redundancy)
rmerg_lastbin = format_value("%.5f", bin_stats.r_merge)
s2n_lastbin = format_value("%.4f", bin_stats.i_over_sigma_mean)
lines.append(" HIGHEST RESOLUTION SHELL, RANGE HIGH (A) : %s" % d_min)
lines.append(" HIGHEST RESOLUTION SHELL, RANGE LOW (A) : %s" % d_max)
lines.append(" COMPLETENESS FOR SHELL (%%) : %s" % comp_lastbin)
lines.append(" DATA REDUNDANCY IN SHELL : %s" % mult_lastbin)
lines.append(" R MERGE FOR SHELL (I) : %s" % rmerg_lastbin)
lines.append(" R SYM FOR SHELL (I) : NULL")
lines.append(" <I/SIGMA(I)> FOR SHELL : %s" % s2n_lastbin)
lines.append("")
remark_lines = ["REMARK 200 %s" % line for line in lines]
return "\n".join(remark_lines)
def _is_hbond(self, item, fsc0):
"""
Check if a nonbonded proxy is a H bond
Parameters:
item: list item of nonbonded_list
fsc0: shell_sym_table
"""
is_hbond = False
i_seq = item[1]
j_seq = item[2]
model_distance = item[3]
vdw_sum = item[4]
symop_str = item[5]
symop = item[6]
is_candidate = hbond.precheck(
atoms = self.atoms,
i = i_seq,
j = j_seq,
Hs = self.Hs,
As = self.As,
Ds = self.Ds,
fsc0 = fsc0)
if (not is_candidate):
return is_hbond
crystal_symmetry = self.model.crystal_symmetry()
rt_mx_ji = None
if symop is not None:
rt_mx_ji = sgtbx.rt_mx(str(symop))
#
D, H, A, Y, atom_A, atom_H, atom_D = hbond.get_D_H_A_Y(
i = i_seq,
j = j_seq,
Hs = self.Hs,
fsc0 = fsc0,
rt_mx_ji = rt_mx_ji,
fm = crystal_symmetry.unit_cell().fractionalization_matrix(),
om = crystal_symmetry.unit_cell().orthogonalization_matrix(),
atoms = self.atoms)
d_HA = A.distance(H)
# something went wrong if the distances are not equal
assert approx_equal(d_HA, model_distance, eps=0.1)
d_DA = D.distance(A)
a_DHA = H.angle(A, D, deg=True)
# Values from Steiner, Angew. Chem. Int. Ed. 2002, 41, 48-76, Table 2
# Modification: minimum angle is 110, not 90
# TODO: do we want to adapt to acceptor element?
# TODO: h_a_y angle could be interesting, too
# if ((d_HA >= 1.2 and d_HA <= 2.2) and
# (d_DA >= 2.2 and d_DA <= 3.2) and
# (a_DHA >= 110)):
if ((d_HA >= self.d_HA_cutoff[0] and d_HA <= self.d_HA_cutoff[1]) and
(d_DA >= self.d_DA_cutoff[0] and d_DA <= self.d_DA_cutoff[1]) and
(a_DHA >= self.a_DHA_cutoff)):
is_hbond = True
self._hbonds.add_hbond(
hbond_tuple = (D.i_seq, H.i_seq, A.i_seq),
hbond_info = [d_HA, d_DA, a_DHA, symop_str, symop, vdw_sum])
# TODO: if several atom_x, use the first one found
# (show shortest or both)
#break
return is_hbond
def exercise(pdb_str, eps, idealize):
mon_lib_srv = monomer_library.server.server()
ener_lib = monomer_library.server.ener_lib()
processed_pdb_file = monomer_library.pdb_interpretation.process(
mon_lib_srv=mon_lib_srv,
ener_lib=ener_lib,
raw_records=pdb_str,
force_symmetry=True)
pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy
xray_structure = processed_pdb_file.xray_structure()
sites_cart = xray_structure.sites_cart()
geometry = processed_pdb_file.geometry_restraints_manager(
show_energies=False, plain_pairs_radius=5.0)
es = geometry.energies_sites(sites_cart=sites_cart, compute_gradients=True)
g_analytical = es.gradients
#
riding_h_manager = riding.manager(pdb_hierarchy=pdb_hierarchy,
geometry_restraints=geometry)
h_parameterization = riding_h_manager.h_parameterization
riding_h_manager.idealize_hydrogens_inplace(pdb_hierarchy=pdb_hierarchy,
xray_structure=xray_structure)
#sites_cart = pdb_hierarchy.atoms().extract_xyz()
sites_cart = xray_structure.sites_cart()
#for i in g_analytical:
# print i
#print '----------'
g_analytical = geometry.energies_sites(sites_cart=sites_cart,
compute_gradients=True).gradients
modify_gradients.modify_gradients(sites_cart=sites_cart,
h_parameterization=h_parameterization,
grads=g_analytical)
#
ex = [eps, 0, 0]
ey = [0, eps, 0]
ez = [0, 0, eps]
g_fd = flex.vec3_double()
for i_site in xrange(sites_cart.size()):
g_fd_i = []
for e in [ex, ey, ez]:
ts = []
for sign in [-1, 1]:
sites_cart_ = sites_cart.deep_copy()
xray_structure_ = xray_structure.deep_copy_scatterers()
sites_cart_[i_site] = [
sites_cart_[i_site][j] + e[j] * sign for j in xrange(3)
]
xray_structure_.set_sites_cart(sites_cart_)
# after shift, recalculate H position
riding_h_manager.idealize_hydrogens_inplace(
xray_structure=xray_structure_)
sites_cart_ = xray_structure_.sites_cart()
ts.append(
geometry.energies_sites(sites_cart=sites_cart_,
compute_gradients=False).target)
g_fd_i.append((ts[1] - ts[0]) / (2 * eps))
g_fd.append(g_fd_i)
for g1, g2 in zip(g_analytical, g_fd):
#print g1,g2
assert approx_equal(g1, g2, 1.e-4)
def run3(prefix):
file_name = os.path.join(qr_unit_tests_data, "h_altconf_2.pdb")
s_b_W1_A_str = "altloc A or resseq 95:97"
s_f_W1_A_str = "resseq 87:93 or altloc A or resseq 95:97"
s_b_W1_B_str = "altloc B or resseq 95:97"
s_f_W1_B_str = "resseq 87:93 or altloc B or resseq 95:97"
s_b_W1_AB_str = "resseq 95:97"
s_f_W1_AB_str = "resseq 87:93 or resseq 95:97"
s_b_W2_str = "altloc B or resseq 91:93"
s_f_W2_str = "resseq 95:99 or altloc B or resseq 91:93"
s_b_A_str = "resseq 90:93 or resseq 95:96"
s_f_A_str = "altloc A or resseq 90:93 or resseq 95:96"
s_b_B_str = "resseq 90:93 or resseq 95:96"
s_f_B_str = "altloc B or resseq 90:93 or resseq 95:96"
g, junk1, junk2 = get_grads(file_name=file_name,
sel_f_str="all",
sel_buffer_str="not all")
gA_f, s_A_f, s_A_b = get_grads(file_name=file_name,
sel_f_str=s_f_A_str,
sel_buffer_str=s_b_A_str)
gB_f, s_B_f, s_B_b = get_grads(file_name=file_name,
sel_f_str=s_f_B_str,
sel_buffer_str=s_b_B_str)
gW1_A_f, s_W1_A_f, s_W1_A_b = get_grads(file_name=file_name,
sel_f_str=s_f_W1_A_str,
sel_buffer_str=s_b_W1_A_str)
gW1_B_f, s_W1_B_f, s_W1_B_b = get_grads(file_name=file_name,
sel_f_str=s_f_W1_B_str,
sel_buffer_str=s_b_W1_B_str)
gW1_AB_f, s_W1_AB_f, s_W1_AB_b = get_grads(file_name=file_name,
sel_f_str=s_f_W1_AB_str,
sel_buffer_str=s_b_W1_AB_str)
gW2_f, s_W2_f, s_W2_b = get_grads(file_name=file_name,
sel_f_str=s_f_W2_str,
sel_buffer_str=s_b_W2_str)
g = flex.vec3_double(g.size())
g_W1_A = g.set_selected(s_W1_A_f, gW1_A_f)
g_W1_A = g_W1_A.set_selected(s_W1_A_b, [0, 0, 0])
g = flex.vec3_double(g.size())
g_W1_B = g.set_selected(s_W1_B_f, gW1_B_f)
g_W1_B = g_W1_B.set_selected(s_W1_B_b, [0, 0, 0])
g = flex.vec3_double(g.size())
g_W1_AB = g.set_selected(s_W1_AB_f, gW1_AB_f)
g_W1_AB = g_W1_AB.set_selected(s_W1_AB_b, [0, 0, 0])
g = flex.vec3_double(g.size())
g_W2 = g.set_selected(s_W2_f, gW2_f)
g_W2 = g_W2.set_selected(s_W2_b, [0, 0, 0])
g = flex.vec3_double(g.size())
g_A = g.set_selected(s_A_f, gA_f)
g_A = g_A.set_selected(s_A_b, [0, 0, 0])
g = flex.vec3_double(g.size())
g_B = g.set_selected(s_B_f, gB_f)
g_B = g_B.set_selected(s_B_b, [0, 0, 0])
g1, junk1, junk2 = get_grads(file_name=file_name,
sel_f_str="all",
sel_buffer_str="not all")
g2 = g_A + g_B + g_W1_A + g_W1_B + g_W2 - g_W1_AB
diff = g1 - g2
assert approx_equal(diff.max(), [0, 0, 0])
if (0):
print diff.max()
for d in diff:
print d
def exercise_3():
#test torsion restraints
for use_reference in ['True', 'False', 'top_out', 'None']:
pdb_inp = iotbx.pdb.input(lines=flex.std_string(
pdb_str_2.splitlines()),
source_info=None)
model = manager(model_input=pdb_inp, log=null_out())
grm = model.get_restraints_manager().geometry
xrs2 = model.get_xray_structure()
awl2 = model.get_hierarchy().atoms_with_labels()
pdb2 = model.get_hierarchy()
pdb_inp3 = iotbx.pdb.input(source_info=None, lines=pdb_str_3)
xrs3 = pdb_inp3.xray_structure_simple()
ph3 = pdb_inp3.construct_hierarchy()
ph3.atoms().reset_i_seq()
awl3 = ph3.atoms_with_labels()
sites_cart_reference = flex.vec3_double()
selection = flex.size_t()
min_selection = flex.size_t()
reference_names = [
"N", "CA", "CB", "CG", "CD", "NE", "CZ", "NH1", "NH2"
]
minimize_names = ["CG", "CD", "NE", "CZ", "NH1", "NH2"]
for a2, a3 in zip(tuple(awl2), tuple(awl3)):
assert a2.resname == a3.resname
assert a2.name == a3.name
assert a2.i_seq == a3.i_seq
if (a2.resname == "ARG" and a2.name.strip() in reference_names):
selection.append(a2.i_seq)
sites_cart_reference.append(a3.xyz)
if a2.name.strip() in minimize_names:
min_selection.append(a2.i_seq)
assert selection.size() == len(reference_names)
selection_bool = flex.bool(xrs2.scatterers().size(), min_selection)
if (use_reference == 'True'):
grm.add_chi_torsion_restraints_in_place(
pdb_hierarchy=pdb2,
sites_cart=sites_cart_reference,
selection=selection,
sigma=2.5)
elif (use_reference == 'top_out'):
grm.add_chi_torsion_restraints_in_place(
pdb_hierarchy=pdb2,
sites_cart=sites_cart_reference,
selection=selection,
sigma=2.5,
limit=180.0,
top_out_potential=True)
elif (use_reference == 'None'):
grm.add_chi_torsion_restraints_in_place(
pdb_hierarchy=pdb2,
sites_cart=sites_cart_reference,
selection=selection,
sigma=2.5)
grm.remove_chi_torsion_restraints_in_place(selection=selection)
d1 = flex.mean(
flex.sqrt((xrs2.sites_cart().select(min_selection) -
xrs3.sites_cart().select(min_selection)).dot()))
print "distance start (use_reference: %s): %6.4f" % (
str(use_reference), d1)
assert d1 > 4.0
assert approx_equal(
flex.max(
flex.sqrt((xrs2.sites_cart().select(~selection_bool) -
xrs3.sites_cart().select(~selection_bool)).dot())),
0)
from cctbx import geometry_restraints
import mmtbx.refinement.geometry_minimization
import scitbx.lbfgs
grf = geometry_restraints.flags.flags(default=True)
grf.nonbonded = False
sites_cart = xrs2.sites_cart()
minimized = mmtbx.refinement.geometry_minimization.lbfgs(
sites_cart=sites_cart,
correct_special_position_tolerance=1.0,
geometry_restraints_manager=grm,
sites_cart_selection=flex.bool(sites_cart.size(), min_selection),
geometry_restraints_flags=grf,
lbfgs_termination_params=scitbx.lbfgs.termination_parameters(
max_iterations=5000))
xrs2.set_sites_cart(sites_cart=sites_cart)
d2 = flex.mean(
flex.sqrt((xrs2.sites_cart().select(min_selection) -
xrs3.sites_cart().select(min_selection)).dot()))
print "distance final (use_reference: %s): %6.4f" % (
str(use_reference), d2)
if (use_reference in ['True', 'top_out']): assert d2 < 0.02, d2
else: assert d2 > 4.0, d2
assert approx_equal(
flex.max(
flex.sqrt((xrs2.sites_cart().select(~selection_bool) -
xrs3.sites_cart().select(~selection_bool)).dot())),
0)
#test torsion manipulation
grm.remove_chi_torsion_restraints_in_place()
grm.remove_chi_torsion_restraints_in_place()
sites_cart_reference = []
selections_reference = []
for model in pdb2.models():
for chain in model.chains():
for residue in chain.residues():
sites_cart_reference.append(residue.atoms().extract_xyz())
selections_reference.append(residue.atoms().extract_i_seq())
#one residue at a time (effectively chi angles only)
for sites_cart, selection in zip(sites_cart_reference,
selections_reference):
grm.add_chi_torsion_restraints_in_place(pdb_hierarchy=pdb2,
sites_cart=sites_cart,
selection=selection)
assert grm.get_n_chi_torsion_proixes() == 6
grm.remove_chi_torsion_restraints_in_place()
#all sites at once, chi angles only
sites_cart = xrs2.sites_cart()
grm.add_chi_torsion_restraints_in_place(pdb_hierarchy=pdb2,
sites_cart=sites_cart,
selection=None,
chi_angles_only=True)
assert grm.get_n_chi_torsion_proixes() == 6
#all sites at once, all torsions
grm.add_chi_torsion_restraints_in_place(pdb_hierarchy=pdb2,
sites_cart=sites_cart,
selection=None,
chi_angles_only=False)
# grm.get_chi_torsion_proxies().show_sorted(
# by_value='residual',
# sites_cart=sites_cart,
# site_labels=[atom.id_str() for atom in pdb2.atoms()])
assert grm.get_n_chi_torsion_proixes(
) == 12, grm.get_n_chi_torsion_proixes()
def test(dials_regression):
from scitbx import matrix
from libtbx.phil import parse
from libtbx.test_utils import approx_equal
from scitbx.array_family import flex
# Get modules to build models and minimiser using PHIL
from dials.test.algorithms.refinement import setup_geometry
from dials.test.algorithms.refinement import setup_minimiser
from dials.algorithms.refinement.parameterisation.crystal_parameters import \
CrystalOrientationParameterisation, CrystalUnitCellParameterisation
# Symmetry constrained parameterisation for the unit cell
from cctbx.uctbx import unit_cell
from rstbx.symmetry.constraints.parameter_reduction import \
symmetrize_reduce_enlarge
DEG2RAD = math.pi/180.0
RAD2DEG = 180.0/math.pi
master_phil = parse("""
include scope dials.test.algorithms.refinement.geometry_phil
include scope dials.test.algorithms.refinement.minimiser_phil
""", process_includes=True)
# make cell more oblique
args=["a.direction.close_to.sd=5","b.direction.close_to.sd=5","c.direction.close_to.sd=5"]
models = setup_geometry.Extract(master_phil, cmdline_args = args)
crystal = models.crystal
# a hexagonal crystal is a good test case for behaviour of oblique cells
do_hexagonal = True
if do_hexagonal:
from dxtbx.model.experiment_list import ExperimentListFactory
experiments = ExperimentListFactory.from_json_file(
os.path.join(dials_regression, "refinement_test_data", "multi_stills", "combined_experiments.json"),
check_format=False)
crystal = experiments[0].crystal
# derive finite difference gradients of various quantities wrt each param
def check_fd_gradients(parameterisation):
mp = parameterisation
p_vals = mp.get_param_vals()
deltas = [1.e-7 for p in p_vals]
assert len(deltas) == len(p_vals)
fd_grad = []
# get matrix to unset rotations of unit cell vectors
Ut = matrix.sqr(mp.get_model().get_U()).transpose()
for i, delta in enumerate(deltas):
val = p_vals[i]
p_vals[i] -= delta / 2.
mp.set_param_vals(p_vals)
rev_uc = mp.get_model().get_unit_cell().parameters()
rev_vec = mp.get_model().get_real_space_vectors()
rev_vec = [Ut * vec for vec in rev_vec]
rev_B = matrix.sqr(mp.get_model().get_B())
rev_O = rev_B.transpose().inverse()
p_vals[i] += delta
mp.set_param_vals(p_vals)
fwd_uc = mp.get_model().get_unit_cell().parameters()
fwd_vec = mp.get_model().get_real_space_vectors()
fwd_vec = [Ut * vec for vec in fwd_vec]
fwd_B = matrix.sqr(mp.get_model().get_B())
fwd_O = fwd_B.transpose().inverse()
fd_uc = [(f - r) / delta for f,r in zip(fwd_uc, rev_uc)]
fd_vec = [(f - r) / delta for f,r in zip(fwd_vec, rev_vec)]
fd_B = (fwd_B - rev_B) / delta
fd_O = (fwd_O - rev_O) / delta
fd_grad.append({'da_dp':fd_uc[0],
'db_dp':fd_uc[1],
'dc_dp':fd_uc[2],
'daa_dp':fd_uc[3],
'dbb_dp':fd_uc[4],
'dcc_dp':fd_uc[5],
'davec_dp':fd_vec[0],
'dbvec_dp':fd_vec[1],
'dcvec_dp':fd_vec[2],
'dB_dp':fd_B,
'dO_dp':fd_O})
p_vals[i] = val
# return to the initial state
mp.set_param_vals(p_vals)
return fd_grad
xlo_param = CrystalOrientationParameterisation(crystal)
xluc_param = CrystalUnitCellParameterisation(crystal)
from dials.algorithms.refinement.restraints.restraints import SingleUnitCellTie
uct = SingleUnitCellTie(xluc_param, [None]*6, [None]*6)
from scitbx.math import angle_derivative_wrt_vectors
B = matrix.sqr(crystal.get_B())
O = (B.transpose()).inverse()
a, b, c, aa, bb, cc = crystal.get_unit_cell().parameters()
aa *= DEG2RAD
bb *= DEG2RAD
cc *= DEG2RAD
Ut = matrix.sqr(crystal.get_U()).transpose()
avec, bvec, cvec = [Ut * vec for vec in crystal.get_real_space_vectors()]
# calculate d[B^T]/dp
dB_dp = xluc_param.get_ds_dp()
dBT_dp = [dB.transpose() for dB in dB_dp]
# calculate d[O]/dp
dO_dp = [-O * dBT * O for dBT in dBT_dp]
# function to get analytical derivative of angles wrt vectors
def dangle(u, v):
return [matrix.col(e) for e in angle_derivative_wrt_vectors(u,v)]
dalpha_db, dalpha_dc = dangle(bvec, cvec)
dbeta_da, dbeta_dc = dangle(avec, cvec)
dgamma_da, dgamma_db = dangle(avec, bvec)
# get all FD derivatives
fd_grad = check_fd_gradients(xluc_param)
# look at each parameter
for i, dO in enumerate(dO_dp):
#print
#print "***** PARAMETER {0} *****".format(i)
#print "dB_dp analytical"
#print dB_dp[i]
#print "dB_dp FD"
#print fd_grad[i]['dB_dp']
#print
# dB_dp is good. What about dO_dp?
#print "O MATRIX"
#print "dO_dp analytical"
#print dO.round(6)
#print "dO_dp FD"
#print fd_grad[i]['dO_dp'].round(6)
#print
assert approx_equal(dO, fd_grad[i]['dO_dp'])
# extract derivatives of each unit cell vector wrt p
dav_dp, dbv_dp, dcv_dp = dO.transpose().as_list_of_lists()
dav_dp = matrix.col(dav_dp)
dbv_dp = matrix.col(dbv_dp)
dcv_dp = matrix.col(dcv_dp)
# check these are correct vs FD
#print "CELL VECTORS"
#diff = dav_dp - fd_grad[i]['davec_dp']
#print 2 * diff.length() / (dav_dp.length() + fd_grad[i]['davec_dp'].length()) * 100
#print 'davec_dp analytical: {0:.5f} {1:.5f} {2:.5f}'.format(*dav_dp.elems)
#print 'davec_dp finite diff: {0:.5f} {1:.5f} {2:.5f}'.format(*fd_grad[i]['davec_dp'].elems)
assert approx_equal(dav_dp, fd_grad[i]['davec_dp'])
#diff = dbv_dp - fd_grad[i]['dbvec_dp']
#print 2 * diff.length() / (dbv_dp.length() + fd_grad[i]['dbvec_dp'].length()) * 100
#print 'dbvec_dp analytical: {0:.5f} {1:.5f} {2:.5f}'.format(*dbv_dp.elems)
#print 'dbvec_dp finite diff: {0:.5f} {1:.5f} {2:.5f}'.format(*fd_grad[i]['dbvec_dp'].elems)
assert approx_equal(dbv_dp, fd_grad[i]['dbvec_dp'])
#diff = dcv_dp - fd_grad[i]['dcvec_dp']
#print 2 * diff.length() / (dcv_dp.length() + fd_grad[i]['dcvec_dp'].length()) * 100
#print 'dcvec_dp analytical: {0:.5f} {1:.5f} {2:.5f}'.format(*dcv_dp.elems)
#print 'dcvec_dp finite diff: {0:.5f} {1:.5f} {2:.5f}'.format(*fd_grad[i]['dcvec_dp'].elems)
#print
assert approx_equal(dcv_dp, fd_grad[i]['dcvec_dp'])
#print "CELL LENGTHS"
da_dp = 1./a * avec.dot(dav_dp)
#print "d[a]/dp{2} analytical: {0:.5f} FD: {1:.5f}".format(da_dp, fd_grad[i]['da_dp'], i)
assert approx_equal(da_dp, fd_grad[i]['da_dp'])
db_dp = 1./b * bvec.dot(dbv_dp)
#print "d[b]/dp{2} analytical: {0:.5f} FD: {1:.5f}".format(db_dp, fd_grad[i]['db_dp'], i)
assert approx_equal(db_dp, fd_grad[i]['db_dp'])
dc_dp = 1./c * cvec.dot(dcv_dp)
#print "d[c]/dp{2} analytical: {0:.5f} FD: {1:.5f}".format(dc_dp, fd_grad[i]['dc_dp'], i)
assert approx_equal(dc_dp, fd_grad[i]['dc_dp'])
#print
#print "CELL ANGLES"
daa_dp = RAD2DEG * (dbv_dp.dot(dalpha_db) + dcv_dp.dot(dalpha_dc))
dbb_dp = RAD2DEG * (dav_dp.dot(dbeta_da) + dcv_dp.dot(dbeta_dc))
dcc_dp = RAD2DEG * (dav_dp.dot(dgamma_da) + dbv_dp.dot(dgamma_db))
#print "d[alpha]/dp{2} analytical: {0:.5f} FD: {1:.5f}".format(daa_dp, fd_grad[i]['daa_dp'], i)
#print "d[beta]/dp{2} analytical: {0:.5f} FD: {1:.5f}".format(dbb_dp, fd_grad[i]['dbb_dp'], i)
#print "d[gamma]/dp{2} analytical: {0:.5f} FD: {1:.5f}".format(dcc_dp, fd_grad[i]['dcc_dp'], i)
assert approx_equal(daa_dp, fd_grad[i]['daa_dp'])
assert approx_equal(dbb_dp, fd_grad[i]['dbb_dp'])
assert approx_equal(dcc_dp, fd_grad[i]['dcc_dp'])
def test_01():
# Source data
data_dir = os.path.dirname(os.path.abspath(__file__))
data_ccp4 = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4')
data_pdb = os.path.join(data_dir, 'data', 'non_zero_origin_model.pdb')
data_ncs_spec = os.path.join(data_dir, 'data',
'non_zero_origin_ncs_spec.ncs_spec')
# DataManager
dm = DataManager(['ncs_spec', 'model', 'real_map', 'phil'])
dm.set_overwrite(True)
# Read in map and model and ncs
map_file = data_ccp4
dm.process_real_map_file(map_file)
mm = dm.get_real_map(map_file)
model_file = data_pdb
dm.process_model_file(model_file)
model = dm.get_model(model_file)
ncs_file = data_ncs_spec
dm.process_ncs_spec_file(ncs_file)
ncs = dm.get_ncs_spec(ncs_file)
ncs_dc = ncs.deep_copy()
mmmn = match_map_model_ncs()
mmmn.add_map_manager(mm)
mmmn.add_model(model)
mmmn.add_ncs_object(ncs)
# Save it
mmmn_dc = mmmn.deep_copy()
# Test creating mmm from model:
mmm_from_model = model.as_map_model_manager(create_model_map=False)
mmm_from_model = model.as_map_model_manager(create_model_map=True,
resolution=5)
assert mmm_from_model.map_manager() is not None
# Make sure we can add an ncs object that is either shifted or not
mmmn_dcdc = mmmn.deep_copy()
new_mmmn = match_map_model_ncs()
new_mmmn.add_map_manager(mmmn_dcdc.map_manager())
new_mmmn.add_model(mmmn_dcdc.model())
new_mmmn.add_ncs_object(mmmn_dcdc.ncs_object())
assert new_mmmn.ncs_object().shift_cart() == new_mmmn.map_manager(
).shift_cart()
mmmn_dcdc = mmmn.deep_copy()
new_mmmn = match_map_model_ncs()
new_mmmn.add_map_manager(mmmn_dcdc.map_manager())
new_mmmn.add_model(mmmn_dcdc.model())
new_mmmn.add_ncs_object(ncs_dc)
assert new_mmmn.ncs_object().shift_cart() == new_mmmn.map_manager(
).shift_cart()
original_ncs = mmmn.ncs_object()
assert approx_equal(
(24.0528, 11.5833, 20.0004),
tuple(original_ncs.ncs_groups()[0].translations_orth()[-1]),
eps=0.1)
assert tuple(mmmn._map_manager.origin_shift_grid_units) == (0, 0, 0)
# Shift origin to (0,0,0)
mmmn = mmmn_dc.deep_copy() # fresh version of match_map_model_ncs
mmmn.shift_origin()
new_ncs = mmmn.ncs_object()
assert tuple(mmmn._map_manager.origin_shift_grid_units) == (100, 100, 100)
mmmn.write_model('s.pdb')
mmmn.write_map('s.mrc')
shifted_ncs = mmmn.ncs_object()
assert approx_equal(
(-153.758, -74.044, -127.487),
tuple(shifted_ncs.ncs_groups()[0].translations_orth()[-1]),
eps=0.1)
# Shift a model and shift it back
mmmn = mmmn_dc.deep_copy() # fresh version of match_map_model_ncs
model = mmmn.model()
shifted_model = mmmn.shift_model_to_match_working_map(model=model)
model_in_original_position = mmmn.shift_model_to_match_original_map(
model=shifted_model)
assert (approx_equal(
model.get_sites_cart(), # not a copy
shifted_model.get_sites_cart()))
assert approx_equal(model.get_sites_cart(),
model_in_original_position.get_sites_cart())
# test data_manager map_model_manager
generated_mmm = dm.get_map_model_manager()
print(generated_mmm)
assert (isinstance(generated_mmm, map_model_manager))
# Generate a map and model
import sys
mmm = map_model_manager(log=sys.stdout)
mmm.generate_map()
model = mmm.model()
mm = mmm.map_manager()
assert approx_equal(model.get_sites_cart()[0], (14.476, 10.57, 8.34),
eps=0.01)
assert approx_equal(mm.map_data()[10, 10, 10], -0.0506, eps=0.001)
# Save it
mmm_dc = mmm.deep_copy()
# Create model from sites
mmm_sites = mmm_dc.deep_copy()
from scitbx.array_family import flex
sites_cart = flex.vec3_double()
sites_cart.append((3, 4, 5))
mmm_sites.model_from_sites_cart(sites_cart=sites_cart,
model_id='new_model')
assert mmm_sites.get_model_by_id('new_model').get_sites_cart()[0] == (3, 4,
5)
ph_sites = mmm_sites.get_model_by_id('new_model').get_hierarchy()
text_sites = mmm_sites.get_model_by_id('new_model').model_as_pdb()
# Create model from hierarchy
mmm_sites = mmm_dc.deep_copy()
mmm_sites.model_from_hierarchy(hierarchy=ph_sites, model_id='new_model')
assert mmm_sites.get_model_by_id('new_model').get_sites_cart()[0] == (3, 4,
5)
# Create model from text
mmm_sites = mmm_dc.deep_copy()
mmm_sites.model_from_text(text=text_sites, model_id='new_model')
assert mmm_sites.get_model_by_id('new_model').get_sites_cart()[0] == (3, 4,
5)
# Set crystal_symmetry and unit_cell_crystal_symmetry and shift_cart
# Box and shift the map_model_manager so we have new coordinate system
mmm_sites.box_all_maps_around_model_and_shift_origin(box_cushion=4.5)
new_model = mmm_sites.get_model_by_id('new_model')
assert approx_equal(
(3., 4., 5.0),
mmm_sites.get_model_by_id('new_model').get_sites_cart()[0])
# arbitrarily set unit_cell crystal symmetry of model to
# match crystal_symmetry. First have to set shift_cart to None
new_model.set_shift_cart(shift_cart=None)
new_model.set_unit_cell_crystal_symmetry_and_shift_cart()
assert new_model.crystal_symmetry() != mmm_sites.crystal_symmetry()
# now set crystal symmetries and shift cart of model to match the manager
mmm_sites.set_model_symmetries_and_shift_cart_to_match_map(new_model)
assert new_model.crystal_symmetry().is_similar_symmetry(
mmm_sites.crystal_symmetry())
assert new_model.unit_cell_crystal_symmetry().is_similar_symmetry(
mmm_sites.unit_cell_crystal_symmetry())
assert new_model.shift_cart() == mmm_sites.shift_cart()
# Import hierarchy into a model and set symmetries and shift to match
mmm_sites.model_from_hierarchy(hierarchy=mmm_sites.model().get_hierarchy(),
model_id='model_from_hierarchy')
assert mmm_sites.get_model_by_id('model_from_hierarchy').model_as_pdb() \
== mmm_sites.get_model_by_id('model').model_as_pdb()
# Check on wrapping
assert not mm.wrapping(
) # this one should not wrap because it is zero at edges
# Make a new one with no buffer so it is not zero at edges
mmm = map_model_manager()
mmm.generate_map(box_cushion=0)
mm = mmm.map_manager()
# check its compatibility with wrapping
assert mm.is_consistent_with_wrapping()
mmm.show_summary()
# now box it
sel = mmm.model().selection("resseq 221:221")
new_model = mmm.model().deep_copy().select(sel)
new_mmm = map_model_manager(model=new_model, map_manager=mm.deep_copy())
new_mmm.box_all_maps_around_model_and_shift_origin()
new_mm = new_mmm.map_manager()
assert not new_mm.wrapping()
assert not new_mm.is_consistent_with_wrapping()
# now box it with selection
new_mmm_1 = map_model_manager(model=mmm.model().deep_copy(),
map_manager=mm.deep_copy())
new_mmm_1.box_all_maps_around_model_and_shift_origin(
selection_string="resseq 221:221")
new_mm_1 = new_mmm_1.map_manager()
assert not new_mm_1.wrapping()
assert not new_mm_1.is_consistent_with_wrapping()
assert new_mm_1.map_data().all() == new_mm.map_data().all()
# create map_model_manager with just half-maps
mm1 = mm.deep_copy()
mm2 = mm.deep_copy()
map_data = mm2.map_data()
map_data += 1.
new_mmm = map_model_manager(model=mmm.model().deep_copy(),
map_manager_1=mm1,
map_manager_2=mm2)
assert new_mmm._map_dict.get(
'map_manager') is None # should not be any yet
assert approx_equal(new_mmm.map_manager().map_data()[232],
mm.deep_copy().map_data()[232] + 0.5)
assert new_mmm._map_dict.get(
'map_manager') is not None # now should be there
# generate map data from a model
mm1 = mm.deep_copy()
mm2 = mm.deep_copy()
new_mmm = map_model_manager(model=mmm.model().deep_copy(), map_manager=mm1)
mmm.generate_map(model=mmm.model())
mm = mmm.map_manager()
mmm.show_summary()
# check get_map_model_manager function
dm = DataManager(['model'])
assert not hasattr(dm, 'get_map_model_manager')
dm = DataManager(['real_map'])
assert not hasattr(dm, 'get_map_model_manager')
dm = DataManager(['sequence'])
assert not hasattr(dm, 'get_map_model_manager')
dm = DataManager(['model', 'real_map'])
assert hasattr(dm, 'get_map_model_manager')
# usage
dm.get_map_model_manager(model_file=data_pdb, map_files=data_ccp4)
dm.get_map_model_manager(model_file=data_pdb, map_files=[data_ccp4])
dm.get_map_model_manager(model_file=data_pdb,
map_files=[data_ccp4, data_ccp4, data_ccp4])
dm.get_map_model_manager(model_file=data_pdb,
map_files=data_ccp4,
ignore_symmetry_conflicts=True)
# errors
try:
dm.get_map_model_manager(model_file=data_pdb,
map_files=data_ccp4,
from_phil=True)
except Sorry as e:
assert 'from_phil is set to True' in str(e)
try:
dm.get_map_model_manager(model_file=data_pdb,
map_files=data_ccp4,
abc=123)
except TypeError as e:
assert 'unexpected keyword argument' in str(e)
try:
dm.get_map_model_manager(model_file=data_pdb,
map_files=[data_ccp4, data_ccp4])
except Sorry as e:
assert '1 full map and 2 half maps' in str(e)
# PHIL
class test_program(ProgramTemplate):
master_phil_str = '''
include scope iotbx.map_model_manager.map_model_phil_str
'''
working_phil_str = '''
map_model {
full_map = %s
half_map = %s
half_map = s.mrc
model = %s
}
''' % (data_ccp4, data_ccp4, data_pdb)
master_phil = parse(test_program.master_phil_str, process_includes=True)
working_phil = master_phil.fetch(parse(working_phil_str))
tp = test_program(dm, working_phil.extract())
try:
dm.get_map_model_manager(from_phil=True)
except Exception as e:
assert 'ignore_symmetry_conflicts' in str(e)
try:
dm.get_map_model_manager(from_phil=True,
ignore_symmetry_conflicts=True)
except AssertionError:
pass
def exercise_protein():
pdb_file = libtbx.env.find_in_repositories(
relative_path="phenix_regression/pdb/3ifk.pdb", test=op.isfile)
hkl_file = libtbx.env.find_in_repositories(
relative_path="phenix_regression/reflection_files/3ifk.mtz",
test=op.isfile)
if (pdb_file is None):
print "phenix_regression not available, skipping."
return
args1 = [
pdb_file,
"outliers_only=True",
"output.prefix=tst_molprobity",
"--pickle",
"flags.xtriage=True",
]
result = molprobity.run(args=args1, out=null_out()).validation
out1 = StringIO()
result.show(out=out1)
result = loads(dumps(result))
out2 = StringIO()
result.show(out=out2)
assert (result.nqh_flips.n_outliers == 6)
assert (not "RNA validation" in out2.getvalue())
assert (out2.getvalue() == out1.getvalue())
dump("tst_molprobity.pkl", result)
mc = result.as_multi_criterion_view()
assert (result.neutron_stats is None)
mpscore = result.molprobity_score()
# percentiles
out4 = StringIO()
result.show_summary(out=out4, show_percentiles=True)
assert (""" Clashscore = 49.59 (percentile: 0.2)"""
in out4.getvalue())
# misc
assert approx_equal(result.r_work(), 0.237) # from PDB header
assert approx_equal(result.r_free(), 0.293) # from PDB header
assert approx_equal(result.d_min(), 2.03) # from PDB header
assert (result.d_max_min() is None)
assert approx_equal(result.rms_bonds(), 0.02585)
assert approx_equal(result.rms_angles(), 2.356740)
assert approx_equal(result.rama_favored(), 96.47059)
assert (result.cbeta_outliers() == 10)
assert approx_equal(result.molprobity_score(), 3.40, eps=0.01)
summary = result.summarize()
gui_fields = list(summary.iter_molprobity_gui_fields())
assert (len(gui_fields) == 6)
#result.show()
assert (str(mc.data()[2]) == ' A 5 THR rota,cb,clash')
import mmtbx.validation.molprobity
from iotbx import file_reader
pdb_in = file_reader.any_file(pdb_file)
hierarchy = pdb_in.file_object.hierarchy
result = mmtbx.validation.molprobity.molprobity(pdb_hierarchy=hierarchy)
out3 = StringIO()
result.show_summary(out=out3)
assert """\
Ramachandran outliers = 1.76 %
favored = 96.47 %
Rotamer outliers = 20.00 %
""" in out3.getvalue()
# now with data
args2 = args1 + [hkl_file, "--maps"]
result, cmdline = molprobity.run(args=args2,
out=null_out(),
return_input_objects=True)
out = StringIO()
result.show(out=out)
stats = result.get_statistics_for_phenix_gui()
#print stats
stats = result.get_polygon_statistics([
"r_work", "r_free", "adp_mean_all", "angle_rmsd", "bond_rmsd",
"clashscore"
])
#print stats
assert approx_equal(result.r_work(), 0.2276, eps=0.001)
assert approx_equal(result.r_free(), 0.2805, eps=0.001)
assert approx_equal(result.d_min(), 2.0302, eps=0.0001)
assert approx_equal(result.d_max_min(), [34.546125, 2.0302], eps=0.0001)
assert approx_equal(result.rms_bonds(), 0.02585)
assert approx_equal(result.rms_angles(), 2.356740)
assert approx_equal(result.rama_favored(), 96.47059)
assert (result.cbeta_outliers() == 10)
assert approx_equal(result.unit_cell().parameters(),
(55.285, 58.851, 67.115, 90, 90, 90))
assert (str(result.space_group_info()) == "P 21 21 21")
bins = result.fmodel_statistics_by_resolution()
assert (len(bins) == 10)
assert approx_equal(result.atoms_to_observations_ratio(),
0.09755,
eps=0.0001)
assert approx_equal(result.b_iso_mean(), 31.11739)
assert op.isfile("tst_molprobity_maps.mtz")
bins = result.fmodel_statistics_by_resolution()
#bins.show()
bin_plot = result.fmodel_statistics_graph_data()
lg = bin_plot.format_loggraph()
# fake fmodel_neutron
fmodel_neutron = cmdline.fmodel.deep_copy()
result2 = mmtbx.validation.molprobity.molprobity(
pdb_hierarchy=cmdline.pdb_hierarchy,
fmodel=cmdline.fmodel,
fmodel_neutron=fmodel_neutron,
geometry_restraints_manager=cmdline.geometry,
nuclear=True,
keep_hydrogens=True)
stats = result2.get_statistics_for_phenix_gui()
assert ('R-work (neutron)' in [label for (label, stat) in stats])
def exercise_gaussian_fit():
# test fitting of a gaussian
def do_gaussian_fit(scale, mu, sigma):
start = mu - 6 * sigma
stop = mu + 6 * sigma
step = (stop - start) / 1000
x = flex.double(frange(start, stop, step))
y = scale * flex.exp(-flex.pow2(x - mu) / (2 * sigma**2))
fit = curve_fitting.single_gaussian_fit(x, y)
assert approx_equal(fit.a, scale, 1e-4)
assert approx_equal(fit.b, mu, eps=1e-4)
assert approx_equal(fit.c, sigma, eps=1e-4)
for i in range(10):
scale = random.random() * 1000
sigma = (random.random() + 0.0001) * 10
mu = (-1)**random.randint(0, 1) * random.random() * 1000
functor = curve_fitting.gaussian(scale, mu, sigma)
start = mu - 6 * sigma
stop = mu + 6 * sigma
step = (stop - start) / 1000
x = flex.double(frange(start, stop, step))
fd_grads = finite_differences(functor, x)
assert approx_equal(functor.partial_derivatives(x), fd_grads, 1e-4)
do_gaussian_fit(scale, mu, sigma)
# if we take the log of a gaussian we can fit a parabola
scale = 123
mu = 3.2
sigma = 0.1
x = flex.double(frange(2, 4, 0.01))
y = scale * flex.exp(-flex.pow2(x - mu) / (2 * sigma**2))
# need to be careful to only use values of y > 0
eps = 1e-15
x = flex.double([x[i] for i in range(x.size()) if y[i] > eps])
y = flex.double([y[i] for i in range(y.size()) if y[i] > eps])
fit = curve_fitting.univariate_polynomial_fit(x, flex.log(y), degree=2)
c, b, a = fit.params
assert approx_equal(mu, -b / (2 * a))
assert approx_equal(sigma * sigma, -1 / (2 * a))
# test multiple gaussian fits
gaussians = [
curve_fitting.gaussian(0.3989538, 3.7499764, 0.7500268),
curve_fitting.gaussian(0.7978957, 6.0000004, 0.5000078)
]
x = flex.double(frange(0, 10, 0.1))
y = flex.double(x.size())
for i in range(len(gaussians)):
g = gaussians[i]
scale, mu, sigma = g.a, g.b, g.c
y += g(x)
starting_gaussians = [
curve_fitting.gaussian(1, 4, 1),
curve_fitting.gaussian(1, 5, 1)
]
fit = curve_fitting.gaussian_fit(x, y, starting_gaussians)
for g1, g2 in zip(gaussians, fit.gaussians):
assert approx_equal(g1.a, g2.a, eps=1e-4)
assert approx_equal(g1.b, g2.b, eps=1e-4)
assert approx_equal(g1.c, g2.c, eps=1e-4)
# use example of 5-gaussian fit from here:
# http://research.stowers-institute.org/efg/R/Statistics/MixturesOfDistributions/index.htm
gaussians = [
curve_fitting.gaussian(0.10516252, 23.32727, 2.436638),
curve_fitting.gaussian(0.46462715, 33.09053, 2.997594),
curve_fitting.gaussian(0.29827916, 41.27244, 4.274585),
curve_fitting.gaussian(0.08986616, 51.24468, 5.077521),
curve_fitting.gaussian(0.04206501, 61.31818, 7.070303)
]
x = flex.double(frange(0, 80, 0.1))
y = flex.double(x.size())
for i in range(len(gaussians)):
g = gaussians[i]
scale, mu, sigma = g.a, g.b, g.c
y += g(x)
termination_params = scitbx.lbfgs.termination_parameters(
min_iterations=500)
starting_gaussians = [
curve_fitting.gaussian(1, 21, 2.1),
curve_fitting.gaussian(1, 30, 2.8),
curve_fitting.gaussian(1, 40, 2.2),
curve_fitting.gaussian(1, 51, 1.2),
curve_fitting.gaussian(1, 60, 2.3)
]
fit = curve_fitting.gaussian_fit(x,
y,
starting_gaussians,
termination_params=termination_params)
y_calc = fit.compute_y_calc()
assert approx_equal(y, y_calc, eps=1e-2)
have_cma_es = libtbx.env.has_module("cma_es")
if have_cma_es:
fit = curve_fitting.cma_es_minimiser(starting_gaussians, x, y)
y_calc = fit.compute_y_calc()
assert approx_equal(y, y_calc, eps=5e-2)
def exercise_2():
for use_reference in [True, False, None]:
pdb_inp = iotbx.pdb.input(lines=flex.std_string(
pdb_str_2.splitlines()),
source_info=None)
model = manager(model_input=pdb_inp, log=null_out())
grm = model.get_restraints_manager().geometry
xrs2 = model.get_xray_structure()
awl2 = model.get_hierarchy().atoms_with_labels()
pdb_inp3 = iotbx.pdb.input(source_info=None, lines=pdb_str_3)
xrs3 = pdb_inp3.xray_structure_simple()
ph3 = pdb_inp3.construct_hierarchy()
ph3.atoms().reset_i_seq()
awl3 = ph3.atoms_with_labels()
sites_cart_reference = flex.vec3_double()
selection = flex.size_t()
reference_names = ["CG", "CD", "NE", "CZ", "NH1", "NH2"]
for a2, a3 in zip(tuple(awl2), tuple(awl3)):
assert a2.resname == a3.resname
assert a2.name == a3.name
assert a2.i_seq == a3.i_seq
if (a2.resname == "ARG" and a2.name.strip() in reference_names):
selection.append(a2.i_seq)
sites_cart_reference.append(a3.xyz)
assert selection.size() == len(reference_names)
selection_bool = flex.bool(xrs2.scatterers().size(), selection)
if (use_reference):
grm.adopt_reference_coordinate_restraints_in_place(
reference.add_coordinate_restraints(
sites_cart=sites_cart_reference,
selection=selection,
sigma=0.01))
elif (use_reference is None):
grm.adopt_reference_coordinate_restraints_in_place(
reference.add_coordinate_restraints(
sites_cart=sites_cart_reference,
selection=selection,
sigma=0.01))
grm.remove_reference_coordinate_restraints_in_place(
selection=selection)
d1 = flex.mean(
flex.sqrt((xrs2.sites_cart().select(selection) -
xrs3.sites_cart().select(selection)).dot()))
print "distance start (use_reference: %s): %6.4f" % (
str(use_reference), d1)
assert d1 > 4.0
assert approx_equal(
flex.max(
flex.sqrt((xrs2.sites_cart().select(~selection_bool) -
xrs3.sites_cart().select(~selection_bool)).dot())),
0)
from cctbx import geometry_restraints
import mmtbx.refinement.geometry_minimization
import scitbx.lbfgs
grf = geometry_restraints.flags.flags(default=True)
sites_cart = xrs2.sites_cart()
minimized = mmtbx.refinement.geometry_minimization.lbfgs(
sites_cart=sites_cart,
correct_special_position_tolerance=1.0,
geometry_restraints_manager=grm,
sites_cart_selection=flex.bool(sites_cart.size(), selection),
geometry_restraints_flags=grf,
lbfgs_termination_params=scitbx.lbfgs.termination_parameters(
max_iterations=5000))
xrs2.set_sites_cart(sites_cart=sites_cart)
d2 = flex.mean(
flex.sqrt((xrs2.sites_cart().select(selection) -
xrs3.sites_cart().select(selection)).dot()))
print "distance final (use_reference: %s): %6.4f" % (
str(use_reference), d2)
if (use_reference): assert d2 < 0.005, "failed: %f<0.05" % d2
else: assert d2 > 4.0, d2
assert approx_equal(
flex.max(
flex.sqrt((xrs2.sites_cart().select(~selection_bool) -
xrs3.sites_cart().select(~selection_bool)).dot())),
0)
def exercise_non_crystallographic_conserving_bonds_and_angles():
sites_cart, geo = geometry_restraints.manager \
.construct_non_crystallographic_conserving_bonds_and_angles(
sites_cart=flex.vec3_double([
(10.949, 12.815, 15.189),
(10.405, 13.954, 15.917),
(10.779, 15.262, 15.227),
( 9.916, 16.090, 14.936)]),
edge_list_bonds=[(0, 1), (1, 2), (2, 3)],
edge_list_angles=[(0, 2), (1, 3)])
assert approx_equal(sites_cart, [(6.033, 5.000, 5.253),
(5.489, 6.139, 5.981),
(5.863, 7.447, 5.291),
(5.000, 8.275, 5.000)])
assert approx_equal(geo.energies_sites(sites_cart=sites_cart).target, 0)
sites_cart_noise = flex.vec3_double([ # Just to make all residuals unique,
(6.043, 5.030, 5.233), # so that the sorted bond list below
(5.469, 6.119, 5.941), # has the same order on all platforms.
(5.893, 7.487, 5.281),
(5.040, 8.225, 5.020)
])
sio = StringIO()
geo.show_sorted(sites_cart=sites_cart_noise, f=sio)
expected_first_part = """\
Bond restraints: 5
Sorted by residual:
bond 2
3
ideal model delta sigma weight residual
1.231 1.158 0.073 1.00e-01 1.00e+02 5.35e-01
bond 1
2
ideal model delta sigma weight residual
1.525 1.577 -0.052 1.00e-01 1.00e+02 2.66e-01
bond 1
3
ideal model delta sigma weight residual
2.401 2.338 0.063 1.41e-01 5.00e+01 1.96e-01
bond 0
1
ideal model delta sigma weight residual
1.457 1.420 0.037 1.00e-01 1.00e+02 1.37e-01
bond 0
2
ideal model delta sigma weight residual
2.453 2.462 -0.009 1.41e-01 5.00e+01 3.92e-03
Bond-like restraints: 0
Sorted by residual:
Metal coordination restraints: 0
Sorted by residual:
"""
assert not show_diff(
sio.getvalue(), expected_first_part + """\
Nonbonded interactions: 0
""")
#
sites_cart, geo = geometry_restraints.manager \
.construct_non_crystallographic_conserving_bonds_and_angles(
sites_cart=flex.vec3_double([
(10.949, 12.815, 15.189),
(10.405, 13.954, 15.917),
(10.779, 15.262, 15.227),
( 9.916, 16.090, 14.936),
(10.749, 12.615, 15.389)]),
edge_list_bonds=[(0, 1), (1, 2), (2, 3)],
edge_list_angles=[(0, 2), (1, 3)])
sites_cart_noise.append(sites_cart[-1])
sio = StringIO()
geo.show_sorted(sites_cart=sites_cart_noise, f=sio)
assert not show_diff(
sio.getvalue(), expected_first_part + """\
Nonbonded interactions: 2
Sorted by model distance:
nonbonded 0
4
model vdw
0.306 1.200
nonbonded 1
4
model vdw
1.274 1.200
""")
def exercise_00(prefix="tst_polder_box"):
"""
Test for phenix.polder using the compute_box=True option.
"""
f = open("%s.pdb" % prefix, "w")
f.write(pdb_str)
f.close()
f = open("%s_ligand.pdb" % prefix, "w")
f.write(pdb_str + pdb_str_ligand)
f.close()
cmd = " ".join([
"phenix.fmodel",
"%s_ligand.pdb" % prefix, "high_res=2.0", "type=real", "label=f-obs",
"k_sol=0.4", "b_sol=50",
"output.file_name=%s.mtz" % prefix,
"> %s.log" % prefix
])
print(cmd)
easy_run.call(cmd)
#
selection_string = '((resseq 65 and name CG) or (resseq 7 and name OH) or \
resseq 183 or resseq 95 or (resseq 148 and name CG))'
cmd = " ".join([
"phenix.polder",
"%s.pdb" % prefix,
"%s.mtz" % prefix, "compute_box=True",
'solvent_exclusion_mask_selection="%s" ' % selection_string,
'mask_output=True',
"> %s.log" % prefix
])
print(cmd)
easy_run.call(cmd)
#
miller_arrays = reflection_file_reader.any_reflection_file(
file_name="tst_polder_box_polder_map_coeffs.mtz").as_miller_arrays()
mc_polder, mc_bias_omit, mc_omit = [
None,
] * 3
for ma in miller_arrays:
lbl = ma.info().label_string()
if (lbl == "mFo-DFc_polder,PHImFo-DFc_polder"):
mc_polder = ma.deep_copy()
if (lbl == "mFo-DFc_bias_omit,PHImFo-DFc_bias_omit"):
mc_bias_omit = ma.deep_copy()
if (lbl == "mFo-DFc_omit,PHImFo-DFc_omit"):
mc_omit = ma.deep_copy()
assert [mc_polder, mc_omit].count(None) == 0
cg = maptbx.crystal_gridding(unit_cell=mc_polder.unit_cell(),
d_min=mc_polder.d_min(),
resolution_factor=0.25,
space_group_info=mc_polder.space_group_info())
map_polder = get_map(cg=cg, mc=mc_polder)
map_omit = get_map(cg=cg, mc=mc_omit)
pdb_hierarchy = iotbx.pdb.input(source_info=None,
lines=pdb_str).construct_hierarchy()
sel = pdb_hierarchy.atom_selection_cache().selection(
string=selection_string)
sites_cart_lig = pdb_hierarchy.atoms().extract_xyz().select(sel)
sites_frac_lig = mc_polder.unit_cell().fractionalize(sites_cart_lig)
mp = get_map_stats(map=map_polder, sites_frac=sites_frac_lig)
mo = get_map_stats(map=map_omit, sites_frac=sites_frac_lig)
#
mmm_mp = mp.min_max_mean().as_tuple()
mmm_o = mo.min_max_mean().as_tuple()
print("Polder map : %7.3f %7.3f %7.3f" % mmm_mp)
print("Omit : %7.3f %7.3f %7.3f" % mmm_o)
#
assert approx_equal(mmm_mp, [-1.932, 1.673, -0.021], eps=0.15)
assert approx_equal(mmm_o, [-0.633, 0.326, -0.035], eps=0.15)
def run(args,
crystal_symmetry=None,
ncs_object=None,
pdb_hierarchy=None,
map_data=None,
mask_data=None,
half_map_data_list=None,
half_map_labels_list=None,
lower_bounds=None,
upper_bounds=None,
write_output_files=True,
log=None):
h = "phenix.map_box: extract box with model and map around selected atoms"
if (log is None): log = sys.stdout
print_statistics.make_header(h, out=log)
default_message = """\
%s.
Usage:
phenix.map_box model.pdb map_coefficients.mtz selection="chain A and resseq 1:10"
or
phenix.map_box map.ccp4 density_select=True
Parameters:""" % h
if (len(args) == 0 and not pdb_hierarchy):
print(default_message)
master_phil.show(prefix=" ")
return
# Process inputs ignoring symmetry conflicts just to get the value of
# ignore_symmetry_conflicts...
inputs = mmtbx.utils.process_command_line_args(
args=args,
cmd_cs=crystal_symmetry,
master_params=master_phil,
suppress_symmetry_related_errors=True)
params = inputs.params.extract()
# Now process inputs for real and write a nice error message if necessary.
try:
inputs = mmtbx.utils.process_command_line_args(
args=args,
cmd_cs=crystal_symmetry,
master_params=master_phil,
suppress_symmetry_related_errors=params.ignore_symmetry_conflicts)
except Exception as e:
if str(e).find("symmetry mismatch ") > 1:
raise Sorry(str(e) + "\nTry 'ignore_symmetry_conflicts=True'")
else:
raise e
params = inputs.params.extract()
master_phil.format(python_object=params).show(out=log)
# Overwrite params with parameters in call if available
if lower_bounds:
params.lower_bounds = lower_bounds
if upper_bounds:
params.upper_bounds = upper_bounds
# PDB file
if params.pdb_file and not inputs.pdb_file_names and not pdb_hierarchy:
inputs.pdb_file_names = [params.pdb_file]
if (len(inputs.pdb_file_names) != 1 and not params.density_select
and not params.mask_select and not pdb_hierarchy
and not params.keep_map_size and not params.upper_bounds
and not params.extract_unique
and not params.bounds_match_this_file):
raise Sorry(
"PDB file is needed unless extract_unique, " +
"density_select, mask_select, keep_map_size \nor bounds are set .")
if (len(inputs.pdb_file_names)!=1 and not pdb_hierarchy and \
(params.mask_atoms )):
raise Sorry("PDB file is needed for mask_atoms")
if params.soft_mask and (not params.resolution) and \
(len(inputs.pdb_file_names)!=1 and not pdb_hierarchy):
raise Sorry("Need resolution for soft_mask without PDB file")
if ((params.density_select or params.mask_select)
and params.keep_map_size):
raise Sorry(
"Cannot set both density_select/mask_select and keep_map_size")
if ((params.density_select or params.mask_select) and params.upper_bounds):
raise Sorry("Cannot set both density_select/mask_select and bounds")
if (params.keep_map_size and params.upper_bounds):
raise Sorry("Cannot set both keep_map_size and bounds")
if (params.upper_bounds and not params.lower_bounds):
raise Sorry("Please set lower_bounds if you set upper_bounds")
if (params.extract_unique):
if (not params.resolution):
raise Sorry("Please set resolution for extract_unique")
if (not params.symmetry) and (not params.symmetry_file) and \
(not ncs_object):
raise Sorry(
"Please supply a symmetry file or symmetry for extract_unique (you "
+
"\ncan try symmetry=ALL if you do not know your symmetry or " +
"symmetry=C1 if \nthere is none)")
from mmtbx.ncs.ncs import ncs
ncs_object = ncs()
ncs_object.set_unit_ncs()
if params.keep_input_unit_cell_and_grid and (
(params.output_unit_cell_grid is not None) or
(params.output_unit_cell is not None)):
raise Sorry("If you set keep_input_unit_cell_and_grid then you cannot "+\
"set \noutput_unit_cell_grid or output_unit_cell")
if (write_output_files) and ("mtz" in params.output_format) and (
(params.keep_origin) and (not params.keep_map_size)):
print("\nNOTE: Skipping write of mtz file as keep_origin=True and \n"+\
"keep_map_size is False\n")
params.output_format = remove_element(params.output_format,
element='mtz')
if (write_output_files) and ("mtz" in params.output_format) and (
(params.extract_unique)):
print("\nNOTE: Skipping write of mtz file as extract_unique=True\n")
params.output_format = remove_element(params.output_format,
element='mtz')
if params.output_origin_match_this_file or params.bounds_match_this_file:
if params.output_origin_match_this_file:
fn = params.output_origin_match_this_file
if params.bounds_match_this_file:
raise Sorry("Cannot match origin and bounds at same time")
else:
fn = params.bounds_match_this_file
if not params.ccp4_map_file:
raise Sorry(
"Need to specify your input file with ccp4_map_file=xxx if you use "
+
"output_origin_match_this_file=xxxx or bounds_match_this_file=xxxx"
)
af = any_file(fn)
if (af.file_type == 'ccp4_map'):
origin = af.file_content.map_data().origin()
if params.output_origin_match_this_file:
params.output_origin_grid_units = origin
print("Origin of (%s,%s,%s) taken from %s" %
(origin[0], origin[1], origin[2], fn))
else:
all = af.file_content.map_data().all()
params.lower_bounds = origin
print("Lower bounds of (%s,%s,%s) taken from %s" %
(params.lower_bounds[0], params.lower_bounds[1],
params.lower_bounds[2], fn))
params.upper_bounds = list(
col(origin) + col(all) - col((1, 1, 1)))
print("upper bounds of (%s,%s,%s) taken from %s" %
(params.upper_bounds[0], params.upper_bounds[1],
params.upper_bounds[2], fn))
params.bounds_are_absolute = True
else:
raise Sorry("Unable to interpret %s as map file" % (fn))
if params.output_origin_grid_units is not None and params.keep_origin:
params.keep_origin = False
print("Setting keep_origin=False as output_origin_grid_units is set")
print_statistics.make_sub_header("pdb model", out=log)
if len(inputs.pdb_file_names) > 0:
pdb_inp = iotbx.pdb.input(file_name=inputs.pdb_file_names[0])
pdb_hierarchy = pdb_inp.construct_hierarchy()
if pdb_hierarchy:
pdb_atoms = pdb_hierarchy.atoms()
pdb_atoms.reset_i_seq()
else:
pdb_hierarchy = None
# Map or map coefficients
map_coeff = None
input_unit_cell_grid = None
input_unit_cell = None
input_map_labels = None
if (not map_data):
# read first mtz file
if ((len(inputs.reflection_file_names) > 0)
or (params.map_coefficients_file is not None)):
# file in phil takes precedent
if (params.map_coefficients_file is not None):
if (len(inputs.reflection_file_names) == 0):
inputs.reflection_file_names.append(
params.map_coefficients_file)
else:
inputs.reflection_file_names[
0] = params.map_coefficients_file
map_coeff = reflection_file_utils.extract_miller_array_from_file(
file_name=inputs.reflection_file_names[0],
label=params.label,
type="complex",
log=log)
if not crystal_symmetry:
crystal_symmetry = map_coeff.crystal_symmetry()
fft_map = map_coeff.fft_map(
resolution_factor=params.resolution_factor)
fft_map.apply_sigma_scaling()
map_data = fft_map.real_map_unpadded()
map_or_map_coeffs_prefix = os.path.basename(
inputs.reflection_file_names[0][:-4])
# or read CCP4 map
elif ((inputs.ccp4_map is not None)
or (params.ccp4_map_file is not None)):
print("ZZB", params.ccp4_map_file)
if (params.ccp4_map_file is not None):
af = any_file(params.ccp4_map_file)
print("ZZC", af, dir(af), af.file_type, dir(af.file_content))
if (af.file_type == 'ccp4_map'):
inputs.ccp4_map = af.file_content
inputs.ccp4_map_file_name = params.ccp4_map_file
print_statistics.make_sub_header("CCP4 map", out=log)
ccp4_map = inputs.ccp4_map
ccp4_map.show_summary(prefix=" ", out=log)
if not crystal_symmetry:
crystal_symmetry = ccp4_map.crystal_symmetry()
map_data = ccp4_map.map_data()
input_unit_cell_grid = ccp4_map.unit_cell_grid
input_unit_cell = ccp4_map.unit_cell().parameters()
input_map_labels = ccp4_map.get_labels()
if inputs.ccp4_map_file_name.endswith(".ccp4"):
map_or_map_coeffs_prefix = os.path.basename(
inputs.ccp4_map_file_name[:-5])
else:
map_or_map_coeffs_prefix = os.path.basename(
inputs.ccp4_map_file_name[:-4])
else: # have map_data
map_or_map_coeffs_prefix = None
if params.half_map_list and (not half_map_data_list):
if not params.extract_unique:
raise Sorry("Can only use half_map_with extract_unique")
print("Reading half-maps", params.half_map_list)
half_map_data_list = []
half_map_labels_list = []
for fn in params.half_map_list:
print("Reading half map from %s" % (fn), file=log)
af = any_file(fn)
print_statistics.make_sub_header("CCP4 map", out=log)
h_ccp4_map = af.file_content
h_ccp4_map.show_summary(prefix=" ", out=log)
h_map_data = h_ccp4_map.map_data()
half_map_data_list.append(h_map_data)
half_map_labels_list.append(h_ccp4_map.get_labels())
if params.map_scale_factor:
print("Applying scale factor of %s to map data on read-in" %
(params.map_scale_factor))
map_data = map_data * params.map_scale_factor
if params.output_origin_grid_units is not None:
origin_to_match = tuple(params.output_origin_grid_units)
else:
origin_to_match = None
if origin_to_match:
sc = []
for x, o, a in zip(crystal_symmetry.unit_cell().parameters()[:3],
origin_to_match, map_data.all()):
sc.append(-x * o / a)
shift_cart_for_origin_to_match = tuple(sc)
else:
origin_to_match = None
shift_cart_for_origin_to_match = None
if crystal_symmetry and not inputs.crystal_symmetry:
inputs.crystal_symmetry = crystal_symmetry
# final check that map_data exists
if (map_data is None):
raise Sorry("Map or map coefficients file is needed.")
if len(inputs.pdb_file_names) > 0:
output_prefix = os.path.basename(inputs.pdb_file_names[0])[:-4]
else:
output_prefix = map_or_map_coeffs_prefix
if not pdb_hierarchy: # get an empty hierarchy
from cctbx.array_family import flex
pdb_hierarchy = iotbx.pdb.input(
source_info='', lines=flex.split_lines('')).construct_hierarchy()
xray_structure = pdb_hierarchy.extract_xray_structure(
crystal_symmetry=inputs.crystal_symmetry)
xray_structure.show_summary(f=log)
#
if not params.selection: params.selection = "all"
selection = pdb_hierarchy.atom_selection_cache().selection(
string=params.selection)
if selection.size():
print_statistics.make_sub_header("atom selection", out=log)
print("Selection string: selection='%s'" % params.selection, file=log)
print(" selects %d atoms from total %d atoms." %
(selection.count(True), selection.size()),
file=log)
sites_cart_all = xray_structure.sites_cart()
sites_cart = sites_cart_all.select(selection)
selection = xray_structure.selection_within(radius=params.selection_radius,
selection=selection)
if not ncs_object:
from mmtbx.ncs.ncs import ncs
ncs_object = ncs()
if params.symmetry_file:
ncs_object.read_ncs(params.symmetry_file, log=log)
print("Total of %s operators read" % (ncs_object.max_operators()),
file=log)
if not ncs_object or ncs_object.max_operators() < 1:
print("No symmetry available", file=log)
if ncs_object:
n_ops = max(1, ncs_object.max_operators())
else:
n_ops = 1
# Get sequence if extract_unique is set
sequence = None
if params.extract_unique or params.mask_select:
if params.sequence_file:
if n_ops > 1: # get unique part of sequence
remove_duplicates = True
else:
remove_duplicates = False
from iotbx.bioinformatics import get_sequences
sequence = (" ".join(
get_sequences(file_name=params.sequence_file,
remove_duplicates=remove_duplicates)))
if params.chain_type in ['None', None]: params.chain_type = None
if sequence and not params.molecular_mass:
# get molecular mass from sequence
from iotbx.bioinformatics import text_from_chains_matching_chain_type
if params.chain_type in [None, 'PROTEIN']:
n_protein = len(
text_from_chains_matching_chain_type(text=sequence,
chain_type='PROTEIN'))
else:
n_protein = 0
if params.chain_type in [None, 'RNA']:
n_rna = len(
text_from_chains_matching_chain_type(text=sequence,
chain_type='RNA'))
else:
n_rna = 0
if params.chain_type in [None, 'DNA']:
n_dna = len(
text_from_chains_matching_chain_type(text=sequence,
chain_type='DNA'))
else:
n_dna = 0
params.molecular_mass = n_ops * (n_protein * 110 +
(n_rna + n_dna) * 330)
print("\nEstimate of molecular mass is %.0f " %
(params.molecular_mass),
file=log)
if params.density_select or params.mask_select:
print_statistics.make_sub_header(
"Extracting box around selected density and writing output files",
out=log)
else:
print_statistics.make_sub_header(
"Extracting box around selected atoms and writing output files",
out=log)
#
if params.value_outside_atoms == 'mean':
print("\nValue outside atoms mask will be set to mean inside mask",
file=log)
if params.get_half_height_width and params.density_select:
print("\nHalf width at half height will be used to id boundaries",
file=log)
if params.soft_mask and sites_cart_all.size() > 0:
print("\nSoft mask will be applied to model-based mask", file=log)
elif params.soft_mask:
print("\nSoft mask will be applied to outside of map box", file=log)
if params.keep_map_size:
print("\nEntire map will be kept (not cutting out region)", file=log)
if params.restrict_map_size:
print("\nOutput map will be within input map", file=log)
if params.lower_bounds and params.upper_bounds:
print("Bounds for cut out map are (%s,%s,%s) to (%s,%s,%s)" %
(tuple(list(params.lower_bounds) + list(params.upper_bounds))),
file=log)
if mask_data:
mask_data = mask_data.as_double()
box = mmtbx.utils.extract_box_around_model_and_map(
xray_structure=xray_structure,
map_data=map_data.as_double(),
mask_data=mask_data,
box_cushion=params.box_cushion,
selection=selection,
mask_select=params.mask_select,
density_select=params.density_select,
threshold=params.density_select_threshold,
get_half_height_width=params.get_half_height_width,
mask_atoms=params.mask_atoms,
soft_mask=params.soft_mask,
soft_mask_radius=params.soft_mask_radius,
mask_atoms_atom_radius=params.mask_atoms_atom_radius,
value_outside_atoms=params.value_outside_atoms,
keep_map_size=params.keep_map_size,
restrict_map_size=params.restrict_map_size,
lower_bounds=params.lower_bounds,
upper_bounds=params.upper_bounds,
bounds_are_absolute=params.bounds_are_absolute,
zero_outside_original_map=params.zero_outside_original_map,
extract_unique=params.extract_unique,
target_ncs_au_file=params.target_ncs_au_file,
regions_to_keep=params.regions_to_keep,
box_buffer=params.box_buffer,
soft_mask_extract_unique=params.soft_mask_extract_unique,
mask_expand_ratio=params.mask_expand_ratio,
keep_low_density=params.keep_low_density,
chain_type=params.chain_type,
sequence=sequence,
solvent_content=params.solvent_content,
molecular_mass=params.molecular_mass,
resolution=params.resolution,
ncs_object=ncs_object,
symmetry=params.symmetry,
half_map_data_list=half_map_data_list,
)
ph_box = pdb_hierarchy.select(selection)
ph_box.adopt_xray_structure(box.xray_structure_box)
box.hierarchy = ph_box
if params.mask_select:
print("\nSolvent content used in mask_select: %.3f " %
(box.get_solvent_content()),
file=log)
if (inputs and inputs.crystal_symmetry and inputs.ccp4_map
and inputs.crystal_symmetry.unit_cell().parameters()
and inputs.ccp4_map.unit_cell().parameters()) and (
inputs.crystal_symmetry.unit_cell().parameters() !=
inputs.ccp4_map.unit_cell().parameters()):
print("\nNOTE: Input CCP4 map is only part of unit cell:", file=log)
print("Full unit cell ('unit cell parameters'): "+\
"(%.1f, %.1f, %.1f, %.1f, %.1f, %.1f) A" %tuple(
inputs.ccp4_map.unit_cell().parameters()), file=log)
print("Size of CCP4 map 'map unit cell': "+\
"(%.1f, %.1f, %.1f, %.1f, %.1f, %.1f) A" %tuple(
inputs.crystal_symmetry.unit_cell().parameters()), file=log)
print("Full unit cell as grid units: (%s, %s, %s)" %
(inputs.ccp4_map.unit_cell_grid),
file=log)
print("Map unit cell as grid units: (%s, %s, %s)" % (map_data.all()),
file=log)
box.unit_cell_parameters_from_ccp4_map = inputs.ccp4_map.unit_cell(
).parameters()
box.unit_cell_parameters_deduced_from_map_grid=\
inputs.crystal_symmetry.unit_cell().parameters()
else:
box.unit_cell_parameters_from_ccp4_map = None
box.unit_cell_parameters_deduced_from_map_grid = None
if box.pdb_outside_box_msg:
print(box.pdb_outside_box_msg, file=log)
# NOTE: box object is always shifted to place origin at (0,0,0)
# NOTE ON ORIGIN SHIFTS: The shifts are applied locally here. The box
# object is not affected and always has the origin at (0,0,0)
# output_box is copy of box with shift_cart corresponding to the output
# files. Normally this is the same as the original shift_cart. However
# if user has specified a new output origin it will differ.
# For output files ONLY:
# keep_origin==False leave origin at (0,0,0)
# keep_origin==True: we shift everything back to where it was,
# output_origin_grid_units=10,10,10: output origin is at (10,10,10)
# ncs_object is original
# box.ncs_object is shifted by shift_cart
# output_box.ncs_object is shifted back by -new shift_cart
# Additional note on output unit_cell and grid_units.
# The ccp4-style output map can specify the unit cell and grid units
# corresponding to that cell. This can be separate from the origin and
# number of grid points in the map as written. If specified, write these
# out to the output ccp4 map and also use this unit cell for writing
# any output PDB files
from copy import deepcopy
output_box = deepcopy(box) # won't use box below here except to return it
print("\nBox cell dimensions: (%.2f, %.2f, %.2f) A" %
(box.box_crystal_symmetry.unit_cell().parameters()[:3]),
file=log)
if box.shift_cart:
print("Working origin moved from grid position of"+\
": (%d, %d, %d) to (0,0,0) " %(
tuple(box.origin_shift_grid_units(reverse=True))), file=log)
print("Working origin moved from coordinates of:"+\
" (%.2f, %.2f, %.2f) A to (0,0,0)\n" %(
tuple(-col(box.shift_cart))), file=log)
if (params.keep_origin):
print("\nRestoring original position for output files", file=log)
print("Origin will be at grid position of"+\
": (%d, %d, %d) " %(
tuple(box.origin_shift_grid_units(reverse=True))), file=log)
print("\nOutput files will be in same location as original",
end=' ',
file=log)
if not params.keep_map_size:
print("just cut out.", file=log)
else:
print("keeping entire map", file=log)
print("Note that output maps are only valid in the cut out region.\n",
file=log)
else:
if origin_to_match:
output_box.shift_cart = shift_cart_for_origin_to_match
if params.output_origin_grid_units:
print("Output map origin to be shifted to match target",
file=log)
print("Placing origin at grid point (%s, %s, %s)" %(
origin_to_match)+"\n"+ \
"Final coordinate shift for output files: (%.2f,%.2f,%.2f) A\n" %(
tuple(col(output_box.shift_cart)-col(box.shift_cart))), file=log)
elif box.shift_cart:
output_box.shift_cart = (0, 0, 0) # not shifting back
print("Final origin will be at (0,0,0)", file=log)
print(
"Final coordinate shift for output files: (%.2f,%.2f,%.2f) A\n"
% (tuple(col(output_box.shift_cart) - col(box.shift_cart))),
file=log)
else:
print("\nOutput files are in same location as original and origin "+\
"is at (0,0,0)\n", file=log)
print("\nBox grid: (%s, %s, %s) " % (output_box.map_box.all()), file=log)
ph_output_box_output_location = ph_box.deep_copy()
if output_box.shift_cart: # shift coordinates and NCS back by shift_cart
# NOTE output_box.shift_cart could be different than box.shift_cart if
# there is a target position for the origin and it is not the same as the
# original origin.
sites_cart = output_box.shift_sites_cart_back(
output_box.xray_structure_box.sites_cart())
xrs_offset = ph_output_box_output_location.extract_xray_structure(
crystal_symmetry=output_box.xray_structure_box.crystal_symmetry(
)).replace_sites_cart(new_sites=sites_cart)
ph_output_box_output_location.adopt_xray_structure(xrs_offset)
if output_box.ncs_object:
output_box.ncs_object = output_box.ncs_object.coordinate_offset(
tuple(-col(output_box.shift_cart)))
shift_back = True
else:
shift_back = False
if params.keep_input_unit_cell_and_grid and \
(input_unit_cell_grid is not None) and \
(input_unit_cell is not None):
params.output_unit_cell = input_unit_cell
params.output_unit_cell_grid = input_unit_cell_grid
print("Setting output unit cell parameters and unit cell grid to"+\
" match\ninput map file", file=log)
if params.output_unit_cell: # Set output unit cell parameters
from cctbx import crystal
output_crystal_symmetry = crystal.symmetry(
unit_cell=params.output_unit_cell, space_group="P1")
output_unit_cell = output_crystal_symmetry.unit_cell()
print("Output unit cell set to: %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)" %
tuple(output_crystal_symmetry.unit_cell().parameters()),
file=log)
else:
output_crystal_symmetry = None
# ============= Check/set output unit cell grid and cell parameters =======
if params.output_unit_cell_grid or output_crystal_symmetry:
if params.output_unit_cell_grid:
output_unit_cell_grid = params.output_unit_cell_grid
else:
output_unit_cell_grid = output_box.map_box.all()
print("Output unit cell grid set to: (%s, %s, %s)" %
tuple(output_unit_cell_grid),
file=log)
expected_output_abc = []
box_spacing = []
output_spacing = []
box_abc=output_box.xray_structure_box.\
crystal_symmetry().unit_cell().parameters()[:3]
if output_crystal_symmetry:
output_abc = output_crystal_symmetry.unit_cell().parameters()[:3]
else:
output_abc = [None, None, None]
for a_box, a_output, n_box, n_output in zip(box_abc, output_abc,
output_box.map_box.all(),
output_unit_cell_grid):
expected_output_abc.append(a_box * n_output / n_box)
box_spacing.append(a_box / n_box)
if output_crystal_symmetry:
output_spacing.append(a_output / n_output)
else:
output_spacing.append(a_box / n_box)
if output_crystal_symmetry: # make sure it is compatible...
r0 = expected_output_abc[0] / output_abc[0]
r1 = expected_output_abc[1] / output_abc[1]
r2 = expected_output_abc[2] / output_abc[2]
from libtbx.test_utils import approx_equal
if not approx_equal(r0, r1, eps=0.001) or not approx_equal(
r0, r2, eps=0.001):
print("WARNING: output_unit_cell and cell_grid will "+\
"change ratio of grid spacing.\nOld spacings: "+\
"(%.2f, %.2f, %.2f) A " %(tuple(box_spacing))+\
"\nNew spacings: (%.2f, %.2f, %.2f) A \n" %(tuple(output_spacing)), file=log)
else:
output_abc = expected_output_abc
from cctbx import crystal
output_crystal_symmetry = crystal.symmetry(unit_cell=list(output_abc) +
[90, 90, 90],
space_group="P1")
print(
"Output unit cell will be: (%.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n"
% (tuple(output_crystal_symmetry.unit_cell().parameters())),
file=log)
else:
output_unit_cell_grid = output_box.map_box.all()
output_crystal_symmetry = output_box.xray_structure_box.crystal_symmetry(
)
# ========== Done check/set output unit cell grid and cell parameters =====
if write_output_files:
# Write PDB file
if ph_box.overall_counts().n_residues > 0:
if (params.output_file_name_prefix is None):
file_name = "%s_box.pdb" % output_prefix
else:
file_name = "%s.pdb" % params.output_file_name_prefix
ph_output_box_output_location.write_pdb_file(
file_name=file_name, crystal_symmetry=output_crystal_symmetry)
print("Writing boxed PDB with box unit cell to %s" % (file_name),
file=log)
# Write NCS file if NCS
if output_box.ncs_object and output_box.ncs_object.max_operators() > 0:
if (params.output_file_name_prefix is None):
output_symmetry_file = "%s_box.ncs_spec" % output_prefix
else:
output_symmetry_file = "%s.ncs_spec" % params.output_file_name_prefix
output_box.ncs_object.format_all_for_group_specification(
file_name=output_symmetry_file)
print("\nWriting symmetry to %s" % (output_symmetry_file),
file=log)
# Write ccp4 map.
if ("ccp4" in params.output_format):
if (params.output_file_name_prefix is None):
file_name = "%s_box.ccp4" % output_prefix
else:
file_name = "%s.ccp4" % params.output_file_name_prefix
from iotbx.mrcfile import create_output_labels
if params.extract_unique:
program_name = 'map_box using extract_unique'
limitations = ["extract_unique"]
else:
program_name = 'map_box'
limitations = []
labels = create_output_labels(
program_name=program_name,
input_file_name=inputs.ccp4_map_file_name,
input_labels=input_map_labels,
limitations=limitations,
output_labels=params.output_map_labels)
output_box.write_ccp4_map(
file_name=file_name,
output_crystal_symmetry=output_crystal_symmetry,
output_mean=params.output_ccp4_map_mean,
output_sd=params.output_ccp4_map_sd,
output_unit_cell_grid=output_unit_cell_grid,
shift_back=shift_back,
output_map_labels=labels,
output_external_origin=params.output_external_origin)
print("Writing boxed map "+\
"to CCP4 formatted file: %s"%file_name, file=log)
if not params.half_map_list:
params.half_map_list = []
if not output_box.map_box_half_map_list:
output_box.map_box_half_map_list = []
if not half_map_labels_list:
half_map_labels_list = len(
output_box.map_box_half_map_list) * [None]
for hm, labels, fn in zip(
output_box.map_box_half_map_list, half_map_labels_list,
params.half_map_list): # half maps matching
labels = create_output_labels(
program_name=program_name,
input_file_name=fn,
input_labels=labels,
limitations=limitations,
output_labels=params.output_map_labels)
hm_fn = "%s_box.ccp4" % (".".join(
os.path.basename(fn).split(".")[:-1]))
output_box.write_ccp4_map(
file_name=hm_fn,
map_data=hm,
output_crystal_symmetry=output_crystal_symmetry,
output_mean=params.output_ccp4_map_mean,
output_sd=params.output_ccp4_map_sd,
output_unit_cell_grid=output_unit_cell_grid,
shift_back=shift_back,
output_map_labels=labels,
output_external_origin=params.output_external_origin)
print("Writing boxed half map to: %s " % (hm_fn), file=log)
# Write xplor map. Shift back if keep_origin=True
if ("xplor" in params.output_format):
if (params.output_file_name_prefix is None):
file_name = "%s_box.xplor" % output_prefix
else:
file_name = "%s.xplor" % params.output_file_name_prefix
output_box.write_xplor_map(
file_name=file_name,
output_crystal_symmetry=output_crystal_symmetry,
output_unit_cell_grid=output_unit_cell_grid,
shift_back=shift_back,
)
print("Writing boxed map "+\
"to X-plor formatted file: %s"%file_name, file=log)
# Write mtz map coeffs. Shift back if keep_origin=True
if ("mtz" in params.output_format):
if (params.output_file_name_prefix is None):
file_name = "%s_box.mtz" % output_prefix
else:
file_name = "%s.mtz" % params.output_file_name_prefix
print("Writing map coefficients "+\
"to MTZ file: %s"%file_name, file=log)
if (map_coeff is not None):
d_min = map_coeff.d_min()
elif params.resolution is not None:
d_min = params.resolution
else:
d_min = maptbx.d_min_from_map(
map_data=output_box.map_box,
unit_cell=output_box.xray_structure_box.unit_cell())
output_box.map_coefficients(
d_min=d_min,
scale_max=params.scale_max,
resolution_factor=params.resolution_factor,
file_name=file_name,
shift_back=shift_back)
print(file=log)
return box
def exercise_header_misc(regression_pdb):
pdb_inp = pdb.input(file_name=op.join(regression_pdb, "pdb1a1q.ent"))
wavelength = pdb_inp.extract_wavelength()
assert approx_equal(wavelength, 0.995)
expt_type = pdb_inp.get_experiment_type()
assert (expt_type == 'X-RAY DIFFRACTION')
def exercise_2():
hkl_file = libtbx.env.find_in_repositories(
relative_path="phenix_regression/wizards/data/p9_se_w2.sca",
test=os.path.isfile)
if (hkl_file is None):
warnings.warn("phenix_regression not available, skipping test")
return
hkl_in = file_reader.any_file(hkl_file).assert_file_type("hkl")
i_obs_raw = hkl_in.file_object.as_miller_arrays(
merge_equivalents=False,
crystal_symmetry=crystal.symmetry(space_group_symbol="I4",
unit_cell=(113.949, 113.949, 32.474,
90, 90, 90)))[0]
i_obs = i_obs_raw.merge_equivalents().array()
# completeness and data strength
cstats = ds.i_sigi_completeness_stats(i_obs)
d_min_cut = cstats.resolution_cut
assert approx_equal(d_min_cut, 2.150815)
ws = ds.wilson_scaling(miller_array=i_obs, n_residues=120)
# outliers - this shouldn't actually work, since it requires additional
# processing steps on the input data
try:
outliers = ds.possible_outliers(i_obs)
except AssertionError:
pass
else:
raise Exception_expected
######################################################################
# OVERALL ANALYSIS
pdb_file = libtbx.env.find_in_repositories(
relative_path="phenix_examples/p9-build/p9.pdb", test=os.path.isfile)
f_calc = None
if (pdb_file is not None):
pdb_in = file_reader.any_file(pdb_file).assert_file_type("pdb")
hierarchy = pdb_in.file_object.hierarchy
xrs = pdb_in.file_object.xray_structure_simple(crystal_symmetry=i_obs)
f_calc = xrs.structure_factors(d_min=i_obs.d_min()).f_calc()
f_calc = abs(f_calc).generate_bijvoet_mates()
f_calc = f_calc.set_observation_type_xray_amplitude()
i_obs, f_calc = i_obs.common_sets(other=f_calc)
open("tmp_xtriage.pdb",
"w").write(hierarchy.as_pdb_string(crystal_symmetry=i_obs))
pdb_file = "tmp_xtriage.pdb"
params = xtriage.master_params.extract()
params.scaling.input.asu_contents.n_residues = 141
result = xtriage.xtriage_analyses(miller_obs=i_obs,
miller_calc=f_calc,
params=params,
unmerged_obs=i_obs_raw,
text_out=open("logfile3.log",
"w")) #sys.stdout)
# XXX there appears to be some system-dependence here, hence sloppy limits
assert (15.5 < result.aniso_b_min < 15.9)
assert (10 < result.aniso_range_of_b < 11)
# check relative Wilson
if (pdb_file is not None):
assert (result.relative_wilson is not None)
# FIXME
#assert (result.relative_wilson.n_outliers() == 34)
#show_pickled_object_sizes(result)
test_pickle_consistency_and_size(result)
# XXX PDB validation server
assert approx_equal(result.iso_b_wilson, 18.33, eps=0.1)
assert approx_equal(result.aniso_b_ratio, 0.546, eps=0.1)
assert (result.number_of_wilson_outliers == 0)
assert approx_equal(result.l_test_mean_l, 0.493, eps=0.1)
assert approx_equal(result.l_test_mean_l_squared, 0.326, eps=0.1)
assert approx_equal(result.i_over_sigma_outer_shell, 3.25, eps=0.1)
assert ("No significant pseudotranslation is detected"
in result.patterson_verdict)
# test consistency of output after pickling and unpickling
try:
from phenix_dev.phenix_cloud import xtriage_json
except ImportError:
pass
else:
json_out = xtriage_json.json_output("p9.sca")
result.show(out=json_out)
open("xtriage.json", "w").write(json_out.export())
# unmerged data
assert result.merging_stats is not None
out = StringIO()
result.merging_stats.show(out=out)
assert ("R-merge: 0.073" in out.getvalue())
assert approx_equal(result.estimate_d_min(min_i_over_sigma=10),
1.9645,
eps=0.001)
# FIXME PDB doesn't actually have unit cell!
# test detection of symmetry in reference file
if (pdb_file is not None):
args = [hkl_file, pdb_file]
result = xtriage.run(args=args, out=null_out())
def test2():
"""Run scan-varying refinement, comparing RMSD table with expected values.
This test automates what was manually done periodically and recorded in
dials_regression/refinement_test_data/centroid/README.txt"""
dials_regression = libtbx.env.find_in_repositories(
relative_path="dials_regression", test=os.path.isdir)
# use the i04_weak_data for this test
data_dir = os.path.join(dials_regression, "refinement_test_data",
"centroid")
experiments_path = os.path.join(data_dir,
"experiments_XPARM_REGULARIZED.json")
pickle_path = os.path.join(data_dir, "spot_all_xds.pickle")
for pth in (experiments_path, pickle_path):
assert os.path.exists(pth)
# scan-static refinement first to get refined_experiments.json as start point
cmd1 = ("dials.refine " + experiments_path + " " + pickle_path +
" reflections_per_degree=50 "
" outlier.algorithm=null close_to_spindle_cutoff=0.05")
cmd2 = ("dials.refine refined_experiments.json " + pickle_path +
" scan_varying=true output.history=history.pickle"
" reflections_per_degree=50"
" outlier.algorithm=null close_to_spindle_cutoff=0.05"
" crystal.orientation.smoother.interval_width_degrees=36.0"
" crystal.unit_cell.smoother.interval_width_degrees=36.0")
# work in a temporary directory
cwd = os.path.abspath(os.curdir)
tmp_dir = open_tmp_directory(suffix="test_dials_refine")
os.chdir(tmp_dir)
try:
print cmd1
result1 = easy_run.fully_buffered(command=cmd1).raise_if_errors()
print cmd2
result2 = easy_run.fully_buffered(command=cmd2).raise_if_errors()
# load and check results
import cPickle as pickle
history = pickle.load(open("history.pickle", "r"))
expected_rmsds = [(0.088488398, 0.114583571, 0.001460382),
(0.080489334, 0.086406517, 0.001284069),
(0.078835086, 0.086052630, 0.001195882),
(0.077476911, 0.086194611, 0.001161143),
(0.076755840, 0.086090630, 0.001157239),
(0.076586376, 0.085939462, 0.001155641),
(0.076603722, 0.085878953, 0.001155065),
(0.076611382, 0.085862959, 0.001154863),
(0.076608732, 0.085856935, 0.001154384),
(0.076605731, 0.085852271, 0.001153858),
(0.076604576, 0.085852318, 0.001153643),
(0.076603981, 0.085854175, 0.001153594)]
assert approx_equal(history['rmsd'], expected_rmsds)
# check that the used_in_refinement flag got set correctly
rt = flex.reflection_table.from_pickle('refined.pickle')
uir = rt.get_flags(rt.flags.used_in_refinement)
assert uir.count(True) == history['num_reflections'][-1]
finally:
os.chdir(cwd)
print "OK"
return
mydetector = models.detector
mygonio = models.goniometer
mycrystal = models.crystal
mybeam = models.beam
# Build a mock scan for a 180 degree sweep
sf = ScanFactory()
myscan = sf.make_scan(image_range=(1, 1800),
exposure_times=0.1,
oscillation=(0, 0.1),
epochs=range(1800),
deg=True)
sweep_range = myscan.get_oscillation_range(deg=False)
im_width = myscan.get_oscillation(deg=False)[1]
assert sweep_range == (0., pi)
assert approx_equal(im_width, 0.1 * pi / 180.)
# Build an experiment list
experiments = ExperimentList()
experiments.append(
Experiment(beam=mybeam,
detector=mydetector,
goniometer=mygonio,
scan=myscan,
crystal=mycrystal,
imageset=None))
###########################
# Parameterise the models #
###########################
def exercise_crystal_model():
real_space_a = matrix.col((10, 0, 0))
real_space_b = matrix.col((0, 11, 0))
real_space_c = matrix.col((0, 0, 12))
model = crystal_model(real_space_a=(10, 0, 0),
real_space_b=(0, 11, 0),
real_space_c=(0, 0, 12),
space_group_symbol="P 1")
assert isinstance(model.get_unit_cell(), uctbx.unit_cell)
assert model.get_unit_cell().parameters() == (10.0, 11.0, 12.0, 90.0, 90.0,
90.0)
assert approx_equal(model.get_A(),
(1 / 10, 0, 0, 0, 1 / 11, 0, 0, 0, 1 / 12))
assert approx_equal(model.get_A().inverse(),
(10, 0, 0, 0, 11, 0, 0, 0, 12))
assert approx_equal(model.get_B(), model.get_A())
assert approx_equal(model.get_U(), (1, 0, 0, 0, 1, 0, 0, 0, 1))
assert approx_equal(model.get_real_space_vectors(),
(real_space_a, real_space_b, real_space_c))
assert approx_equal(model.get_mosaicity(), 0)
model2 = crystal_model(real_space_a=(10, 0, 0),
real_space_b=(0, 11, 0),
real_space_c=(0, 0, 12),
space_group_symbol="P 1")
assert model == model2
model2.set_mosaicity(0.01)
assert model != model2
# rotate 45 degrees about x-axis
R1 = matrix.sqr(
(1, 0, 0, 0, math.cos(math.pi / 4), -math.sin(math.pi / 4), 0,
math.sin(math.pi / 4), math.cos(math.pi / 4)))
# rotate 30 degrees about y-axis
R2 = matrix.sqr((math.cos(math.pi / 6), 0, math.sin(math.pi / 6), 0, 1, 0,
-math.sin(math.pi / 6), 0, math.cos(math.pi / 6)))
# rotate 60 degrees about z-axis
R3 = matrix.sqr((math.cos(math.pi / 3), -math.sin(math.pi / 3), 0,
math.sin(math.pi / 3), math.cos(math.pi / 3), 0, 0, 0, 1))
R = R1 * R2 * R3
model.set_U(R)
# B is unchanged
assert approx_equal(model.get_B(),
(1 / 10, 0, 0, 0, 1 / 11, 0, 0, 0, 1 / 12))
assert approx_equal(model.get_U(), R)
assert approx_equal(model.get_A(), model.get_U() * model.get_B())
a_, b_, c_ = model.get_real_space_vectors()
assert approx_equal(a_, R * real_space_a)
assert approx_equal(b_, R * real_space_b)
assert approx_equal(c_, R * real_space_c)
s = StringIO()
print >> s, model
assert not show_diff(
s.getvalue().replace("-0.0000", " 0.0000"), """\
Crystal:
Unit cell: (10.000, 11.000, 12.000, 90.000, 90.000, 90.000)
Space group: P 1
U matrix: {{ 0.4330, -0.7500, 0.5000},
{ 0.7891, 0.0474, -0.6124},
{ 0.4356, 0.6597, 0.6124}}
B matrix: {{ 0.1000, 0.0000, 0.0000},
{ 0.0000, 0.0909, 0.0000},
{ 0.0000, 0.0000, 0.0833}}
A = UB: {{ 0.0433, -0.0682, 0.0417},
{ 0.0789, 0.0043, -0.0510},
{ 0.0436, 0.0600, 0.0510}}
""")
model.set_B((1 / 12, 0, 0, 0, 1 / 12, 0, 0, 0, 1 / 12))
assert approx_equal(model.get_unit_cell().parameters(),
(12, 12, 12, 90, 90, 90))
U = matrix.sqr((0.3455, -0.2589, -0.9020, 0.8914, 0.3909, 0.2293, 0.2933,
-0.8833, 0.3658))
B = matrix.sqr((1 / 13, 0, 0, 0, 1 / 13, 0, 0, 0, 1 / 13))
model.set_A(U * B)
assert approx_equal(model.get_A(), U * B)
assert approx_equal(model.get_U(), U, 1e-4)
assert approx_equal(model.get_B(), B, 1e-5)
model3 = crystal_model(real_space_a=(10, 0, 0),
real_space_b=(0, 11, 0),
real_space_c=(0, 0, 12),
space_group=sgtbx.space_group_info("P 222").group(),
mosaicity=0.01)
assert model3.get_space_group().type().hall_symbol() == " P 2 2"
assert model != model3
#
sgi_ref = sgtbx.space_group_info(number=230)
model_ref = crystal_model(real_space_a=(44, 0, 0),
real_space_b=(0, 44, 0),
real_space_c=(0, 0, 44),
space_group=sgi_ref.group())
assert approx_equal(model_ref.get_U(), (1, 0, 0, 0, 1, 0, 0, 0, 1))
assert approx_equal(model_ref.get_B(),
(1 / 44, 0, 0, 0, 1 / 44, 0, 0, 0, 1 / 44))
assert approx_equal(model_ref.get_A(), model_ref.get_B())
assert approx_equal(model_ref.get_unit_cell().parameters(),
(44, 44, 44, 90, 90, 90))
a_ref, b_ref, c_ref = model_ref.get_real_space_vectors()
cb_op_to_primitive = sgi_ref.change_of_basis_op_to_primitive_setting()
model_primitive = model_ref.change_basis(cb_op_to_primitive)
cb_op_to_reference = model_primitive.get_space_group().info()\
.change_of_basis_op_to_reference_setting()
a_prim, b_prim, c_prim = model_primitive.get_real_space_vectors()
#print cb_op_to_primitive.as_abc()
##'-1/2*a+1/2*b+1/2*c,1/2*a-1/2*b+1/2*c,1/2*a+1/2*b-1/2*c'
assert approx_equal(a_prim, -1 / 2 * a_ref + 1 / 2 * b_ref + 1 / 2 * c_ref)
assert approx_equal(b_prim, 1 / 2 * a_ref - 1 / 2 * b_ref + 1 / 2 * c_ref)
assert approx_equal(c_prim, 1 / 2 * a_ref + 1 / 2 * b_ref - 1 / 2 * c_ref)
#print cb_op_to_reference.as_abc()
##b+c,a+c,a+b
assert approx_equal(a_ref, b_prim + c_prim)
assert approx_equal(b_ref, a_prim + c_prim)
assert approx_equal(c_ref, a_prim + b_prim)
assert approx_equal(model_primitive.get_U(), [
-0.5773502691896258, 0.40824829046386285, 0.7071067811865476,
0.5773502691896257, -0.4082482904638631, 0.7071067811865476,
0.5773502691896257, 0.8164965809277259, 0.0
])
assert approx_equal(model_primitive.get_B(), [
0.0262431940540739, 0.0, 0.0, 0.00927837023781507, 0.02783511071344521,
0.0, 0.01607060866333063, 0.01607060866333063, 0.03214121732666125
])
assert approx_equal(
model_primitive.get_A(),
(0, 1 / 44, 1 / 44, 1 / 44, 0, 1 / 44, 1 / 44, 1 / 44, 0))
assert approx_equal(model_primitive.get_unit_cell().parameters(), [
38.1051177665153, 38.1051177665153, 38.1051177665153,
109.47122063449069, 109.47122063449069, 109.47122063449069
])
assert model_ref != model_primitive
model_ref_recycled = model_primitive.change_basis(cb_op_to_reference)
assert approx_equal(model_ref.get_U(), model_ref_recycled.get_U())
assert approx_equal(model_ref.get_B(), model_ref_recycled.get_B())
assert approx_equal(model_ref.get_A(), model_ref_recycled.get_A())
assert approx_equal(model_ref.get_unit_cell().parameters(),
model_ref_recycled.get_unit_cell().parameters())
assert model_ref == model_ref_recycled
#
uc = uctbx.unit_cell(
(58.2567, 58.1264, 39.7093, 46.9077, 46.8612, 62.1055))
sg = sgtbx.space_group_info(symbol="P1").group()
cs = crystal.symmetry(unit_cell=uc, space_group=sg)
cb_op_to_minimum = cs.change_of_basis_op_to_minimum_cell()
# the reciprocal matrix
B = matrix.sqr(uc.fractionalization_matrix()).transpose()
U = random_rotation()
direct_matrix = (U * B).inverse()
model = crystal_model(direct_matrix[:3],
direct_matrix[3:6],
direct_matrix[6:9],
space_group=sg)
assert uc.is_similar_to(model.get_unit_cell())
uc_minimum = uc.change_basis(cb_op_to_minimum)
model_minimum = model.change_basis(cb_op_to_minimum)
assert uc_minimum.is_similar_to(model_minimum.get_unit_cell())
assert model_minimum != model
model_minimum.update(model)
assert model_minimum == model
#
from scitbx.math import euler_angles
A_static = model.get_A()
A_as_scan_points = [A_static]
num_scan_points = 11
for i in range(num_scan_points - 1):
A_as_scan_points.append(
A_as_scan_points[-1] *
matrix.sqr(euler_angles.xyz_matrix(0.1, 0.2, 0.3)))
model.set_A_at_scan_points(A_as_scan_points)
model_minimum = model.change_basis(cb_op_to_minimum)
assert model.num_scan_points == model_minimum.num_scan_points == num_scan_points
M = matrix.sqr(cb_op_to_minimum.c_inv().r().transpose().as_double())
M_inv = M.inverse()
for i in range(num_scan_points):
A_orig = model.get_A_at_scan_point(i)
A_min = model_minimum.get_A_at_scan_point(i)
assert A_min == A_orig * M_inv
def exercise_flood_fill():
uc = uctbx.unit_cell('10 10 10 90 90 90')
for uc in (uctbx.unit_cell('10 10 10 90 90 90'),
uctbx.unit_cell('9 10 11 87 91 95')):
gridding = maptbx.crystal_gridding(unit_cell=uc,
pre_determined_n_real=(5, 5, 5))
corner_cube = (0, 4, 20, 24, 100, 104, 120, 124
) # cube across all 8 corners
channel = (12, 37, 38, 39, 42, 43, 62, 63, 67, 68, 87, 112)
data = flex.int(flex.grid(gridding.n_real()))
for i in (corner_cube + channel):
data[i] = 1
flood_fill = masks.flood_fill(data, uc)
assert data.count(0) == 105
for i in corner_cube:
assert data[i] == 2
for i in channel:
assert data[i] == 3
assert approx_equal(flood_fill.centres_of_mass(),
((-0.5, -0.5, -0.5), (-2.5, 7 / 3, 2.5)))
assert approx_equal(flood_fill.centres_of_mass_frac(),
((-0.1, -0.1, -0.1), (-0.5, 7 / 15, 0.5)))
assert approx_equal(
flood_fill.centres_of_mass_cart(),
uc.orthogonalize(flood_fill.centres_of_mass_frac()))
assert flood_fill.n_voids() == 2
assert approx_equal(flood_fill.grid_points_per_void(), (8, 12))
if 0:
from crys3d import wx_map_viewer
wx_map_viewer.display(raw_map=data.as_double(),
unit_cell=uc,
wires=False)
#
gridding = maptbx.crystal_gridding(unit_cell=uc,
pre_determined_n_real=(10, 10, 10))
data = flex.int(flex.grid(gridding.n_real()))
# parallelogram
points = [(2, 4, 5), (3, 4, 5), (4, 4, 5), (5, 4, 5), (6, 4, 5),
(3, 5, 5), (4, 5, 5), (5, 5, 5), (6, 5, 5), (7, 5, 5),
(4, 6, 5), (5, 6, 5), (6, 6, 5), (7, 6, 5), (8, 6, 5)]
points_frac = flex.vec3_double()
for p in points:
data[p] = 1
points_frac.append([p[i] / gridding.n_real()[i] for i in range(3)])
points_cart = uc.orthogonalize(points_frac)
flood_fill = masks.flood_fill(data, uc)
assert data.count(2) == 15
assert approx_equal(flood_fill.centres_of_mass_frac(),
((0.5, 0.5, 0.5), ))
pai_cart = math.principal_axes_of_inertia(points=points_cart,
weights=flex.double(
points_cart.size(), 1.0))
F = matrix.sqr(uc.fractionalization_matrix())
O = matrix.sqr(uc.orthogonalization_matrix())
assert approx_equal(pai_cart.center_of_mass(),
flood_fill.centres_of_mass_cart()[0])
assert approx_equal(
flood_fill.covariance_matrices_cart()[0],
(F.transpose() *
matrix.sym(sym_mat3=flood_fill.covariance_matrices_frac()[0]) *
F).as_sym_mat3())
assert approx_equal(pai_cart.inertia_tensor(),
flood_fill.inertia_tensors_cart()[0])
assert approx_equal(pai_cart.eigensystem().vectors(),
flood_fill.eigensystems_cart()[0].vectors())
assert approx_equal(pai_cart.eigensystem().values(),
flood_fill.eigensystems_cart()[0].values())
return
def exercise_1():
pdb_raw = """\
CRYST1 23.000 6.666 25.000 90.00 107.08 90.00 P 1 21 1 2
ATOM 1 N GLY A 1 -9.009 4.612 6.102 1.00 16.77 N
ATOM 2 CA GLY A 1 -9.052 4.207 4.651 1.00 16.57 C
ATOM 3 C GLY A 1 -8.015 3.140 4.419 1.00 16.16 C
ATOM 4 O GLY A 1 -7.523 2.521 5.381 1.00 16.78 O
ATOM 5 N ASN A 2 -7.656 2.923 3.155 1.00 15.02 N
ATOM 6 CA ASN A 2 -6.522 2.038 2.831 1.00 14.10 C
ATOM 7 C ASN A 2 -5.241 2.537 3.427 1.00 13.13 C
ATOM 8 O ASN A 2 -4.978 3.742 3.426 1.00 11.91 O
ATOM 9 CB ASN A 2 -6.346 1.881 1.341 1.00 15.38 C
ATOM 10 CG ASN A 2 -7.584 1.342 0.692 1.00 14.08 C
ATOM 11 OD1 ASN A 2 -8.025 0.227 1.016 1.00 17.46 O
ATOM 12 ND2 ASN A 2 -8.204 2.155 -0.169 1.00 11.72 N
ATOM 13 N ASN A 3 -4.438 1.590 3.905 1.00 12.26 N
ATOM 14 CA ASN A 3 -3.193 1.904 4.589 1.00 11.74 C
ATOM 15 C ASN A 3 -1.955 1.332 3.895 1.00 11.10 C
ATOM 16 O ASN A 3 -1.872 0.119 3.648 1.00 10.42 O
ATOM 17 CB ASN A 3 -3.259 1.378 6.042 1.00 12.15 C
ATOM 18 CG ASN A 3 -2.006 1.739 6.861 1.00 12.82 C
ATOM 19 OD1 ASN A 3 -1.702 2.925 7.072 1.00 15.05 O
ATOM 20 ND2 ASN A 3 -1.271 0.715 7.306 1.00 13.48 N
ATOM 21 N MET A 4 -1.005 2.228 3.598 1.00 10.29 N
ATOM 22 CA MET A 4 0.384 1.888 3.199 1.00 10.53 C
ATOM 23 C MET A 4 1.435 2.606 4.088 1.00 10.24 C
ATOM 24 O MET A 4 1.547 3.843 4.115 1.00 8.86 O
ATOM 25 CB MET A 4 0.616 2.241 1.729 1.00 20.00 C
ATOM 26 CG MET A 4 -0.207 1.416 0.754 1.00 20.00 C
ATOM 27 SD MET A 4 0.132 -0.349 0.876 1.00 20.00 S
ATOM 28 CE MET A 4 1.822 -0.411 0.285 1.00 20.00 C
ATOM 29 N GLN A 5 2.154 1.821 4.871 1.00 10.38 N
ATOM 30 CA GLN A 5 3.270 2.361 5.640 1.00 11.39 C
ATOM 31 C GLN A 5 4.594 1.768 5.172 1.00 11.52 C
ATOM 32 O GLN A 5 4.768 0.546 5.054 1.00 12.05 O
ATOM 33 CB GLN A 5 3.056 2.183 7.147 1.00 11.96 C
ATOM 34 CG GLN A 5 1.829 2.950 7.647 1.00 10.81 C
ATOM 35 CD GLN A 5 1.344 2.414 8.954 1.00 13.10 C
ATOM 36 OE1 GLN A 5 0.774 1.325 9.002 1.00 10.65 O
ATOM 37 NE2 GLN A 5 1.549 3.187 10.039 1.00 12.30 N
ATOM 38 N ASN A 6 5.514 2.664 4.856 1.00 11.99 N
ATOM 39 CA ASN A 6 6.831 2.310 4.318 1.00 12.30 C
ATOM 40 C ASN A 6 7.854 2.761 5.324 1.00 13.40 C
ATOM 41 O ASN A 6 8.219 3.943 5.374 1.00 13.92 O
ATOM 42 CB ASN A 6 7.065 3.016 2.993 1.00 12.13 C
ATOM 43 CG ASN A 6 5.961 2.735 2.003 1.00 12.77 C
ATOM 44 OD1 ASN A 6 5.798 1.604 1.551 1.00 14.27 O
ATOM 45 ND2 ASN A 6 5.195 3.747 1.679 1.00 10.07 N
ATOM 46 N TYR A 7 8.292 1.817 6.147 1.00 14.70 N
ATOM 47 CA TYR A 7 9.159 2.144 7.299 1.00 15.18 C
ATOM 48 C TYR A 7 10.603 2.331 6.885 1.00 15.91 C
ATOM 49 O TYR A 7 11.041 1.811 5.855 1.00 15.76 O
ATOM 50 CB TYR A 7 9.061 1.065 8.369 1.00 15.35 C
ATOM 51 CG TYR A 7 7.665 0.929 8.902 1.00 14.45 C
ATOM 52 CD1 TYR A 7 6.771 0.021 8.327 1.00 15.68 C
ATOM 53 CD2 TYR A 7 7.210 1.756 9.920 1.00 14.80 C
ATOM 54 CE1 TYR A 7 5.480 -0.094 8.796 1.00 13.46 C
ATOM 55 CE2 TYR A 7 5.904 1.649 10.416 1.00 14.33 C
ATOM 56 CZ TYR A 7 5.047 0.729 9.831 1.00 15.09 C
ATOM 57 OH TYR A 7 3.766 0.589 10.291 1.00 14.39 O
ATOM 58 OXT TYR A 7 11.358 2.999 7.612 1.00 17.49 O
TER 59 TYR A 7
HETATM 1 CA CA A 8 10.431 1.858 3.216 1.00 30.00 CA
HETATM 60 O HOH A 9 -6.471 5.227 7.124 1.00 22.62 O
HETATM 62 O HOH A 10 -11.286 1.756 -1.468 1.00 17.08 O
HETATM 63 O HOH A 11 11.808 4.179 9.970 1.00 23.99 O
HETATM 64 O HOH A 12 13.605 1.327 9.198 1.00 26.17 O
HETATM 65 O HOH A 13 -2.749 3.429 10.024 1.00 39.15 O
HETATM 66 O HOH A 14 -1.500 0.682 10.967 1.00 43.49 O
END
"""
pdb_file = "tst_xtriage_in.pdb"
open(pdb_file, "w").write(pdb_raw)
fmodel_args = [
pdb_file,
"high_resolution=1.5",
"k_sol=0.35",
"b_sol=20",
"wavelength=1.54",
"add_random_error_to_amplitudes_percent=3",
"random_seed=12345",
"output.type=real",
"output.label=F",
"output.file_name=tst_xtriage_fmodel.mtz",
]
fmodel.run(args=fmodel_args, log=null_out())
mtz_in = file_reader.any_file("tst_xtriage_fmodel.mtz").assert_file_type(
"hkl")
f_obs = mtz_in.file_server.miller_arrays[0].remove_cone(0.1)
data = f_obs.data()
# add some outliers
#data[17] = 20
#data[334] = 26
#data[1908] = 13
# and sigmas
sigf = flex.double(f_obs.size(), 0.1) + (f_obs.data() * 0.03)
f_obs = f_obs.customized_copy(sigmas=sigf)
mtz_file = "tst_xtriage_in.mtz"
f_obs.as_mtz_dataset(column_root_label="F").mtz_object().write(mtz_file)
seq_file = "tst_xtriage_in.fa"
open(seq_file, "w").write("> tst_xtriage\nGNNMQNY")
# check with completeness_as_non_anomalous=True
xtriage_args = [
mtz_file,
pdb_file,
seq_file,
"log=tst_xtriage_1.log",
"l_test_dhkl=2,2,2",
"completeness_as_non_anomalous=True",
]
result = xtriage.run(args=xtriage_args, out=null_out())
test_pickle_consistency_and_size(result)
assert (result.matthews.n_copies == 1)
assert (str(result.matthews.table) == """\
Solvent content analysis
Copies Solvent content Matthews coeff. P(solvent content)
1 0.472 2.33 1.000
""")
data_strength = result.data_strength_and_completeness
assert approx_equal(data_strength.data_strength.resolution_cut,
1.5351,
eps=0.001)
out1 = data_strength.low_resolution_completeness.format()
assert (out1 == """\
---------------------------------------------------------
| Resolution range | N(obs)/N(possible) | Completeness |
---------------------------------------------------------
| 21.9858 - 10.4368 | [6/7] | 0.857 |
| 10.4368 - 8.4369 | [3/3] | 1.000 |
| 8.4369 - 7.4172 | [3/4] | 0.750 |
| 7.4172 - 6.7606 | [4/4] | 1.000 |
| 6.7606 - 6.2882 | [5/5] | 1.000 |
| 6.2882 - 5.9252 | [3/4] | 0.750 |
| 5.9252 - 5.6337 | [7/7] | 1.000 |
| 5.6337 - 5.3922 | [5/5] | 1.000 |
| 5.3922 - 5.1874 | [4/4] | 1.000 |
| 5.1874 - 5.0106 | [4/4] | 1.000 |
---------------------------------------------------------"""), out1
# ANOMALOUS SIGNAL
a_meas = result.anomalous_info.measurability
assert approx_equal(a_meas.high_d_cut, 4.7636, eps=0.0001)
assert approx_equal(a_meas.low_d_cut, 2.2357, eps=0.0001)
# ABSOLUTE SCALING
ws = result.wilson_scaling
assert ("%.2f" % ws.iso_p_scale) == "0.66"
assert ("%.2f" % ws.iso_b_wilson) == "14.51"
# FIXME these may need to be adjusted for different hardware/OS
assert approx_equal(ws.aniso_p_scale, 0.66106, eps=0.001)
assert approx_equal(
ws.aniso_u_star,
[0.00034473, 0.00479983, 0.000287162, -0.0, 9.00962e-05, 0.0])
assert approx_equal(ws.aniso_b_cart,
(13.218423, 16.840142, 12.948426, 1.0354e-15,
-0.0685311, -7.92862e-16))
# convenience methods for GUI
assert approx_equal(result.aniso_b_min, 12.948426)
assert approx_equal(result.aniso_range_of_b, 3.891716)
#
assert approx_equal(
ws.outlier_shell_table.data[0], # d_spacing
[9.865132, 8.369653, 4.863587, 4.648635, 3.126905, 1.729609])
assert approx_equal(
ws.outlier_shell_table.data[1], # z_score
[5.587749, 15.425036, 4.763399, 6.57819, 4.650204, 4.580195])
assert (len(ws.outliers.acentric_outliers_table.data[0]) == 2)
assert (ws.outliers.acentric_outliers_table.data[1] == [(0, -1, -1),
(0, 1, 1)])
assert approx_equal(ws.outliers.acentric_outliers_table.data[2],
[3.440749, 3.253775])
assert (ws.outliers.centric_outliers_table.data is None)
assert (len(ws.ice_rings.table._rows) == 10)
assert (ws.ice_rings.table._rows[0] ==
[' 3.897', ' 1.000', ' 0.52', ' 1.00']), \
ws.ice_rings.table._rows[0]
tw = result.twin_results
wm = tw.wilson_moments
out = StringIO()
wm.show(out)
assert not show_diff(
out.getvalue(), """
----------Wilson ratio and moments----------
Acentric reflections:
<I^2>/<I>^2 :2.047 (untwinned: 2.000; perfect twin 1.500)
<F>^2/<F^2> :0.779 (untwinned: 0.785; perfect twin 0.885)
<|E^2 - 1|> :0.743 (untwinned: 0.736; perfect twin 0.541)
Centric reflections:
<I^2>/<I>^2 :3.043 (untwinned: 3.000; perfect twin 2.000)
<F>^2/<F^2> :0.626 (untwinned: 0.637; perfect twin 0.785)
<|E^2 - 1|> :0.996 (untwinned: 0.968; perfect twin 0.736)
""")
# XXX PDB validation server
assert approx_equal(result.iso_b_wilson, 14.51, eps=0.1)
assert approx_equal(result.aniso_b_ratio, 0.271, eps=0.1)
assert (result.number_of_wilson_outliers == 2)
assert approx_equal(result.l_test_mean_l, 0.481, eps=0.1)
assert approx_equal(result.l_test_mean_l_squared, 0.322, eps=0.1)
assert approx_equal(result.i_over_sigma_outer_shell, 10.64, eps=0.01)
assert ("indicating pseudo-translationa" in result.patterson_verdict)
# check relative Wilson
# FIXME
#result.relative_wilson.show()
#assert (result.relative_wilson.n_outliers() == 0)
#show_pickled_object_sizes(result)
#
# check with completeness_as_non_anomalous=False
xtriage_args = [
mtz_file,
pdb_file,
seq_file,
"log=tst_xtriage_1.log",
"l_test_dhkl=2,2,2",
"completeness_as_non_anomalous=False",
]
result = xtriage.run(args=xtriage_args, out=null_out())
test_pickle_consistency_and_size(result)
assert (result.matthews.n_copies == 1)
assert (str(result.matthews.table) == """\
Solvent content analysis
Copies Solvent content Matthews coeff. P(solvent content)
1 0.472 2.33 1.000
""")
data_strength = result.data_strength_and_completeness
assert approx_equal(data_strength.data_strength.resolution_cut,
1.5351,
eps=0.001)
out1 = data_strength.low_resolution_completeness.format()
assert (out1 == """\
---------------------------------------------------------
| Resolution range | N(obs)/N(possible) | Completeness |
---------------------------------------------------------
| 21.9858 - 10.4368 | [ 6/7 ] | 0.857 |
| 10.4368 - 8.4369 | [ 3/3 ] | 1.000 |
| 8.4369 - 7.4172 | [ 3/4 ] | 0.750 |
| 7.4172 - 6.7606 | [ 4/4 ] | 1.000 |
| 6.7606 - 6.2882 | [ 8/8 ] | 1.000 |
| 6.2882 - 5.9252 | [ 4/5 ] | 0.800 |
| 5.9252 - 5.6337 | [11/11] | 1.000 |
| 5.6337 - 5.3922 | [ 7/7 ] | 1.000 |
| 5.3922 - 5.1874 | [ 6/6 ] | 1.000 |
| 5.1874 - 5.0106 | [ 7/7 ] | 1.000 |
---------------------------------------------------------"""), out1
# ANOMALOUS SIGNAL
a_meas = result.anomalous_info.measurability
assert approx_equal(a_meas.high_d_cut, 4.7636, eps=0.0001)
assert approx_equal(a_meas.low_d_cut, 2.2357, eps=0.0001)
# ABSOLUTE SCALING
ws = result.wilson_scaling
assert ("%.2f" % ws.iso_p_scale) == "0.66"
assert ("%.2f" % ws.iso_b_wilson) == "14.51"
# FIXME these may need to be adjusted for different hardware/OS
assert approx_equal(ws.aniso_p_scale, 0.66106, eps=0.001)
assert approx_equal(
ws.aniso_u_star,
[0.00034473, 0.00479983, 0.000287162, -0.0, 9.00962e-05, 0.0])
assert approx_equal(ws.aniso_b_cart,
(13.218423, 16.840142, 12.948426, 1.0354e-15,
-0.0685311, -7.92862e-16))
# convenience methods for GUI
assert approx_equal(result.aniso_b_min, 12.948426)
assert approx_equal(result.aniso_range_of_b, 3.891716)
#
assert approx_equal(
ws.outlier_shell_table.data[0], # d_spacing
[9.865132, 8.369653, 4.863587, 4.648635, 3.126905, 1.729609])
assert approx_equal(
ws.outlier_shell_table.data[1], # z_score
[5.587749, 15.425036, 4.763399, 6.57819, 4.650204, 4.580195])
assert (len(ws.outliers.acentric_outliers_table.data[0]) == 2)
assert (ws.outliers.acentric_outliers_table.data[1] == [(0, -1, -1),
(0, 1, 1)])
assert approx_equal(ws.outliers.acentric_outliers_table.data[2],
[3.440749, 3.253775])
assert (ws.outliers.centric_outliers_table.data is None)
assert (len(ws.ice_rings.table._rows) == 10)
assert (ws.ice_rings.table._rows[0] ==
[' 3.897', ' 1.000', ' 0.52', ' 1.00']), \
ws.ice_rings.table._rows[0]
tw = result.twin_results
wm = tw.wilson_moments
out = StringIO()
wm.show(out)
assert not show_diff(
out.getvalue(), """
----------Wilson ratio and moments----------
Acentric reflections:
<I^2>/<I>^2 :2.047 (untwinned: 2.000; perfect twin 1.500)
<F>^2/<F^2> :0.779 (untwinned: 0.785; perfect twin 0.885)
<|E^2 - 1|> :0.743 (untwinned: 0.736; perfect twin 0.541)
Centric reflections:
<I^2>/<I>^2 :3.043 (untwinned: 3.000; perfect twin 2.000)
<F>^2/<F^2> :0.626 (untwinned: 0.637; perfect twin 0.785)
<|E^2 - 1|> :0.996 (untwinned: 0.968; perfect twin 0.736)
""")
# XXX PDB validation server
assert approx_equal(result.iso_b_wilson, 14.51, eps=0.1)
assert approx_equal(result.aniso_b_ratio, 0.271, eps=0.1)
assert (result.number_of_wilson_outliers == 2)
assert approx_equal(result.l_test_mean_l, 0.481, eps=0.1)
assert approx_equal(result.l_test_mean_l_squared, 0.322, eps=0.1)
assert approx_equal(result.i_over_sigma_outer_shell, 10.64, eps=0.01)
assert ("indicating pseudo-translationa" in result.patterson_verdict)
# check relative Wilson
# FIXME
#result.relative_wilson.show()
#assert (result.relative_wilson.n_outliers() == 0)
#show_pickled_object_sizes(result)
#
# test without sigmas
f_obs_2 = f_obs.customized_copy(sigmas=None)
mtz_file = "tst_xtriage_in_2.mtz"
f_obs_2.as_mtz_dataset(column_root_label="F").mtz_object().write(mtz_file)
xtriage_args = [
mtz_file,
pdb_file,
seq_file,
"log=tst_xtriage_1.log",
]
result = xtriage.run(args=xtriage_args, out=null_out())
result.summarize_issues()
# test in lower symmetry
f_obs_3 = f_obs.expand_to_p1()
mtz_file = "tst_xtriage_in_3.mtz"
f_obs_3.as_mtz_dataset(column_root_label="F").mtz_object().write(mtz_file)
xtriage_args = [
mtz_file,
seq_file,
"log=tst_xtriage_2.log",
]
result = xtriage.run(args=xtriage_args, out=null_out())
assert ((
1,
'One or more symmetry operators suggest that the data has a higher crystallographic symmetry (P 2 1 1).',
'Point group and R-factor analysis')
in result.summarize_issues()._issues)
# test with elliptical truncation
f_obs_3 = f_obs.customized_copy(
crystal_symmetry=crystal.symmetry((23, 5, 20, 90, 107.8, 90), "P 21"))
f_obs_3 = f_obs_3.resolution_filter(d_min=1.5)
f_obs_3 = f_obs_3.customized_copy(
crystal_symmetry=f_obs.crystal_symmetry())
reso = ds.analyze_resolution_limits(f_obs_3)
out = StringIO()
reso.show(out=out)
assert ("max. difference between axes = 0.652" in out.getvalue()), \
out.getvalue()
assert ("elliptically truncated" in out.getvalue())
# make sure the elliptical truncation detection still works in higher space
# groups - we only need a miller.set for this
miller_set = miller.build_set(crystal_symmetry=crystal.symmetry(
(20, 20, 20, 90, 90, 90), "P422"),
d_min=1.5,
anomalous_flag=False)
reso = ds.analyze_resolution_limits(miller_set)
out = StringIO()
reso.show(out=out)
assert ("Resolution limits are within expected tolerances"
in out.getvalue())
# log binning
out = StringIO()
log_binned = ds.log_binned_completeness(f_obs_3)
log_binned.show(out=out)
assert ("""| 1.9724 - 1.5094 | 368/1230 | 29.9% |"""
in out.getvalue()), out.getvalue()
# test with no acentrics
cf = f_obs.centric_flags().data()
centrics = f_obs.select(cf)
acentrics = f_obs.select(~cf)
mtz_file = "tst_xtriage_in_3.mtz"
centrics.as_mtz_dataset(column_root_label="F").mtz_object().write(mtz_file)
args = [
mtz_file,
pdb_file,
seq_file,
"log=tst_xtriage_3.log",
]
try:
xtriage.run(args=args, out=null_out())
except Sorry:
pass
else:
raise Exception_expected
# with only a handful of acentrics
sel = flex.bool(acentrics.size(), False)
for i in range(10):
sel[i] = True
f_obs_4 = centrics.concatenate(acentrics.select(sel))
f_obs_4.as_mtz_dataset(column_root_label="F").mtz_object().write(mtz_file)
try:
xtriage.run(args=args, out=null_out())
except Sorry:
pass
else:
raise Exception_expected
def exercise_d_data_target_d_atomic_params():
import iotbx.pdb
import mmtbx.f_model
from scitbx.array_family import flex
good = """
CRYST1 15.000 15.000 15.000 90.00 90.00 90.00 P 212121
HETATM 115 O HOH A 18 3.000 5.000 5.000 1.00 10.00 O
HETATM 115 O HOH A 18 5.000 5.000 8.000 1.00 10.00 O
TER
END
"""
bad = """
CRYST1 15.000 15.000 15.000 90.00 90.00 90.00 P 212121
HETATM 115 O HOH A 18 3.000 5.000 5.000 0.50 10.00 O
HETATM 115 O HOH A 19 5.000 5.000 8.000 0.90 10.00 O
TER
END
"""
for update_f_part1 in [True, False]:
pdb_inp = iotbx.pdb.input(source_info=None, lines=bad)
xrs = pdb_inp.xray_structure_simple()
xrs.scattering_type_registry(table = "wk1995")
#
xb = iotbx.pdb.input(source_info=None, lines=good).xray_structure_simple()
xb.scattering_type_registry(table = "wk1995")
f_obs = abs(xb.structure_factors(d_min=1,
algorithm="direct").f_calc()).set_observation_type_xray_amplitude()
#
sfp = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract()
sfp.algorithm="direct"
for target_name in ["ls_wunit_kunit", "ls_wunit_k1", "ml"]:
print("%s"%target_name, "-"*50)
fmodel = mmtbx.f_model.manager(
f_obs = f_obs,
xray_structure = xrs.deep_copy_scatterers(),
target_name = target_name,
sf_and_grads_accuracy_params = sfp)
fmodel.update_all_scales(update_f_part1=update_f_part1)
alpha_beta = fmodel.alpha_beta()
print("R-work: %6.4f"%fmodel.r_work())
#
tg = mmtbx.utils.experimental_data_target_and_gradients(fmodel = fmodel,
alpha_beta=alpha_beta)
tg.show()
eps = 1.e-6
# occupancies
go = tg.grad_occ()
for i in [0,1]:
xrs1 = fmodel.xray_structure.deep_copy_scatterers()
xrs2 = fmodel.xray_structure.deep_copy_scatterers()
#
xrs1.scatterers()[i].occupancy+=+eps
tg.update_xray_structure(xray_structure=xrs1, alpha_beta=alpha_beta)
t1 = tg.target()
#
xrs2.scatterers()[i].occupancy+=-eps
tg.update_xray_structure(xray_structure=xrs2, alpha_beta=alpha_beta)
t2 = tg.target()
#
gfd = (t1-t2)/(2*eps)
print(gfd, go[i])
assert approx_equal(go[i], gfd, 1.e-5)
# sites_cart
gc = tg.grad_sites_cart()
uc = fmodel.xray_structure.unit_cell()
for i in [0,1]:
gfd = []
for e in [(eps,0,0),(0,eps,0),(0,0,eps)]:
xrs1 = fmodel.xray_structure.deep_copy_scatterers()
xrs2 = fmodel.xray_structure.deep_copy_scatterers()
#
s1 = flex.vec3_double([uc.orthogonalize(xrs1.scatterers()[i].site)])
s1 = s1+flex.vec3_double([e])
xrs1.scatterers()[i].site = uc.fractionalize(s1[0])
tg.update_xray_structure(xray_structure=xrs1, alpha_beta=alpha_beta)
t1 = tg.target()
#
s2 = flex.vec3_double([uc.orthogonalize(xrs2.scatterers()[i].site)])
s2 = s2-flex.vec3_double([e])
xrs2.scatterers()[i].site = uc.fractionalize(s2[0])
tg.update_xray_structure(xray_structure=xrs2, alpha_beta=alpha_beta)
t2 = tg.target()
#
gfd.append( (t1-t2)/(2*eps) )
print(gfd, list(gc[i]))
assert approx_equal(gc[i], gfd, 1.e-5)
def run_group(symbol):
group = space_group_info(symbol);
print("\n==")
elements = ('C', 'N', 'O', 'H')*11
struc = random_structure.xray_structure(
space_group_info = group,
volume_per_atom = 25.,
general_positions_only = False,
elements = elements,
min_distance = 1.0)
struc.show_summary()
d_min = 2.
fc = struc.structure_factors(d_min=d_min).f_calc()
symmetry_flags = maptbx.use_space_group_symmetry
fftmap = fc.fft_map(symmetry_flags = symmetry_flags)
grid_size = fftmap.real_map().accessor().focus()
###
rm = fftmap.real_map().deep_copy()
amap0 = asymmetric_map(struc.space_group().type(), rm)
p1_map00 = amap0.symmetry_expanded_map()
assert approx_equal(p1_map00, rm)
#
maptbx.unpad_in_place(rm)
amap1 = asymmetric_map(struc.space_group().type(), rm)
p1_map10 = amap1.symmetry_expanded_map()
assert approx_equal(p1_map00, p1_map10)
###
grid_tags = maptbx.grid_tags(grid_size)
grid_tags.build(fftmap.space_group_info().type(), fftmap.symmetry_flags())
grid_tags.verify(fftmap.real_map())
print("FFT grid_size = ", grid_size)
amap = asymmetric_map(struc.space_group().type(), fftmap.real_map())
afc = amap.structure_factors(fc.indices())
afftmap = amap.map_for_fft()
print("whole cell map size: ", afftmap.accessor().focus())
adata = amap.data()
acc = adata.accessor()
print("Asu map size: ", acc.origin(), " ", acc.last(), " ", acc.focus(), \
" ", acc.all())
df = flex.abs(afc - fc.data())
r1 = flex.sum(df) / flex.sum(flex.abs(fc.data()))
print("R1: ", r1)
assert r1 < 1.e-5
# just to prove to myself that I can shift origin to 000 and then reshape back
adata = adata.shift_origin()
adata.reshape(acc)
#
adata2 = adata.deep_copy()*2.
amap2 = asymmetric_map(struc.space_group().type(), adata2, grid_size)
afc2 = amap2.structure_factors(fc.indices())
df2 = flex.abs(afc2*.5-fc.data())
r12 = flex.sum(df2) / flex.sum(flex.abs(fc.data()))
print("R1 again: ", r12)
assert r12 < 1.e-5
p1_map = amap.symmetry_expanded_map()
assert p1_map.accessor().focus() == grid_size
rel_tol = 1.e-6
n = 0
mean_rel_dif = 0.
for (m1,m2) in zip(fftmap.real_map(),p1_map):
dif = abs(m1-m2)
av = 0.5*(abs(m1)+abs(m2))
assert dif <= rel_tol * av, "%f not <= %f * %f" % (dif, rel_tol, av)
if av != 0:
mean_rel_dif = mean_rel_dif + dif/av
n = n + 1
mean_rel_dif = mean_rel_dif / n
print("mean rel err: ", mean_rel_dif)
assert mean_rel_dif < 1.e-6
print 'FAIL: dials_regression not configured'
exit(0)
orig_expt_json = os.path.join(
dials_regression, "experiment_test_data/kappa_experiments.json")
new_expt_json = os.path.join(os.getcwd(), 'modified_experiments.json')
cmd = "dials.modify_geometry %s angles=10,20,30" % orig_expt_json
result = easy_run.fully_buffered(cmd).raise_if_errors()
from dxtbx.serialize import load
assert os.path.exists(orig_expt_json), orig_expt_json
orig_expt = load.experiment_list(orig_expt_json, check_format=False)
assert os.path.exists(new_expt_json), new_expt_json
new_expt = load.experiment_list(new_expt_json, check_format=False)
orig_gonio = orig_expt.goniometers()[0]
new_gonio = new_expt.goniometers()[0]
assert approx_equal(orig_gonio.get_angles(), [0, 180, 0])
assert approx_equal(new_gonio.get_angles(), [10, 20, 30])
return
if __name__ == '__main__':
from dials.test import cd_auto
with cd_auto(__file__):
run()
print "OK"
def plot_samples_ix(O, stage, ix):
p = O.params.plot_samples
i_sc, x_type = O.x_info[ix]
def f_calc_without_moving_scatterer():
sc = O.xray_structure.scatterers()[i_sc]
occ = sc.occupancy
try:
sc.occupancy = 0
result = O.get_f_calc().data()
finally:
sc.occupancy = occ
return result
f_calc_fixed = f_calc_without_moving_scatterer()
xs = O.xray_structure.select(flex.size_t([i_sc]))
def f_calc_moving():
return O.f_obs.structure_factors_from_scatterers(
xray_structure=xs, algorithm="direct",
cos_sin_table=False).f_calc().data()
sc = xs.scatterers()[0]
ss = xs.site_symmetry_table().get(0)
def build_info_str():
return "%s|%03d|%03d|%s|%s|occ=%.2f|%s|%s" % (
O.plot_samples_id, ix, i_sc, sc.label, sc.scattering_type,
sc.occupancy, ss.special_op_simplified(), x_type)
info_str = build_info_str()
print "plot_samples:", info_str
sys.stdout.flush()
ys = []
def ys_append():
tg = O.__get_tg(f_cbs=O.get_f_cbs(f_calc=O.f_obs.customized_copy(
data=f_calc_moving() + f_calc_fixed)),
derivatives_depth=0,
target=O.ps_target,
weights=O.ps_weights)
y = tg.target_work()
ys.append(y)
return y
xyv = []
if (x_type == "u"):
assert p.u_min < p.u_max
assert p.u_steps > 0
for i_step in xrange(p.u_steps + 1):
u = p.u_min + i_step / p.u_steps * (p.u_max - p.u_min)
sc.u_iso = u
y = ys_append()
xyv.append((u, y, sc.u_iso))
else:
assert p.x_radius > 0
assert p.x_steps > 0
ss_constr = ss.site_constraints()
ss_np = ss_constr.n_independent_params()
ss_ip = "xyz".find(x_type)
assert ss_ip >= 0
ixx = ix - ss_ip
indep = list(O.x[ixx:ixx + ss_np])
i_inp = indep[ss_ip]
from libtbx.test_utils import approx_equal
assert approx_equal(ss_constr.all_params(independent_params=indep),
sc.site)
site_inp = sc.site
indep[ss_ip] = i_inp + 1
sc.site = ss_constr.all_params(independent_params=indep)
dist = xs.unit_cell().distance(sc.site, site_inp)
assert dist != 0
x_scale = p.x_radius / dist
for i_step in xrange(-p.x_steps // 2, p.x_steps // 2 + 1):
x = i_step / p.x_steps * 2 * x_scale
indep[ss_ip] = i_inp + x
sc.site = ss_constr.all_params(independent_params=indep)
y = ys_append()
dist = xs.unit_cell().distance(sc.site, site_inp)
if (i_step < 0): dist *= -1
xyv.append((dist, y, indep[ss_ip]))
#
base_name_plot_files = "%s_%03d_%s" % (p.file_prefix, ix, stage)
def write_xyv():
if (p.file_prefix is None): return
f = open(base_name_plot_files + ".xy", "w")
print >> f, "# %s" % info_str
print >> f, "# %s" % str(xs.unit_cell())
print >> f, "# %s" % str(xs.space_group_info().symbol_and_number())
for x, y, v in xyv:
print >> f, x, y, v
write_xyv()
if (len(p.pyplot) != 0):
from libtbx import pyplot
fig = pyplot.figure()
ax = fig.add_subplot(1, 1, 1)
x, y, v = zip(*xyv)
ax.plot(x, y, "r-")
x = O.x[ix]
ax.plot([x, x], [min(ys), max(ys)], "k--")
if (O.x_reference is not None):
x = O.x_reference[ix]
ax.plot([x, x], [min(ys), max(ys)], "r--")
ax.set_title(info_str, fontsize=12)
ax.axis([xyv[0][0], xyv[-1][0], None, None])
def write_pdf():
if (p.file_prefix is None): return
fig.savefig(base_name_plot_files + ".pdf", bbox_inches="tight")
if ("pdf" in p.pyplot):
write_pdf()
if ("gui" in p.pyplot):
pyplot.show()