def exercise(space_group_info, n_scatterers=8, d_min=2, verbose=0, e_min=1.5): structure = random_structure.xray_structure( space_group_info, elements=["const"] * n_scatterers, volume_per_atom=200, min_distance=3.0, general_positions_only=True, u_iso=0.0, ) if 0 or verbose: structure.show_summary().show_scatterers() f_calc = structure.structure_factors(d_min=d_min, anomalous_flag=False).f_calc() f_obs = abs(f_calc) q_obs = miller.array( miller_set=f_obs, data=f_obs.data() / math.sqrt(f_obs.space_group().order_p() * n_scatterers) / f_obs.space_group().n_ltr(), ) q_obs = q_obs.sort(by_value="abs") q_obs.setup_binner(auto_binning=True) n_obs = q_obs.quasi_normalize_structure_factors() r = flex.linear_regression(q_obs.data(), n_obs.data()) if 0 or verbose: r.show_summary() assert r.is_well_defined() assert abs(r.y_intercept()) < 0.1 assert abs(r.slope() - 1) < 0.2 q_large = q_obs.select(q_obs.quasi_normalized_as_normalized().data() > e_min) if 0 or verbose: print "Number of e-values > %.6g: %d" % (e_min, q_large.size()) other_structure = random_structure.xray_structure( space_group_info, elements=["const"] * n_scatterers, volume_per_atom=200, min_distance=3.0, general_positions_only=True, u_iso=0.0, ) assert other_structure.unit_cell().is_similar_to(structure.unit_cell()) q_calc = q_large.structure_factors_from_scatterers(other_structure, algorithm="direct").f_calc() start = q_large.phase_transfer(q_calc.data()) for selection_fixed in (None, flex.double([random.random() for i in xrange(start.size())]) < 0.4): from_map_data = direct_space_squaring(start, selection_fixed) direct_space_result = start.phase_transfer(phase_source=from_map_data) new_phases = reciprocal_space_squaring(start, selection_fixed, verbose) reciprocal_space_result = start.phase_transfer(phase_source=flex.polar(1, new_phases)) mwpe = direct_space_result.mean_weighted_phase_error(reciprocal_space_result) if 0 or verbose: print "mwpe: %.2f" % mwpe, start.space_group_info() for i, h in enumerate(direct_space_result.indices()): amp_d, phi_d = complex_math.abs_arg(direct_space_result.data()[i], deg=True) amp_r, phi_r = complex_math.abs_arg(reciprocal_space_result.data()[i], deg=True) phase_err = scitbx.math.phase_error(phi_d, phi_r, deg=True) assert phase_err < 1.0 or abs(from_map_data[i]) < 1.0e-6 exercise_truncate(q_large)
def test_grid_step(n_sites = 50, volume_per_atom = 50, d_min = 2.0): grid_step = (0.2,0.4,0.6,0.7,0.9,1.0) for step in grid_step: symmetry = crystal.symmetry(space_group_symbol="P1") structure = random_structure.xray_structure(space_group_info = symmetry.space_group_info(), elements=["C"]*n_sites, volume_per_atom=volume_per_atom, random_u_iso=False) fc = structure.structure_factors(d_min = d_min, anomalous_flag=False, algorithm="fft").f_calc() manager = max_like_non_uniform.ordered_solvent_distribution( structure = structure, fo = fc, grid_step = step) f_water_dist = manager.fcalc_from_distribution() ### check phase compatibility with the symmetry: centrics = f_water_dist.select_centric() if(centrics.indices().size() > 0): ideal = centrics.phase_transfer(centrics) assert flex.max(flex.abs(ideal.data() - centrics.data())) < 1.e-6 ### #print "max = ", flex.max( flex.abs( f_water_dist.data() ) ) #print "min = ", flex.min( flex.abs( f_water_dist.data() ) ) #print "ave = ", flex.mean( flex.abs( f_water_dist.data() ) ) assert flex.max( flex.abs( f_water_dist.data() ) ) < 1.0
def exercise_subtract_continuous_allowed_origin_shifts( space_group_info, use_niggli_cell, n_elements=3): structure = random_structure.xray_structure( space_group_info, elements=["Si"]*n_elements, volume_per_atom=300, min_distance=3., general_positions_only=False) if (use_niggli_cell): structure = structure.niggli_cell() f_obs = abs(structure.structure_factors( d_min=3, algorithm="direct").f_calc()) assert f_obs.indices().size() >= 10 transl = matrix.col(flex.random_double_point_on_sphere()) * 2.345 transl_no_cont = matrix.col( structure.subtract_continuous_allowed_origin_shifts( translation_cart=transl)) transl_cont = transl - transl_no_cont structure_transl = structure.apply_shift( shift=structure.unit_cell().fractionalize(transl_cont), recompute_site_symmetries=True) f_transl = abs(f_obs.structure_factors_from_scatterers( xray_structure=structure_transl, algorithm="direct").f_calc()) assert approx_equal(f_transl.data(), f_obs.data())
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 exercise_xray_structure(use_u_aniso, verbose=0): structure = random_structure.xray_structure( space_group_info=sgtbx.space_group_info("P 31"), elements=["N", "C", "C", "O", "Si"] * 2, volume_per_atom=500, min_distance=2.0, general_positions_only=False, random_u_iso=True, use_u_aniso=use_u_aniso, ) f_abs = abs(structure.structure_factors(anomalous_flag=False, d_min=2, algorithm="direct").f_calc()) for resname in (None, "res"): for fractional_coordinates in (False, True): pdb_file = structure.as_pdb_file( remark="Title", remarks=["Any", "Thing"], fractional_coordinates=fractional_coordinates, resname=resname ) if 0 or verbose: sys.stdout.write(pdb_file) structure_read = iotbx.pdb.input( source_info=None, lines=flex.std_string(pdb_file.splitlines()) ).xray_structure_simple(fractional_coordinates=fractional_coordinates, use_scale_matrix_if_available=False) f_read = abs( f_abs.structure_factors_from_scatterers(xray_structure=structure_read, algorithm="direct").f_calc() ) regression = flex.linear_regression(f_abs.data(), f_read.data()) assert regression.is_well_defined() if 0 or verbose: regression.show_summary() assert approx_equal(regression.slope(), 1, eps=1.0e-2) assert approx_equal(regression.y_intercept(), 0, eps=flex.max(f_abs.data()) * 0.01)
def get_xray_structure_random(space_group_info): xray_structure = random_structure.xray_structure( space_group_info = space_group_info, elements = ["N"]*100, volume_per_atom = 50.0, random_u_iso = True) return xray_structure
def exercise_sdb(verbose=0): structure = random_structure.xray_structure( space_group_info=sgtbx.space_group_info("P 31"), elements=["N","C","C","O"]*2, volume_per_atom=500, min_distance=2., general_positions_only=False, random_u_iso=True) f_abs = abs(structure.structure_factors( anomalous_flag=False, d_min=2, algorithm="direct").f_calc()) sdb_out = structure.as_cns_sdb_file( file="foo.sdb", description="random_structure", comment=["any", "thing"], group="best") if (0 or verbose): sys.stdout.write(sdb_out) sdb_files = sdb_reader.multi_sdb_parser(StringIO(sdb_out)) assert len(sdb_files) == 1 structure_read = sdb_files[0].as_xray_structure( crystal_symmetry=crystal.symmetry( unit_cell=structure.unit_cell(), space_group_info=None)) f_read = abs(f_abs.structure_factors_from_scatterers( xray_structure=structure_read, algorithm="direct").f_calc()) regression = flex.linear_regression(f_abs.data(), f_read.data()) assert regression.is_well_defined() if (0 or verbose): regression.show_summary() assert abs(regression.slope()-1) < 1.e-4 assert abs(regression.y_intercept()) < 1.e-3
def exercise_translational_phase_shift(n_sites=100, d_min=1.5, resolution_factor=0.3): sgi = space_group_info("P1") xrs = random_structure.xray_structure( space_group_info=sgi, elements=(("O", "N", "C") * (n_sites // 3 + 1))[:n_sites], volume_per_atom=50, min_distance=1.5) f_calc = xrs.structure_factors(d_min=d_min).f_calc() print f_calc.unit_cell() from scitbx.matrix import col shift_frac = col((.23984120, .902341127, .51219021)) # Shift phases directly phase_shifted = f_calc.translational_shift(shift_frac=shift_frac) # Check that map from phase_shifted FC matches map calculated from # translated xrs # Map from phase-shifted FC shifted_fft_map = phase_shifted.fft_map( resolution_factor=resolution_factor) shifted_fft_map.apply_sigma_scaling() shifted_map_data = shifted_fft_map.real_map_unpadded() cs = xrs.crystal_symmetry() from cctbx.maptbx import crystal_gridding cg = crystal_gridding(unit_cell=cs.unit_cell(), space_group_info=cs.space_group_info(), pre_determined_n_real=shifted_map_data.all()) # Map from translated xrs sites_shifted = xrs.sites_frac() + shift_frac xrs.set_sites_frac(sites_shifted) f_calc_from_shifted_xrs = xrs.structure_factors(d_min=d_min).f_calc() fft_map_from_shifted_xrs = f_calc_from_shifted_xrs.fft_map( resolution_factor=resolution_factor, crystal_gridding=cg) map_data_from_shifted_xrs = fft_map_from_shifted_xrs.real_map_unpadded() # shifted_map_data (map from phase shifted f_calc), # map_data_from_shifted_xrs (recalculated with shifted xrs) assert shifted_map_data.all() == map_data_from_shifted_xrs.all() from cctbx import maptbx sel = maptbx.grid_indices_around_sites(unit_cell=xrs.unit_cell(), fft_n_real=shifted_map_data.focus(), fft_m_real=shifted_map_data.all(), sites_cart=xrs.sites_cart(), site_radii=flex.double( xrs.scatterers().size(), 1.5)) shifted_map_data = shifted_map_data.select(sel) map_data_from_shifted_xrs = map_data_from_shifted_xrs.select(sel) cc_map_data_from_shifted_xrs_shifted_map_data = flex.linear_correlation( x=map_data_from_shifted_xrs.as_1d(), y=shifted_map_data.as_1d()).coefficient() print "cc_map_data_from_shifted_xrs_shifted_map_data",\ cc_map_data_from_shifted_xrs_shifted_map_data assert cc_map_data_from_shifted_xrs_shifted_map_data > 0.99 print "*" * 25
def run_call_back(flags, space_group_info): d_min = 2.0 structure = random_structure.xray_structure( space_group_info=space_group_info, elements=["N", "C", "O", "S"]*3 + ["Fe"]*2, volume_per_atom=100) if (not space_group_info.group().is_centric()): fp_fdp_targets = [(-1,2), (-2,6)] else: fp_fdp_targets = [(-1,0), (-2,0)] anomalous_scatterer_groups = [ xray.anomalous_scatterer_group( iselection=flex.size_t(), f_prime=fp, f_double_prime=fdp, refine=["f_prime", "f_double_prime"]) for fp,fdp in fp_fdp_targets] for i_seq,scatterer in enumerate(structure.scatterers()): if (scatterer.scattering_type == "S"): anomalous_scatterer_groups[0].iselection.append(i_seq) if (scatterer.scattering_type == "Fe"): anomalous_scatterer_groups[1].iselection.append(i_seq) for group in anomalous_scatterer_groups: group.copy_to_scatterers_in_place(scatterers=structure.scatterers()) if (flags.Verbose): structure.show_summary().show_scatterers() f_obs = abs(structure.structure_factors( d_min=2.0, anomalous_flag=True).f_calc()) if (flags.Verbose): f_obs.show_comprehensive_summary() # for group in anomalous_scatterer_groups: group.f_prime = 0 group.f_double_prime = 0 group.copy_to_scatterers_in_place(scatterers=structure.scatterers()) sfg_params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract() sfg_params.algorithm = "direct" fmodel = mmtbx.f_model.manager( xray_structure=structure, f_obs=f_obs, r_free_flags=f_obs.generate_r_free_flags(), sf_and_grads_accuracy_params = sfg_params, target_name="ls") # n_cycles = [0] def call_back(minimizer): n_cycles[0] += 1 return True minimized = mmtbx.refinement.anomalous_scatterer_groups.minimizer( fmodel=fmodel, groups=anomalous_scatterer_groups, call_back_after_minimizer_cycle=call_back, number_of_finite_difference_tests=3) assert n_cycles == [3] # for group,(fp,fdp) in zip(anomalous_scatterer_groups, fp_fdp_targets): # Large eps because the minimization doesn't reliably converge. # We don't want to exercise the minimizer here, the important # test is the finite difference test embedded in the minimizer. assert approx_equal(group.f_prime, fp, eps=1) assert approx_equal(group.f_double_prime, fdp, eps=1)
def generate_random_f_calc( space_group_info, n_elements=10, d_min=1.5, verbose=0): structure = random_structure.xray_structure( space_group_info, elements=["Si"]*n_elements, volume_per_atom=1000, min_distance=3., general_positions_only=False) if (0 or verbose): structure.show_summary() structure.show_scatterers() print print "Writing tmp.pdb" s = structure.as_pdb_file( remark="random structure", resname="RND") open("tmp.pdb", "w").write(s) if (0 or verbose): print f_calc = structure.structure_factors( d_min=d_min, anomalous_flag=False).f_calc() if (0 or verbose): f_calc.show_summary() print print "Writing: tmp.phs" f_calc.as_phases_phs(out=open("tmp.phs", "w")) if (0 or verbose): print
def test_grid_step(n_sites=50, volume_per_atom=50, d_min=2.0): grid_step = (0.2, 0.4, 0.6, 0.7, 0.9, 1.0) for step in grid_step: symmetry = crystal.symmetry(space_group_symbol="P1") structure = random_structure.xray_structure( space_group_info=symmetry.space_group_info(), elements=["C"] * n_sites, volume_per_atom=volume_per_atom, random_u_iso=False) fc = structure.structure_factors(d_min=d_min, anomalous_flag=False, algorithm="fft").f_calc() manager = max_like_non_uniform.ordered_solvent_distribution( structure=structure, fo=fc, grid_step=step) f_water_dist = manager.fcalc_from_distribution() ### check phase compatibility with the symmetry: centrics = f_water_dist.select_centric() if (centrics.indices().size() > 0): ideal = centrics.phase_transfer(centrics) assert flex.max(flex.abs(ideal.data() - centrics.data())) < 1.e-6 ### #print "max = ", flex.max( flex.abs( f_water_dist.data() ) ) #print "min = ", flex.min( flex.abs( f_water_dist.data() ) ) #print "ave = ", flex.mean( flex.abs( f_water_dist.data() ) ) assert flex.max(flex.abs(f_water_dist.data())) < 1.0
def skewness_calculation(space_group_info, n_test_points=10, n_sites=20, d_min=3, volume_per_atom=200): structure = random_structure.xray_structure( space_group_info=space_group_info, elements=["Se"] * n_sites, volume_per_atom=volume_per_atom, random_u_iso=True) structure.show_summary() print() f_calc = structure.structure_factors(d_min=d_min, anomalous_flag=False).f_calc() f_calc.show_summary() print() for i_fudge_factor in range(n_test_points + 1): fudge_factor = i_fudge_factor / float(n_test_points) randomized_f_calc = randomize_phases(f_calc, fudge_factor) mwpe = f_calc.mean_weighted_phase_error(randomized_f_calc) rho = randomized_f_calc.fft_map().real_map_unpadded() # <(rho-rho_bar)**3>/<(rho-rho_bar)**2>**3/2 rho_rho_bar = rho - flex.mean(rho) num = flex.mean(flex.pow(rho_rho_bar, 3)) den = flex.mean(flex.pow(rho_rho_bar, 2))**(3 / 2.) assert den != 0 skewness = num / den print("fudge factor, phase difference, map skewness:", end=' ') print("%4.2f, %5.2f, %.4g" % (fudge_factor, mwpe, skewness)) print()
def get_xray_structure_random(space_group_info): xray_structure = random_structure.xray_structure( space_group_info=space_group_info, elements=["N"] * 100, volume_per_atom=50.0, random_u_iso=True) return xray_structure
def exercise_2(): xray_structure = random_structure.xray_structure( space_group_info=sgtbx.space_group_info("C 1 2/c 1"), elements=("O", "N", "C") * 50, volume_per_atom=100, min_distance=1.5, general_positions_only=True, random_u_iso=True, random_occupancy=True) xray_structure.scattering_type_registry(table="wk1995") f_obs = abs(xray_structure.structure_factors(d_min=2.0).f_calc()) sfg_params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract() for algorithm in ["fft", "direct"]: flags = f_obs.generate_r_free_flags(fraction=0.1, max_free=99999999) fmodel = mmtbx.f_model.manager(xray_structure=xray_structure, f_obs=f_obs, r_free_flags=flags, sf_and_grads_accuracy_params=sfg_params) f_calc_1 = abs(fmodel.f_calc()).data() f_calc_2 = abs( f_obs.structure_factors_from_scatterers( xray_structure=xray_structure, algorithm=sfg_params.algorithm).f_calc()).data() delta = flex.abs(f_calc_1 - f_calc_2) assert approx_equal(flex.sum(delta), 0.0)
def run(): xrs = random_structure.xray_structure( space_group_info = sgtbx.space_group_info("P1"), elements = ["N"]*500, unit_cell = (20, 30, 40, 70, 80, 120)) xrs = xrs.set_b_iso(value=25) d_mins = [1.5] result = [] for d_min in d_mins: f_obs = abs(xrs.structure_factors(d_min=d_min).f_calc()) f_obs = f_obs.customized_copy(data = f_obs.data() * 135.) shifts = [0.0, 0.3] for xyz_shake_amount in shifts: xrs_shaken = xrs.deep_copy_scatterers() xrs_shaken.shake_sites_in_place(mean_distance = xyz_shake_amount) ml_err = flex.double() ml_err_new = flex.double() for trial in xrange(10): r_free_flags = f_obs.generate_r_free_flags() fmodel = mmtbx.f_model.manager( f_obs = f_obs, r_free_flags = r_free_flags, xray_structure = xrs_shaken) ml_err_ = fmodel.model_error_ml() ml_err.append(ml_err_) result.append(flex.mean(ml_err)) assert result[0] > 0 and result[0] < 0.03 assert result[1] > 0.2 and result[1] <= 0.32
def exercise_01 () : """ Sanity check - don't crash when mean intensity for a bin is zero. """ xrs = random_structure.xray_structure( unit_cell=(50,50,50,90,90,90), space_group_symbol="P1", n_scatterers=1200, elements="random") fc = abs(xrs.structure_factors(d_min=1.5).f_calc()) fc = fc.set_observation_type_xray_amplitude() cs = fc.complete_set(d_min=1.4) ls = cs.lone_set(other=fc) f_zero = ls.array(data=flex.double(ls.size(), 0)) f_zero.set_observation_type_xray_amplitude() fc = fc.concatenate(other=f_zero) sigf = flex.double(fc.size(), 0.1) + (fc.data() * 0.03) fc = fc.customized_copy(sigmas=sigf) try : fc_fc = french_wilson.french_wilson_scale(miller_array=fc, log=null_out()) except Sorry : pass else : raise Exception_expected ic = fc.f_as_f_sq().set_observation_type_xray_intensity() fc_fc = french_wilson.french_wilson_scale(miller_array=ic, log=null_out())
def exercise_centrics(space_group_info, n_sites=10): structure = random_structure.xray_structure( space_group_info=space_group_info, elements=(("O", "N", "C") * (n_sites // 3 + 1))[:n_sites], volume_per_atom=30, min_distance=1) for anomalous_flag in [False, True]: miller_set = miller.build_set(crystal_symmetry=structure, d_min=1, anomalous_flag=anomalous_flag) for shrink_truncation_radius in [0, .5 * 6**.5]: for solvent_radius in [0, .5 * 5**.5]: bulk_solvent_mask = mmtbx.masks.bulk_solvent( xray_structure=structure, grid_step=0.5, ignore_zero_occupancy_atoms=False, solvent_radius=solvent_radius, shrink_truncation_radius=shrink_truncation_radius) f_mask = bulk_solvent_mask.structure_factors( miller_set=miller_set) centrics = f_mask.select_centric() if (centrics.indices().size() > 0): ideal = centrics.phase_transfer(centrics) assert flex.max( flex.abs(ideal.data() - centrics.data())) < 1.e-6
def generate_random_f_calc(space_group_info, n_elements=10, d_min=1.5, verbose=0): structure = random_structure.xray_structure(space_group_info, elements=["Si"] * n_elements, volume_per_atom=1000, min_distance=3., general_positions_only=False) if (0 or verbose): structure.show_summary() structure.show_scatterers() print print "Writing tmp.pdb" s = structure.as_pdb_file(remark="random structure", resname="RND") open("tmp.pdb", "w").write(s) if (0 or verbose): print f_calc = structure.structure_factors(d_min=d_min, anomalous_flag=False).f_calc() if (0 or verbose): f_calc.show_summary() print print "Writing: tmp.phs" f_calc.as_phases_phs(out=open("tmp.phs", "w")) if (0 or verbose): print
def run(): xrs = random_structure.xray_structure( space_group_info=sgtbx.space_group_info("P1"), elements=["N"] * 500, unit_cell=(20, 30, 40, 70, 80, 120)) xrs = xrs.set_b_iso(value=25) d_mins = [1.5] result = [] for d_min in d_mins: f_obs = abs(xrs.structure_factors(d_min=d_min).f_calc()) f_obs = f_obs.customized_copy(data=f_obs.data() * 135.) shifts = [0.0, 0.3] for xyz_shake_amount in shifts: xrs_shaken = xrs.deep_copy_scatterers() xrs_shaken.shake_sites_in_place(mean_distance=xyz_shake_amount) ml_err = flex.double() ml_err_new = flex.double() for trial in range(10): r_free_flags = f_obs.generate_r_free_flags() fmodel = mmtbx.f_model.manager(f_obs=f_obs, r_free_flags=r_free_flags, xray_structure=xrs_shaken) ml_err_ = fmodel.model_error_ml() ml_err.append(ml_err_) result.append(flex.mean(ml_err)) assert result[0] > 0 and result[0] < 0.03 assert result[1] > 0.2 and result[1] <= 0.32
def exercise_3(): from mmtbx import masks from cctbx import sgtbx xs = random_structure.xray_structure( space_group_info=sgtbx.space_group_info("P1"), elements=["C"] * 2, unit_cell=(10, 20, 30, 70, 80, 120)) f_calc = xs.structure_factors(d_min=2.0).f_calc() mp = masks.mask_master_params.extract() mm1 = masks.manager(miller_array=f_calc, xray_structure=xs) assert list(xs.scatterers().extract_occupancies()) == [1.0, 1.0] fmasks1 = mm1.shell_f_masks() assert len(fmasks1) == 1 assert flex.mean(flex.abs(fmasks1[0].data())) > 4.0 # xs.set_occupancies(value=0) mp.ignore_zero_occupancy_atoms = False mp.use_asu_masks = False mm2 = masks.manager(miller_array=f_calc, xray_structure=xs, mask_params=mp) assert list(xs.scatterers().extract_occupancies()) == [0.0, 0.0] fmasks1 = mm1.shell_f_masks() assert len(fmasks1) == 1 fmasks2 = mm2.shell_f_masks() assert len(fmasks2) == 1 assert flex.mean( flex.abs(fmasks1[0].data()) ) == \ flex.mean( flex.abs(fmasks2[0].data()) ) # mp.ignore_zero_occupancy_atoms = True mp.use_asu_masks = False mm3 = masks.manager(miller_array=f_calc, xray_structure=xs, mask_params=mp) assert list(xs.scatterers().extract_occupancies()) == [0.0, 0.0] fmasks3 = mm3.shell_f_masks() assert len(fmasks3) == 1 assert approx_equal( flex.abs(fmasks3[0].data()).min_max_mean().as_tuple(), (0.0, 0.0, 0.0))
def exercise_ellipsoidal_truncation(space_group_info, n_sites=100, d_min=1.5): xrs = random_structure.xray_structure( space_group_info=space_group_info, elements=(("O", "N", "C") * (n_sites // 3 + 1))[:n_sites], volume_per_atom=50, min_distance=1.5, ) f_obs = abs(xrs.structure_factors(d_min=d_min).f_calc()) # exercise reciprocal_space_vector() for mi, d in zip(f_obs.indices(), f_obs.d_spacings().data()): rsv = flex.double(f_obs.unit_cell().reciprocal_space_vector(mi)) assert approx_equal(d, 1.0 / math.sqrt(rsv.dot(rsv))) ## print f_obs.unit_cell() f = flex.random_double(f_obs.data().size()) * flex.mean(f_obs.data()) / 10 # f_obs1 = f_obs.customized_copy(data=f_obs.data(), sigmas=f_obs.data() * f) print "datat in:", f_obs1.data().size() r = f_obs1.ellipsoidal_truncation_by_sigma(sigma_cutoff=1) print "data left:", r.data().size() r.miller_indices_as_pdb_file(file_name="indices1.pdb", expand_to_p1=False) r.miller_indices_as_pdb_file(file_name="indices2.pdb", expand_to_p1=True) # f_obs.miller_indices_as_pdb_file(file_name="indices3.pdb", expand_to_p1=False) f_obs.miller_indices_as_pdb_file(file_name="indices4.pdb", expand_to_p1=True) print "*" * 25
def get_random_structure_and_map( use_static_structure=False, random_seed=171413, ): if use_static_structure: mmm = map_model_manager() mmm.generate_map() return group_args(model=mmm.model(), mm=mmm.map_manager()) import random random.seed(random_seed) i = random.randint(1, 714717) flex.set_random_seed(i) xrs = random_structure.xray_structure( space_group_info=space_group_info(19), volume_per_atom=25., elements=('C', 'N', 'O', 'H') * 10, min_distance=1.5) fc = xrs.structure_factors(d_min=2).f_calc() fft_map = fc.fft_map(resolution_factor=0.25) fft_map.apply_volume_scaling() ph = iotbx.pdb.input(source_info=None, lines=xrs.as_pdb_file()).construct_hierarchy() ph.atoms().set_xyz(xrs.sites_cart()) map_data = fft_map.real_map_unpadded() mm = map_manager(unit_cell_grid=map_data.accessor().all(), unit_cell_crystal_symmetry=fc.crystal_symmetry(), origin_shift_grid_units=(0, 0, 0), map_data=map_data) model = mmtbx.model.manager(model_input=None, pdb_hierarchy=ph, crystal_symmetry=fc.crystal_symmetry()) return group_args(model=model, mm=mm)
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_xray_structure(use_u_aniso, verbose=0): structure = random_structure.xray_structure( space_group_info=sgtbx.space_group_info("P 31"), elements=["N","C","C","O","Si"]*2, volume_per_atom=500, min_distance=2., general_positions_only=False, random_u_iso=True, use_u_aniso=use_u_aniso) f_abs = abs(structure.structure_factors( anomalous_flag=False, d_min=2, algorithm="direct").f_calc()) for resname in (None, "res"): for fractional_coordinates in (False, True): pdb_file = structure.as_pdb_file( remark="Title", remarks=["Any", "Thing"], fractional_coordinates=fractional_coordinates, resname=resname) if (0 or verbose): sys.stdout.write(pdb_file) structure_read = iotbx.pdb.input( source_info=None, lines=flex.std_string(pdb_file.splitlines())).xray_structure_simple( fractional_coordinates=fractional_coordinates, use_scale_matrix_if_available=False) f_read = abs(f_abs.structure_factors_from_scatterers( xray_structure=structure_read, algorithm="direct").f_calc()) regression = flex.linear_regression(f_abs.data(), f_read.data()) assert regression.is_well_defined() if (0 or verbose): regression.show_summary() assert approx_equal(regression.slope(), 1, eps=1.e-2) assert approx_equal( regression.y_intercept(), 0, eps=flex.max(f_abs.data())*0.01)
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 exercise(flags, space_group_info): # Prepare a structure compatible with the ShelX model xs = random_structure.xray_structure(space_group_info, elements="random", n_scatterers=10, use_u_iso=True, random_u_iso=True, use_u_aniso=True) xs.apply_symmetry_sites() xs.apply_symmetry_u_stars() for isotropic, sc in itertools.izip(variate(bernoulli_distribution(0.4)), xs.scatterers()): sc.flags.set_grad_site(True) if isotropic: sc.flags.set_use_u_iso(True) sc.flags.set_use_u_aniso(False) sc.flags.set_grad_u_iso(True) else: sc.flags.set_use_u_iso(False) sc.flags.set_use_u_aniso(True) sc.flags.set_grad_u_aniso(True) not_origin_centric = (xs.space_group().is_centric() and not xs.space_group().is_origin_centric()) try: ins = list( shelx.writer.generator(xs, full_matrix_least_squares_cycles=4, weighting_scheme_params=(0, 0), sort_scatterers=False)) except AssertionError: if (not_origin_centric): print( "Omitted %s\n because it is centric but not origin centric" % xs.space_group().type().hall_symbol()) return raise else: if (not_origin_centric): raise Exception_expected ins = cStringIO.StringIO("".join(ins)) xs1 = xs.from_shelx(file=ins) xs.crystal_symmetry().is_similar_symmetry(xs1.crystal_symmetry(), relative_length_tolerance=1e-3, absolute_angle_tolerance=1e-3) uc = xs.unit_cell() uc1 = xs1.unit_cell() for sc, sc1 in itertools.izip(xs.scatterers(), xs1.scatterers()): assert sc.label.upper() == sc1.label.upper() assert sc.scattering_type == sc1.scattering_type assert sc.flags.bits == sc1.flags.bits assert approx_equal(sc.site, sc1.site, eps=1e-6) if sc.flags.use_u_iso(): assert approx_equal(sc.u_iso, sc1.u_iso, eps=1e-5) else: assert approx_equal(adptbx.u_star_as_u_cif(uc, sc.u_star), adptbx.u_star_as_u_cif(uc1, sc1.u_star), eps=1e-5)
def randomly_exercise( flipping_type, space_group_info, elements, anomalous_flag, d_min, grid_resolution_factor=1.0 / 2, verbose=False, amplitude_type="F", ): # Generate a random structure in real space, that we will try to recover target_structure = random_structure.xray_structure( space_group_info=space_group_info, elements=elements, use_u_iso=True, random_u_iso=True, random_u_iso_scale=0.04, use_u_aniso=False, ) exercise_one_structure( target_structure, flipping_type, anomalous_flag, d_min, grid_resolution_factor=grid_resolution_factor, verbose=verbose, amplitude_type=amplitude_type, )
def __init__(self, model_id="SBT", n_elements=4): if (model_id is None): return self.model_id = model_id pos = emma.position if (type(model_id) == type("")): if (model_id == "SBT"): emma.model.__init__( self, crystal.special_position_settings( crystal.symmetry((16.8986, 16.8986, 16.8986, 61.1483, 61.1483, 61.1483), "R -3 m :R")), (pos("SI1", (-0.3584, 0.2844, 0.4622)), pos("SI2", (-0.2133, 0.9659, -0.6653)), pos("SI3", (-0.8358, 0.7, 0.3431)), pos("SI4", (0.4799, 1.836, 0.6598)))) else: raise RuntimeError("Unknown model_id: " + model_id) else: structure = random_structure.xray_structure(model_id, elements=["S"] * n_elements, volume_per_atom=50., min_distance=2.0) positions = [] for scatterer in structure.scatterers(): positions.append(emma.position(scatterer.label, scatterer.site)) emma.model.__init__(self, structure, positions)
def exercise_01(grid_step = 0.03, d_min = 1.0, wing_cutoff = 1.e-9): xrs = random_structure.xray_structure( space_group_info = sgtbx.space_group_info("P 1"), elements = ["O","N","C","P","S","U","AU"]*1, random_u_iso = True, general_positions_only = False) # avoid excessive_range_error_limit crash bs = xrs.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1) sel = bs < 1 bs = bs.set_selected(sel, 1) xrs.set_b_iso(values = bs) # p = xrs.unit_cell().parameters() timer = user_plus_sys_time() res = manager(nx = int(p[0]/grid_step), ny = int(p[1]/grid_step), nz = int(p[2]/grid_step), scattering_type_registry = xrs.scattering_type_registry(), unit_cell = xrs.unit_cell(), scatterers = xrs.scatterers(), wing_cutoff = wing_cutoff) print "time: %10.4f" % (timer.elapsed()) f_calc_dir = xrs.structure_factors( d_min = d_min, algorithm = "direct").f_calc() # f_calc_den = f_calc_dir.structure_factors_from_map(map = res.density_array, use_scale = True) f1 = flex.abs(f_calc_dir.data()) f2 = flex.abs(f_calc_den.data()) r = flex.sum(flex.abs(f1-f2))/flex.sum(f2) print "r-factor:", r assert r < 1.e-4, r
def random_structure(self, crystal): """We're going to do some very approximate stuff here. Given a unit cell & SG, will put typical atomic contents in the unit cell & get structure factors. """ import random random.seed(0) from scitbx.array_family import flex flex.set_random_seed(0) from cctbx.development import random_structure uc_volume = crystal.get_unit_cell().volume() asu_volume = uc_volume / crystal.get_space_group().order_z() target_number_scatterers = int( asu_volume ) // 128 # Very approximate rule of thumb for proteins with ~50% solvent content element_unit = ['O'] * 19 + ['N'] * 18 + ['C'] * 62 + ['S'] * 1 + [ 'Fe' ] * 1 element_pallet = element_unit * ( 1 + (target_number_scatterers // len(element_unit))) assert len(element_pallet) >= target_number_scatterers # Ersatz hard limit to prevent excessive execution time of xray_structure() below. elements = element_pallet[:min(1000, target_number_scatterers)] xs = random_structure.xray_structure( space_group_info=crystal.get_space_group().info(), unit_cell=crystal.get_unit_cell(), elements=elements, min_distance=1.2) self.xs = xs
def exercise_sdb(verbose=0): structure = random_structure.xray_structure( space_group_info=sgtbx.space_group_info("P 31"), elements=["N", "C", "C", "O"] * 2, volume_per_atom=500, min_distance=2., general_positions_only=False, random_u_iso=True) f_abs = abs( structure.structure_factors(anomalous_flag=False, d_min=2, algorithm="direct").f_calc()) sdb_out = structure.as_cns_sdb_file(file="foo.sdb", description="random_structure", comment=["any", "thing"], group="best") if (0 or verbose): sys.stdout.write(sdb_out) sdb_files = sdb_reader.multi_sdb_parser(StringIO(sdb_out)) assert len(sdb_files) == 1 structure_read = sdb_files[0].as_xray_structure( crystal_symmetry=crystal.symmetry(unit_cell=structure.unit_cell(), space_group_info=None)) f_read = abs( f_abs.structure_factors_from_scatterers(xray_structure=structure_read, algorithm="direct").f_calc()) regression = flex.linear_regression(f_abs.data(), f_read.data()) assert regression.is_well_defined() if (0 or verbose): regression.show_summary() assert abs(regression.slope() - 1) < 1.e-4 assert abs(regression.y_intercept()) < 1.e-3
def exercise_ellipsoidal_truncation(space_group_info, n_sites=100, d_min=1.5): xrs = random_structure.xray_structure( space_group_info=space_group_info, elements=(("O", "N", "C") * (n_sites // 3 + 1))[:n_sites], volume_per_atom=50, min_distance=1.5) f_obs = abs(xrs.structure_factors(d_min=d_min).f_calc()) # exercise reciprocal_space_vector() for mi, d in zip(f_obs.indices(), f_obs.d_spacings().data()): rsv = flex.double(f_obs.unit_cell().reciprocal_space_vector(mi)) assert approx_equal(d, 1. / math.sqrt(rsv.dot(rsv))) ## print f_obs.unit_cell() f = flex.random_double(f_obs.data().size()) * flex.mean(f_obs.data()) / 10 # f_obs1 = f_obs.customized_copy(data=f_obs.data(), sigmas=f_obs.data() * f) print "datat in:", f_obs1.data().size() r = f_obs1.ellipsoidal_truncation_by_sigma(sigma_cutoff=1) print "data left:", r.data().size() r.miller_indices_as_pdb_file(file_name="indices1.pdb", expand_to_p1=False) r.miller_indices_as_pdb_file(file_name="indices2.pdb", expand_to_p1=True) # f_obs.miller_indices_as_pdb_file(file_name="indices3.pdb", expand_to_p1=False) f_obs.miller_indices_as_pdb_file(file_name="indices4.pdb", expand_to_p1=True) print "*" * 25
def __init__(self, model_id="SBT", n_elements=4): if (model_id is None): return self.model_id = model_id pos = emma.position if (type(model_id) == type("")): if (model_id == "SBT"): emma.model.__init__(self, crystal.special_position_settings(crystal.symmetry( (16.8986, 16.8986, 16.8986, 61.1483, 61.1483, 61.1483), "R -3 m :R")), (pos("SI1", (-0.3584, 0.2844, 0.4622)), pos("SI2", (-0.2133, 0.9659, -0.6653)), pos("SI3", (-0.8358, 0.7, 0.3431)), pos("SI4", (0.4799, 1.836, 0.6598)))) else: raise RuntimeError, "Unknown model_id: " + model_id else: structure = random_structure.xray_structure( model_id, elements=["S"]*n_elements, volume_per_atom=50., min_distance=2.0) positions = [] for scatterer in structure.scatterers(): positions.append(emma.position(scatterer.label, scatterer.site)) emma.model.__init__(self, structure, positions)
def exercise_writer(space_group_info, n_sites=100, d_min=1.5): if op.isfile("tst_iotbx_dsn6.omap"): os.remove("tst_iotbx_dsn6.omap") xrs = random_structure.xray_structure( space_group_info=space_group_info, elements=(("O", "N", "C") * (n_sites // 3 + 1))[:n_sites], volume_per_atom=50, min_distance=1.5) fc = xrs.structure_factors(d_min=d_min).f_calc() fft_map = fc.fft_map(resolution_factor=1 / 3).apply_sigma_scaling() n_real = fft_map.n_real() n_blocks = iceil(n_real[0] / 8) * iceil(n_real[1] / 8) * iceil( n_real[2] / 8) fft_map.as_dsn6_map(file_name="tst_iotbx_dsn6.omap") assert op.isfile("tst_iotbx_dsn6.omap") size = op.getsize("tst_iotbx_dsn6.omap") assert (size == (n_blocks + 1) * 512) os.remove("tst_iotbx_dsn6.omap") fft_map.as_dsn6_map(file_name="tst_iotbx_dsn6.omap", gridding_first=[-5, -5, -5], gridding_last=n_real) n_blocks = iceil(1 + n_real[0] / 8) * iceil(1 + n_real[1] / 8) * iceil(1 + n_real[2] / 8) size = op.getsize("tst_iotbx_dsn6.omap") assert (size == (n_blocks + 1) * 512)
def exercise(space_group_info, anomalous_flag, n_scatterers=8, d_min=2, verbose=0): structure = random_structure.xray_structure( space_group_info, elements=["const"]*n_scatterers) f_calc = structure.structure_factors( d_min=d_min, anomalous_flag=anomalous_flag).f_calc() f = abs(f_calc) f = miller.array(miller_set=f, data=f.data(), sigmas=flex.sqrt(f.data())) f = f.f_as_f_sq() g = f.expand_to_p1() merger_p1 = xray.merger( g.indices(), g.data(), g.sigmas(), g.space_group(), g.anomalous_flag(), g.unit_cell() ) p1_bic = merger_p1.bic() p1_r = merger_p1.r_abs() merger_nat = xray.merger( g.indices(), g.data(), g.sigmas(), f.space_group(), g.anomalous_flag(), g.unit_cell() ) nat_bic = merger_nat.bic() nat_r = merger_nat.r_abs() assert nat_bic >= p1_bic assert p1_r <= 1e-8
def test_less_one(space_group_info, volume_per_atom=100, d_min=1.8): #symmetry = crystal.symmetry(space_group_symbol="p212121") #space_group_info = symmetry.space_group_info() #n_sym = space_group_info.type().group().n_smx() for n_atoms in (1, 10): if (n_atoms == 1): denom = 16.0 else: denom = 4.0 for element in ("C", "O", "N"): structure = random_structure.xray_structure( space_group_info=space_group_info, elements=[element] * n_atoms, volume_per_atom=volume_per_atom, random_u_iso=False) fc = structure.structure_factors(d_min=d_min, anomalous_flag=False, algorithm="fft").f_calc() manager = max_like_non_uniform.ordered_solvent_distribution( structure=structure, fo=fc, grid_step=fc.d_min() / denom) f_water_dist = manager.fcalc_from_distribution() ### check phase compatibility with the symmetry: centrics = f_water_dist.select_centric() if (centrics.indices().size() > 0): ideal = centrics.phase_transfer(centrics) assert flex.max( flex.abs(ideal.data() - centrics.data())) < 1.e-6 ### #print "max = ", flex.max( flex.abs( f_water_dist.data() ) ) #print "min = ", flex.min( flex.abs( f_water_dist.data() ) ) #print "ave = ", flex.mean( flex.abs( f_water_dist.data() ) ) assert flex.max(flex.abs(f_water_dist.data())) < 1.0
def skewness_calculation(space_group_info, n_test_points=10, n_sites=20, d_min=3, volume_per_atom=200): structure = random_structure.xray_structure( space_group_info=space_group_info, elements=["Se"]*n_sites, volume_per_atom=volume_per_atom, random_u_iso=True) structure.show_summary() print f_calc = structure.structure_factors( d_min=d_min, anomalous_flag=False).f_calc() f_calc.show_summary() print for i_fudge_factor in xrange(n_test_points+1): fudge_factor = i_fudge_factor/float(n_test_points) randomized_f_calc = randomize_phases(f_calc, fudge_factor) mwpe = f_calc.mean_weighted_phase_error(randomized_f_calc) rho = randomized_f_calc.fft_map().real_map_unpadded() # <(rho-rho_bar)**3>/<(rho-rho_bar)**2>**3/2 rho_rho_bar = rho - flex.mean(rho) num = flex.mean(flex.pow(rho_rho_bar, 3)) den = flex.mean(flex.pow(rho_rho_bar, 2))**(3/2.) assert den != 0 skewness = num / den print "fudge factor, phase difference, map skewness:", print "%4.2f, %5.2f, %.4g" % (fudge_factor, mwpe, skewness) print
def exercise_01(): """ Sanity check - don't crash when mean intensity for a bin is zero. """ xrs = random_structure.xray_structure(unit_cell=(50, 50, 50, 90, 90, 90), space_group_symbol="P1", n_scatterers=1200, elements="random") fc = abs(xrs.structure_factors(d_min=1.5).f_calc()) fc = fc.set_observation_type_xray_amplitude() cs = fc.complete_set(d_min=1.4) ls = cs.lone_set(other=fc) f_zero = ls.array(data=flex.double(ls.size(), 0)) f_zero.set_observation_type_xray_amplitude() fc = fc.concatenate(other=f_zero) sigf = flex.double(fc.size(), 0.1) + (fc.data() * 0.03) fc = fc.customized_copy(sigmas=sigf) try: fc_fc = french_wilson.french_wilson_scale(miller_array=fc, log=null_out()) except Sorry: pass else: raise Exception_expected ic = fc.f_as_f_sq().set_observation_type_xray_intensity() fc_fc = french_wilson.french_wilson_scale(miller_array=ic, log=null_out())
def exercise(flags, space_group_info, n_sampled): symbol = space_group_info.type().hall_symbol() print symbol, if flags.fix_seed: random.seed(0) if not flags.include_high_symmetry: if space_group_info.group().order_p() > 8: if len(symbol) > 15: print print " [ Omitted, rerun with --include_high_symmetry to override ]" return print n = int(flags.repeats) if n == 0: n = 1 progress = progress_displayed_as_fraction(n) for i in xrange(n): xs = random_structure.xray_structure( space_group_info=space_group_info, elements=['C']*5 + ['O']*2 + ['N'], use_u_iso=True, random_u_iso=True, random_u_iso_scale=0.04, use_u_aniso=False) f_c = miller.build_set( xs, anomalous_flag=False, d_min=0.8 ).structure_factors_from_scatterers( xs, algorithm='direct').f_calc() f_o = f_c.as_amplitude_array() f_c_in_p1 = f_c.expand_to_p1() exercise_value(f_c_in_p1, f_o, flags, n_sampled) exercise_gradient(f_c_in_p1, f_o, flags, n_sampled) progress.advance() progress.done()
def run(): structure = random_structure.xray_structure( sgtbx.space_group_info("P21/c"), elements=["Si"]*10, volume_per_atom=18.6, min_distance=1.2, general_positions_only=False) miller_set_f_obs = miller.build_set( crystal_symmetry=structure, anomalous_flag=True, d_min=0.8) f_obs = miller_set_f_obs.structure_factors_from_scatterers( xray_structure=structure, algorithm="direct").f_calc() fft_map = f_obs.fft_map(symmetry_flags=maptbx.use_space_group_symmetry) padded = fft_map.real_map() unpadded = fft_map.real_map_unpadded() # copy unpadded_1d = unpadded.as_1d() # 1D view => in-place mmm = flex.min_max_mean_double(unpadded_1d) for delta in ((mmm.min + mmm.mean)/2, mmm.mean, (mmm.mean + mmm.max)/2): # in-place charge flipping ab_initio.ext.flip_charges_in_place(padded, delta) # same but on an unpadded copy using the flex tools flipped_selection = unpadded_1d < delta flipped = unpadded_1d.select(flipped_selection) flipped *= -1 unpadded_1d.set_selected(flipped_selection, flipped) assert approx_equal(padded, unpadded, 1e-15) print format_cpu_times()
def random_f_calc(space_group_info, n_scatterers, d_min, anomalous_flag, verbose=0): if (anomalous_flag and space_group_info.group().is_centric()): return None structure = random_structure.xray_structure(space_group_info, elements=["const"] * n_scatterers, volume_per_atom=500, min_distance=2., general_positions_only=True) if (0 or verbose): structure.show_summary().show_scatterers() f_calc = structure.structure_factors( d_min=d_min, anomalous_flag=anomalous_flag).f_calc() f_calc = miller.array(miller_set=f_calc, data=f_calc.data() / flex.mean(flex.abs(f_calc.data()))) if (f_calc.anomalous_flag()): selection = flex.bool(f_calc.indices().size(), True) for i in xrange(f_calc.indices().size() // 10): j = random.randrange(f_calc.indices().size()) selection[j] = False f_calc = f_calc.select(selection) return f_calc
def exercise_subtract_continuous_allowed_origin_shifts(space_group_info, use_niggli_cell, n_elements=3): structure = random_structure.xray_structure(space_group_info, elements=["Si"] * n_elements, volume_per_atom=300, min_distance=3., general_positions_only=False) if (use_niggli_cell): structure = structure.niggli_cell() f_obs = abs( structure.structure_factors(d_min=3, algorithm="direct").f_calc()) assert f_obs.indices().size() >= 10 transl = matrix.col(flex.random_double_point_on_sphere()) * 2.345 transl_no_cont = matrix.col( structure.subtract_continuous_allowed_origin_shifts( translation_cart=transl)) transl_cont = transl - transl_no_cont structure_transl = structure.apply_shift( shift=structure.unit_cell().fractionalize(transl_cont), recompute_site_symmetries=True) f_transl = abs( f_obs.structure_factors_from_scatterers( xray_structure=structure_transl, algorithm="direct").f_calc()) assert approx_equal(f_transl.data(), f_obs.data())
def exercise(flags, space_group_info, n_sampled): symbol = space_group_info.type().hall_symbol() print symbol, if flags.fix_seed: random.seed(0) if not flags.include_high_symmetry: if space_group_info.group().order_p() > 8: if len(symbol) > 15: print print " [ Omitted, rerun with --include_high_symmetry to override ]" return print n = int(flags.repeats) if n == 0: n = 1 progress = progress_displayed_as_fraction(n) for i in xrange(n): xs = random_structure.xray_structure(space_group_info=space_group_info, elements=['C'] * 5 + ['O'] * 2 + ['N'], use_u_iso=True, random_u_iso=True, random_u_iso_scale=0.04, use_u_aniso=False) f_c = miller.build_set(xs, anomalous_flag=False, d_min=0.8).structure_factors_from_scatterers( xs, algorithm='direct').f_calc() f_o = f_c.as_amplitude_array() f_c_in_p1 = f_c.expand_to_p1() exercise_value(f_c_in_p1, f_o, flags, n_sampled) exercise_gradient(f_c_in_p1, f_o, flags, n_sampled) progress.advance() progress.done()
def exercise(space_group_info, anomalous_flag=False, d_min=2., verbose=0): sg_fcalc = random_structure.xray_structure( space_group_info, elements=("N", "C", "C", "O"), random_f_double_prime=anomalous_flag, random_u_iso=True, random_occupancy=True ).structure_factors( anomalous_flag=anomalous_flag, d_min=d_min, algorithm="direct").f_calc() sg_hl = generate_random_hl(sg_fcalc) write_cns_input(sg_fcalc, sg_hl.data()) try: os.unlink("tmp_sg.hkl") except OSError: pass try: os.unlink("tmp_p1.hkl") except OSError: pass easy_run.fully_buffered(command="cns < tmp.cns > tmp.out") \ .raise_if_errors_or_output() sg_cns = read_reflection_arrays("tmp_sg.hkl", anomalous_flag, verbose) p1_cns = read_reflection_arrays("tmp_p1.hkl", anomalous_flag, verbose) verify(sg_fcalc, sg_hl.data(), sg_cns, p1_cns) if (anomalous_flag): hl_merged = sg_hl.average_bijvoet_mates() fc_merged = sg_fcalc.average_bijvoet_mates() write_cns_input(sg_fcalc, sg_hl.data(), test_merge=True) try: os.unlink("tmp_merged.hkl") except OSError: pass easy_run.fully_buffered(command="cns < tmp.cns > tmp.out") \ .raise_if_errors_or_output() reflection_file = reflection_reader.cns_reflection_file( open("tmp_merged.hkl")) if (not sg_fcalc.space_group().is_centric()): fc_merged_cns = reflection_file.reciprocal_space_objects["FCALC"] fc_merged_cns = fc_merged.customized_copy( indices=fc_merged_cns.indices, data=fc_merged_cns.data).map_to_asu().common_set(fc_merged) assert fc_merged_cns.indices().all_eq(fc_merged.indices()) fc_merged_a = fc_merged.select_acentric() fc_merged_cns_a = fc_merged_cns.select_acentric() for part in [flex.real, flex.imag]: cc = flex.linear_correlation( part(fc_merged_a.data()), part(fc_merged_cns_a.data())).coefficient() if (cc < 1-1.e-6): print "FAILURE acentrics", sg_fcalc.space_group_info() if (0): return raise AssertionError names, miller_indices, hl = reflection_file.join_hl_group() assert names == ["PA", "PB", "PC", "PD"] hl_merged_cns = hl_merged.customized_copy(indices=miller_indices, data=hl)\ .map_to_asu().common_set(hl_merged) assert hl_merged_cns.indices().all_eq(hl_merged.indices()) for h,a,b in zip(hl_merged.indices(), hl_merged.data(), hl_merged_cns.data()): if (not approx_equal(a, b, eps=5.e-3)): print h print "cctbx:", a print " cns:", b if (0): return raise AssertionError
def run(): structure = random_structure.xray_structure( sgtbx.space_group_info("P21/c"), elements=["Si"] * 10, volume_per_atom=18.6, min_distance=1.2, general_positions_only=False) miller_set_f_obs = miller.build_set(crystal_symmetry=structure, anomalous_flag=True, d_min=0.8) f_obs = miller_set_f_obs.structure_factors_from_scatterers( xray_structure=structure, algorithm="direct").f_calc() fft_map = f_obs.fft_map(symmetry_flags=maptbx.use_space_group_symmetry) padded = fft_map.real_map() unpadded = fft_map.real_map_unpadded() # copy unpadded_1d = unpadded.as_1d() # 1D view => in-place mmm = flex.min_max_mean_double(unpadded_1d) for delta in ((mmm.min + mmm.mean) / 2, mmm.mean, (mmm.mean + mmm.max) / 2): # in-place charge flipping ab_initio.ext.flip_charges_in_place(padded, delta) # same but on an unpadded copy using the flex tools flipped_selection = unpadded_1d < delta flipped = unpadded_1d.select(flipped_selection) flipped *= -1 unpadded_1d.set_selected(flipped_selection, flipped) assert approx_equal(padded, unpadded, 1e-15) print(format_cpu_times())
def run_call_back(flags, space_group_info, params): structure_shake = random_structure.xray_structure( space_group_info, elements=("N", "C", "O", "S", "Yb"), volume_per_atom=200, min_distance=2.0, general_positions_only=params.general_positions_only, random_u_iso=True) structure_ideal = structure_shake.deep_copy_scatterers() structure_shake.shake_sites_in_place( rms_difference=params.shake_sites_rmsd) structure_shake.shake_adp(spread=params.shake_adp_spread) # run_id = "" if (params.pickle_root_name is not None): run_id += params.pickle_root_name + "_" run_id += str(space_group_info).replace(" ", "").replace("/", "_").lower() if (params.pickle_root_name is not None): pickle_file_name = run_id + "_ideal_shake.pickle" print "writing file:", pickle_file_name easy_pickle.dump(file_name=pickle_file_name, obj=(structure_ideal, structure_shake)) print sys.stdout.flush() # ls_result = run_refinement(structure_ideal=structure_ideal, structure_shake=structure_shake, params=params, run_id=run_id) if (ls_result is not None and params.pickle_root_name is not None): pickle_file_name = run_id + "_ls_history.pickle" print "writing file:", pickle_file_name easy_pickle.dump(file_name=pickle_file_name, obj=ls_result.history) print sys.stdout.flush()
def exercise(space_group_info, anomalous_flag, n_scatterers=8, d_min=2, verbose=0): structure = random_structure.xray_structure(space_group_info, elements=["const"] * n_scatterers) f_calc = structure.structure_factors( d_min=d_min, anomalous_flag=anomalous_flag).f_calc() f = abs(f_calc) f = miller.array(miller_set=f, data=f.data(), sigmas=flex.sqrt(f.data())) f = f.f_as_f_sq() g = f.expand_to_p1() merger_p1 = xray.merger(g.indices(), g.data(), g.sigmas(), g.space_group(), g.anomalous_flag(), g.unit_cell()) p1_bic = merger_p1.bic() p1_r = merger_p1.r_abs() merger_nat = xray.merger(g.indices(), g.data(), g.sigmas(), f.space_group(), g.anomalous_flag(), g.unit_cell()) nat_bic = merger_nat.bic() nat_r = merger_nat.r_abs() assert nat_bic >= p1_bic assert p1_r <= 1e-8
def randomly_exercise( flipping_type, space_group_info, elements, anomalous_flag, d_min, grid_resolution_factor=1. / 2, verbose=False, amplitude_type="F", ): # Generate a random structure in real space, that we will try to recover target_structure = random_structure.xray_structure( space_group_info=space_group_info, elements=elements, use_u_iso=True, random_u_iso=True, random_u_iso_scale=0.04, use_u_aniso=False, ) exercise_one_structure( target_structure, flipping_type, anomalous_flag, d_min, grid_resolution_factor=grid_resolution_factor, verbose=verbose, amplitude_type=amplitude_type, )
def exercise(space_group_info, anomalous_flag, d_min=1.0, reflections_per_bin=200, n_bins=10, verbose=0): elements = ("N", "C", "C", "O") * 5 structure_factors = random_structure.xray_structure( space_group_info, elements=elements, volume_per_atom=50., min_distance=1.5, general_positions_only=True, use_u_aniso=False, u_iso=adptbx.b_as_u(10) ).structure_factors( anomalous_flag=anomalous_flag, d_min=d_min, algorithm="direct") if (0 or verbose): structure_factors.xray_structure().show_summary() asu_contents = dicts.with_default_value(0) for elem in elements: asu_contents[elem] += 1 f_calc = abs(structure_factors.f_calc()) f_calc.setup_binner( auto_binning=True, reflections_per_bin=reflections_per_bin, n_bins=n_bins) if (0 or verbose): f_calc.binner().show_summary() for k_given in [1,0.1,0.01,10,100]: f_obs = miller.array( miller_set=f_calc, data=f_calc.data()*k_given).set_observation_type_xray_amplitude() f_obs.use_binner_of(f_calc) wp = statistics.wilson_plot(f_obs, asu_contents, e_statistics=True) if (0 or verbose): print "wilson_k, wilson_b:", wp.wilson_k, wp.wilson_b print "space group:", space_group_info.group().type().hall_symbol() print "<E^2-1>:", wp.mean_e_sq_minus_1 assert 0.8 < wp.wilson_k/k_given < 1.2 assert 0.64 < wp.wilson_intensity_scale_factor/(k_given*k_given) < 1.44 assert 9 < wp.wilson_b < 11 assert wp.xy_plot_info().fit_correlation == wp.fit_correlation if space_group_info.group().is_centric(): assert 0.90 < wp.mean_e_sq_minus_1 < 1.16 assert 3.15 < wp.percent_e_sq_gt_2 < 6.5 else: assert 0.65 < wp.mean_e_sq_minus_1 < 0.90 assert 1.0 < wp.percent_e_sq_gt_2 < 3.15 assert wp.normalised_f_obs.size() == f_obs.size() f_obs = f_calc.array(data=flex.double(f_calc.indices().size(), 0)) f_obs.use_binner_of(f_calc) n_bins = f_obs.binner().n_bins_used() try: statistics.wilson_plot(f_obs, asu_contents) except RuntimeError, e: assert not show_diff(str(e), """\ wilson_plot error: %d empty bins: Number of bins: %d Number of f_obs > 0: 0 Number of f_obs <= 0: %d""" % (n_bins, n_bins, f_obs.indices().size()))
def exercise_3_f_part1_and_f_part2(): x = random_structure.xray_structure( space_group_info = sgtbx.space_group_info("P 4"), elements =(("O","N","C")*10), volume_per_atom = 200, min_distance = 1.5, general_positions_only = True, random_u_iso = True, random_occupancy = False) x.scattering_type_registry(table="wk1995") fc = x.structure_factors(d_min = 2.0, algorithm="direct").f_calc() # x1 = random_structure.xray_structure( space_group_info = sgtbx.space_group_info("P 4"), unit_cell = x.unit_cell(), elements =(("C")*10), volume_per_atom = 200, min_distance = 1.5, general_positions_only = True, random_u_iso = True, random_occupancy = False) x1.scattering_type_registry(table="wk1995") fc1 = x1.structure_factors(d_min = 2.0, algorithm="direct").f_calc() # x2 = random_structure.xray_structure( space_group_info = sgtbx.space_group_info("P 4"), unit_cell = x.unit_cell(), elements =(("C")*10), volume_per_atom = 200, min_distance = 1.5, general_positions_only = True, random_u_iso = True, random_occupancy = False) x2.scattering_type_registry(table="wk1995") fc2 = x2.structure_factors(d_min = 2.0, algorithm="direct").f_calc() # fc_all = fc.customized_copy(data = fc.data()+fc1.data()+fc2.data()) f_obs = abs(fc_all.deep_copy()) r_free_flags = f_obs.generate_r_free_flags(fraction = 0.1) sfg_params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract() sfg_params.algorithm = "direct" # t_exercise_3_1(x=x, f_obs=f_obs, fc1=fc1, fc2=fc2, r_free_flags=r_free_flags, sfg_params=sfg_params)
def run_00(): time_aniso_u_scaler = 0 for symbol in sgtbx.bravais_types.acentric + sgtbx.bravais_types.centric: #print symbol, "-"*50 space_group_info = sgtbx.space_group_info(symbol = symbol) xrs = random_structure.xray_structure( space_group_info = space_group_info, elements = ["N"]*100, volume_per_atom = 50.0, random_u_iso = True) # XXX ad a method to adptbx to do this point_group = sgtbx.space_group_info( symbol=symbol).group().build_derived_point_group() adp_constraints = sgtbx.tensor_rank_2_constraints( space_group=point_group, reciprocal_space=True) u_star = adptbx.u_cart_as_u_star(xrs.unit_cell(), adptbx.random_u_cart(u_scale=1,u_min=0.1)) u_indep = adp_constraints.independent_params(all_params=u_star) u_star = adp_constraints.all_params(independent_params=u_indep) b_cart_start=adptbx.u_as_b(adptbx.u_star_as_u_cart(xrs.unit_cell(), u_star)) # tr = (b_cart_start[0]+b_cart_start[1]+b_cart_start[2])/3 b_cart_start = [b_cart_start[0]-tr,b_cart_start[1]-tr,b_cart_start[2]-tr, b_cart_start[3],b_cart_start[4],b_cart_start[5]] tr = (b_cart_start[0]+b_cart_start[1]+b_cart_start[2])/3 # #print "Input b_cart :", " ".join(["%8.4f"%i for i in b_cart_start]), "tr:", tr F = xrs.structure_factors(d_min = 2.0).f_calc() u_star = adptbx.u_cart_as_u_star( F.unit_cell(), adptbx.b_as_u(b_cart_start)) fbc = mmtbx.f_model.ext.k_anisotropic(F.indices(), u_star) fc = F.structure_factors_from_scatterers(xray_structure=xrs).f_calc() f_obs = F.customized_copy(data = flex.abs(fc.data()*fbc)) t0 = time.time() # obj = bulk_solvent.aniso_u_scaler( f_model_abs = flex.abs(fc.data()), f_obs = f_obs.data(), miller_indices = f_obs.indices(), adp_constraint_matrix = adp_constraints.gradient_sum_matrix()) time_aniso_u_scaler += (time.time()-t0) b_cart_final = adptbx.u_as_b(adptbx.u_star_as_u_cart(f_obs.unit_cell(), adp_constraints.all_params(tuple(obj.u_star_independent)))) # obj = bulk_solvent.aniso_u_scaler( f_model_abs = flex.abs(fc.data()), f_obs = f_obs.data(), miller_indices = f_obs.indices()) b_cart_final2 = adptbx.u_as_b(adptbx.u_star_as_u_cart(f_obs.unit_cell(), tuple(obj.u_star))) # assert approx_equal(b_cart_final, b_cart_final2) #print "Output b_cart:", " ".join(["%8.4f"%i for i in b_cart_final]) assert approx_equal(b_cart_start, b_cart_final, 1.e-4) print "Time (aniso_u_scaler only): %6.4f"%time_aniso_u_scaler
def exercise_SFweight_spline( space_group_info, n_scatterers=10, d_min=4, verbose=0): structure = random_structure.xray_structure( space_group_info, elements=["C"]*n_scatterers, volume_per_atom=1000) sfweight = exercise_SFweight_spline_core( structure=structure, d_min=d_min, verbose=verbose)
def run_group(symbol): group = space_group_info(symbol); print "\n==" elements = ('C', 'N', 'O', 'H')*11 xrs = random_structure.xray_structure( space_group_info = group, volume_per_atom = 25., general_positions_only = False, elements = elements, min_distance = 1.0) fo = abs(xrs.structure_factors(d_min=2).f_calc()) fmodel = mmtbx.f_model.manager( f_obs = fo, xray_structure = xrs) # k_sol=flex.double([10.35,5.34]) b_sol=flex.double([30.0, 24.0]) b_cart = [10,20,30,40,50,60] u_star = flex.double(adptbx.b_as_u( adptbx.u_cart_as_u_star(xrs.unit_cell(), b_cart))) # TGO = cpp_tg(fmodel=fmodel) tg = TGO.get_tg(k_sol=k_sol, b_sol=b_sol, u_star=u_star) # k_sol gk_a=list(tg.grad_k_sols()) ck_a=list(tg.curv_k_sols()) gk_fd, ck_fd=fd(TGO=TGO, k_sol=k_sol, b_sol=b_sol, u_star=u_star, param="k_sol") # b_sol gb_a=list(tg.grad_b_sols()) cb_a=list(tg.curv_b_sols()) gb_fd, cb_fd=fd(TGO=TGO, k_sol=k_sol, b_sol=b_sol, u_star=u_star, param="b_sol") # u_star gu_a=list(tg.grad_u_star()) gu_fd, junk=fd(TGO=TGO, k_sol=k_sol, b_sol=b_sol, u_star=u_star, param="u_star") print "u_star:",gu_a print "u_star:",gu_fd TGO2 = cpp_tg_u_star_only(fmodel=fmodel) tg2 = TGO2.get_tg(k_sol=k_sol, b_sol=b_sol, u_star=u_star) gu_a2=list(tg2.grad_u_star()) gu_fd2, junk=fd(TGO=TGO2, k_sol=k_sol, b_sol=b_sol, u_star=u_star, param="u_star") print "u_star:",gu_a2 print "u_star:",gu_fd2 # print "k_sol:", gk_a, ck_a print "k_sol:", gk_fd, ck_fd print "b_sol:", gb_a, cb_a print "b_sol:", gb_fd, cb_fd # assert approx_equal(gk_a, gk_fd, eps=1.e-4) assert approx_equal(gb_a, gb_fd, eps=1.e-4) assert approx_equal(ck_a, ck_fd, eps=1.e-4) assert approx_equal(cb_a, cb_fd, eps=1.e-4) assert approx_equal(gu_a, gu_fd, eps=1.e-4) assert approx_equal(gu_a2, gu_fd2, eps=1.e-6)
def exercise_all(flags, space_group_info): exercise_float_asu(space_group_info) exercise_asu_mappings(space_group_info) exercise_neighbors_pair_generators( structure = random_structure.xray_structure( space_group_info, elements=["Si"]*5, volume_per_atom=100, min_distance=3., general_positions_only=False), verbose=flags.Verbose)
def exercise_4(grid_step, radius, shell, a, b, d_min, volume_per_atom, use_weights, optimize_cutoff_radius, scatterer_chemical_type = "C"): xray_structure = random_structure.xray_structure( space_group_info = sgtbx.space_group_info("P 1"), elements = ((scatterer_chemical_type)*1), volume_per_atom = volume_per_atom, min_distance = 1.5, general_positions_only = True) custom_dict = \ {scatterer_chemical_type: eltbx.xray_scattering.gaussian([a],[b])} xray_structure.scattering_type_registry(custom_dict = custom_dict) miller_set = miller.build_set( crystal_symmetry = xray_structure.crystal_symmetry(), anomalous_flag = False, d_min = d_min, d_max = None) f_calc = miller_set.structure_factors_from_scatterers( xray_structure = xray_structure, algorithm = "direct", cos_sin_table = False, exp_table_one_over_step_size = False).f_calc() fft_map = f_calc.fft_map(grid_step = grid_step, symmetry_flags = None) fft_map = fft_map.apply_volume_scaling() site_frac = xray_structure.sites_frac() m = fft_map.real_map_unpadded() amm = abs(flex.max(m)) r = abs(amm-abs(m.value_at_closest_grid_point(site_frac[0]))) / amm assert r < 0.15, r around_atom_obj_ = mmtbx.real_space.around_atom( unit_cell = xray_structure.unit_cell(), map_data = fft_map.real_map_unpadded(), radius = radius, shell = shell, site_frac = list(xray_structure.sites_frac())[0]) data = around_atom_obj_.data() dist = around_atom_obj_.distances() approx_obj_ = maptbx.one_gaussian_peak_approximation( data_at_grid_points = data, distances = dist, use_weights = use_weights, optimize_cutoff_radius = optimize_cutoff_radius) assert approx_equal(approx_obj_.a_reciprocal_space(), 6.0, 0.1) assert approx_equal(approx_obj_.b_reciprocal_space(), 3.0, 0.1) assert approx_obj_.gof() < 1.0 assert approx_obj_.cutoff_radius() < radius
def exercise(flags, space_group_info): # Prepare a structure compatible with the ShelX model xs = random_structure.xray_structure( space_group_info, elements="random", n_scatterers=10, use_u_iso=True, random_u_iso=True, use_u_aniso=True ) xs.apply_symmetry_sites() xs.apply_symmetry_u_stars() for isotropic, sc in itertools.izip(variate(bernoulli_distribution(0.4)), xs.scatterers()): sc.flags.set_grad_site(True) if isotropic: sc.flags.set_use_u_iso(True) sc.flags.set_use_u_aniso(False) sc.flags.set_grad_u_iso(True) else: sc.flags.set_use_u_iso(False) sc.flags.set_use_u_aniso(True) sc.flags.set_grad_u_aniso(True) not_origin_centric = xs.space_group().is_centric() and not xs.space_group().is_origin_centric() try: ins = list( shelx.writer.generator( xs, full_matrix_least_squares_cycles=4, weighting_scheme_params=(0, 0), sort_scatterers=False ) ) except AssertionError: if not_origin_centric: print("Omitted %s\n because it is centric but not origin centric" % xs.space_group().type().hall_symbol()) return raise else: if not_origin_centric: raise Exception_expected ins = cStringIO.StringIO("".join(ins)) xs1 = xs.from_shelx(file=ins) xs.crystal_symmetry().is_similar_symmetry( xs1.crystal_symmetry(), relative_length_tolerance=1e-3, absolute_angle_tolerance=1e-3 ) uc = xs.unit_cell() uc1 = xs1.unit_cell() for sc, sc1 in itertools.izip(xs.scatterers(), xs1.scatterers()): assert sc.label.upper() == sc1.label.upper() assert sc.scattering_type == sc1.scattering_type assert sc.flags.bits == sc1.flags.bits assert approx_equal(sc.site, sc1.site, eps=1e-6) if sc.flags.use_u_iso(): assert approx_equal(sc.u_iso, sc1.u_iso, eps=1e-5) else: assert approx_equal( adptbx.u_star_as_u_cif(uc, sc.u_star), adptbx.u_star_as_u_cif(uc1, sc1.u_star), eps=1e-5 )
def set_up_random_structure(space_group_info): from cctbx.development import random_structure xray_structure = random_structure.xray_structure( space_group_info = space_group_info, elements =("O", "P")*4, volume_per_atom = 100, min_distance = 1.5, general_positions_only = True, random_u_iso = True, random_occupancy = True) xray_structure.scattering_type_registry(table="wk1995") return xray_structure