def torsion_search_nested ( clusters, sites_cart, last_chi_symmetric=None, increment_degrees=10) : """ Iterate over all possible sidechain Chi angle combinations. """ from scitbx.array_family import flex from scitbx.matrix import rotate_point_around_axis n_angles = len(clusters) assert (n_angles >= 1) angle_range = 180 r1 = [ifloor(-angle_range/increment_degrees)] * n_angles r2 = [iceil(angle_range/increment_degrees)] * n_angles if (last_chi_symmetric) : r1[-1] = ifloor(-90/increment_degrees) r2[-1] = iceil(90/increment_degrees) nested_loop = flex.nested_loop(begin=r1, end=r2, open_range=False) selection = clusters[0].atoms_to_rotate for angles in nested_loop: xyz_moved = sites_cart.deep_copy() for i, angle_fraction in enumerate(angles): cl = clusters[i] for atom in cl.atoms_to_rotate: new_xyz = rotate_point_around_axis( axis_point_1 = xyz_moved[cl.axis[0]], axis_point_2 = xyz_moved[cl.axis[1]], point = xyz_moved[atom], angle = angle_fraction*increment_degrees, deg=True) xyz_moved[atom] = new_xyz yield xyz_moved
def torsion_search_nested(clusters, sites_cart, last_chi_symmetric=None, increment_degrees=10): """ Iterate over all possible sidechain Chi angle combinations. """ from scitbx.array_family import flex from scitbx.matrix import rotate_point_around_axis n_angles = len(clusters) assert (n_angles >= 1) angle_range = 180 r1 = [ifloor(-angle_range / increment_degrees)] * n_angles r2 = [iceil(angle_range / increment_degrees)] * n_angles if (last_chi_symmetric): r1[-1] = ifloor(-90 / increment_degrees) r2[-1] = iceil(90 / increment_degrees) nested_loop = flex.nested_loop(begin=r1, end=r2, open_range=False) selection = clusters[0].atoms_to_rotate for angles in nested_loop: xyz_moved = sites_cart.deep_copy() for i, angle_fraction in enumerate(angles): cl = clusters[i] for atom in cl.atoms_to_rotate: new_xyz = rotate_point_around_axis( axis_point_1=xyz_moved[cl.axis[0]], axis_point_2=xyz_moved[cl.axis[1]], point=xyz_moved[atom], angle=angle_fraction * increment_degrees, deg=True) xyz_moved[atom] = new_xyz yield xyz_moved
def exercise_real_space_refinement(verbose): if (verbose): out = sys.stdout else: out = StringIO() out_of_bounds_clamp = maptbx.out_of_bounds_clamp(0) out_of_bounds_raise = maptbx.out_of_bounds_raise() crystal_symmetry = crystal.symmetry(unit_cell=(10, 10, 10, 90, 90, 90), space_group_symbol="P 1") xray_structure = xray.structure(crystal_symmetry=crystal_symmetry, scatterers=flex.xray_scatterer([ xray.scatterer(label="C", site=(0, 0, 0)) ])) miller_set = miller.build_set(crystal_symmetry=crystal_symmetry, anomalous_flag=False, d_min=1) f_calc = miller_set.structure_factors_from_scatterers( xray_structure=xray_structure).f_calc() fft_map = f_calc.fft_map() fft_map.apply_sigma_scaling() real_map = fft_map.real_map_unpadded() #### unit_cell test delta_h = .005 basic_map = maptbx.basic_map( maptbx.basic_map_unit_cell_flag(), real_map, real_map.focus(), crystal_symmetry.unit_cell().orthogonalization_matrix(), out_of_bounds_clamp.as_handle(), crystal_symmetry.unit_cell()) testing_function_for_rsfit(basic_map, delta_h, xray_structure, out) ### non_symmetric test # minfrac = crystal_symmetry.unit_cell().fractionalize((-5, -5, -5)) maxfrac = crystal_symmetry.unit_cell().fractionalize((5, 5, 5)) gridding_first = [ifloor(n * b) for n, b in zip(fft_map.n_real(), minfrac)] gridding_last = [iceil(n * b) for n, b in zip(fft_map.n_real(), maxfrac)] data = maptbx.copy(real_map, gridding_first, gridding_last) # basic_map = maptbx.basic_map( maptbx.basic_map_non_symmetric_flag(), data, fft_map.n_real(), crystal_symmetry.unit_cell().orthogonalization_matrix(), out_of_bounds_clamp.as_handle(), crystal_symmetry.unit_cell()) testing_function_for_rsfit(basic_map, delta_h, xray_structure, out) ### asu test # minfrac = crystal_symmetry.unit_cell().fractionalize((0, 0, 0)) maxfrac = crystal_symmetry.unit_cell().fractionalize((10, 10, 10)) gridding_first = [ifloor(n * b) for n, b in zip(fft_map.n_real(), minfrac)] gridding_last = [iceil(n * b) for n, b in zip(fft_map.n_real(), maxfrac)] data = maptbx.copy(real_map, gridding_first, gridding_last) # basic_map = maptbx.basic_map( maptbx.basic_map_asu_flag(), data, crystal_symmetry.space_group(), crystal_symmetry.direct_space_asu().as_float_asu(), real_map.focus(), crystal_symmetry.unit_cell().orthogonalization_matrix(), out_of_bounds_clamp.as_handle(), crystal_symmetry.unit_cell(), 0.5, True) testing_function_for_rsfit(basic_map, delta_h, xray_structure, out)
def translate_image (self, delta_x, delta_y) : """ Translate the viewport to a different area of the image. Arguments are in pixels. """ scale = self.get_scale() x_new = max(0, ifloor(self.img_x_offset - (delta_x / scale))) y_new = max(0, ifloor(self.img_y_offset - (delta_y / scale))) max_x = ifloor(self.img_w - (self.screen_w / scale)) max_y = ifloor(self.img_h - (self.screen_h / scale)) self.img_x_offset = min(x_new, max_x) self.img_y_offset = min(y_new, max_y)
def screen_coords_as_image_coords (self, x, y) : """ Convert pixel coordinates in the viewport to pixel coordinates in the raw image. """ scale = self.get_scale() xi, yi, w, h = self.get_bitmap_params() x1 = x - max(0, (self.screen_w - (w*scale)) / 2) y1 = y - max(0, (self.screen_h - (h*scale)) / 2) x2 = self.img_x_offset + (x1 / scale) y2 = self.img_y_offset + (y1 / scale) return (ifloor(x2) + 1, ifloor(y2) + 1)
def screen_coords_as_image_coords(self, x, y): """ Convert pixel coordinates in the viewport to pixel coordinates in the raw image. """ scale = self.get_scale() xi, yi, w, h = self.get_bitmap_params() x1 = x - max(0, (self.screen_w - (w * scale)) / 2) y1 = y - max(0, (self.screen_h - (h * scale)) / 2) x2 = self.img_x_offset + (x1 / scale) y2 = self.img_y_offset + (y1 / scale) return (ifloor(x2) + 1, ifloor(y2) + 1)
def translate_image(self, delta_x, delta_y): """ Translate the viewport to a different area of the image. Arguments are in pixels. """ scale = self.get_scale() x_new = max(0, ifloor(self.img_x_offset - (delta_x / scale))) y_new = max(0, ifloor(self.img_y_offset - (delta_y / scale))) max_x = ifloor(self.img_w - (self.screen_w / scale)) max_y = ifloor(self.img_h - (self.screen_h / scale)) self.img_x_offset = min(x_new, max_x) self.img_y_offset = min(y_new, max_y)
def get_bounds_around_model( map_manager=None, model=None, box_cushion=None, ): ''' Calculate the lower and upper bounds to box around a model Allow bounds to go outside the available box (this has to be dealt with at the boxing stage) ''' # get items needed to do the shift cs = map_manager.crystal_symmetry() uc = cs.unit_cell() sites_cart = model.get_sites_cart() sites_frac = uc.fractionalize(sites_cart) map_data = map_manager.map_data() # convert box_cushion into fractional vector cushion_frac = flex.double(uc.fractionalize((box_cushion, ) * 3)) # find fractional corners frac_min = sites_frac.min() frac_max = sites_frac.max() frac_max = list(flex.double(frac_max) + cushion_frac) frac_min = list(flex.double(frac_min) - cushion_frac) # find corner grid nodes all_orig = map_data.all() lower_bounds = [ifloor(f * n) for f, n in zip(frac_min, all_orig)] upper_bounds = [iceil(f * n) for f, n in zip(frac_max, all_orig)] return group_args( lower_bounds=lower_bounds, upper_bounds=upper_bounds, )
def write_xplor_map(sites_cart, unit_cell, map_data, n_real, file_name, buffer=10): import iotbx.xplor.map if sites_cart is not None: frac_min, frac_max = unit_cell.box_frac_around_sites( sites_cart=sites_cart, buffer=buffer) else: frac_min, frac_max = (0.0, 0.0, 0.0), (1.0, 1.0, 1.0) gridding_first = [ifloor(f * n) for f, n in zip(frac_min, n_real)] gridding_last = [iceil(f * n) for f, n in zip(frac_max, n_real)] gridding = iotbx.xplor.map.gridding(n=map_data.focus(), first=gridding_first, last=gridding_last) iotbx.xplor.map.writer(file_name=file_name, is_p1_cell=True, title_lines=[ ' None', ], unit_cell=unit_cell, gridding=gridding, data=map_data, average=-1, standard_deviation=-1)
def write_ccp4_map(sites_cart, unit_cell, map_data, n_real, file_name, buffer=10): import iotbx.ccp4_map from cctbx import sgtbx from scitbx.array_family import flex if sites_cart is not None: frac_min, frac_max = unit_cell.box_frac_around_sites( sites_cart=sites_cart, buffer=buffer) else: frac_min, frac_max = (0.0, 0.0, 0.0), (1.0, 1.0, 1.0) gridding_first = tuple([ifloor(f * n) for f, n in zip(frac_min, n_real)]) gridding_last = tuple([iceil(f * n) for f, n in zip(frac_max, n_real)]) space_group = sgtbx.space_group_info("P1").group() iotbx.ccp4_map.write_ccp4_map( file_name=file_name, unit_cell=unit_cell, space_group=space_group, gridding_first=gridding_first, gridding_last=gridding_last, map_data=map_data, labels=flex.std_string(["iotbx.map_conversion.write_ccp4_map_box"]))
def rt_mx_as_rational(rot_mat): # make sure one provides an integer matrix! tmp_mat = rot_mat.r().as_double() rational_list = [] for ij in tmp_mat: rational_list.append(rational.int(ifloor(ij))) return matrix.sqr(rational_list)
def rt_mx_as_rational(rot_mat): # make sure one provides an integer matrix! tmp_mat = rot_mat.num() rational_list = [] for ij in tmp_mat: rational_list.append(rational.int(ifloor(ij))) return matrix.sqr(rational_list)
def run(args): if (len(args) == 0): args = ["--help"] command_line = (libtbx.option_parser.option_parser( usage="iotbx.python pdb_to_map_simple.py [options] pdb_file..." ).option(None, "--d_min", type="float", default=3, help="high-resolution limit for structure-factor calculation", metavar="FLOAT")).process(args=args) d_min = command_line.options.d_min assert d_min > 0 for file_name in command_line.args: pdb_inp = iotbx.pdb.input(file_name=file_name) xray_structure = pdb_inp.xray_structure_simple() xray_structure.show_summary() print() print("d_min:", d_min) f_calc = xray_structure.structure_factors(d_min=d_min).f_calc() f_calc.show_summary() print() fft_map = f_calc.fft_map() n = fft_map.n_real() print("unit cell gridding:", n) fft_map.as_xplor_map(file_name="unit_cell.map") print() block_first = tuple([ifloor(i * 0.2) for i in n]) block_last = tuple( [max(f + 10, iceil(i * 0.7)) for f, i in zip(block_first, n)]) print("block first:", block_first) print("block last: ", block_last) fft_map.as_xplor_map(file_name="block.map", gridding_first=block_first, gridding_last=block_last) print()
def resample_ordered_list_of_values(vals, redundancy=8): """resample a list of values with interpolation""" # Number of vals given num_inp_vals = len(vals) # Number of vals to be returned num_samp_vals = int(1 + (num_inp_vals - 1) / redundancy) # Sort in descending order ordered_vals = sorted(vals, reverse=True) sampled_vals = [] if num_samp_vals == 1: return [ordered_vals[0]] else: sample_dist = (num_inp_vals - 1) / (num_samp_vals - 1) # # Make sure it doesn't overrun the end of the array # while sample_dist*(num_samp_vals-1) > num_inp_vals-1: # sample_dist = 0.99999999*sample_dist # Resample points with interpolation for i_point in range(num_samp_vals - 1): sample_index = sample_dist * i_point p1 = ifloor(sample_index) v1 = ordered_vals[p1] p2 = iceil(sample_index) v2 = ordered_vals[p2] sample_val = interpolate(x=sample_index, p1=p1, v1=v1, p2=p2, v2=v2) sampled_vals.append(sample_val) # Add the last point sampled_vals.append(ordered_vals[-1]) assert len(sampled_vals) == num_samp_vals return sampled_vals
def run(args): if (len(args) == 0): args = ["--help"] command_line = (libtbx.option_parser.option_parser( usage="iotbx.python pdb_to_map_simple.py [options] pdb_file...") .option(None, "--d_min", type="float", default=3, help="high-resolution limit for structure-factor calculation", metavar="FLOAT") ).process(args=args) d_min = command_line.options.d_min assert d_min > 0 for file_name in command_line.args: pdb_inp = iotbx.pdb.input(file_name=file_name) xray_structure = pdb_inp.xray_structure_simple() xray_structure.show_summary() print print "d_min:", d_min f_calc = xray_structure.structure_factors(d_min=d_min).f_calc() f_calc.show_summary() print fft_map = f_calc.fft_map() n = fft_map.n_real() print "unit cell gridding:", n fft_map.as_xplor_map(file_name="unit_cell.map") print block_first = tuple([ifloor(i*0.2) for i in n]) block_last = tuple([max(f+10, iceil(i*0.7)) for f,i in zip(block_first, n)]) print "block first:", block_first print "block last: ", block_last fft_map.as_xplor_map( file_name="block.map", gridding_first=block_first, gridding_last=block_last) print
def __init__(self, map_manager, model, box_cushion, wrapping=None, log=sys.stdout): self._map_manager = map_manager self._model = model self._force_wrapping = wrapping if wrapping is None: wrapping = self.map_manager().wrapping() self.basis_for_boxing_string = 'using_model, wrapping = %s' % ( wrapping) # safeguards assert isinstance(map_manager, iotbx.map_manager.map_manager) assert isinstance(model, mmtbx.model.manager) assert self._map_manager.map_data().accessor().origin() == (0, 0, 0) # Make sure working model and map_manager crystal_symmetry match assert map_manager.is_compatible_model(model) assert box_cushion >= 0 if self.map_manager().wrapping(): # map must be entire unit cell assert map_manager.unit_cell_grid == map_manager.map_data().all() # NOTE: We are going to use crystal_symmetry and sites_frac based on # the map_manager (the model could still have different crystal_symmetry) # get items needed to do the shift cs = map_manager.crystal_symmetry() uc = cs.unit_cell() sites_cart = model.get_sites_cart() sites_frac = uc.fractionalize(sites_cart) map_data = map_manager.map_data() # convert box_cushion into fractional vector cushion_frac = flex.double(uc.fractionalize((box_cushion, ) * 3)) # find fractional corners frac_min = sites_frac.min() frac_max = sites_frac.max() frac_max = list(flex.double(frac_max) + cushion_frac) frac_min = list(flex.double(frac_min) - cushion_frac) # find corner grid nodes all_orig = map_data.all() self.gridding_first = [ ifloor(f * n) for f, n in zip(frac_min, all_orig) ] self.gridding_last = [iceil(f * n) for f, n in zip(frac_max, all_orig)] # Ready with gridding...set up shifts and box crystal_symmetry self.set_shifts_and_crystal_symmetry() # Apply boxing to model, ncs, and map (if available) self.apply_to_model_ncs_and_map()
def center_view_from_thumbnail (self, x, y) : """ Translate the viewport to center on the X,Y coordinates equivalent to the point clicked in the thumbnail view. Arguments are in screen coordinates relative to the upper left corner of the thumbnail (which is assumed to be displayed in its entirety). """ if (self.zoom == 0) : return self.last_thumb_x = x self.last_thumb_y = y x0, y0, w, h = self.get_bitmap_params() img_x = max(0, ifloor((x * self.thumb_ratio) - (w / 2))) img_y = max(0, ifloor((y * self.thumb_ratio) - (h / 2))) scale = self.get_scale() max_x = ifloor(self.img_w - (self.screen_w / scale)) max_y = ifloor(self.img_h - (self.screen_h / scale)) self.img_x_offset = min(img_x, max_x) self.img_y_offset = min(img_y, max_y)
def center_view_from_thumbnail(self, x, y): """ Translate the viewport to center on the X,Y coordinates equivalent to the point clicked in the thumbnail view. Arguments are in screen coordinates relative to the upper left corner of the thumbnail (which is assumed to be displayed in its entirety). """ if (self.zoom == 0): return self.last_thumb_x = x self.last_thumb_y = y x0, y0, w, h = self.get_bitmap_params() img_x = max(0, ifloor((x * self.thumb_ratio) - (w / 2))) img_y = max(0, ifloor((y * self.thumb_ratio) - (h / 2))) scale = self.get_scale() max_x = ifloor(self.img_w - (self.screen_w / scale)) max_y = ifloor(self.img_h - (self.screen_h / scale)) self.img_x_offset = min(img_x, max_x) self.img_y_offset = min(img_y, max_y)
def get_padding(text, margin=2, center=self.center): from libtbx.math_utils import ifloor, iceil fill = max(0, width - len(text) - (margin * 2)) if (center): rfill = ifloor(fill / 2) lfill = iceil(fill / 2) else: rfill = 0 lfill = fill return (rfill, lfill)
def get_padding (text, margin=2, center=self.center) : from libtbx.math_utils import ifloor, iceil fill = max(0, width - len(text) - (margin * 2)) if (center) : rfill = ifloor(fill / 2) lfill = iceil(fill / 2) else : rfill = 0 lfill = fill return (rfill, lfill)
def exercise_integer(): from libtbx.math_utils import iround, iceil, ifloor, nearest_integer assert iround(0) == 0 assert iround(1.4) == 1 assert iround(-1.4) == -1 assert iround(1.6) == 2 assert iround(-1.6) == -2 assert iceil(0) == 0 assert iceil(1.1) == 2 assert iceil(-1.1) == -1 assert iceil(1.9) == 2 assert iceil(-1.9) == -1 assert ifloor(0) == 0 assert ifloor(1.1) == 1 assert ifloor(-1.1) == -2 assert ifloor(1.9) == 1 assert ifloor(-1.9) == -2 for i in xrange(-3,3+1): assert nearest_integer(i+0.3) == i assert nearest_integer(i+0.7) == i+1
def exercise_integer(): from libtbx.math_utils import iround, iceil, ifloor, nearest_integer assert iround(0) == 0 assert iround(1.4) == 1 assert iround(-1.4) == -1 assert iround(1.6) == 2 assert iround(-1.6) == -2 assert iceil(0) == 0 assert iceil(1.1) == 2 assert iceil(-1.1) == -1 assert iceil(1.9) == 2 assert iceil(-1.9) == -1 assert ifloor(0) == 0 assert ifloor(1.1) == 1 assert ifloor(-1.1) == -2 assert ifloor(1.9) == 1 assert ifloor(-1.9) == -2 for i in xrange(-3, 3 + 1): assert nearest_integer(i + 0.3) == i assert nearest_integer(i + 0.7) == i + 1
def find_max_x_multi(null_fit, existing_gaussian, target_powers, minimize_using_sigmas, shift_sqrt_b_mod_n, b_min, max_max_error, n_start_fractions, n_repeats_minimization, factor_y_x_begin=0.9, factor_y_x_end=0.1, factor_x_step=2.): i_x_begin = None i_x_end = None y0 = null_fit.table_y()[0] for i, target_value in enumerate(null_fit.table_y()): if (i_x_begin is None and target_value < y0 * factor_y_x_begin): i_x_begin = i if (i_x_end is None and target_value < y0 * factor_y_x_end): i_x_end = i + 1 break if (i_x_end is None): i_x_end = null_fit.table_y().size() if (i_x_begin is None): i_x_begin = min(existing_gaussian.n_parameters(), i_x_end - 1) assert i_x_end > 0 assert i_x_begin < i_x_end n_terms = existing_gaussian.n_terms() + 1 i_x_step = max(1, ifloor( (i_x_end - i_x_begin) / (factor_x_step * n_terms))) if (n_terms == 1): n_start_fractions = 2 best_min = None for i_x in range(i_x_begin, i_x_end, i_x_step): for i_split in range(-1, existing_gaussian.n_terms()): for i_start_fraction in range(0, n_start_fractions): gaussian_fit = make_start_gaussian( null_fit=null_fit, existing_gaussian=existing_gaussian, i_split=i_split, i_x=i_x, start_fraction=i_start_fraction / float(n_start_fractions)) for target_power in target_powers: good_min = find_max_x( gaussian_fit=gaussian_fit, target_powers=[target_power], minimize_using_sigmas=minimize_using_sigmas, n_repeats_minimization=n_repeats_minimization, shift_sqrt_b_mod_n=shift_sqrt_b_mod_n, b_min=b_min, max_max_error=max_max_error) if (good_min is not None and good_min.is_better_than(best_min)): best_min = good_min return best_min
def __init__(self, params, coeffs, atom_selection_manager=None, xray_structure=None): adopt_init_args(self, locals()) fft_map = coeffs.fft_map( resolution_factor=self.params.grid_resolution_factor) if (self.params.scale == "volume"): fft_map.apply_volume_scaling() elif (self.params.scale == "sigma"): fft_map.apply_sigma_scaling() else: raise RuntimeError title_lines = [ "REMARK file: %s" % show_string(os.path.basename(self.params.file_name)) ] title_lines.append("REMARK directory: %s" % show_string(os.path.dirname(self.params.file_name))) title_lines.append("REMARK %s" % date_and_time()) assert self.params.region in ["selection", "cell"] if (self.params.region == "selection" and xray_structure is not None): map_iselection = None if atom_selection_manager is not None: map_iselection = self.atom_iselection() frac_min, frac_max = self.box_around_selection( iselection=map_iselection, buffer=self.params.atom_selection_buffer) n_real = fft_map.n_real() gridding_first = [ifloor(f * n) for f, n in zip(frac_min, n_real)] gridding_last = [iceil(f * n) for f, n in zip(frac_max, n_real)] title_lines.append('REMARK map around selection') title_lines.append('REMARK atom_selection=%s' % show_string(self.params.atom_selection)) title_lines.append('REMARK atom_selection_buffer=%.6g' % self.params.atom_selection_buffer) if (map_iselection is None): sel_size = self.xray_structure.scatterers().size() else: sel_size = map_iselection.size() title_lines.append('REMARK number of atoms selected: %d' % sel_size) else: gridding_first = None gridding_last = None title_lines.append("REMARK map covering the unit cell") if params.format == "xplor": fft_map.as_xplor_map(file_name=self.params.file_name, title_lines=title_lines, gridding_first=gridding_first, gridding_last=gridding_last) else: fft_map.as_ccp4_map(file_name=self.params.file_name, gridding_first=gridding_first, gridding_last=gridding_last, labels=title_lines)
def find_max_x_multi(null_fit, existing_gaussian, target_powers, minimize_using_sigmas, shift_sqrt_b_mod_n, b_min, max_max_error, n_start_fractions, n_repeats_minimization, factor_y_x_begin=0.9, factor_y_x_end=0.1, factor_x_step=2.): i_x_begin = None i_x_end = None y0 = null_fit.table_y()[0] for i,target_value in enumerate(null_fit.table_y()): if (i_x_begin is None and target_value < y0 * factor_y_x_begin): i_x_begin = i if (i_x_end is None and target_value < y0 * factor_y_x_end): i_x_end = i+1 break if (i_x_end is None): i_x_end = null_fit.table_y().size() if (i_x_begin is None): i_x_begin = min(existing_gaussian.n_parameters(), i_x_end-1) assert i_x_end > 0 assert i_x_begin < i_x_end n_terms = existing_gaussian.n_terms() + 1 i_x_step = max(1, ifloor((i_x_end-i_x_begin) / (factor_x_step*n_terms))) if (n_terms == 1): n_start_fractions = 2 best_min = None for i_x in xrange(i_x_begin, i_x_end, i_x_step): for i_split in xrange(-1, existing_gaussian.n_terms()): for i_start_fraction in xrange(0,n_start_fractions): gaussian_fit = make_start_gaussian( null_fit=null_fit, existing_gaussian=existing_gaussian, i_split=i_split, i_x=i_x, start_fraction=i_start_fraction/float(n_start_fractions)) for target_power in target_powers: good_min = find_max_x( gaussian_fit=gaussian_fit, target_powers=[target_power], minimize_using_sigmas=minimize_using_sigmas, n_repeats_minimization=n_repeats_minimization, shift_sqrt_b_mod_n=shift_sqrt_b_mod_n, b_min=b_min, max_max_error=max_max_error) if (good_min is not None and good_min.is_better_than(best_min)): best_min = good_min return best_min
def write_xplor_map_file(coeffs, frac_min, frac_max, file_base): fft_map = coeffs.fft_map(resolution_factor=1 / 3.0) fft_map.apply_sigma_scaling() n_real = fft_map.n_real() gridding_first = [ifloor(f * n) for f, n in zip(frac_min, n_real)] gridding_last = [iceil(f * n) for f, n in zip(frac_max, n_real)] title_lines = ["REMARK map covering model + 3.0A buffer"] file_name = "%s.map" % file_base fft_map.as_xplor_map(file_name=file_name, title_lines=title_lines, gridding_first=gridding_first, gridding_last=gridding_last) return file_name
def mask_grid(xrs, buffer, map_data, n_real): # XXX move to C++ frac_min, frac_max = xrs.unit_cell().box_frac_around_sites( sites_cart=xrs.sites_cart(), buffer=buffer - 1.5) gridding_first = [ifloor(f * n) for f, n in zip(frac_min, n_real)] gridding_last = [iceil(f * n) for f, n in zip(frac_max, n_real)] new_map = flex.double(flex.grid(n_real), 0) for i in range(gridding_first[0], gridding_last[0]): for j in xrange(gridding_first[1], gridding_last[1]): for k in xrange(gridding_first[2], gridding_last[2]): if (i > 0 and i < n_real[0] and j > 0 and j < n_real[1] and k > 0 and k < n_real[2]): new_map[(i, j, k)] = map_data[(i, j, k)] return new_map
def write_xplor_map_file (coeffs, frac_min, frac_max, file_base) : fft_map = coeffs.fft_map(resolution_factor=1/3.0) fft_map.apply_sigma_scaling() n_real = fft_map.n_real() gridding_first=[ifloor(f*n) for f,n in zip(frac_min,n_real)] gridding_last=[iceil(f*n) for f,n in zip(frac_max,n_real)] title_lines=["REMARK map covering model + 3.0A buffer"] file_name = "%s.map" % file_base fft_map.as_xplor_map( file_name=file_name, title_lines=title_lines, gridding_first=gridding_first, gridding_last=gridding_last) return file_name
def __init__(self, params, coeffs, atom_selection_manager=None, xray_structure=None): adopt_init_args(self, locals()) fft_map = coeffs.fft_map(resolution_factor = self.params.grid_resolution_factor) if(self.params.scale == "volume"): fft_map.apply_volume_scaling() elif(self.params.scale == "sigma"): fft_map.apply_sigma_scaling() else: raise RuntimeError title_lines=["REMARK file: %s" % show_string(os.path.basename(self.params.file_name))] title_lines.append("REMARK directory: %s" % show_string(os.path.dirname(self.params.file_name))) title_lines.append("REMARK %s" % date_and_time()) assert self.params.region in ["selection", "cell"] if(self.params.region == "selection" and xray_structure is not None) : map_iselection = None if atom_selection_manager is not None : map_iselection = self.atom_iselection() frac_min, frac_max = self.box_around_selection( iselection = map_iselection, buffer = self.params.atom_selection_buffer) n_real = fft_map.n_real() gridding_first=[ifloor(f*n) for f,n in zip(frac_min,n_real)] gridding_last=[iceil(f*n) for f,n in zip(frac_max,n_real)] title_lines.append('REMARK map around selection') title_lines.append('REMARK atom_selection=%s' % show_string(self.params.atom_selection)) title_lines.append('REMARK atom_selection_buffer=%.6g' % self.params.atom_selection_buffer) if(map_iselection is None): sel_size = self.xray_structure.scatterers().size() else: sel_size = map_iselection.size() title_lines.append('REMARK number of atoms selected: %d' % sel_size) else: gridding_first = None gridding_last = None title_lines.append("REMARK map covering the unit cell") if params.format == "xplor" : fft_map.as_xplor_map( file_name = self.params.file_name, title_lines = title_lines, gridding_first = gridding_first, gridding_last = gridding_last) else : fft_map.as_ccp4_map( file_name = self.params.file_name, gridding_first = gridding_first, gridding_last = gridding_last, labels=title_lines)
def mask_grid(xrs, buffer, map_data, n_real): # XXX move to C++ frac_min, frac_max = xrs.unit_cell().box_frac_around_sites( sites_cart = xrs.sites_cart(), buffer = buffer-1.5) gridding_first=[ifloor(f*n) for f,n in zip(frac_min,n_real)] gridding_last=[iceil(f*n) for f,n in zip(frac_max,n_real)] new_map = flex.double(flex.grid(n_real),0) for i in range(gridding_first[0], gridding_last[0]): for j in xrange(gridding_first[1], gridding_last[1]): for k in xrange(gridding_first[2], gridding_last[2]): if(i> 0 and i<n_real[0] and j> 0 and j<n_real[1] and k> 0 and k<n_real[2]): new_map[(i,j,k)] = map_data[(i,j,k)] return new_map
def get_processes (processes) : """ Determine number of processes dynamically: number of CPUs minus the current load average (with a minimum of 1). """ if (processes in [None, Auto]) : if (os.name == "nt") or (sys.version_info < (2,6)) : return 1 from libtbx import introspection auto_adjust = (processes is Auto) processes = introspection.number_of_processors() if (auto_adjust) : processes = max(ifloor(processes - os.getloadavg()[0]), 1) else : assert (processes > 0) return processes
def modify_mask_box(self, mask_data, sites_frac): box_buffer = self.params.box_buffer # Number of selected atoms n_selected = self.selection_bool.count(True) na = mask_data.all() n_selected_p1 = sites_frac.size() n_boxes = int(n_selected_p1 / n_selected) box_list = [[] for i in range(n_boxes)] for n_box in range(n_boxes): for i in range(n_selected): box_list[n_box].append(sites_frac[n_box + n_boxes * i]) na = self.mask_data_all.all() k = 0 for box in box_list: k += 1 x_min = min(frac[0] for frac in box) y_min = min(frac[1] for frac in box) z_min = min(frac[2] for frac in box) x_max = max(frac[0] for frac in box) y_max = max(frac[1] for frac in box) z_max = max(frac[2] for frac in box) frac_min = [x_min, y_min, z_min] frac_max = [x_max, y_max, z_max] cs = self.xray_structure.crystal_symmetry() # Add buffer to box if indicated. if (box_buffer is not None): cushion = flex.double(cs.unit_cell().fractionalize( (box_buffer, ) * 3)) frac_min = list(flex.double(frac_min) - cushion) frac_max = list(flex.double(frac_max) + cushion) gridding_first = [ifloor(f * n) for f, n in zip(frac_min, na)] gridding_last = [iceil(f * n) for f, n in zip(frac_max, na)] for j in range(3): if (gridding_last[j] - gridding_first[j] >= na[j]): raise Sorry( "The box is too big. Decrease box_buffer or use a " + "different selection") maptbx.set_box(value=0, map_data_to=mask_data, start=gridding_first, end=gridding_last) return mask_data
def __init__(self, map_manager, model, cushion, wrapping, log=sys.stdout): adopt_init_args(self, locals()) self.basis_for_boxing_string = 'using model, wrapping=%s' % (wrapping) # safeguards assert isinstance(wrapping, bool) assert isinstance(map_manager, iotbx.map_manager.map_manager) assert isinstance(model, mmtbx.model.manager) assert self.map_manager.map_data().accessor().origin() == (0, 0, 0) # Make sure original map_manager symmetry matches model or original model original_uc_symmetry = map_manager.original_unit_cell_crystal_symmetry assert (original_uc_symmetry.is_similar_symmetry( model.crystal_symmetry()) or (model.get_shift_manager() and original_uc_symmetry.is_similar_symmetry( model.get_shift_manager().get_original_cs()))) assert cushion >= 0 if wrapping: assert map_manager.unit_cell_grid == map_manager.map_data().all() # get items needed to do the shift cs = map_manager.crystal_symmetry() uc = cs.unit_cell() sites_frac = model.get_sites_frac() map_data = map_manager.map_data() # convert cushion into fractional vector cushion_frac = flex.double(uc.fractionalize((cushion, ) * 3)) # find fractional corners frac_min = sites_frac.min() frac_max = sites_frac.max() frac_max = list(flex.double(frac_max) + cushion_frac) frac_min = list(flex.double(frac_min) - cushion_frac) # find corner grid nodes all_orig = map_data.all() self.gridding_first = [ ifloor(f * n) for f, n in zip(frac_min, all_orig) ] self.gridding_last = [iceil(f * n) for f, n in zip(frac_max, all_orig)] # Ready with gridding...set up shifts and box crystal_symmetry self.set_shifts_and_crystal_symmetry() # Apply to model and to map_manager so that self.model() # and self.map_manager are boxed versions self.map_manager = self.apply_to_map(self.map_manager) self.model = self.apply_to_model(self.model)
def elliptical_truncation(array, b_cart, scale_factor=1.0, target_completeness=None): from cctbx import adptbx from scitbx.array_family import flex indices = array.indices() axis_index = -1 min_b_directional = sys.maxsize for n, b_index in enumerate(b_cart[0:3]): if (b_index < min_b_directional): min_b_directional = b_index axis_index = n assert (0 <= axis_index <= 3) max_index_along_axis = [0, 0, 0] for hkl in indices: if (hkl[axis_index] > max_index_along_axis[axis_index]): max_index_along_axis[axis_index] = hkl[axis_index] assert (max_index_along_axis != [0, 0, 0]) scale_cutoff = array.unit_cell().debye_waller_factor( miller_index=max_index_along_axis, b_cart=b_cart) * scale_factor scale = array.debye_waller_factors(b_cart=b_cart).data() if (target_completeness is not None): assert (target_completeness > 0) and (target_completeness <= 100) completeness_start = array.completeness() * 100.0 assert (completeness_start > target_completeness) scale_srt = sorted(scale) i_max = ifloor( len(scale_srt) * (completeness_start - target_completeness) / 100) scale_cutoff = scale_srt[i_max] data = array.data() sigmas = array.sigmas() n_hkl = indices.size() i = 0 while (i < len(indices)): if (scale[i] < scale_cutoff): del indices[i] del data[i] del scale[i] if (sigmas is not None): del sigmas[i] else: i += 1 delta_n_hkl = n_hkl - indices.size() return (n_hkl, delta_n_hkl)
def __init__(self, map_manager=None, model=None, cushion=None, wrapping=None): self.map_manager = map_manager self.model = model self.wrapping = wrapping self.basis_for_boxing_string = 'using model, wrapping=%s' % (wrapping) # safeguards assert wrapping is not None assert isinstance(map_manager, iotbx.map_manager.map_manager) assert isinstance(model, mmtbx.model.manager) assert self.map_manager.map_data().accessor().origin() == (0, 0, 0) assert map_manager.crystal_symmetry().is_similar_symmetry( model.crystal_symmetry()) assert cushion >= 0 if wrapping: assert map_manager.unit_cell_grid == map_manager.map_data().all() # get items needed to do the shift cs = map_manager.crystal_symmetry() uc = cs.unit_cell() sites_frac = model.get_sites_frac() map_data = map_manager.map_data() # convert cushion into fractional vector cushion_frac = flex.double(uc.fractionalize((cushion, ) * 3)) # find fractional corners frac_min = sites_frac.min() frac_max = sites_frac.max() frac_max = list(flex.double(frac_max) + cushion_frac) frac_min = list(flex.double(frac_min) - cushion_frac) # find corner grid nodes all_orig = map_data.all() self.gridding_first = [ ifloor(f * n) for f, n in zip(frac_min, all_orig) ] self.gridding_last = [iceil(f * n) for f, n in zip(frac_max, all_orig)] # Ready with gridding...set up shifts and box crystal_symmetry self.set_shifts_and_crystal_symmetry()
def elliptical_truncation (array, b_cart, scale_factor=1.0, target_completeness=None) : from cctbx import adptbx from scitbx.array_family import flex indices = array.indices() axis_index = -1 min_b_directional = sys.maxint for n, b_index in enumerate(b_cart[0:3]) : if (b_index < min_b_directional) : min_b_directional = b_index axis_index = n assert (0 <= axis_index <= 3) max_index_along_axis = [0,0,0] for hkl in indices : if (hkl[axis_index] > max_index_along_axis[axis_index]) : max_index_along_axis[axis_index] = hkl[axis_index] assert (max_index_along_axis != [0,0,0]) scale_cutoff = array.unit_cell().debye_waller_factor( miller_index=max_index_along_axis, b_cart=b_cart) * scale_factor scale = array.debye_waller_factors(b_cart=b_cart).data() if (target_completeness is not None) : assert (target_completeness > 0) and (target_completeness <= 100) completeness_start = array.completeness() * 100.0 assert (completeness_start > target_completeness) scale_srt = sorted(scale) i_max = ifloor(len(scale_srt)*(completeness_start-target_completeness)/100) scale_cutoff = scale_srt[i_max] data = array.data() sigmas = array.sigmas() n_hkl = indices.size() i = 0 while (i < len(indices)) : if (scale[i] < scale_cutoff) : del indices[i] del data[i] del scale[i] if (sigmas is not None) : del sigmas[i] else : i += 1 delta_n_hkl = n_hkl - indices.size() return (n_hkl, delta_n_hkl)
def get_processes(processes): """ Determine number of processes dynamically: number of CPUs minus the current load average (with a minimum of 1). :param processes: default number of processes (may be None or Auto) :returns: actual number of processes to use """ if (processes in [None, Auto]): if os.name == "nt": return 1 from libtbx import introspection auto_adjust = (processes is Auto) processes = introspection.number_of_processors() if (auto_adjust): processes = max(ifloor(processes - os.getloadavg()[0]), 1) else: assert (processes > 0) return processes
def __init__(self, nb, bf=1, skew=0, taper=1): """ % autoTree Create System Models of Kinematic Trees % autoTree(nb,bf,skew,taper) creates system models of kinematic trees % having revolute joints. nb and bf specify the number of bodies in the % tree, and the branching factor, respectively. The latter is the average % number of children of a nonterminal node, and must be >=1. bf=1 produces % an unbranched tree; bf=2 produces a binary tree; and non-integer values % produce trees in which the number of children alternates between % floor(bf) and ceil(bf) in such a way that the average is bf. Trees are % constructed (and numbered) breadth-first. Link i is a thin-walled % cylindrical tube of length l(i), radius l(i)/20, and mass m(i), lying % between 0 and l(i) on the x axis of its local coordinate system. The % values of l(i) and m(i) are determined by the tapering coefficient: % l(i)=taper^(i-1) and m(i)=taper^(3*(i-1)). Thus, if taper=1 then % m(i)=l(i)=1 for all i. The inboard joint axis of link i lies on the % local z axis, and its outboard axis passes through the point (l(i),0,0) % and is rotated about the x axis by an angle of skew radians relative to % the inboard axis. If the link has more than one outboard joint then they % all have the same axis. If skew=0 then the mechanism is planar. The % final one, two or three arguments can be omitted, in which case they % assume default values of taper=1, skew=0 and bf=1. """ self.NB = nb self.pitch = [0] * nb self.parent = [None] * nb self.Xtree = [] self.I = [] len_ = [] for i in xrange(nb): self.parent[i] = ifloor((i - 1 + math.ceil(bf)) / bf) - 1 if (self.parent[i] == -1): self.Xtree.append(Xtrans([0, 0, 0])) else: self.Xtree.append( Xrotx(skew) * Xtrans([len_[self.parent[i]], 0, 0])) len_.append(taper**i) mass = taper**(3 * i) CoM = len_[i] * matrix.col([0.5, 0, 0]) Icm = mass * len_[i]**2 * matrix.diag( [0.0025, 1.015 / 12, 1.015 / 12]) self.I.append(mcI(mass, CoM, Icm))
def __init__(self, nb, bf=1, skew=0, taper=1): """ % autoTree Create System Models of Kinematic Trees % autoTree(nb,bf,skew,taper) creates system models of kinematic trees % having revolute joints. nb and bf specify the number of bodies in the % tree, and the branching factor, respectively. The latter is the average % number of children of a nonterminal node, and must be >=1. bf=1 produces % an unbranched tree; bf=2 produces a binary tree; and non-integer values % produce trees in which the number of children alternates between % floor(bf) and ceil(bf) in such a way that the average is bf. Trees are % constructed (and numbered) breadth-first. Link i is a thin-walled % cylindrical tube of length l(i), radius l(i)/20, and mass m(i), lying % between 0 and l(i) on the x axis of its local coordinate system. The % values of l(i) and m(i) are determined by the tapering coefficient: % l(i)=taper^(i-1) and m(i)=taper^(3*(i-1)). Thus, if taper=1 then % m(i)=l(i)=1 for all i. The inboard joint axis of link i lies on the % local z axis, and its outboard axis passes through the point (l(i),0,0) % and is rotated about the x axis by an angle of skew radians relative to % the inboard axis. If the link has more than one outboard joint then they % all have the same axis. If skew=0 then the mechanism is planar. The % final one, two or three arguments can be omitted, in which case they % assume default values of taper=1, skew=0 and bf=1. """ self.NB = nb self.pitch = [0] * nb self.parent = [None] * nb self.Xtree = [] self.I = [] len_ = [] for i in xrange(nb): self.parent[i] = ifloor((i-1+math.ceil(bf))/bf)-1 if (self.parent[i] == -1): self.Xtree.append(Xtrans([0,0,0])) else: self.Xtree.append(Xrotx(skew) * Xtrans([len_[self.parent[i]],0,0])) len_.append(taper**i) mass = taper**(3*i) CoM = len_[i] * matrix.col([0.5,0,0]) Icm = mass * len_[i]**2 * matrix.diag([0.0025,1.015/12,1.015/12]) self.I.append(mcI(mass, CoM, Icm))
def write_dsn6_map (sites_cart, unit_cell, map_data, n_real, file_name, buffer=10) : import iotbx.dsn6 from cctbx import sgtbx from scitbx.array_family import flex if sites_cart is not None : frac_min, frac_max = unit_cell.box_frac_around_sites( sites_cart=sites_cart, buffer=buffer) else : frac_min, frac_max = (0.0, 0.0, 0.0), (1.0, 1.0, 1.0) gridding_first = tuple([ifloor(f*n) for f,n in zip(frac_min,n_real)]) gridding_last = tuple([iceil(f*n) for f,n in zip(frac_max,n_real)]) print "n_real:", n_real print "gridding start:", gridding_first print "gridding end:", gridding_last iotbx.dsn6.write_dsn6_map( file_name=file_name, unit_cell=unit_cell, gridding_first=gridding_first, gridding_last=gridding_last, map_data=map_data)
def write_ccp4_map (sites_cart, unit_cell, map_data, n_real, file_name, buffer=10) : import iotbx.ccp4_map from cctbx import sgtbx from scitbx.array_family import flex if sites_cart is not None : frac_min, frac_max = unit_cell.box_frac_around_sites( sites_cart=sites_cart, buffer=buffer) else : frac_min, frac_max = (0.0, 0.0, 0.0), (1.0, 1.0, 1.0) gridding_first = tuple([ifloor(f*n) for f,n in zip(frac_min,n_real)]) gridding_last = tuple([iceil(f*n) for f,n in zip(frac_max,n_real)]) space_group = sgtbx.space_group_info("P1").group() iotbx.ccp4_map.write_ccp4_map( file_name=file_name, unit_cell=unit_cell, space_group=space_group, gridding_first=gridding_first, gridding_last=gridding_last, map_data=map_data, labels=flex.std_string(["iotbx.map_conversion.write_ccp4_map_box"]))
def write_dsn6_map(sites_cart, unit_cell, map_data, n_real, file_name, buffer=10): import iotbx.dsn6 from cctbx import sgtbx from scitbx.array_family import flex if sites_cart is not None : frac_min, frac_max = unit_cell.box_frac_around_sites( sites_cart=sites_cart, buffer=buffer) else : frac_min, frac_max = (0.0, 0.0, 0.0), (1.0, 1.0, 1.0) gridding_first = tuple([ifloor(f*n) for f,n in zip(frac_min,n_real)]) gridding_last = tuple([iceil(f*n) for f,n in zip(frac_max,n_real)]) print "n_real:", n_real print "gridding start:", gridding_first print "gridding end:", gridding_last iotbx.dsn6.write_dsn6_map( file_name=file_name, unit_cell=unit_cell, gridding_first=gridding_first, gridding_last=gridding_last, map_data=map_data)
def write_xplor_map(sites_cart, unit_cell, map_data, n_real, file_name, buffer=10) : import iotbx.xplor.map if sites_cart is not None : frac_min, frac_max = unit_cell.box_frac_around_sites( sites_cart=sites_cart, buffer=buffer) else : frac_min, frac_max = (0.0, 0.0, 0.0), (1.0, 1.0, 1.0) gridding_first=[ifloor(f*n) for f,n in zip(frac_min,n_real)] gridding_last=[iceil(f*n) for f,n in zip(frac_max,n_real)] gridding = iotbx.xplor.map.gridding(n = map_data.focus(), first = gridding_first, last = gridding_last) iotbx.xplor.map.writer( file_name = file_name, is_p1_cell = True, title_lines = [' None',], unit_cell = unit_cell, gridding = gridding, data = map_data, average = -1, standard_deviation = -1)
def pdbMap(fileName): d_min = 0.4 pdb_inp = iotbx.pdb.input(fileName) xray_structure = pdb_inp.xray_structure_simple() print("d_min:", d_min) f_calc = xray_structure.structure_factors(d_min=d_min).f_calc() x = f_calc.amplitudes() file2 = open(r"computedValues.txt", 'w') for i in x: for m in i: file2.write(str(m) + " ") file2.write('\n') fft_map = f_calc.fft_map() n = fft_map.n_real() print("unit cell gridding:", n) fft_map.as_xplor_map(file_name="unit_cell.map") block_first = tuple([ifloor(i * 0.2) for i in n]) block_last = tuple( [max(f + 10, iceil(i * 0.7)) for f, i in zip(block_first, n)]) print("block first:", block_first) print "block last: ", block_last fft_map.as_xplor_map(file_name="block.map", gridding_first=block_first, gridding_last=block_last)
def format_x_axis(self): if self.tables[0].x_is_inverse_d_min: xdata = self.tables[0].get_x_as_resolution() self.p.set_xlabel("Resolution", fontproperties=self.get_font("axis_label")) if (getattr(self.tables[0], "force_exact_x_labels", False)): xticks_ = self.tables[0].get_x_values() else: xticks_ = self.p.get_xticks() n_skip = max(1, ifloor(len(xticks_) / 10)) xticks = [] xticklabels = [] k = 0 while (k < len(xticks_)): x = xticks_[k] xticks.append(x) if (x != 0): if x > 0.0: x = math.sqrt(1 / x) else: x = -math.sqrt(1 / abs(x)) xticklabels.append("%.2f" % x) else: # FIXME? xticklabels.append("") k += n_skip self.p.set_xticks(xticks) self.p.set_xticklabels(xticklabels) else: if self.graph.x_axis_label is not None: self.p.set_xlabel(self.graph.x_axis_label, fontproperties=self.get_font("axis_label")) else: self.p.set_xlabel(self.graph.x_label, fontproperties=self.get_font("axis_label")) for ticklabel in self.p.get_xticklabels(): ticklabel.set_fontproperties(self.get_font("value_label"))
def exercise_real_space_refinement(verbose): if (verbose): out = sys.stdout else: out = StringIO() out_of_bounds_clamp = maptbx.out_of_bounds_clamp(0) out_of_bounds_raise = maptbx.out_of_bounds_raise() crystal_symmetry = crystal.symmetry( unit_cell=(10,10,10,90,90,90), space_group_symbol="P 1") xray_structure = xray.structure( crystal_symmetry=crystal_symmetry, scatterers=flex.xray_scatterer([ xray.scatterer(label="C", site=(0,0,0))])) miller_set = miller.build_set( crystal_symmetry=crystal_symmetry, anomalous_flag=False, d_min=1) f_calc = miller_set.structure_factors_from_scatterers( xray_structure=xray_structure).f_calc() fft_map = f_calc.fft_map() fft_map.apply_sigma_scaling() real_map = fft_map.real_map_unpadded() #### unit_cell test delta_h = .005 basic_map = maptbx.basic_map( maptbx.basic_map_unit_cell_flag(), real_map, real_map.focus(), crystal_symmetry.unit_cell().orthogonalization_matrix(), out_of_bounds_clamp.as_handle(), crystal_symmetry.unit_cell()) testing_function_for_rsfit(basic_map,delta_h,xray_structure,out) ### non_symmetric test # minfrac = crystal_symmetry.unit_cell().fractionalize((-5,-5,-5)) maxfrac = crystal_symmetry.unit_cell().fractionalize((5,5,5)) gridding_first = [ifloor(n*b) for n,b in zip(fft_map.n_real(), minfrac)] gridding_last = [iceil(n*b) for n,b in zip(fft_map.n_real(), maxfrac)] data=maptbx.copy(real_map, gridding_first, gridding_last) # basic_map = maptbx.basic_map( maptbx.basic_map_non_symmetric_flag(), data, fft_map.n_real(), crystal_symmetry.unit_cell().orthogonalization_matrix(), out_of_bounds_clamp.as_handle(), crystal_symmetry.unit_cell()) testing_function_for_rsfit(basic_map,delta_h,xray_structure,out) ### asu test # minfrac = crystal_symmetry.unit_cell().fractionalize((0,0,0)) maxfrac = crystal_symmetry.unit_cell().fractionalize((10,10,10)) gridding_first = [ifloor(n*b) for n,b in zip(fft_map.n_real(), minfrac)] gridding_last = [iceil(n*b) for n,b in zip(fft_map.n_real(), maxfrac)] data=maptbx.copy(real_map, gridding_first, gridding_last) # basic_map = maptbx.basic_map( maptbx.basic_map_asu_flag(), data, crystal_symmetry.space_group(), crystal_symmetry.direct_space_asu().as_float_asu(), real_map.focus(), crystal_symmetry.unit_cell().orthogonalization_matrix(), out_of_bounds_clamp.as_handle(), crystal_symmetry.unit_cell(), 0.5, True) testing_function_for_rsfit(basic_map,delta_h,xray_structure,out)
def line_between_points (self, x1, y1, x2, y2, n_values=100) : """ Given two points on the image, sample intensities along a line connecting them (using linear interpolation). This also calculates the coordinates of each sample point, which is used for lattice dimension calculations once peaks have been identified. Arguments are in image pixel coordinates (starting at 1,1). """ x1_, y1_ = self.image_coords_as_array_coords(x1, y1) x2_, y2_ = self.image_coords_as_array_coords(x2, y2) n_values = ifloor(math.sqrt((x2_-x1_)**2 + (y2_-y1_)**2)) delta_x = (x2_ - x1_) / (n_values - 1) delta_y = (y2_ - y1_) / (n_values - 1) vals = [] img_coords = [] d = self._raw.linearintdata # TODO remarkably, this is reasonably fast in Python, but it would # probably be more at home in scitbx.math for n in range(n_values) : x = x1_ + (n * delta_x) y = y1_ + (n * delta_y) xd, yd = self.array_coords_as_detector_coords(x, y) img_coords.append((xd,yd)) x_1 = ifloor(x) x_2 = iceil(x) y_1 = ifloor(y) y_2 = iceil(y) v11 = d[(x_1, y_1)] v12 = d[(x_1, y_2)] v21 = d[(x_2, y_1)] v22 = d[(x_2, y_2)] if (x_2 == x_1) : if (y_2 == y_1) : vxy = v11 else : vxy = ((v12 * (y - y_1)) + (v11 * (y_2 - y))) / (y_2 - y_1) elif (y_2 == y_1) : vxy = ((v21 * (x - x_1)) + (v11 * (x_2 - x))) / (x_2 - x_1) else : dxdy = (y_2 - y_1) * (x_2 - x_1) vxy = ((v11 / dxdy) * (x_2 - x) * (y_2 - y)) + \ ((v21 / dxdy) * (x - x_1) * (y_2 - y)) + \ ((v12 / dxdy) * (x_2 - x) * (y - y_1)) + \ ((v22 / dxdy) * (x - x_1) * (y - y_1)) vals.append(vxy) lattice_length = None if (len(vals) > 5) : # first find peaks in the profile peaks = [] avg = sum(vals) / len(vals) filtered_vals = [] for x in vals : if (x <= avg*3) : filtered_vals.append(x) background = sum(filtered_vals) / len(filtered_vals) i = 2 while (i < len(vals) - 2) : x = vals[i] if (x <= background) : pass elif ((x > vals[i-1]) and (x > vals[i-2]) and (x > vals[i+1]) and (x > vals[i+2])) : peaks.append(i) i += 1 if (len(peaks) > 0) : # calculate the average lattice length center_x, center_y = self.get_beam_center_mm() distances = [] i = 1 while (i < len(peaks)) : x1,y1 = img_coords[peaks[i-1]] x2,y2 = img_coords[peaks[i]] rs_distance = rstbx.utils.reciprocal_space_distance(x1, y1, x2, y2, wavelength=self.get_wavelength(), center_x=center_x, center_y=center_y, distance=self.get_detector_distance(), detector_two_theta=self.get_detector_2theta(), distance_is_corrected=True) assert (rs_distance > 0) distances.append(1 / rs_distance) i += 1 lattice_length = sum(distances) / len(distances) distance = self.distance_between_points(x1, y1, x2, y2) return line_profile(vals, distance, lattice_length)
def region_density_correlation( large_unit_cell, large_d_min, large_density_map, sites_cart, site_radii, work_scatterers): sites_frac_large = large_unit_cell.fractionalize(sites_cart) large_frac_min = sites_frac_large.min() large_frac_max = sites_frac_large.max() large_n_real = large_density_map.focus() from scitbx import fftpack from libtbx.math_utils import ifloor, iceil large_ucp = large_unit_cell.parameters() small_n_real = [0,0,0] small_origin_in_large_grid = [0,0,0] small_abc = [0,0,0] sites_frac_shift = [0,0,0] for i in xrange(3): grid_step = large_ucp[i] / large_n_real[i] buffer = large_d_min / grid_step grid_min = ifloor(large_frac_min[i] * large_n_real[i] - buffer) grid_max = iceil(large_frac_max[i] * large_n_real[i] + buffer) min_grid = grid_max - grid_min + 1 small_n_real[i] = fftpack.adjust_gridding(min_grid=min_grid, max_prime=5) if (small_n_real[i] < large_n_real[i]): shift_min = (small_n_real[i] - min_grid) // 2 small_origin_in_large_grid[i] = grid_min - shift_min small_abc[i] = small_n_real[i] * grid_step sites_frac_shift[i] = small_origin_in_large_grid[i] / large_n_real[i] else: small_n_real[i] = large_n_real[i] small_origin_in_large_grid[i] = 0 small_abc[i] = large_ucp[i] sites_frac_shift[i] = 0 sites_cart_shift = large_unit_cell.orthogonalize(sites_frac_shift) sites_cart_small = sites_cart - sites_cart_shift from cctbx import xray small_xray_structure = xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=tuple(small_abc)+large_ucp[3:], space_group_symbol="P1"), scatterers=work_scatterers) small_xray_structure.set_sites_cart(sites_cart=sites_cart_small) small_f_calc = small_xray_structure.structure_factors( d_min=large_d_min).f_calc() small_gridding = crystal_gridding( unit_cell=small_f_calc.unit_cell(), space_group_info=small_f_calc.space_group_info(), pre_determined_n_real=small_n_real) from cctbx import miller small_fft_map = miller.fft_map( crystal_gridding=small_gridding, fourier_coefficients=small_f_calc) small_fft_map.apply_sigma_scaling() small_map = small_fft_map.real_map_unpadded() grid_indices = grid_indices_around_sites( unit_cell=small_xray_structure.unit_cell(), fft_n_real=small_n_real, fft_m_real=small_n_real, sites_cart=sites_cart_small, site_radii=site_radii) small_copy_from_large_map = copy( map_unit_cell=large_density_map, first=small_origin_in_large_grid, last=matrix.col(small_origin_in_large_grid) + matrix.col(small_n_real) - matrix.col((1,1,1))) assert small_copy_from_large_map.all() == small_map.all() corr = flex.linear_correlation( x=small_map.select(grid_indices), y=small_copy_from_large_map.select(grid_indices)) if (not corr.is_well_defined()): return None return corr.coefficient()
def rho_stats( xray_structure, d_min, resolution_factor, electron_sum_radius, zero_out_f000): n_real = [] n_half_plus = [] n_half_minus = [] s2 = d_min * resolution_factor * 2 for l in xray_structure.unit_cell().parameters()[:3]: nh = ifloor(l / s2) n_real.append(2*nh+1) n_half_plus.append(nh) n_half_minus.append(-nh) n_real = tuple(n_real) n_real_product = matrix.col(n_real).product() crystal_gridding = maptbx.crystal_gridding( unit_cell=xray_structure.unit_cell(), space_group_info=xray_structure.space_group_info(), pre_determined_n_real=n_real) miller_indices = flex.miller_index() miller_indices.reserve(n_real_product) for h in flex.nested_loop(n_half_minus, n_half_plus, open_range=False): miller_indices.append(h) assert miller_indices.size() == n_real_product # miller_set = miller.set( crystal_symmetry=xray_structure, anomalous_flag=True, indices=miller_indices).sort(by_value="resolution") assert miller_set.indices()[0] == (0,0,0) f_calc = miller_set.structure_factors_from_scatterers( xray_structure=xray_structure, algorithm="direct", cos_sin_table=False).f_calc() if (zero_out_f000): f_calc.data()[0] = 0j # unit_cell_volume = xray_structure.unit_cell().volume() voxel_volume = unit_cell_volume / n_real_product number_of_miller_indices = [] rho_max = [] electron_sums_around_atoms = [] densities_along_x = [] for f in [f_calc, f_calc.resolution_filter(d_min=d_min)]: assert f.indices()[0] == (0,0,0) number_of_miller_indices.append(f.indices().size()) fft_map = miller.fft_map( crystal_gridding=crystal_gridding, fourier_coefficients=f) assert fft_map.n_real() == n_real rho = fft_map.real_map_unpadded() / unit_cell_volume assert approx_equal(voxel_volume*flex.sum(rho), f_calc.data()[0]) if (xray_structure.scatterers().size() == 1): assert flex.max_index(rho) == 0 rho_max.append(rho[0]) else: rho_max.append(flex.max(rho)) site_cart = xray_structure.sites_cart()[0] gias = maptbx.grid_indices_around_sites( unit_cell=xray_structure.unit_cell(), fft_n_real=n_real, fft_m_real=n_real, sites_cart=flex.vec3_double([site_cart]), site_radii=flex.double([electron_sum_radius])) electron_sums_around_atoms.append( flex.sum(rho.as_1d().select(gias))*voxel_volume) # a = xray_structure.unit_cell().parameters()[0] nx = n_real[0] nxh = nx//2 x = [] y = [] for ix in xrange(-nxh,nxh+1): x.append(a*ix/nx) y.append(rho[(ix%nx,0,0)]) densities_along_x.append((x,y)) # print \ "%3.1f %4.2f %-12s %5d %5d | %6.3f %6.3f | %6.3f %6.3f | %4.2f %5.1f" % ( d_min, resolution_factor, n_real, number_of_miller_indices[0], number_of_miller_indices[1], electron_sums_around_atoms[0], electron_sums_around_atoms[1], rho_max[0], rho_max[1], f_calc.data()[0].real, u_as_b(xray_structure.scatterers()[0].u_iso)) # return densities_along_x
def get_zoom_box(self, x, y, boxsize=400, mag=16): #assert ((boxsize % mag) == 0) n_pixels = iceil(boxsize / mag) x0 = min(self.img_w - n_pixels, ifloor(x - (n_pixels / 2))) y0 = min(self.img_h - n_pixels, ifloor(y - (n_pixels / 2))) return (x0, y0, n_pixels, n_pixels)
def hcp_fill_box(cb_op_original_to_sampling, float_asu, continuous_shift_flags, point_distance, buffer_thickness=-1, all_twelve_neighbors=False, exercise_cpp=True): if (exercise_cpp): cpp = close_packing.hexagonal_sampling_generator( cb_op_original_to_sampling=cb_op_original_to_sampling, float_asu=float_asu, continuous_shift_flags=continuous_shift_flags, point_distance=point_distance, buffer_thickness=buffer_thickness, all_twelve_neighbors=all_twelve_neighbors) assert point_distance > 0 if (buffer_thickness < 0): buffer_thickness = point_distance * (2/3. * (.5 * math.sqrt(3))) if (exercise_cpp): assert cpp.cb_op_original_to_sampling().c()==cb_op_original_to_sampling.c() assert cpp.float_asu().unit_cell().is_similar_to(float_asu.unit_cell()) assert cpp.continuous_shift_flags() == continuous_shift_flags assert approx_equal(cpp.point_distance(), point_distance) assert approx_equal(cpp.buffer_thickness(), buffer_thickness) assert cpp.all_twelve_neighbors() == all_twelve_neighbors float_asu_buffer = float_asu.add_buffer(thickness=buffer_thickness) hex_cell = hexagonal_sampling_cell(point_distance=point_distance) hex_box = hexagonal_box( hex_cell=hex_cell, vertices_cart=float_asu.shape_vertices(cartesian=True)) hex_box_buffer = hexagonal_box( hex_cell=hex_cell, vertices_cart=float_asu_buffer.shape_vertices(cartesian=True)) box_lower = [] box_upper = [] for i in xrange(3): if (continuous_shift_flags[i]): box_lower.append(0) box_upper.append(0) else: n = iceil(abs(hex_box.max[i]-hex_box.pivot[i])) box_lower.append(min(-2,ifloor(hex_box_buffer.min[i]-hex_box.pivot[i]))) box_upper.append(n+max(2,iceil(hex_box_buffer.max[i]-hex_box.max[i]))) if (exercise_cpp): assert list(cpp.box_lower()) == box_lower assert list(cpp.box_upper()) == box_upper hex_to_frac_matrix = ( matrix.sqr(float_asu.unit_cell().fractionalization_matrix()) * matrix.sqr(hex_cell.orthogonalization_matrix())) sites_frac = flex.vec3_double() for point in flex.nested_loop(begin=box_lower, end=box_upper, open_range=False): site_hex = matrix.col(hex_box.pivot) \ + matrix.col(hex_indices_as_site(point)) site_frac = hex_to_frac_matrix * site_hex if (float_asu_buffer.is_inside(site_frac)): sites_frac.append(site_frac) elif (all_twelve_neighbors): for offset in [(1,0,0),(1,1,0),(0,1,0),(-1,0,0),(-1,-1,0),(0,-1,0), (0,0,1),(-1,-1,1),(0,-1,1), (0,0,-1),(-1,-1,-1),(0,-1,-1)]: offset_hex = hex_indices_as_site(offset, layer=point[2]) offset_frac = hex_to_frac_matrix * matrix.col(offset_hex) other_site_frac = site_frac + offset_frac if (float_asu.is_inside(other_site_frac)): sites_frac.append(site_frac) break assert sites_frac.size() > 0 rt = cb_op_original_to_sampling.c_inv().as_double_array() sites_frac = rt[:9] * sites_frac sites_frac += rt[9:] if (exercise_cpp): assert not cpp.at_end() cpp_sites_frac = cpp.all_sites_frac() assert cpp.at_end() assert cpp_sites_frac.size() == sites_frac.size() assert approx_equal(cpp_sites_frac, sites_frac) cpp.restart() assert not cpp.at_end() assert approx_equal(cpp.next_site_frac(), sites_frac[0]) assert cpp.count_sites() == sites_frac.size()-1 assert cpp.at_end() cpp.restart() n = 0 for site in cpp: n += 1 assert n == sites_frac.size() return sites_frac
def update_solvent_and_scale_2(self, fast, params, apply_back_trace, refine_hd_scattering, log): if(params is None): params = bss.master_params.extract() if(self.xray_structure is not None): # Figure out Fcalc and Fmask based on presence of H hd_selection = self.xray_structure.hd_selection() xrs_no_h = self.xray_structure.select(~hd_selection) xrs_h = self.xray_structure.select(hd_selection) # Create data container for scalers. If H scattering is refined then it is # assumed that self.f_calc() does not contain H contribution at all. fmodel_kbu = mmtbx.f_model.manager_kbu( f_obs = self.f_obs(), f_calc = self.f_calc(), f_masks = self.f_masks(), ss = self.ss) # Compute k_total and k_mask using one of the two methods (anal or min). # Note: this intentionally ignores previously existing f_part1 and f_part2. # k_sol, b_sol, b_cart, b_adj = [None,]*4 if(fast): # analytical assert len(fmodel_kbu.f_masks)==1 result = mmtbx.bulk_solvent.scaler.run_simple( fmodel_kbu = fmodel_kbu, r_free_flags = self.r_free_flags(), bulk_solvent = params.bulk_solvent, bin_selections = self.bin_selections) r_all_from_scaler = result.r_all() # must be here, before apply_back_trace else: # using minimization: exp solvent and scale model (k_sol,b_sol,b_cart) result = bss.bulk_solvent_and_scales( fmodel_kbu = fmodel_kbu, params = params) k_sol, b_sol, b_cart = result.k_sols(), result.b_sols(), result.b_cart() r_all_from_scaler = result.r_all() # must be here, before apply_back_trace if(apply_back_trace and len(fmodel_kbu.f_masks)==1 and self.xray_structure is not None): o = result.apply_back_trace_of_overall_exp_scale_matrix( xray_structure = self.xray_structure) b_adj = o.b_adj if(not fast): b_sol, b_cart = [o.b_sol], o.b_cart self.update_xray_structure( xray_structure = o.xray_structure, update_f_calc = True) fmodel_kbu = fmodel_kbu.update(f_calc = self.f_calc()) self.show(prefix = "overall B=%s to atoms"%str("%7.2f"%o.b_adj).strip(), log = log) # Update self with new arrays so that H correction knows current R factor. # If no H to account for, then this is the final result. k_masks = result.k_masks() k_anisotropic = result.k_anisotropic() k_isotropic = result.k_isotropic() self.update_core( k_mask = k_masks, k_anisotropic = k_anisotropic, k_isotropic = k_isotropic) self.show(prefix = "bulk-solvent and scaling", log = log) # Consistency check assert approx_equal(self.r_all(), r_all_from_scaler) # Add contribution from H (if present and riding). This goes to f_part2. kh, bh = 0, 0 if(refine_hd_scattering and self.need_to_refine_hd_scattering_contribution()): # Obsolete previous contribution f_part2 f_part2 = fmodel_kbu.f_calc.array(data=fmodel_kbu.f_calc.data()*0) self.update_core(f_part2 = f_part2) xrs_h = xrs_h.set_occupancies(value=1).set_b_iso(value = 0) f_h = self.compute_f_calc(xray_structure = xrs_h) # Accumulate all mask contributions: Fcalc_atoms+Fbulk_1+...+Fbulk_N data = fmodel_kbu.f_calc.data() for k_mask_, f_mask_ in zip(k_masks, fmodel_kbu.f_masks): data = data + k_mask_*f_mask_.data() f_calc_plus_f_bulk_no_scales = fmodel_kbu.f_calc.array(data = data) # Consistency check assert approx_equal(self.f_model().data(), f_calc_plus_f_bulk_no_scales.data()*k_isotropic*k_anisotropic) assert approx_equal(self.f_model_no_scales().data(), f_calc_plus_f_bulk_no_scales.data()) # # Compute contribution from H (F_H) # # Coarse sampling b_mean = flex.mean(xrs_no_h.extract_u_iso_or_u_equiv())*adptbx.u_as_b(1.) b_min = int(max(0,b_mean)*0.5) b_max = int(b_mean*1.5) sc = 1000. kr=[i/sc for i in range(ifloor(0*sc), iceil(1.5*sc)+1, int(0.1*sc))] br=[i/sc for i in range(ifloor(b_min*sc), iceil(b_max*sc)+1, int(5.*sc))] o = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin( f_obs = fmodel_kbu.f_obs.data(), f_calc = f_calc_plus_f_bulk_no_scales.data(), f_mask = f_h.data(), k_total = k_isotropic*k_anisotropic, ss = fmodel_kbu.ss, k_sol_range = flex.double(kr), b_sol_range = flex.double(br), r_ref = self.r_work()) if(o.updated()): f_part2 = f_h.array(data = o.k_mask()*f_h.data()) kh, bh = o.k_sol(), o.b_sol() self.show(prefix = "add H (%4.2f, %6.2f)"%(kh, bh), log = log, r=o.r()) # Fine sampling k_min = max(0,o.k_sol()-0.1) k_max = o.k_sol()+0.1 b_min = max(0,o.b_sol()-5.) b_max = o.b_sol()+5. kr=[i/sc for i in range(ifloor(k_min*sc),iceil(k_max*sc)+1,int(0.01*sc))] br=[i/sc for i in range(ifloor(b_min*sc),iceil(b_max*sc)+1,int(1.*sc))] o = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin( f_obs = fmodel_kbu.f_obs.data(), f_calc = f_calc_plus_f_bulk_no_scales.data(), f_mask = f_h.data(), k_total = k_isotropic*k_anisotropic, ss = fmodel_kbu.ss, k_sol_range = flex.double(kr), b_sol_range = flex.double(br), r_ref = o.r()) if(o.updated()): f_part2 = f_h.array(data = o.k_mask()*f_h.data()) kh, bh = o.k_sol(), o.b_sol() self.show(prefix = "add H (%4.2f, %6.2f)"%(kh, bh), log = log, r=o.r()) # THIS HELPS if fast=true is used, see how it works in reality # if(fast): fmodel_kbu_ = mmtbx.f_model.manager_kbu( f_obs = self.f_obs(), f_calc = f_calc_plus_f_bulk_no_scales, f_masks = [f_part2], ss = self.ss) result = mmtbx.bulk_solvent.scaler.run_simple( fmodel_kbu = fmodel_kbu_, r_free_flags = self.r_free_flags(), bulk_solvent = params.bulk_solvent, bin_selections = self.bin_selections) f_part2 = f_part2.array(data = result.core.k_mask()*f_part2.data()) k_isotropic = result.core.k_isotropic*result.core.k_isotropic_exp k_anisotropic = result.core.k_anisotropic # Update self with final scales self.update_core( k_mask = k_masks, k_anisotropic = k_anisotropic, k_isotropic = k_isotropic, f_part2 = f_part2) # Make sure what came out of scaling matches what self thinks it really is # It must match at least up to 1.e-6. self.show(prefix = "add H (%4.2f, %6.2f)"%(kh, bh), log = log) if(fast): assert approx_equal(result.r_factor(), self.r_work()) else: assert approx_equal(self.r_all(), o.r()), [self.r_all(), o.r()] return group_args( k_sol = k_sol, b_sol = b_sol, b_cart = b_cart, k_h = kh, b_h = bh, b_adj = b_adj)
def get_zoom_box (self, x, y, boxsize=400, mag=16) : #assert ((boxsize % mag) == 0) n_pixels = iceil(boxsize / mag) x0 = min(self.img_w - n_pixels, ifloor(x - (n_pixels / 2))) y0 = min(self.img_h - n_pixels, ifloor(y - (n_pixels / 2))) return (x0, y0, n_pixels, n_pixels)
def line_between_points(self, x1, y1, x2, y2, n_values=100): """ Given two points on the image, sample intensities along a line connecting them (using linear interpolation). This also calculates the coordinates of each sample point, which is used for lattice dimension calculations once peaks have been identified. Arguments are in image pixel coordinates (starting at 1,1). """ x1_, y1_ = self.image_coords_as_array_coords(x1, y1) x2_, y2_ = self.image_coords_as_array_coords(x2, y2) n_values = ifloor(math.sqrt((x2_ - x1_)**2 + (y2_ - y1_)**2)) delta_x = (x2_ - x1_) / (n_values - 1) delta_y = (y2_ - y1_) / (n_values - 1) vals = [] img_coords = [] d = self._raw.linearintdata # TODO remarkably, this is reasonably fast in Python, but it would # probably be more at home in scitbx.math for n in range(n_values): x = x1_ + (n * delta_x) y = y1_ + (n * delta_y) xd, yd = self.array_coords_as_detector_coords(x, y) img_coords.append((xd, yd)) x_1 = ifloor(x) x_2 = iceil(x) y_1 = ifloor(y) y_2 = iceil(y) v11 = d[(x_1, y_1)] v12 = d[(x_1, y_2)] v21 = d[(x_2, y_1)] v22 = d[(x_2, y_2)] if (x_2 == x_1): if (y_2 == y_1): vxy = v11 else: vxy = ((v12 * (y - y_1)) + (v11 * (y_2 - y))) / (y_2 - y_1) elif (y_2 == y_1): vxy = ((v21 * (x - x_1)) + (v11 * (x_2 - x))) / (x_2 - x_1) else: dxdy = (y_2 - y_1) * (x_2 - x_1) vxy = ((v11 / dxdy) * (x_2 - x) * (y_2 - y)) + \ ((v21 / dxdy) * (x - x_1) * (y_2 - y)) + \ ((v12 / dxdy) * (x_2 - x) * (y - y_1)) + \ ((v22 / dxdy) * (x - x_1) * (y - y_1)) vals.append(vxy) lattice_length = None if (len(vals) > 5): # first find peaks in the profile peaks = [] avg = sum(vals) / len(vals) filtered_vals = [] for x in vals: if (x <= avg * 3): filtered_vals.append(x) background = sum(filtered_vals) / len(filtered_vals) i = 2 while (i < len(vals) - 2): x = vals[i] if (x <= background): pass elif ((x > vals[i - 1]) and (x > vals[i - 2]) and (x > vals[i + 1]) and (x > vals[i + 2])): peaks.append(i) i += 1 if (len(peaks) > 0): # calculate the average lattice length center_x, center_y = self.get_beam_center_mm() distances = [] i = 1 while (i < len(peaks)): x1, y1 = img_coords[peaks[i - 1]] x2, y2 = img_coords[peaks[i]] rs_distance = rstbx.utils.reciprocal_space_distance( x1, y1, x2, y2, wavelength=self.get_wavelength(), center_x=center_x, center_y=center_y, distance=self.get_detector_distance(), detector_two_theta=self.get_detector_2theta(), distance_is_corrected=True) assert (rs_distance > 0) distances.append(1 / rs_distance) i += 1 lattice_length = sum(distances) / len(distances) distance = self.distance_between_points(x1, y1, x2, y2) return line_profile(vals, distance, lattice_length)
def update_solvent_and_scale_twin(self, refine_hd_scattering, log): if(not self.twinned()): return assert len(self.f_masks()) == 1 # Re-set all scales to unit or zero self.show(prefix = "update scales twin start", log = log) self.reset_all_scales() self.show(prefix = "reset f_part, k_(total,mask)", log = log) f_calc_data = self.f_calc().data() f_calc_data_twin = self.f_calc_twin().data() # Initial trial set sc = 1000. ksr = [i/sc for i in range(ifloor(0*sc), iceil(0.6*sc)+1, int(0.05*sc))] bsr = [i/sc for i in range(ifloor(0*sc), iceil(150.*sc)+1, int(10.*sc))] o_kbu_sol = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin( f_obs = self.f_obs().data(), f_calc_1 = f_calc_data, f_calc_2 = f_calc_data_twin, f_mask_1 = self.arrays.core.f_masks[0].data(), f_mask_2 = self.arrays.core_twin.f_masks[0].data(), ss = self.ss, twin_fraction = self.twin_fraction, k_sol_range = flex.double(ksr), b_sol_range = flex.double(bsr), miller_indices = self.f_obs().indices(), #XXX ??? What about twin-related? unit_cell = self.f_obs().unit_cell(), r_ref = self.r_all()) if(o_kbu_sol.updated()): self.update( k_mask = o_kbu_sol.k_mask(), k_anisotropic = o_kbu_sol.k_anisotropic()) # Second (finer) trial set k_min = max(o_kbu_sol.k_sol()-0.05, 0) k_max = min(o_kbu_sol.k_sol()+0.05, 0.6) ksr = [i/sc for i in range(ifloor(k_min*sc), iceil(k_max*sc)+1, int(0.01*sc))] b_min = max(o_kbu_sol.b_sol()-10, 0) b_max = min(o_kbu_sol.b_sol()+10, 150) bsr = [i/sc for i in range(ifloor(b_min*sc), iceil(b_max*sc)+1, int(1.*sc))] o_kbu_sol = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin( f_obs = self.f_obs().data(), f_calc_1 = f_calc_data, f_calc_2 = f_calc_data_twin, f_mask_1 = self.arrays.core.f_masks[0].data(), f_mask_2 = self.arrays.core_twin.f_masks[0].data(), ss = self.ss, twin_fraction = self.twin_fraction, k_sol_range = flex.double(ksr), b_sol_range = flex.double(bsr), miller_indices = self.f_obs().indices(), #XXX ??? What about twin-related? unit_cell = self.f_obs().unit_cell(), r_ref = o_kbu_sol.r()) if(o_kbu_sol.updated()): self.update( k_mask = o_kbu_sol.k_mask(), k_anisotropic = o_kbu_sol.k_anisotropic()) assert approx_equal(self.r_all(), o_kbu_sol.r()) ############## # use apply_back_trace in if below if(self.xray_structure is not None): o = mmtbx.bulk_solvent.scaler.tmp( xray_structure = self.xray_structure, k_anisotropic = o_kbu_sol.k_anisotropic(), k_masks = [o_kbu_sol.k_mask()], ss = self.ss) self.update_xray_structure( xray_structure = o.xray_structure, update_f_calc = True) ############# self.update( k_mask = o.k_masks, k_anisotropic = o.k_anisotropic) self.show(prefix = "bulk-solvent and scaling", log = log) # # Add contribution from H (if present and riding). This goes to f_part2. # kh, bh = 0, 0 if(refine_hd_scattering and self.need_to_refine_hd_scattering_contribution()): hd_selection = self.xray_structure.hd_selection() xrs_no_h = self.xray_structure.select(~hd_selection) xrs_h = self.xray_structure.select(hd_selection) # Accumulate all mask contributions: Fcalc_atoms+Fbulk_1+...+Fbulk_N data = self.f_calc().data()+self.f_masks()[0].data()*self.k_masks()[0] f_calc_plus_f_bulk_no_scales = self.f_calc().array(data = data) data = self.f_calc_twin().data()+\ self.f_masks_twin()[0].data()*self.k_masks_twin()[0] f_calc_plus_f_bulk_no_scales_twin = self.f_calc_twin().array(data = data) # Initial FH contribution xrs_h = xrs_h.set_occupancies(value=1).set_b_iso(value = 0) f_h = self.compute_f_calc(xray_structure = xrs_h) f_h_twin = self.compute_f_calc(xray_structure = xrs_h, miller_array = self.f_calc_twin()) # Coarse sampling b_mean = flex.mean(xrs_no_h.extract_u_iso_or_u_equiv())*adptbx.u_as_b(1.) b_min = int(max(0,b_mean)*0.5) b_max = int(b_mean*1.5) sc = 1000. kr=[i/sc for i in range(ifloor(0*sc), iceil(1.5*sc)+1, int(0.1*sc))] br=[i/sc for i in range(ifloor(b_min*sc), iceil(b_max*sc)+1, int(5.*sc))] obj = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin( f_obs = self.f_obs().data(), f_calc_1 = f_calc_plus_f_bulk_no_scales.data(), f_calc_2 = f_calc_plus_f_bulk_no_scales_twin.data(), f_mask_1 = f_h.data(), f_mask_2 = f_h_twin.data(), ss = self.ss, twin_fraction = self.twin_fraction, k_sol_range = flex.double(kr), b_sol_range = flex.double(br), miller_indices = self.f_obs().indices(), # XXX What about twin-related? unit_cell = self.f_obs().unit_cell(), r_ref = self.r_work()) if(obj.updated()): f_part2 = f_h.array( data = obj.k_mask()*f_h.data()) f_part2_twin = f_h_twin.array(data = obj.k_mask()*f_h_twin.data()) kh, bh = obj.k_sol(), obj.b_sol() # Fine sampling k_min = max(0,obj.k_sol()-0.1) k_max = obj.k_sol()+0.1 b_min = max(0,obj.b_sol()-5.) b_max = obj.b_sol()+5. kr=[i/sc for i in range(ifloor(k_min*sc),iceil(k_max*sc)+1,int(0.01*sc))] br=[i/sc for i in range(ifloor(b_min*sc),iceil(b_max*sc)+1,int(5.*sc))] obj = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin( f_obs = self.f_obs().data(), f_calc_1 = f_calc_plus_f_bulk_no_scales.data(), f_calc_2 = f_calc_plus_f_bulk_no_scales_twin.data(), f_mask_1 = f_h.data(), f_mask_2 = f_h_twin.data(), ss = self.ss, twin_fraction = self.twin_fraction, k_sol_range = flex.double(kr), b_sol_range = flex.double(br), miller_indices = self.f_obs().indices(), # XXX What about twin-related? unit_cell = self.f_obs().unit_cell(), r_ref = obj.r()) if(obj.updated()): f_part2 = f_h.array( data = obj.k_mask()*f_h.data()) f_part2_twin = f_h_twin.array(data = obj.k_mask()*f_h_twin.data()) kh, bh = obj.k_sol(), obj.b_sol() self.update_core( f_part2 = f_part2, f_part2_twin = f_part2_twin, k_anisotropic = obj.k_anisotropic()) self.show(prefix = "add H (%4.2f, %6.2f)"%(kh, bh), log = log) b_cart = adptbx.u_as_b(adptbx.u_star_as_u_cart( self.f_obs().unit_cell(), o_kbu_sol.u_star())) return group_args( k_sol = o_kbu_sol.k_sol(), b_sol = o_kbu_sol.b_sol(), b_cart = b_cart, k_h = kh, b_h = bh)