def run(): random.seed(0) flex.set_random_seed(0) test_rosenbrock_function(3) random.seed(0) flex.set_random_seed(0) test_rosenbrock_function(4)
def run(args): from scitbx.array_family import flex import random random.seed(0) flex.set_random_seed(0) from cctbx.development import debug_utils debug_utils.parse_options_loop_space_groups(args, run_call_back)
def exercise_twin_detwin () :
random.seed(12345)
flex.set_random_seed(12345)
xrs = random_structure.xray_structure(
unit_cell=(12,5,12,90,90,90),
space_group_symbol="P1",
n_scatterers=12,
elements="random")
fc = abs(xrs.structure_factors(d_min=1.5).f_calc())
fc = fc.set_observation_type_xray_amplitude()
mtz_file = "tmp_massage_in.mtz"
fc.as_mtz_dataset(column_root_label="F").mtz_object().write(mtz_file)
massage_data.run(
args=[
mtz_file,
"aniso.action=None",
"outlier.action=None",
"symmetry.action=twin",
"twin_law='l,-k,h'",
"fraction=0.3",
"hklout=tmp_massage_twinned.mtz",
],
out=null_out())
assert op.isfile("tmp_massage_twinned.mtz")
mtz_in = file_reader.any_file("tmp_massage_twinned.mtz")
fc_twin = mtz_in.file_server.miller_arrays[0].f_sq_as_f()
fc_twin, fc_tmp = fc_twin.common_sets(other=fc)
for hkl, f1, f2 in zip(fc_tmp.indices(), fc_tmp.data(), fc_twin.data()) :
if (abs(hkl[0]) != abs(hkl[2])) :
assert not approx_equal(f1, f2, eps=0.01, out=null_out()), (hkl, f1, f2)
massage_data.run(
args=[
mtz_file,
"aniso.action=None",
"outlier.action=None",
"symmetry.action=twin",
"twin_law='l,-k,h'",
"fraction=0.3",
"hklout=tmp_massage_twinned.sca",
],
out=null_out())
assert op.isfile("tmp_massage_twinned.sca")
massage_data.run(
args=[
"tmp_massage_twinned.mtz",
"aniso.action=None",
"outlier.action=None",
"symmetry.action=detwin",
"twin_law='l,-k,h'",
"fraction=0.3",
"hklout=tmp_massage_detwinned.mtz",
],
out=null_out())
mtz_in = file_reader.any_file("tmp_massage_detwinned.mtz")
fc_detwin = mtz_in.file_server.miller_arrays[0].f_sq_as_f()
fc_detwin, fc_tmp = fc_detwin.common_sets(other=fc)
# XXX we appear to lose some accuracy here, possibly due to the use of
# MTZ format
for hkl, f1, f2 in zip(fc_tmp.indices(), fc_tmp.data(), fc_detwin.data()) :
assert approx_equal(f1, f2, eps=0.01), hkl
def run(self, random_seed):
tmp = self.xray_structure.deep_copy_scatterers()
# Shake and minimize to get variable starting points
tmp.shake_sites_in_place(
rms_difference = None,
mean_distance = 5)
sites_cart_ = tmp.sites_cart()
minimized = geometry_minimization.lbfgs(
sites_cart = sites_cart_,
correct_special_position_tolerance= 1.0,
geometry_restraints_manager = self.restraints_manager.geometry,
geometry_restraints_flags = self.grf,
lbfgs_exception_handling_params = self.lbfgs_exception_handling_params,
lbfgs_termination_params = scitbx.lbfgs.termination_parameters(
max_iterations=50))
tmp = tmp.replace_sites_cart(new_sites = sites_cart_)
#
random.seed(random_seed)
flex.set_random_seed(random_seed)
sa.run(
params = self.params,
xray_structure = tmp,
real_space = True,
target_map = self.map_data,
restraints_manager = self.restraints_manager,
wx = self.weight,
wc = 1.,
verbose = False)
return tmp
def run():
flex.set_random_seed(0)
for ii in xrange(10):
test_rosenbrock_function(1)
test_function(1)
test_function(2)
test_function(3)
test_function(4)
def __init__(self): # # FIXME!!!!! # Setting random seed to avoid test failure, need to take anothe look at # this to figure out why this is failing sometimes anyway. # from random import seed from scitbx.array_family import flex seed(0) flex.set_random_seed(0)
def plot_uc_3Dplot(self, info):
assert self.interactive
import numpy as np
from mpl_toolkits.mplot3d import Axes3D # import dependency
fig = self.plt.figure(figsize=(12, 10))
# Extract uc dimensions from info list
a = flex.double([i['a'] for i in info])
b = flex.double([i['b'] for i in info])
c = flex.double([i['c'] for i in info])
alpha = flex.double([i['alpha'] for i in info])
beta = flex.double([i['beta'] for i in info])
gamma = flex.double([i['gamma'] for i in info])
n_total = len(a)
accepted = flex.bool(n_total, True)
for d in [a, b, c, alpha, beta, gamma]:
outliers = self.reject_outliers(d)
accepted &= ~outliers
a = a.select(accepted)
b = b.select(accepted)
c = c.select(accepted)
AA = "a-edge (%.2f +/- %.2f $\AA$)" % (flex.mean(a),
flex.mean_and_variance(a).unweighted_sample_standard_deviation())
BB = "b-edge (%.2f +/- %.2f $\AA$)" % (flex.mean(b),
flex.mean_and_variance(b).unweighted_sample_standard_deviation())
CC = "c-edge (%.2f +/- %.2f $\AA$)" % (flex.mean(c),
flex.mean_and_variance(c).unweighted_sample_standard_deviation())
subset = min(len(a),1000)
flex.set_random_seed(123)
rnd_sel = flex.random_double(len(a))<(subset/n_total)
a = a.select(rnd_sel)
b = b.select(rnd_sel)
c = c.select(rnd_sel)
fig.suptitle('{} randomly selected cells out of total {} images'
''.format(len(a),n_total), fontsize=18)
ax = fig.add_subplot(111, projection='3d')
for ia in xrange(len(a)):
ax.scatter(a[ia],b[ia],c[ia],c='r',marker='+')
ax.set_xlabel(AA)
ax.set_ylabel(BB)
ax.set_zlabel(CC)
def run(
args,
map_data=None,
map_coeffs=None,
pdb_inp=None,
pdb_string=None,
crystal_symmetry=None,
params_edits=None,
out=sys.stdout,
):
# Get the parameters
params = get_params(args=args, out=out)
if params.control.random_seed:
import random
random.seed(params.control.random_seed)
flex.set_random_seed(params.control.random_seed)
print >> out, "\nUsing random seed of %d" % (params.control.random_seed)
# Get map_data if not present
map_data, map_coeffs, crystal_symmetry = get_map_data_and_symmetry(
crystal_symmetry=crystal_symmetry,
map_data=map_data,
map_coeffs=map_coeffs,
map_coeffs_file=params.input_files.map_coeffs_file,
map_coeffs_labels=params.input_files.map_coeffs_labels,
)
# Get the starting model
pdb_inp, cryst1_line, pdb_string = get_pdb_inp(
crystal_symmetry=crystal_symmetry, pdb_inp=pdb_inp, pdb_string=pdb_string, pdb_in=params.input_files.pdb_in
)
pdb_hierarchy, multiple_models_hierarchy = run_one_cycle(
params=params,
map_data=map_data,
pdb_inp=pdb_inp,
pdb_string=pdb_string,
crystal_symmetry=crystal_symmetry,
params_edits=params_edits,
out=out,
)
if params.output_files.pdb_out:
f = open(params.output_files.pdb_out, "w")
print >> f, cryst1_line
print >> f, pdb_hierarchy.as_pdb_string()
print >> out, "\nWrote output model to %s" % (params.output_files.pdb_out)
f.close()
# all done
return pdb_hierarchy, multiple_models_hierarchy
def exercise_space_group_handling () :
flex.set_random_seed(123456)
random.seed(123456)
base = "tst_cc_star_space_group"
pdb_in = iotbx.pdb.hierarchy.input(pdb_string=model_1yjp)
xrs = pdb_in.xray_structure_simple()
xrs.set_inelastic_form_factors(
photon=1.54,
table="sasaki")
fc = abs(xrs.structure_factors(d_min=1.5).f_calc()).average_bijvoet_mates()
fc.set_observation_type_xray_amplitude()
flags = fc.generate_r_free_flags()
mtz = fc.as_mtz_dataset(column_root_label="F")
mtz.add_miller_array(flags, column_root_label="FreeR_flag")
mtz.mtz_object().write(base + ".mtz")
xrs_p1 = xrs.expand_to_p1()
xrs_p1.shake_sites_in_place(rms_difference=0.1)
fc_p1 = xrs_p1.structure_factors(d_min=1.4).f_calc()
fc_p1_extra = fc_p1.randomize_amplitude_and_phase(amplitude_error=1.0,
phase_error_deg=0,
random_seed=123456)
fc_p1 = abs(fc_p1.concatenate(other=fc_p1_extra)).sort(
by_value="packed_indices")
fc_p1.set_observation_type_xray_amplitude()
sg_p2 = sgtbx.space_group_info("P2")
ic = fc_p1.f_as_f_sq().customized_copy(
space_group_info=sg_p2,
sigmas=flex.double(fc_p1.size(), 10.0))
ic.export_as_scalepack_unmerged(file_name=base + ".sca")
open(base + ".pdb", "w").write(model_1yjp)
args = [
base + ".mtz",
base + ".pdb",
"unmerged_data=%s.sca" % base,
]
cc_star.run(args=args, out=null_out())
# now with .sca in P1 (raises Sorry)
ic2 = fc_p1.f_as_f_sq().customized_copy(
sigmas=flex.double(fc_p1.size(), 10.0))
ic2.export_as_scalepack_unmerged(file_name=base + "_p1.sca")
args = [
base + ".mtz",
base + ".pdb",
"unmerged_data=%s_p1.sca" % base,
]
try :
cc_star.run(args=args, out=null_out())
except Sorry, s :
assert (str(s) == "Incompatible space groups in merged and unmerged data:P 1 21 1 versus P 1"), s
def exercise_1():
random.seed(0)
flex.set_random_seed(0)
pi = get_pdb_inputs(pdb_str=pdb_str_1)
f_obs = abs(pi.xrs.structure_factors(d_min = 2.5).f_calc())
r_free_flags = f_obs.generate_r_free_flags(use_lattice_symmetry=False)
if(0):
pi.ph.adopt_xray_structure(pi.xrs)
pi.ph.write_pdb_file(file_name="start.pdb",
crystal_symmetry = pi.xrs.crystal_symmetry())
xrs_poor = shake_sites(xrs = pi.xrs.deep_copy_scatterers(), random=False,
shift = 1.5, grm=pi.grm)
if(0):
pi.ph.adopt_xray_structure(xrs_poor)
pi.ph.write_pdb_file(file_name="poor.pdb",
crystal_symmetry = xrs_poor.crystal_symmetry())
fmodel = mmtbx.f_model.manager(
f_obs = f_obs,
r_free_flags = r_free_flags,
xray_structure = xrs_poor)
print "start r_work:", fmodel.r_work()
#
params = sa.master_params().extract()
params.start_temperature=3000
params.final_temperature=0
params.cool_rate = 100
params.number_of_steps = 100
params.update_grads_shift = 0.
#
sa.run(
params = params,
fmodel = fmodel,
restraints_manager = pi.grm,
wx = 20,
wc = 1,
verbose = True)
#
r = fmodel.r_work()
print "final r_work:", r
assert r < 0.03, r
dist = flex.mean(flex.sqrt((pi.xrs.sites_cart() -
fmodel.xray_structure.sites_cart()).dot()))
print "Distance(refined, answer): %6.4f"%dist
assert dist < 0.25, dist
if(0):
pi.ph.adopt_xray_structure(fmodel.xray_structure)
pi.ph.write_pdb_file(file_name="refined.pdb",
crystal_symmetry = fmodel.xray_structure.crystal_symmetry())
def generate_reflections(self):
sweep_range = self.scan.get_oscillation_range(deg=False)
resolution = 2.0
index_generator = IndexGenerator(self.crystal.get_unit_cell(),
space_group(space_group_symbols(1).hall()).type(),
resolution)
indices = index_generator.to_array()
# Predict rays within the sweep range
ray_predictor = ScansRayPredictor(self.experiments, sweep_range)
obs_refs = ray_predictor(indices)
# Take only those rays that intersect the detector
intersects = ray_intersection(self.detector, obs_refs)
obs_refs = obs_refs.select(intersects)
# Re-predict using the Experiments predictor for all these reflections. The
# result is the same, but we gain also the flags and xyzcal.px columns
obs_refs['id'] = flex.int(len(obs_refs), 0)
obs_refs = self.ref_predictor(obs_refs)
# Set 'observed' centroids from the predicted ones
obs_refs['xyzobs.mm.value'] = obs_refs['xyzcal.mm']
# Invent some variances for the centroid positions of the simulated data
im_width = 0.1 * pi / 180.
px_size = self.detector[0].get_pixel_size()
var_x = flex.double(len(obs_refs), (px_size[0] / 2.)**2)
var_y = flex.double(len(obs_refs), (px_size[1] / 2.)**2)
var_phi = flex.double(len(obs_refs), (im_width / 2.)**2)
obs_refs['xyzobs.mm.variance'] = flex.vec3_double(var_x, var_y, var_phi)
# set the flex random seed to an 'uninteresting' number
flex.set_random_seed(12407)
# take 5 random reflections for speed
reflections = obs_refs.select(flex.random_selection(len(obs_refs), 5))
# use a BlockCalculator to calculate the blocks per image
from dials.algorithms.refinement.reflection_manager import BlockCalculator
block_calculator = BlockCalculator(self.experiments, reflections)
reflections = block_calculator.per_image()
return reflections
def exercise(d_min=3.5):
pi = get_pdb_inputs(pdb_str=pdb_str_1)
selection = flex.bool(pi.xrs.scatterers().size(), True)
f_obs = abs(pi.xrs.structure_factors(d_min=d_min).f_calc())
r_free_flags = f_obs.generate_r_free_flags()
for d_min in [1, 2, 3]:
print "d_min:", d_min
f_calc = pi.xrs.structure_factors(d_min=d_min).f_calc()
fft_map = f_calc.fft_map(resolution_factor=0.25)
fft_map.apply_sigma_scaling()
target_map = fft_map.real_map_unpadded()
from mmtbx.refinement import real_space
rsr_simple_refiner = real_space.simple(
target_map=target_map,
selection=selection,
real_space_gradients_delta=d_min / 4,
max_iterations=150,
geometry_restraints_manager=pi.grm.geometry,
)
for shake_size in [1]:
print " shake_size:", shake_size
for p in [(0.01, 1.0), (0.03, 3.0)]:
print " target:", p
w_opt = flex.double()
for start_value in [0, 1000]:
xrs_poor = pi.xrs.deep_copy_scatterers()
random.seed(0)
flex.set_random_seed(0)
xrs_poor.shake_sites_in_place(mean_distance=shake_size)
#
refined = real_space.refinery(
refiner=rsr_simple_refiner,
xray_structure=xrs_poor,
start_trial_weight_value=start_value,
rms_bonds_limit=p[0],
rms_angles_limit=p[1],
)
w_opt.append(refined.weight_final)
dist = flex.mean(flex.sqrt((pi.xrs.sites_cart() - refined.sites_cart_result).dot()))
print " start_value:", start_value, refined.weight_final, refined.rms_bonds_final, refined.rms_angles_final, dist
assert refined.rms_bonds_final <= p[0]
assert refined.rms_angles_final <= p[1]
assert flex.max(flex.abs(w_opt - flex.mean(w_opt))) < 1.0
def exercise_01 () :
pdb_raw = """\
CRYST1 10.000 15.000 10.000 90.00 90.00 90.00 P 1
ATOM 6407 N GLY A 388 -0.783 9.368 -16.436 1.00 51.96 N
ATOM 6408 CA GLY A 388 -0.227 9.888 -15.197 1.00 54.04 C
ATOM 6409 C GLY A 388 -0.637 11.320 -14.897 1.00 55.86 C
ATOM 6410 O GLY A 388 -1.728 11.738 -15.347 1.00 56.70 O
ATOM 6411 OXT GLY A 388 0.129 12.024 -14.203 1.00 56.98 O
ATOM 6412 D GLY A 388 -0.460 9.727 -17.309 1.00 51.44 D
ATOM 6413 HA2 GLY A 388 -0.561 9.258 -14.385 1.00 54.07 H
ATOM 6414 HA3 GLY A 388 0.843 9.835 -15.243 1.00 54.13 H
TER 6415 GLY A 388
HETATM 6416 D D8U A 401 2.236 5.695 -12.992 1.00 15.23 D
HETATM 6417 O DOD A1001 -4.151 4.107 -16.592 1.00 13.40 O
HETATM 6418 D1 DOD A1001 -4.760 3.026 -11.326 1.00 15.45 D
HETATM 6419 D2 DOD A1001 -4.625 2.741 -13.845 1.00 14.81 D
"""
random.seed(12345)
flex.set_random_seed(12345)
pdb_in = iotbx.pdb.hierarchy.input(pdb_string=pdb_raw)
xrs = pdb_in.input.xray_structure_simple()
pdb_in.hierarchy.atoms().reset_i_seq()
open("tst_validate_experimental.pdb", "w").write(
pdb_in.hierarchy.as_pdb_string(crystal_symmetry=xrs))
f_calc =abs( xrs.structure_factors(d_min=2.0).f_calc())
f_calc.set_observation_type_xray_amplitude()
flags = f_calc.generate_r_free_flags()
mtz = f_calc.as_mtz_dataset(column_root_label="F")
mtz.add_miller_array(flags, column_root_label="FreeR_flag")
mtz.mtz_object().write("tst_validate_experimental.mtz")
args = [
"tst_validate_experimental.pdb",
"tst_validate_experimental.mtz",
]
args.append("flags.clashscore=%s" % libtbx.env.has_module("probe"))
result = molprobity.run(args=args,
ignore_missing_modules=True,
out=null_out()).validation
assert result.real_space is not None
ds = result.data_stats
assert (ds.n_free > 0)
def exercise():
# Exercise "simple" target
pi = get_pdb_inputs(pdb_str=pdb_str_1)
selection = flex.bool(pi.xrs.scatterers().size(), True)
for d_min in [1, 2, 3]:
print "d_min:", d_min
f_calc = pi.xrs.structure_factors(d_min = d_min).f_calc()
fft_map = f_calc.fft_map(resolution_factor=0.25)
fft_map.apply_sigma_scaling()
target_map = fft_map.real_map_unpadded()
rsr_simple_refiner = individual_sites.simple(
target_map = target_map,
selection = selection,
real_space_gradients_delta = d_min/4,
max_iterations = 150,
geometry_restraints_manager = pi.grm.geometry)
for shake_size in [1,]:
print " shake_size:", shake_size
for p in [(0.01, 1.0), (0.03, 3.0), (0.1, 10.0)]:
print " target:", p
w_opt = flex.double()
for start_value in [0.001, 0.01, 0.1, 0, 1, 10, 100, 1000]:
xrs_poor = pi.xrs.deep_copy_scatterers()
random.seed(0)
flex.set_random_seed(0)
xrs_poor.shake_sites_in_place(mean_distance = shake_size)
#
refined = individual_sites.refinery(
refiner = rsr_simple_refiner,
xray_structure = xrs_poor,
start_trial_weight_value = start_value,
rms_bonds_limit = p[0],
rms_angles_limit = p[1])
w_opt.append(refined.weight_final)
dist = flex.mean(flex.sqrt((pi.xrs.sites_cart() -
refined.sites_cart_result).dot()))
print " w_start,w_final,b,a,dist: %9.4f %9.4f %6.3f %6.3f %6.3f"%(
start_value, refined.weight_final, refined.rms_bonds_final,
refined.rms_angles_final, dist)
assert refined.rms_bonds_final <= p[0]
assert refined.rms_angles_final <= p[1]
def test_curve_scaler(): flex.set_random_seed( 12345 ) x = flex.double( range(10) )/10.0 y = flex.exp( -x ) y0 = y y1 = y*100+50 y2 = y*1000+500 v0 = y0*0+1 v1 = y0*0+1.0 v2 = v1 scaler_object = linear_scaler( [y0,y1,y2], [v0,v1,v2], 0 , factor=5,show_progress=False) s,o,m = scaler_object.retrieve_results() assert approx_equal(s[1],0.01,eps=1e-3) assert approx_equal(s[2],0.001,eps=1e-3) assert approx_equal(o[1],-50,eps=1e-2) assert approx_equal(o[2],-500,eps=1e-2) s,o = scale_it_pairwise([y0,y1,y2],[v0,v1,v2],0, show_progress=False) assert approx_equal(s[1],0.01,eps=1e-3) assert approx_equal(s[2],0.001,eps=1e-3) assert approx_equal(o[1],-50,eps=1e-2) assert approx_equal(o[2],-500,eps=1e-2)
def exercise () :
flex.set_random_seed(12345)
random.seed(12345)
xrs = random_structure.xray_structure(
sgtbx.space_group_info("P21212"),
elements=["const"]*100)
f_calc = xrs.structure_factors(d_min=2.5).f_calc()
i_calc = abs(f_calc).f_as_f_sq().set_observation_type_xray_intensity()
i_calc = i_calc.customized_copy(
space_group_info=sgtbx.space_group_info("P222"),
sigmas=flex.double(i_calc.size(), 1.0))
complete_set = i_calc.complete_set()
lone_set = complete_set.lone_set(other=i_calc)
i_abs = lone_set.array(data=flex.double(lone_set.size(), 5),
sigmas=flex.double(lone_set.size(), 10))
i_calc = i_calc.concatenate(other=i_abs).set_observation_type_xray_intensity()
i_calc.export_as_scalepack_unmerged(file_name="tst_sys_absent.sca")
args = ["tst_sys_absent.sca"]
out = StringIO()
try :
show_systematic_absences.run(args=args, out=out)
except Sorry :
pass
else :
raise Exception_expected
args.append(",".join([ str(x) for x in xrs.unit_cell().parameters() ]))
show_systematic_absences.run(args=args, out=out)
assert (out.getvalue().count(" ( 0, 3, 0): i/sigi = 0.5") == 4)
i_calc = i_calc.customized_copy(sigmas=None)
i_calc.as_mtz_dataset(column_root_label="I").mtz_object().write("tst_sys_absent.mtz")
args = ["tst_sys_absent.mtz"]
try :
show_systematic_absences.run(args=args, out=out)
except Sorry :
pass
else :
raise Exception_expected
def __call__ (self, i_proc) :
import mmtbx.building
from scitbx.array_family import flex
seed = self.params.random_seed
if (seed is None) :
seed = int(time.time() / os.getpid())
random.seed(seed)
flex.set_random_seed(seed)
sites_new = mmtbx.building.run_real_space_annealing(
xray_structure=self.xray_structure.deep_copy_scatterers(),
pdb_hierarchy=self.pdb_hierarchy.deep_copy(),
processed_pdb_file=self.processed_pdb_file,
selection=self.selection,
target_map=self.target_map,
d_min=self.d_min,
resolution_factor=self.resolution_factor,
params=self.params.simulated_annealing,
target_map_rsr=self.two_fofc_map,
rsr_after_anneal=self.params.rsr_after_anneal,
reference_sigma=self.params.reference_sigma,
wc=self.params.wc,
out=self.out,
debug=self.debug)
return sites_new
def find_tls (params,
pdb_inp,
pdb_hierarchy,
xray_structure,
return_as_list=False,
ignore_pdb_header_groups=False,
out=None) :
if (out is None) :
out = sys.stdout
print_statistics.make_header("Analyzing inputs", out=out)
if (params.random_seed is None) :
params.random_seed = flex.get_random_seed()
random.seed(params.random_seed)
flex.set_random_seed(params.random_seed)
xray_structure.convert_to_isotropic()
sites_cart = xray_structure.sites_cart()
u_cart = None
u_iso = xray_structure.extract_u_iso_or_u_equiv()#*adptbx.u_as_b(1.) # ?
bad_i_seqs = check_adp(u_iso=u_iso, out=out)
if (bad_i_seqs is not None) :
atoms = pdb_hierarchy.atoms()
bad_atom_strings = []
for i_seq in bad_i_seqs[:10] :
atom_str = atoms[i_seq].format_atom_record()
bad_atom_strings.append(atom_str)
if (len(bad_i_seqs) > 10) :
bad_atom_strings.append("... (remaining %d not shown)" %
(len(bad_i_seqs)-10))
raise Sorry(("%d atoms in the model contain isotropic B-factors <= 0:\n"+
"\n".join(bad_atom_strings)) % (len(bad_i_seqs)))
#
ssm = mmtbx.secondary_structure.manager(
pdb_hierarchy = pdb_hierarchy,
sec_str_from_pdb_file = None,
params = None)
alpha_h_selection = ssm.alpha_selection()
secondary_structure_selection = ssm.alpha_selection() | \
ssm.beta_selection() | ssm.base_pair_selection()
if(u_cart is not None):
assert secondary_structure_selection.size() == u_cart.size()
else:
assert secondary_structure_selection.size() == u_iso.size()
ssm.show_summary(log=out)
chains_and_residue_selections, secondary_structure_selection = chains_and_atoms(
pdb_hierarchy = pdb_hierarchy,
secondary_structure_selection = secondary_structure_selection,
out = out)
chains_and_permutations = []
chains_and_atom_selection_strings = []
print_statistics.make_header("Processing chains", out=out)
if (params.nproc is None) :
params.nproc = 1
for crs in chains_and_residue_selections:
print_statistics.make_sub_header("Processing chain '%s'"%crs[0],
out=out)
chain_selection = chain_selection_from_residues(crs[1])
groups, perms = get_model_partitioning(residues = crs[1],
secondary_structure_selection = secondary_structure_selection,
out = out)
#
#print
#selection_arrays = sels_as_selection_arrays(sels = groups)
#merge_groups_by_connectivity(
# pdb_hierarchy = pdb_hierarchy,
# xray_structure = xray_structure,
# selection_arrays = selection_arrays)
#assert 0
#
if(len(perms)==1):
print >> out, " Whole chain is considered as one TLS group."
chains_and_atom_selection_strings.append([crs[0],
permutations_as_atom_selection_string(groups, perms[0])])
else:
print >> out, " Fitting TLS matrices..."
dic = {}
target_best = 1.e+9
if (params.nproc is Auto) or (params.nproc > 1) :
process_perms = analyze_permutations(
groups=groups,
sites_cart=sites_cart,
u_cart=u_cart,
u_iso=u_iso)
from libtbx import easy_mp
stdout_and_targets = easy_mp.pool_map(
processes=params.nproc,
fixed_func=process_perms,
args=perms,
chunksize=100,
func_wrapper="buffer_stdout_stderr")
targets = [ t for so, t in stdout_and_targets ]
for (perm, target) in zip(perms, targets) :
dic.setdefault(len(perm), []).append([target,perm])
else :
for i_perm, perm in enumerate(perms):
if i_perm%500==0:
print >> out, " ...perm %d of %d"%(i_perm, len(perms))
selections = tls_group_selections(groups, perm)
target = 0
for selection in selections:
mo = tls_refinery(
u_cart = u_cart,
u_iso = u_iso,
sites_cart = sites_cart,
selection = selection)
target += mo.f
dic.setdefault(len(perm), []).append([target,perm])
#print " perm %d of %d: target=%8.3f (TLS groups: %s), permutation:"%(
# i_perm, len(perms),target,len(perm)),perm
print >> out, " Best fits:"
print >> out, " No. of Targets"
print >> out, " groups best rand.pick diff. score permutation"
score_best = -1.e+9
perm_choice = None
for k, v in zip(dic.keys(),dic.values()):
t_best = v[0][0]
perm_best = v[0][1]
for v_ in v:
if(v_[0]<t_best):
t_best = v_[0]
perm_best = v_[1]
if(u_cart is not None):
u_cart_ = u_cart.select(chain_selection)
else: u_cart_ = None
if(u_iso is not None):
u_iso_ = u_iso.select(chain_selection)
else: u_iso_ = None
r = tls_refinery_random_groups(
u_cart = u_cart_,
u_iso = u_iso_,
sites_cart = sites_cart.select(chain_selection),
n_groups = k)
score = (r-t_best)/(r+t_best)*100.
print >> out, " %3d %6.3f %6.3f %6.2f %6.3f"%(
k,t_best, r, r-t_best, score), perm_best
if(score > score_best):
score_best = score
perm_choice = perm_best[:]
#
chains_and_permutations.append([crs[0],perm_choice])
chains_and_atom_selection_strings.append([crs[0],
permutations_as_atom_selection_string(groups, perm_choice)])
#
if (pdb_inp is not None) and (not ignore_pdb_header_groups) :
external_tls_selections = external_tls(
pdb_inp = pdb_inp,
pdb_hierarchy = pdb_hierarchy,
sites_cart = sites_cart,
u_iso = u_iso,
out = out)
print_statistics.make_header("SUMMARY", out=out)
#print "Optimal TLS groups:"
#for chain_and_permutation in chains_and_permutations:
# print chain_and_permutation
#print
print >> out, "TLS atom selections for phenix.refine:"
groups_out = cStringIO.StringIO()
selection_strings = []
print >> groups_out, "refinement.refine.adp {"
for r in chains_and_atom_selection_strings:
prefix = "chain '%s'"%r[0]
if(len(r[1])>0 and len(r[1:])>0):
prefix += " and "
for r_ in r[1:]:
for r__ in r_:
if(len(r__)>0):
group_selection = prefix+"(%s)"%r__
print >> groups_out, " tls = \"%s\"" % group_selection
selection_strings.append("%s" % group_selection)
else:
print >> groups_out, " tls = \"%s\"" % prefix
selection_strings.append("%s" % prefix)
print >> groups_out, "}"
print >> out, groups_out.getvalue()
print >> out
#XXX
if 0:
merge_groups_by_connectivity(
pdb_hierarchy = pdb_hierarchy,
xray_structure = xray_structure,
selection_strings = selection_strings)
#XXX
if(len(selection_strings)>0):
total_target = total_score(
pdb_hierarchy = pdb_hierarchy,
sites_cart = sites_cart,
u_iso = u_iso,
selection_strings = selection_strings)
print >> out, "Overall best total target for automatically found groups: %10.1f"%total_target
print >> out
if (return_as_list) :
return selection_strings
else :
return groups_out.getvalue()
def run(args, log = sys.stdout):
print >> log, legend
# XXX: pre-processing for GUI; duplicates some of mmtbx.utils
sources = []
for arg in args :
if os.path.isfile(arg) :
try :
file_phil = iotbx.phil.parse(file_name=arg)
except KeyboardInterrupt :
raise
except RuntimeError :
pass
else :
if len(file_phil.objects) != 0 :
sources.append(file_phil)
if len(sources) > 0 :
cmdline_phil = fmodel_from_xray_structure_master_params.fetch(
sources=sources)
params = cmdline_phil.extract()
if len(params.pdb_file) > 0 :
args.extend(params.pdb_file)
if params.reference_file is not None :
args.append(params.reference_file)
# end of preprocessing
processed_args = mmtbx.utils.process_command_line_args(args = args, log = log,
master_params = fmodel_from_xray_structure_master_params)
pdb_combined = iotbx.pdb.combine_unique_pdb_files(
file_names = processed_args.pdb_file_names)
pdb_combined.report_non_unique(out = log)
print >> log, "-"*79
print >> log, "\nParameters to compute Fmodel::\n"
processed_args.params.show(out = log, prefix=" ")
params = processed_args.params.extract()
if(params.random_seed is not None):
random.seed(params.random_seed)
flex.set_random_seed(params.random_seed)
pdb_file_names = processed_args.pdb_file_names
if len(pdb_file_names) == 0 :
pdb_file_names = params.pdb_file # for GUI
pdb_combined = iotbx.pdb.combine_unique_pdb_files(file_names=pdb_file_names)
pdb_combined.report_non_unique(out = log)
if(len(pdb_combined.unique_file_names) == 0):
raise Sorry("Model file is not provided.")
print >> log, "-"*79
print >> log, "\nInput model file(s):", " ".join(processed_args.pdb_file_names)
pdb_inp = iotbx.pdb.input(source_info = None,
lines = flex.std_string(pdb_combined.raw_records))
# select miller array to use as a set of miller indices for f_model
miller_array = None
if(len(processed_args.reflection_files) > 1):
raise Sorry("Multiple reflection files found at input.")
# FIXME this does not pick up the reference_file parameter! in fact, it
# appears to be ignored completely when run on the command line.
if(len(processed_args.reflection_files) == 1):
print >> log, "-"*79
print >> log, "Input reflection data:", \
" ".join(processed_args.reflection_file_names)
if([params.high_resolution, params.low_resolution].count(None) != 2):
raise Sorry("high_resolution and low_resolution must be undefined "+
"if reflection data file is given.")
miller_arrays = processed_args.reflection_files[0].as_miller_arrays()
data_sizes = flex.int([ma.data().size() for ma in miller_arrays])
if(data_sizes.all_eq(data_sizes[0])): miller_array = miller_arrays[0]
else:
all_labels = []
for ma in miller_arrays:
if(params.data_column_label is not None and
ma.info().label_string() == params.data_column_label):
miller_array = ma
break
all_labels.append(",".join(ma.info().labels))
if(miller_array is None):
raise Sorry("Multiple data available in input reflection file:\n%s\n%s"%(
"\n".join(all_labels),"Please select one using 'data_column_label=' keyword."))
else:
miller_array.show_comprehensive_summary(f = log, prefix=" ")
if(miller_array is not None):
miller_array = miller_array.map_to_asu().customized_copy(
data = flex.double(miller_array.data().size(), 1))
#
cryst1 = pdb_inp.crystal_symmetry_from_cryst1()
if(cryst1 is None and miller_array is not None):
cryst1 = miller_array.crystal_symmetry()
if (cryst1 is not None) and (params.generate_fake_p1_symmetry) :
raise Sorry("The input reference data already define crystal symmetry; "+
"you may not use this in combination with the option "+
"generate_fake_p1_symmetry=True.")
if (not params.generate_fake_p1_symmetry) :
if(cryst1 is None) :
raise Sorry(
"CRYST1 record in input PDB file is incomplete or missing. "+
"If you want the program to generate P1 symmetry automatically, set "+
"generate_fake_p1_symmetry=True.")
else:
if([cryst1.unit_cell(), cryst1.space_group_info()].count(None) != 0):
raise Sorry(
"CRYST1 record in input PDB file is incomplete or missing. "+
"If you want the program to generate P1 symmetry automatically, "+
"set generate_fake_p1_symmetry=True.")
pdb_hierarchy = pdb_inp.construct_hierarchy()
# need to preserve the order in the hierarchy in case we have to perform an
# atom selection later
xray_structure = pdb_hierarchy.extract_xray_structure(
crystal_symmetry = cryst1)
if (cryst1 is None) :
cryst1 = xray_structure.crystal_symmetry()
if (miller_array is not None) :
if (miller_array.crystal_symmetry() is None) :
miller_array = miller_array.customized_copy(crystal_symmetry=cryst1)
xray_structure.show_summary(f = log, prefix=" ")
if(len(params.anomalous_scatterers.group) != 0):
pdb_atoms = pdb_hierarchy.atoms()
pdb_atoms.reset_i_seq()
set_fp_fdp_for_anomalous_scatterers(
pdb_hierarchy = pdb_hierarchy,
xray_structure = xray_structure,
anomalous_scatterer_groups = params.anomalous_scatterers.group)
elif (params.wavelength is not None) :
if (params.scattering_table == "neutron") :
raise Sorry("Wavelength parameter not supported when the neutron "+
"scattering table is used.")
print >> log, "Setting inelastic form factors for wavelength = %g" % \
params.wavelength
xray_structure.set_inelastic_form_factors(
photon=params.wavelength,
table="sasaki")
#
validate_params_command_line(params)
#
print >> log, "-"*79
print >> log, "Computing model structure factors, Fmodel:"
if(params.output.format == "cns"): extension = ".hkl"
elif(params.output.format == "mtz"): extension = ".mtz"
ofn = params.output.file_name
if(ofn is None):
ofn = os.path.basename(processed_args.pdb_file_names[0])
if(len(processed_args.pdb_file_names)==1): ofn = ofn + extension
else: ofn = ofn + "_et_al" + extension
if([miller_array, params.high_resolution].count(None)==2):
raise Sorry("Input data file or high_resolution has to be provided.")
mmtbx.utils.fmodel_from_xray_structure(
xray_structure = xray_structure,
f_obs = miller_array,
add_sigmas = params.add_sigmas,
params = params,
twin_law = params.twin_law,
twin_fraction = params.twin_fraction,
out = log).write_to_file(file_name = ofn,
obs_type=params.output.obs_type)
print >> log, "Output file name:", ofn
print >> log, "All done."
print >> log, "-"*79
return ofn
def exercise () :
flex.set_random_seed(123456)
random.seed(123456)
base = "tst_table_one"
pdb_in = iotbx.pdb.hierarchy.input(pdb_string=model_1yjp)
xrs = pdb_in.xray_structure_simple()
xrs.set_inelastic_form_factors(
photon=1.54,
table="sasaki")
fc = abs(xrs.structure_factors(d_min=1.5).f_calc()).average_bijvoet_mates()
fc.set_observation_type_xray_amplitude()
flags = fc.generate_r_free_flags()
mtz = fc.as_mtz_dataset(column_root_label="F",
wavelength=1.54)
mtz.add_miller_array(flags, column_root_label="FreeR_flag")
mtz.mtz_object().write(base + ".mtz")
xrs_p1 = xrs.expand_to_p1()
xrs_p1.shake_sites_in_place(rms_difference=0.1)
fc_p1 = xrs_p1.structure_factors(d_min=1.4).f_calc()
fc_p1_extra = fc_p1.randomize_amplitude_and_phase(amplitude_error=1.0,
phase_error_deg=0,
random_seed=123456)
fc_p1 = abs(fc_p1.concatenate(other=fc_p1_extra)).sort(
by_value="packed_indices")
fc_p1.set_observation_type_xray_amplitude()
sg_p2 = sgtbx.space_group_info("P2")
ic = fc_p1.f_as_f_sq().customized_copy(
space_group_info=sg_p2,
sigmas=flex.double(fc_p1.size(), 10.0))
ic.export_as_scalepack_unmerged(file_name=base + ".sca")
open(base + ".pdb", "w").write(model_1yjp)
args = [
base + ".mtz",
base + ".pdb",
"unmerged_data=%s.sca" % base,
"prefix=tst_table_one_1",
]
table_one.run(args=args, out=null_out(),
use_current_directory_if_not_specified=True)
# now with unmerged data in SHELX format
f = open(base + ".hkl", "w")
ic.export_as_shelx_hklf(file_object=f)
f.close()
args = [
base + ".mtz",
base + ".pdb",
"unmerged_data=%s.hkl=hklf4" % base,
"prefix=tst_table_one_2",
]
table_one.run(args=args, out=null_out(),
use_current_directory_if_not_specified=True)
# now with phil file
f = open("tst_table_one_3.eff", "w")
f.write("""\
table_one {
structure {
name = %(base)s
pdb_file = %(base)s.pdb
mtz_file = %(base)s.mtz
unmerged_data = %(base)s.hkl=hklf4
}
output {
directory = os.getcwd()
base_name = %(base)s_3
}
}""" % {"base" : base })
args = [ "tst_table_one_3.eff" ]
table_one.run(args=args, out=null_out(),
use_current_directory_if_not_specified=True)
obs_refs['id'] = flex.int(len(obs_refs), 0) obs_refs = ref_predictor.predict(obs_refs) # Set 'observed' centroids from the predicted ones obs_refs['xyzobs.mm.value'] = obs_refs['xyzcal.mm'] # Invent some variances for the centroid positions of the simulated data im_width = 0.1 * pi / 180. px_size = mydetector[0].get_pixel_size() var_x = flex.double(len(obs_refs), (px_size[0] / 2.)**2) var_y = flex.double(len(obs_refs), (px_size[1] / 2.)**2) var_phi = flex.double(len(obs_refs), (im_width / 2.)**2) obs_refs['xyzobs.mm.variance'] = flex.vec3_double(var_x, var_y, var_phi) # set the flex random seed to an 'uninteresting' number flex.set_random_seed(12407) # take 5 random reflections for speed reflections = obs_refs.select(flex.random_selection(len(obs_refs), 5)) # use a BlockCalculator to calculate the blocks per image from dials.algorithms.refinement.reflection_manager import BlockCalculator block_calculator = BlockCalculator(experiments, reflections) reflections = block_calculator.per_image() # use a ReflectionManager to exclude reflections too close to the spindle, # plus set the frame numbers from dials.algorithms.refinement.reflection_manager import ReflectionManager refman = ReflectionManager(reflections, experiments, outlier_detector=None)
def exercise_load_unmerged():
flex.set_random_seed(123456)
random.seed(123456)
base = "tst_load_unmerged"
pdb_in = iotbx.pdb.hierarchy.input(pdb_string=model_1yjp)
xrs = pdb_in.xray_structure_simple()
xrs.set_inelastic_form_factors(
photon=1.54,
table="sasaki")
fc = abs(xrs.structure_factors(d_min=1.5).f_calc()).average_bijvoet_mates()
fc.set_observation_type_xray_amplitude()
flags = fc.generate_r_free_flags()
mtz = fc.as_mtz_dataset(column_root_label="F")
mtz.add_miller_array(flags, column_root_label="FreeR_flag")
mtz.mtz_object().write(base + ".mtz")
xrs_p1 = xrs.expand_to_p1()
xrs_p1.shake_sites_in_place(rms_difference=0.1)
fc_p1 = xrs_p1.structure_factors(d_min=1.4).f_calc()
fc_p1_extra = fc_p1.randomize_amplitude_and_phase(amplitude_error=1.0,
phase_error_deg=0,
random_seed=123456)
fc_p1 = abs(fc_p1.concatenate(other=fc_p1_extra)).sort(
by_value="packed_indices")
fc_p1.set_observation_type_xray_amplitude()
sg_p2 = sgtbx.space_group_info("P2")
ic = fc_p1.f_as_f_sq().customized_copy(
space_group_info=sg_p2,
sigmas=flex.double(fc_p1.size(), 10.0))
ic.export_as_scalepack_unmerged(file_name=base + ".sca")
with open(base + ".pdb", "w") as f:
f.write(model_1yjp)
args = [
base + ".mtz",
base + ".pdb",
"unmerged_data=%s.sca" % base,
]
master_phil = mmtbx.command_line.generate_master_phil_with_inputs(
phil_string="",
enable_unmerged_data=True)
cmdline = mmtbx.command_line.load_model_and_data(
args=[ base + ext for ext in [".pdb",".mtz",] ] +
["unmerged_data.file_name=%s.sca" % base ],
master_phil=master_phil,
out=StringIO(),
create_fmodel=False,
process_pdb_file=False,
create_log_buffer=True)
# now with .sca in P1 (raises Sorry)
ic2 = fc_p1.f_as_f_sq().customized_copy(
sigmas=flex.double(fc_p1.size(), 10.0))
ic2.export_as_scalepack_unmerged(file_name=base + "_p1.sca")
args = [
base + ".mtz",
base + ".pdb",
"unmerged_data=%s_p1.sca" % base,
]
try :
cmdline = mmtbx.command_line.load_model_and_data(
args=[ base + ext for ext in [".pdb",".mtz",] ] +
["unmerged_data.file_name=%s_p1.sca" % base ],
master_phil=master_phil,
out=StringIO(),
create_fmodel=False,
process_pdb_file=False,
create_log_buffer=True)
except Sorry as s :
assert (str(s) == "Incompatible space groups in merged and unmerged data:P 1 21 1 versus P 1"), s
else :
raise Exception_expected
# XXX
f = open(base + ".cif", "w")
ic.as_cif_simple(array_type="meas",
out=f)
f.close()
args = [
base + ".mtz",
base + ".pdb",
"unmerged_data=%s.cif" % base,
]
cmdline = mmtbx.command_line.load_model_and_data(
args=[ base + ext for ext in [".pdb",".mtz",] ] +
["unmerged_data.file_name=%s.cif" % base ],
master_phil=master_phil,
out=StringIO(),
create_fmodel=False,
process_pdb_file=False,
create_log_buffer=True)
# bad unit cell
uc2 = uctbx.unit_cell((23,6.5,23.5,90,108,90))
ic3 = ic.customized_copy(unit_cell=uc2)
f = open(base + "_new_uc.cif", "w")
ic3.as_cif_simple(array_type="meas",
out=f)
f.close()
args = [
base + ".mtz",
base + ".pdb",
"unmerged_data=%s_new_uc.cif" % base,
]
try :
cmdline = mmtbx.command_line.load_model_and_data(
args=[ base + ext for ext in [".pdb",".mtz",] ] +
["unmerged_data.file_name=%s_new_uc.cif" % base ],
master_phil=master_phil,
out=StringIO(),
create_fmodel=False,
process_pdb_file=False,
create_log_buffer=True)
except Sorry as s :
assert ("Incompatible symmetry definitions" in str(s)), s
else :
raise Exception_expected
import random
import time
import sys
import mmtbx.f_model
from scitbx.array_family import flex
from libtbx import group_args
import mmtbx.utils
import restraints
import macro_cycle
import mmtbx.command_line
# ase / mopac specific imports
from ase.calculators.mopac import Mopac
if 1:
random.seed(1)
flex.set_random_seed(1)
def get_master_phil():
return mmtbx.command_line.generate_master_phil_with_inputs(
phil_string="""
sf_algorithm = *direct fft
.type = choice(multi=False)
restraints = cctbx *qm
.type = choice(multi=False)
number_of_macro_cycles=50
.type = int
data_weight=None
.type = float
file_out_prefix=None
.type = str
use_convergence_test = True
def manage_random_seed(random_seed):
if(random_seed is None):
random_seed = flex.get_random_seed()
random.seed(random_seed)
flex.set_random_seed(random_seed)
finite_grad_differences_test = True,
use_geometry_restraints = True,
shake_site_mean_distance = 1.5,
d_min = 2)
t.run_test()
t.clean_up_temp_test_files()
def exercise_transformation_refinement():
""" Test transformation refinement """
print 'Running ',sys._getframe().f_code.co_name
t = ncs_minimization_test(
n_macro_cycle = 40,
sites = False,
u_iso = False,
transformations = True,
finite_grad_differences_test = True,
use_geometry_restraints = True,
shake_angles_sigma = 0.032,
shake_translation_sigma = 0.5,
d_min = 2)
t.run_test()
t.clean_up_temp_test_files()
if __name__ == "__main__":
flex.set_random_seed(12345)
random.seed(12345)
exercise_without_geometry_restaints()
exercise_site_refinement()
exercise_u_iso_refinement()
exercise_transformation_refinement()
def run(): random.seed(0) flex.set_random_seed(0) test_rosenbrock_function(1) print "OK"
def exercise () :
random.seed(12345)
flex.set_random_seed(12345)
flags_1 = assign_random_r_free_flags(n_refl=100000, fraction_free=0.05)
assert (flags_1.count(True) == 5000)
flags_1_ccp4 = assign_random_r_free_flags(n_refl=100000, fraction_free=0.05,
format="ccp4")
# XXX this is the best we can do with the current method
assert (flags_1_ccp4.count(0) > 4000) and (flags_1_ccp4.count(0) < 6000)
flags_1_shelx = assign_random_r_free_flags(n_refl=100000, fraction_free=0.05,
format="shelx")
assert (flags_1_shelx.count(-1) == 5000)
flags_2 = assign_r_free_flags_by_shells(n_refl=100000,
fraction_free=0.05,
n_bins=50)
assert (flags_2.count(True) == 5000)
ccp4_flags = export_r_free_flags_for_ccp4(flags_1, True)
assert (ccp4_flags.count(0) == flags_1.count(True))
assert (flex.max(ccp4_flags) == 19)
shelx_flags = export_r_free_flags_for_shelx(flags_1, True)
assert ((shelx_flags==-1).all_eq((ccp4_flags==0)))
flags_3 = assign_random_r_free_flags(n_refl=100000, fraction_free=0.025)
assert (flags_3.count(True) == 2500)
ccp4_flags = export_r_free_flags_for_ccp4(flags_3, True)
assert (ccp4_flags.count(0) == flags_3.count(True))
assert (flex.max(ccp4_flags) == 39)
# now with an actual Miller array
symm = crystal.symmetry(
space_group_info=sgtbx.space_group_info("P212121"),
unit_cell=uctbx.unit_cell((6,7,8,90,90,90)))
set1 = miller.build_set(
crystal_symmetry=symm,
anomalous_flag=True,
d_min=1.0)
flags_4 = set1.generate_r_free_flags()
stats = get_r_free_stats(flags_4, True)
assert (19 <= stats[0] <= 25) # XXX is this even necessary?
# much larger for the last few tests
symm = crystal.symmetry(
space_group_info=sgtbx.space_group_info("P212121"),
unit_cell=uctbx.unit_cell((60,70,80,90,90,90)))
set1 = miller.build_set(
crystal_symmetry=symm,
anomalous_flag=True,
d_min=1.0)
#print set1.indices().size()
flags_5 = set1.generate_r_free_flags(fraction=0.1, max_free=None)
flags_6 = adjust_fraction(flags_5, 0.15, log=null_out())
frac_6 = flags_6.data().count(True) / flags_6.data().size()
assert approx_equal(frac_6, 0.15, eps=0.001)
flags_7 = adjust_fraction(flags_5, 0.05, log=null_out())
frac_7 = flags_7.data().count(True) / flags_7.data().size()
assert approx_equal(frac_7, 0.05, eps=0.001)
n_flipped = 0
for i_hkl, (h,k,l) in enumerate(flags_5.indices()) :
if (i_hkl % 100 == 0) and (h > 0) and (k > 0) and (l > 0) :
flag = flags_5.data()[i_hkl]
if (not flag) :
n_flipped += 1
flags_5.data()[i_hkl] = True
# XXX check this for reproducibility on other systems
#assert (n_flipped == 1559) # setting the random seed should ensure this
try :
flags_8 = flags_5.average_bijvoet_mates()
except Sorry :
pass
else :
raise Exception_expected
out = StringIO()
flags_9 = remediate_mismatches(flags_5, log=out)
# XXX check this for reproducibility on other systems
#assert (out.getvalue() == " 1559 reflections moved to test set\n")
flags_10 = flags_9.average_bijvoet_mates()
def test_fast_mcd_large():
from scitbx.array_family import flex
from dials.algorithms.statistics.fast_mcd import FastMCD
# set random seeds to try to avoid assertion errors due to occasionally
# finding less common solutions
import random
random.seed(42)
flex.set_random_seed(42)
# test large dataset algorithm
import libtbx.load_env # required for libtbx.env.find_in_repositories
if not libtbx.env.has_module("dials_regression"):
print "Skipping test_fast_mcd_large(): dials_regression not available."
return
# load data
import os
dials_regression = libtbx.env.find_in_repositories(
relative_path="dials_regression",
test=os.path.isdir)
data_pth = os.path.join(dials_regression, "refinement_test_data",
"outlier_rejection", "residuals.dat")
with(open(data_pth, "r")) as f:
residuals = f.readlines()
# ignore first line, which is a header
residuals = [[float(val) for val in e.split()] for e in residuals[1:]]
X_resid_mm, Y_resid_mm, Phi_resid_mm = zip(*residuals)
X_resid_mm = flex.double(X_resid_mm)
Y_resid_mm = flex.double(Y_resid_mm)
Phi_resid_mm = flex.double(Phi_resid_mm)
# Fast MCD raw estimates
fast_mcd = FastMCD([X_resid_mm, Y_resid_mm, Phi_resid_mm])
T, S = fast_mcd.get_raw_T_and_S()
from libtbx.test_utils import approx_equal
assert approx_equal(T,
[-0.009702392946856687, 0.008866136837504363, -0.04909037126352747])
assert approx_equal(S, flex.double(
[[0.00527965256891, 0.000864300169087, -0.00145971018701],
[0.000864300169087, 0.00842807897907, -0.00184047321286],
[-0.00145971018701, -0.00184047321286, 0.00698461269031]]))
# Fast MCD corrected estimates
T, S = fast_mcd.get_corrected_T_and_S()
assert approx_equal(T,
[-0.009702392946856687, 0.008866136837504363, -0.04909037126352747])
assert approx_equal(S, flex.double(
[[0.0129950608638, 0.00212734325892, -0.00359285435473],
[0.00212734325892, 0.0207444330604, -0.00453004456394],
[-0.00359285435473, -0.00453004456394, 0.0171915605878]]))
# Correction factors
assert approx_equal(fast_mcd._consistency_fac, 2.45659976388)
assert approx_equal(fast_mcd._finite_samp_fac, 1.00193273884)
print "OK"
return
def exercise_analyze_absences():
"""
Looping over common space groups in macromolecular structures, generate
synthetic data converted to the derived intensity group with absent
reflections present (I=0), and run the analysis to check that the actual
space group is the best-scoring.
"""
# space groups found in structures with data in the PDB as of Sep. 2011,
# minus a few unusual ones
symbols = [
"C 2 2 21",
"P 31 1 2",
"P 62 2 2",
"P 2 3",
"P 3",
"P 1",
"P 63",
"C 1 2 1",
"F 2 2 2",
"A 1 2 1",
"B 1 1 2",
"P 61",
"P 61 2 2",
"P 6 2 2",
"P 2 21 21",
"P 21 21 21",
"R 3 2 :R",
"P 4 3 2",
"P 1 21 1",
"P 32 2 1",
"P 42 2 2",
"P 43 21 2",
"P 21 2 21",
"I 2 3",
"P 43 3 2",
"I 41 3 2",
"P 3 1 2",
"P 2 2 2",
"R 3 :H",
"P 21 21 2",
"P 65 2 2",
"P 21 21 2",
"F 2 3",
"I 41 2 2",
"P 65",
"P 1 1 21",
"P 2 2 21",
"P 4 2 2",
"I 2 2 2",
"I 4 3 2",
"R 3 :R",
"P 4",
"P 42",
"P 64 2 2",
"I 1 2 1",
"P 64",
"C 1 2 1",
"I 41",
"P 63 2 2",
"P 3 2 1",
"P 41 2 2",
"P 62",
"P 1",
"P 32 1 2",
"F 4 3 2",
"P 31 2 1",
"I 4 2 2",
"P 21 3",
"P 43 2 2",
"C 2 2 2",
"P 4 21 2",
"B 2 21 2",
"P 41 21 2",
"P 31",
"P 41",
"P 41 3 2",
"P 32",
"P 6",
"P 1 2 1",
"I 21 3",
"F 41 3 2",
"P 42 3 2",
"P 42 21 2",
"P 43",
"I 21 21 21",
"R 3 2 :H",
"I 4",
]
random.seed(987654321)
flex.set_random_seed(987654321) # 12345)
for symbol in ["P 42 3 2"]: # symbols :
xrs = random_structure.xray_structure(space_group_symbol=symbol, elements=["O"] * 200, n_scatterers=200)
fc = abs(xrs.structure_factors(d_min=1.5).f_calc())
fc.set_observation_type_xray_amplitude()
i_calc = fc.f_as_f_sq()
space_group_info = i_calc.crystal_symmetry().space_group_info()
n_absent = i_calc.sys_absent_flags().data().count(True)
assert n_absent == 0
ig = space_group_info.group().build_derived_reflection_intensity_group(False)
complete_set = i_calc.complete_set()
missing_set = complete_set.lone_set(i_calc)
assert missing_set.size() == 0 # should be complete so far
i_calc_orig = i_calc.deep_copy().customized_copy(sigmas=flex.double(i_calc.size(), 0.01))
symm = i_calc.crystal_symmetry().customized_copy(space_group_info=ig.info())
i_calc = i_calc.customized_copy(crystal_symmetry=symm)
# i_calc.show_summary()
complete_set = i_calc.complete_set()
missing_set = complete_set.lone_set(i_calc) # these are the absences
data = flex.double(missing_set.size(), 0.01)
sys_abs = missing_set.array(data=data)
i_calc = i_calc.concatenate(sys_abs)
sigmas = flex.double(i_calc.size(), 0.01)
i_calc = i_calc.customized_copy(sigmas=sigmas)
i_calc = i_calc.set_observation_type_xray_intensity()
# i_calc is now complete with respect to the derived reflection intensity
# group, with I/sigma=1 for all systematic absences
psgc = protein_space_group_choices(miller_array=i_calc, original_data=i_calc_orig)
table = psgc.suggest_likely_candidates()
min_score = min([row[-1] for row in table])
expected_failures = ["I 4", "I 4 2 2", "P 42 3 2"]
# The actual space group won't always be the first on the list (if the
# absence rules are the same for more than one related space group), but
# it should always have the lowest score. (I think...)
for row in table:
group = row[0]
score = row[-1]
n_abs_viol = int(row[4])
n_pres_viol = int(row[5])
if group == str(space_group_info):
assert n_abs_viol == 0, row
if n_pres_viol != 0:
print group, n_pres_viol
psgc.show()
# XXX Currently this fails for the following space groups:
# I 4
# I 4 2 2
# P 42 3 2
assert (score == min_score) or (str(space_group_info) in expected_failures)
from __future__ import division
from libtbx.test_utils import approx_equal
import mmtbx.f_model
import random, time
from scitbx.array_family import flex
from mmtbx import bulk_solvent
from cctbx import adptbx
from cctbx import sgtbx
from cctbx.development import random_structure
import boost.python
ext = boost.python.import_ext("mmtbx_f_model_ext")
from mmtbx.bulk_solvent import scaler
if(1):
random.seed(0)
flex.set_random_seed(0)
def run_0(symbol = "C 2"):
space_group_info = sgtbx.space_group_info(symbol = symbol)
xrs = random_structure.xray_structure(
space_group_info = space_group_info,
elements = ["N"]*50,
volume_per_atom = 100.0,
random_u_iso = True)
#
b_cart = adptbx.random_traceless_symmetry_constrained_b_cart(
crystal_symmetry=xrs.crystal_symmetry())
u_star = adptbx.u_cart_as_u_star(xrs.unit_cell(), adptbx.b_as_u(b_cart))
#
F = xrs.structure_factors(d_min = 1.5).f_calc()
k_anisotropic = mmtbx.f_model.ext.k_anisotropic(F.indices(), u_star)
def test_fast_mcd_small():
from scitbx.array_family import flex
from dials.algorithms.statistics.fast_mcd import FastMCD
# set random seeds to try to avoid assertion errors due to occasionally
# finding less common solutions
import random
random.seed(42)
flex.set_random_seed(42)
# some test data, from R package robustbase: Hawkins, Bradu, Kass's Artificial Data
hbk = """10.1 19.6 28.3
9.5 20.5 28.9
10.7 20.2 31.0
9.9 21.5 31.7
10.3 21.1 31.1
10.8 20.4 29.2
10.5 20.9 29.1
9.9 19.6 28.8
9.7 20.7 31.0
9.3 19.7 30.3
11.0 24.0 35.0
12.0 23.0 37.0
12.0 26.0 34.0
11.0 34.0 34.0
3.4 2.9 2.1
3.1 2.2 0.3
0.0 1.6 0.2
2.3 1.6 2.0
0.8 2.9 1.6
3.1 3.4 2.2
2.6 2.2 1.9
0.4 3.2 1.9
2.0 2.3 0.8
1.3 2.3 0.5
1.0 0.0 0.4
0.9 3.3 2.5
3.3 2.5 2.9
1.8 0.8 2.0
1.2 0.9 0.8
1.2 0.7 3.4
3.1 1.4 1.0
0.5 2.4 0.3
1.5 3.1 1.5
0.4 0.0 0.7
3.1 2.4 3.0
1.1 2.2 2.7
0.1 3.0 2.6
1.5 1.2 0.2
2.1 0.0 1.2
0.5 2.0 1.2
3.4 1.6 2.9
0.3 1.0 2.7
0.1 3.3 0.9
1.8 0.5 3.2
1.9 0.1 0.6
1.8 0.5 3.0
3.0 0.1 0.8
3.1 1.6 3.0
3.1 2.5 1.9
2.1 2.8 2.9
2.3 1.5 0.4
3.3 0.6 1.2
0.3 0.4 3.3
1.1 3.0 0.3
0.5 2.4 0.9
1.8 3.2 0.9
1.8 0.7 0.7
2.4 3.4 1.5
1.6 2.1 3.0
0.3 1.5 3.3
0.4 3.4 3.0
0.9 0.1 0.3
1.1 2.7 0.2
2.8 3.0 2.9
2.0 0.7 2.7
0.2 1.8 0.8
1.6 2.0 1.2
0.1 0.0 1.1
2.0 0.6 0.3
1.0 2.2 2.9
2.2 2.5 2.3
0.6 2.0 1.5
0.3 1.7 2.2
0.0 2.2 1.6
0.3 0.4 2.6"""
# unpack the data into vectors
rows = [[float(e) for e in row.split()] for row in hbk.splitlines()]
x1, x2, x3 = [flex.double(e) for e in zip(*rows)]
# Fast MCD raw estimates
fast_mcd = FastMCD([x1, x2, x3])
T, S = fast_mcd.get_raw_T_and_S()
from libtbx.test_utils import approx_equal
assert approx_equal(T,
[1.5333333333333334, 2.4564102564102566, 1.6076923076923078])
assert approx_equal(S, flex.double(
[[1.18964912281, 0.00464912280702, 0.217368421053],
[0.00464912280702, 0.37620782726, 0.182186234818],
[0.217368421053, 0.182186234818, 0.910728744939]]))
# Fast MCD corrected estimates
T, S = fast_mcd.get_corrected_T_and_S()
assert approx_equal(T,
[1.5333333333333334, 2.4564102564102566, 1.6076923076923078])
assert approx_equal(S, flex.double(
[[3.17735853174, 0.012417047794, 0.58055555535],
[0.01241704779, 1.00478967011, 0.486589681332],
[0.58055555535, 0.486589681332, 2.43240775146]]))
# Correction factors
assert approx_equal(fast_mcd._consistency_fac, 2.36792847084)
assert approx_equal(fast_mcd._finite_samp_fac, 1.12792118859)
print "OK"
return