def box_iterator(self): p = self.xrs.unit_cell().parameters() b = maptbx.boxes_by_dimension(n_real=self.n_real, dim=self.box_dimension, abc=p[:3]) i_box = 0 for s, e in zip(b.starts, b.ends): i_box += 1 map_box_obs = maptbx.copy(self.map_data_obs, s, e) map_box_calc = maptbx.copy(self.map_data_calc, s, e) map_box_obs.reshape(flex.grid(map_box_obs.all())) map_box_calc.reshape(flex.grid(map_box_calc.all())) ####### # XXX Copy-paste from map_box abc = [] for i in range(3): abc.append(p[i] * map_box_calc.all()[i] / self.n_real[i]) ucb = uctbx.unit_cell(parameters=(abc[0], abc[1], abc[2], p[3], p[4], p[5])) cs = crystal.symmetry(unit_cell=ucb, space_group="P1") ####### diff_map = scale_two_real_maps_in_fourier_space( m1=map_box_obs, m2=map_box_calc, cs=cs, d_min=self.d_min, vector_map=self.vector_map) maptbx.set_box(map_data_from=diff_map, map_data_to=self.map_result, start=s, end=e) sd = self.map_result.sample_standard_deviation() if (sd != 0): self.map_result = self.map_result / sd
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 calculate_exp_i_two_phi_peaks(xray_structure, d_min, min_peak_distance, max_reduced_peaks): f_h = xray_structure.structure_factors( anomalous_flag=False, d_min=d_min).f_calc() two_i_phi_h = miller.array( miller_set=f_h, data=flex.polar(1, flex.arg(f_h.data())*2)) fft_map = two_i_phi_h.fft_map( d_min=d_min, symmetry_flags=maptbx.use_space_group_symmetry) real_map = fft_map.real_map() real_map = maptbx.copy(real_map, flex.grid(real_map.focus())) stats = maptbx.statistics(real_map) if (stats.max() != 0): real_map /= abs(stats.max()) grid_tags = maptbx.grid_tags(real_map.focus()) grid_tags.build(fft_map.space_group_info().type(), fft_map.symmetry_flags()) grid_tags.verify(real_map) peak_list = maptbx.peak_list( data=real_map, tags=grid_tags.tag_array(), max_peaks=10*max_reduced_peaks, interpolate=True) reduced_peaks = peak_cluster_reduction( crystal_symmetry=xray_structure, peak_list=peak_list, min_peak_distance=min_peak_distance, max_reduced_peaks=max_reduced_peaks) return reduced_peaks
def apply_to_map(self, map_manager): assert map_manager is not None # Apply to a map_manager that is similar to the one used to generate # this around_model object assert map_manager.crystal_symmetry().is_similar_symmetry( self.original_crystal_symmetry) ma1 = map_manager.map_data().accessor() ma2 = self.original_accessor assert ma1.all() == ma2.all() assert ma1.origin() == ma2.origin() assert ma1.focus() == ma2.focus() map_data = map_manager.map_data() # Check if map is all valid bounds_info = get_bounds_of_valid_region( map_data=map_data, gridding_first=self.gridding_first, gridding_last=self.gridding_last) if self.wrapping or bounds_info.inside_allowed_bounds: # Just copy everything map_box = maptbx.copy(map_data, self.gridding_first, self.gridding_last) # Note: map_box gridding is self.gridding_first to self.gridding_last else: # Need to copy and then zero outside of defined region map_box = copy_and_zero_map_outside_bounds(map_data=map_data, bounds_info=bounds_info) # Now reshape map_box to put origin at (0,0,0) map_box.reshape(flex.grid(self.box_all)) # Create new map_manager object: # Use original values for: # unit_cell_grid (gridding of original full unit cell) # unit_cell_crystal_symmetry (symmetry of original full unit cell) # input_file_name # Use new (boxed) values for: # map_data # crystal_symmetry (symmetry of the part of the map that is present) # Update: # origin_shift_grid_units (position in the original map of the # (0,0,0) grid point in map_box) # labels (add label specifying boxing operation) # # New origin_shift_grid_units: origin_shift_grid_units = [ self.gridding_first[i] + map_manager.origin_shift_grid_units[i] for i in range(3) ] # New labels: new_label = "Boxed %s to %s %s" % (str(tuple( self.gridding_first)), str(tuple( self.gridding_last)), self.basis_for_boxing_string) # Set up new map_manager. # NOTE: origin_shift_grid_units is required as bounds have changed new_map_manager = map_manager.customized_copy( map_data=map_box, origin_shift_grid_units=origin_shift_grid_units) # Add the label new_map_manager.add_label(new_label) return new_map_manager
def get_diff_map(symmetry, fcalc_map, expt_map, d_min): """Compute a difference map between the calculated and experimental maps. Modified from mmtbx.command_line.real_space_diff_map class compdiff.""" scale = scale_k1(x=expt_map, y=fcalc_map) scaled_fcalc_map = fcalc_map * scale # should already be scaled but okay origin = expt_map.origin() shifted_expt_map = expt_map.shift_origin() shifted_diff_map = flex.double(flex.grid(expt_map.all())) diff_map = flex.double(flex.grid(expt_map.origin(), expt_map.focus())) ucell_params = symmetry.unit_cell().parameters() boxes = maptbx.boxes_by_dimension(n_real=expt_map.all(), dim=30, abc=ucell_params[:3]) i_box = 0 test_map_box_obs_all = None for start, end in zip(boxes.starts, boxes.ends): i_box += 1 map_box_obs = maptbx.copy(shifted_expt_map, start, end) map_box_calc = maptbx.copy(scaled_fcalc_map, start, end) map_box_obs.reshape(flex.grid(map_box_obs.all())) map_box_calc.reshape(flex.grid(map_box_calc.all())) # abc = [ucell_params[i]/expt_map.all()[i] for i in range(3)] # ucb = uctbx.unit_cell(parameters=( # abc[0],abc[1],abc[2],ucell_params[3],ucell_params[4],ucell_params[5])) # cs = crystal.symmetry(unit_cell=ucb, space_group="P1") cs = symmetry diff_map_part = scale_two_real_maps_in_fourier_space( m1=map_box_obs, m2=map_box_calc, cs=cs, d_min=d_min, vector_map=True) # this means yes, use the phases from fcalc maptbx.set_box(map_data_from=diff_map_part, map_data_to=shifted_diff_map, start=start, end=end) # skip this additional scaling step -- it explodes everything # sd = diff_map.sample_standard_deviation() # if(sd!=0): # diff_map = diff_map/sd # somehow put the contents of shifted_diff_map into diff_map but keep origin? for i in xrange(len(shifted_diff_map)): diff_map[i] = shifted_diff_map[i] # FIXME SUPER SLOW but it should work for now return diff_map
def __init__(self, crystal_gridding, fmodel, map_type, max_boxes, box_size_as_fraction=None): sgt = fmodel.f_obs().space_group().type() assert sgt.number() == 1 def get_map(fmodel, map_type, external_complete_set=None): f_map = fmodel.electron_density_map().map_coefficients( map_type=map_type, isotropize=True, fill_missing=False) fft_map = miller.fft_map(crystal_gridding=crystal_gridding, fourier_coefficients=f_map) return fft_map.real_map_unpadded() f_model = fmodel.f_model_scaled_with_k1() fft_map = miller.fft_map(crystal_gridding=crystal_gridding, fourier_coefficients=f_model) f_model_map_data = fft_map.real_map_unpadded() zero_complex_ma = f_model.customized_copy( data=flex.complex_double(f_model.data().size(), 0)) b = maptbx.boxes(fraction=0.3, n_real=f_model_map_data.focus(), max_boxes=max_boxes, log=sys.stdout) self.map_result = flex.double(flex.grid(b.n_real)) self.r = flex.double() for s, e in zip(b.starts, b.ends): f_model_map_data_omit = maptbx.set_box_copy( value=0, map_data_to=f_model_map_data, start=s, end=e) f_model_omit = f_model.structure_factors_from_map( map=f_model_map_data_omit, use_scale=True, anomalous_flag=False, use_sg=False) fmodel_ = mmtbx.f_model.manager(f_obs=fmodel.f_obs(), r_free_flags=fmodel.r_free_flags(), f_calc=f_model_omit, f_mask=zero_complex_ma) self.r.append(fmodel_.r_work()) f_map_data = get_map(fmodel=fmodel_, map_type=map_type) etmp = [e[0] - 1, e[1] - 1, e[2] - 1] # because .copy() includes right edge box = maptbx.copy(f_map_data, s, etmp) box.reshape(flex.grid(box.all())) maptbx.set_box(map_data_from=box, map_data_to=self.map_result, start=s, end=e) sd = self.map_result.sample_standard_deviation() self.map_result = self.map_result / sd self.map_coefficients = fmodel.f_obs().structure_factors_from_map( map=self.map_result, use_scale=True, anomalous_flag=False, use_sg=False)
def exercise_writer(): from iotbx import file_reader from cctbx import uctbx, sgtbx from scitbx.array_family import flex file_name = libtbx.env.find_in_repositories( relative_path= "phenix_regression/wizards/partial_refine_001_map_coeffs.mtz", test=os.path.isfile) if file_name is None: print "Can't find map coefficients file, skipping." return mtz_in = file_reader.any_file(file_name, force_type="hkl").file_object miller_arrays = mtz_in.as_miller_arrays() map_coeffs = miller_arrays[0] fft_map = map_coeffs.fft_map(resolution_factor=1 / 3.0) fft_map.apply_sigma_scaling() fft_map.as_ccp4_map(file_name="2mFo-DFc.map") m = iotbx.ccp4_map.map_reader(file_name="2mFo-DFc.map") real_map = fft_map.real_map_unpadded() mmm = flex.double(list(real_map)).min_max_mean() assert approx_equal(m.unit_cell_parameters, map_coeffs.unit_cell().parameters()) assert approx_equal(mmm.min, m.header_min) assert approx_equal(mmm.max, m.header_max) #assert approx_equal(mmm.mean, m.header_mean) # random small maps of different sizes for nxyz in flex.nested_loop((1, 1, 1), (4, 4, 4)): mt = flex.mersenne_twister(0) grid = flex.grid(nxyz) map = mt.random_double(size=grid.size_1d()) map.reshape(grid) real_map = fft_map.real_map_unpadded() iotbx.ccp4_map.write_ccp4_map( file_name="random.map", unit_cell=uctbx.unit_cell((1, 1, 1, 90, 90, 90)), space_group=sgtbx.space_group_info("P1").group(), gridding_first=(0, 0, 0), gridding_last=tuple(fft_map.n_real()), map_data=real_map, labels=flex.std_string(["iotbx.ccp4_map.tst"])) m = iotbx.ccp4_map.map_reader(file_name="random.map") mmm = flex.double(list(real_map)).min_max_mean() assert approx_equal(m.unit_cell_parameters, (1, 1, 1, 90, 90, 90)) assert approx_equal(mmm.min, m.header_min) assert approx_equal(mmm.max, m.header_max) # gridding_first = (0, 0, 0) gridding_last = tuple(fft_map.n_real()) map_box = maptbx.copy(map, gridding_first, gridding_last) map_box.reshape(flex.grid(map_box.all())) iotbx.ccp4_map.write_ccp4_map( file_name="random_box.map", unit_cell=uctbx.unit_cell((1, 1, 1, 90, 90, 90)), space_group=sgtbx.space_group_info("P1").group(), map_data=map_box, labels=flex.std_string(["iotbx.ccp4_map.tst"]))
def copy_and_zero_map_outside_bounds(map_data=None, bounds_info=None): ''' Copy part of a map and zero outside valid region Goes with get_bounds_of_valid_region First copy requested part of map, wrapping if request goes outside of supplied map. Then zero out everything that was from outside the available region. Returns map with bounds from bounds_info.gridding_first to bounds_info.gridding_last, but everything outside of lower_allowed_bounds to upper_allowed_bounds is zeroed out. ''' # First copy the entire requested region: map_copy = maptbx.copy(map_data, bounds_info.gridding_first, bounds_info.gridding_last) # Note: the origin of map_copy is at gridding_first and goes to last # Make sure we are working with a flex.double array if type(map_copy) != type(flex.double()): # must be double map_copy = map_copy.as_double() # Now zero out everything outside of the valid region # Make sure this map matches the bounds_info assert tuple(map_copy.origin()) == tuple(bounds_info.gridding_first) # We are going to shift the origin in this copy, so shift the bounds to match lower_bounds_after_shift = [] upper_bounds_after_shift = [] for l, u, f in zip(bounds_info.lower_allowed_bounds, bounds_info.upper_allowed_bounds, bounds_info.gridding_first): lower_bounds_after_shift.append(l - f) upper_bounds_after_shift.append(u - f) acc = map_copy.accessor() # save where the origin is map_copy = map_copy.shift_origin() # put origin at (0,0,0) map_copy_all = map_copy.all() # save size of map # XXX work-around for set_box does not allow offset origin map_copy.resize(flex.grid(map_copy_all)) new_map = maptbx.set_box_copy_inside( 0, # copies inside, zero outside bounds map_data_to=map_copy, start=tuple(lower_bounds_after_shift), end=tuple(upper_bounds_after_shift)) # XXX and shift map back new_map = new_map.as_1d() new_map.reshape(acc) return new_map
def exercise_writer () : from iotbx import file_reader from cctbx import uctbx, sgtbx from scitbx.array_family import flex file_name = libtbx.env.find_in_repositories( relative_path="phenix_regression/wizards/partial_refine_001_map_coeffs.mtz", test=os.path.isfile) if file_name is None : print "Can't find map coefficients file, skipping." return mtz_in = file_reader.any_file(file_name, force_type="hkl").file_object miller_arrays = mtz_in.as_miller_arrays() map_coeffs = miller_arrays[0] fft_map = map_coeffs.fft_map(resolution_factor=1/3.0) fft_map.apply_sigma_scaling() fft_map.as_ccp4_map(file_name="2mFo-DFc.map") m = iotbx.ccp4_map.map_reader(file_name="2mFo-DFc.map") real_map = fft_map.real_map_unpadded() mmm = flex.double(list(real_map)).min_max_mean() assert approx_equal(m.unit_cell_parameters, map_coeffs.unit_cell().parameters()) assert approx_equal(mmm.min, m.header_min) assert approx_equal(mmm.max, m.header_max) #assert approx_equal(mmm.mean, m.header_mean) # random small maps of different sizes for nxyz in flex.nested_loop((1,1,1),(4,4,4)): mt = flex.mersenne_twister(0) grid = flex.grid(nxyz) map = mt.random_double(size=grid.size_1d()) map.reshape(grid) real_map = fft_map.real_map_unpadded() iotbx.ccp4_map.write_ccp4_map( file_name="random.map", unit_cell=uctbx.unit_cell((1,1,1,90,90,90)), space_group=sgtbx.space_group_info("P1").group(), gridding_first=(0,0,0), gridding_last=tuple(fft_map.n_real()), map_data=real_map, labels=flex.std_string(["iotbx.ccp4_map.tst"])) m = iotbx.ccp4_map.map_reader(file_name="random.map") mmm = flex.double(list(real_map)).min_max_mean() assert approx_equal(m.unit_cell_parameters, (1,1,1,90,90,90)) assert approx_equal(mmm.min, m.header_min) assert approx_equal(mmm.max, m.header_max) # gridding_first = (0,0,0) gridding_last = tuple(fft_map.n_real()) map_box = maptbx.copy(map, gridding_first, gridding_last) map_box.reshape(flex.grid(map_box.all())) iotbx.ccp4_map.write_ccp4_map( file_name="random_box.map", unit_cell=uctbx.unit_cell((1,1,1,90,90,90)), space_group=sgtbx.space_group_info("P1").group(), map_data=map_box, labels=flex.std_string(["iotbx.ccp4_map.tst"]))
def map_of_coeff_scaled(mask_map,structure,nxyz): assert mask_map.is_0_based() assert not mask_map.is_padded() fft_manager = fftpack.real_to_complex_3d(mask_map.focus()) padded_data = maptbx.copy(mask_map, flex.grid(fft_manager.m_real() ).set_focus(fft_manager.n_real())) map_of_coeff = fft_manager.forward(padded_data) scale = matrix.col(nxyz).product()/structure.unit_cell().volume() sc = matrix.col(mask_map.focus()).product()/structure.unit_cell().volume() assert sc == scale map_of_coeff /= scale return map_of_coeff
def exercise_mask_data_2(space_group_info, n_sites=100, d_min=2.0, resolution_factor=1. / 4): from cctbx import maptbx from cctbx.masks import vdw_radii_from_xray_structure for yn2 in [0, 1]: for yn in [0, 1]: 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) xrs.shake_sites_in_place(mean_distance=10) if (yn2): xrs = xrs.expand_to_p1(sites_mod_positive=True) atom_radii = vdw_radii_from_xray_structure(xray_structure=xrs) asu_mask = masks.atom_mask(unit_cell=xrs.unit_cell(), group=xrs.space_group(), resolution=d_min, grid_step_factor=resolution_factor, solvent_radius=1.0, shrink_truncation_radius=1.0) asu_mask.compute(xrs.sites_frac(), atom_radii) mask_data = asu_mask.mask_data_whole_uc() # xrs_p1 = xrs.expand_to_p1(sites_mod_positive=True) for site_frac in xrs_p1.sites_frac(): mv = mask_data.value_at_closest_grid_point(site_frac) assert mv == 0 # mask_data = mask_data / xrs.space_group().order_z() if (yn == 1): mask_data = maptbx.copy(mask_data, flex.grid(mask_data.focus())) # for site_frac in xrs_p1.sites_frac(): mv = mask_data.value_at_closest_grid_point(site_frac) assert mv == 0 # fc = xrs.structure_factors(d_min=d_min).f_calc() f_mask_1 = fc.set().array( data=asu_mask.structure_factors(fc.indices())) f_mask_2 = f_mask_1.structure_factors_from_map( map=mask_data, use_scale=True, anomalous_flag=False, use_sg=True) fm1 = abs(f_mask_1).data() fm2 = abs(f_mask_2).data() r = flex.sum(flex.abs(fm1 - fm2)) / flex.sum(fm1 + fm2) assert approx_equal(r, 0.0)
def map_of_coeff_scaled(mask_map, structure, nxyz): assert mask_map.is_0_based() assert not mask_map.is_padded() fft_manager = fftpack.real_to_complex_3d(mask_map.focus()) padded_data = maptbx.copy( mask_map, flex.grid(fft_manager.m_real()).set_focus(fft_manager.n_real())) map_of_coeff = fft_manager.forward(padded_data) scale = matrix.col(nxyz).product() / structure.unit_cell().volume() sc = matrix.col( mask_map.focus()).product() / structure.unit_cell().volume() assert sc == scale map_of_coeff /= scale return map_of_coeff
def exercise_mask_data_2(space_group_info, n_sites=100, d_min=2.0, resolution_factor=1./4): from cctbx import maptbx from cctbx.masks import vdw_radii_from_xray_structure for yn2 in [0,1]: for yn in [0,1]: 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) xrs.shake_sites_in_place(mean_distance=10) if(yn2): xrs = xrs.expand_to_p1(sites_mod_positive=True) atom_radii = vdw_radii_from_xray_structure(xray_structure = xrs) asu_mask = masks.atom_mask( unit_cell = xrs.unit_cell(), group = xrs.space_group(), resolution = d_min, grid_step_factor = resolution_factor, solvent_radius = 1.0, shrink_truncation_radius = 1.0) asu_mask.compute(xrs.sites_frac(), atom_radii) mask_data = asu_mask.mask_data_whole_uc() # xrs_p1 = xrs.expand_to_p1(sites_mod_positive=True) for site_frac in xrs_p1.sites_frac(): mv = mask_data.value_at_closest_grid_point(site_frac) assert mv == 0 # mask_data = mask_data / xrs.space_group().order_z() if(yn == 1): mask_data = maptbx.copy(mask_data, flex.grid(mask_data.focus())) # for site_frac in xrs_p1.sites_frac(): mv = mask_data.value_at_closest_grid_point(site_frac) assert mv == 0 # fc = xrs.structure_factors(d_min = d_min).f_calc() f_mask_1 = fc.set().array(data = asu_mask.structure_factors(fc.indices())) f_mask_2 = f_mask_1.structure_factors_from_map(map=mask_data, use_scale = True, anomalous_flag = False, use_sg = True) fm1 = abs(f_mask_1).data() fm2 = abs(f_mask_2).data() r = flex.sum( flex.abs( fm1 - fm2 ) ) / flex.sum( fm1 + fm2 ) assert approx_equal(r, 0.0)
def exercise_set_box(): n_real = (60, 100, 160) n = n_real[0]*n_real[1]*n_real[2] cs=crystal.symmetry( unit_cell=(21,37,58,80,111,117), space_group_symbol="P1") be = maptbx.boxes(n_real = n_real, fraction=0.1) # m1 = flex.double([-1 for i in xrange(n)]) m1.resize(flex.grid(n_real)) m2 = flex.double([1 for i in xrange(n)]) m2.resize(flex.grid(n_real)) # for s,e in zip(be.starts, be.ends): box = maptbx.copy(m2, s, e) box.reshape(flex.grid(box.all())) maptbx.set_box( map_data_from = box, map_data_to = m1, start = s, end = e) assert m2.as_1d().min_max_mean().as_tuple() == (1.,1.,1.)
def __init__(self, map_data, cushion, xray_structure=None, pdb_hierarchy=None, crystal_symmetry=None): # safeguards if (xray_structure is None): assert [pdb_hierarchy, crystal_symmetry].count(None) == 0 cs = crystal_symmetry uc = cs.unit_cell() sites_frac = uc.fractionalize(pdb_hierarchy.atoms().extract_xyz()) else: if (crystal_symmetry is not None): assert crystal_symmetry.is_similar_symmetry( xray_structure.crystal_symmetry()) if (pdb_hierarchy is not None): assert approx_equal(xray_structure.sites_cart(), pdb_hierarchy.atoms().extract_xyz()) cs = xray_structure.crystal_symmetry() uc = cs.unit_cell() sites_frac = xray_structure.sites_frac() assert cushion >= 0 # 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 na = map_data.all() self.gridding_first = [ifloor(f * n) for f, n in zip(frac_min, na)] self.gridding_last = [iceil(f * n) for f, n in zip(frac_max, na)] # extract map box self.map_data = maptbx.copy(map_data, self.gridding_first, self.gridding_last) # get shift vector as result of boxing self.shift_frac = [ -self.map_data.origin()[i] / na[i] for i in range(3) ] self.shift_cart = cs.unit_cell().orthogonalize(self.shift_frac) # this makes the box 'forget' about its parent -- the original box self.map_data.reshape(flex.grid(self.map_data.all())) # get crystal symmetry of the box p = uc.parameters() abc = [p[i] * self.map_data.all()[i] / na[i] for i in range(3)] box_uc = uctbx.unit_cell(parameters=(abc[0], abc[1], abc[2], p[3], p[4], p[5])) self.crystal_symmetry = crystal.symmetry(unit_cell=box_uc, space_group="P1") # new xray_structure or pdb_hierarchy sites_frac_new = box_uc.fractionalize( uc.orthogonalize(sites_frac + self.shift_frac)) sites_cart_new = box_uc.orthogonalize(sites_frac_new) self.xray_structure, self.pdb_hierarchy = None, None if (xray_structure is not None): scatterers = xray_structure.scatterers().deep_copy() scatterers.set_sites(sites_frac_new) sp = crystal.special_position_settings(self.crystal_symmetry) self.xray_structure = xray.structure(sp, scatterers) if (pdb_hierarchy is not None): self.pdb_hierarchy = pdb_hierarchy.deep_copy() self.pdb_hierarchy.atoms().set_xyz(sites_cart_new)
def exercise_writer(): from cctbx import uctbx, sgtbx from scitbx.array_family import flex mt = flex.mersenne_twister(0) nxyz = ( 4, 4, 4, ) grid = flex.grid(nxyz) real_map_data = mt.random_double(size=grid.size_1d()) real_map_data.reshape(grid) unit_cell = uctbx.unit_cell((10, 10, 10, 90, 90, 90)) iotbx.ccp4_map.write_ccp4_map( file_name="four_by_four.map", unit_cell=unit_cell, space_group=sgtbx.space_group_info("P1").group(), map_data=real_map_data, labels=flex.std_string(["iotbx.ccp4_map.tst"])) input_real_map = iotbx.ccp4_map.map_reader(file_name="four_by_four.map") input_map_data = input_real_map.map_data() real_map_mmm = real_map_data.as_1d().min_max_mean() input_map_mmm = input_map_data.as_1d().min_max_mean() cc = flex.linear_correlation(real_map_data.as_1d(), input_map_data.as_1d()).coefficient() assert cc > 0.999 assert approx_equal(input_real_map.unit_cell_parameters, unit_cell.parameters()) assert approx_equal(real_map_mmm.min, input_real_map.header_min, eps=0.001) assert approx_equal(real_map_mmm.min, input_map_mmm.min, eps=0.001) # random small maps of different sizes for nxyz in flex.nested_loop((2, 1, 1), (4, 4, 4)): mt = flex.mersenne_twister(0) grid = flex.grid(nxyz) real_map = mt.random_double(size=grid.size_1d()) real_map = real_map - 0.5 real_map.reshape(grid) iotbx.ccp4_map.write_ccp4_map( file_name="random.map", unit_cell=uctbx.unit_cell((1, 1, 1, 90, 90, 90)), space_group=sgtbx.space_group_info("P1").group(), gridding_first=(0, 0, 0), gridding_last=tuple(grid.last(False)), map_data=real_map, labels=flex.std_string(["iotbx.ccp4_map.tst"])) m = iotbx.ccp4_map.map_reader(file_name="random.map") mmm = flex.double(list(real_map)).min_max_mean() m1 = real_map.as_1d() m2 = m.map_data().as_1d() cc = flex.linear_correlation(m1, m2).coefficient() assert cc > 0.999 assert approx_equal(m.unit_cell_parameters, (1, 1, 1, 90, 90, 90)) assert approx_equal(mmm.min, m.header_min) assert approx_equal(mmm.max, m.header_max) # # write unit_cell_grid explicitly to map iotbx.ccp4_map.write_ccp4_map( file_name="random_b.map", unit_cell=uctbx.unit_cell((1, 1, 1, 90, 90, 90)), space_group=sgtbx.space_group_info("P1").group(), unit_cell_grid=real_map.all(), map_data=real_map, labels=flex.std_string(["iotbx.ccp4_map.tst"])) m = iotbx.ccp4_map.map_reader(file_name="random_b.map") m1 = real_map.as_1d() m2 = m.map_data().as_1d() cc = flex.linear_correlation(m1, m2).coefficient() assert cc > 0.999 mmm = flex.double(list(real_map)).min_max_mean() assert approx_equal(m.unit_cell_parameters, (1, 1, 1, 90, 90, 90)) assert approx_equal(mmm.min, m.header_min) assert approx_equal(mmm.max, m.header_max) # # gridding_first = (0, 0, 0) gridding_last = tuple(grid.last(False)) map_box = maptbx.copy(real_map, gridding_first, gridding_last) map_box.reshape(flex.grid(map_box.all())) iotbx.ccp4_map.write_ccp4_map( file_name="random_box.map", unit_cell=uctbx.unit_cell((1, 1, 1, 90, 90, 90)), space_group=sgtbx.space_group_info("P1").group(), map_data=map_box, labels=flex.std_string(["iotbx.ccp4_map.tst"])) print "OK"
def real_map_unpadded(self): from cctbx import maptbx result = self.real_map() if (not result.is_padded()): return result return maptbx.copy(result, flex.grid(result.focus()))
def run_test(space_group_info, n_elements=5, d_min=1.5, grid_resolution_factor=1. / 3, max_prime=5, verbose=0): structure = random_structure.xray_structure(space_group_info, elements=["Si"] * n_elements, volume_per_atom=200, min_distance=3., general_positions_only=False) miller_set_f_obs = miller.build_set(crystal_symmetry=structure, anomalous_flag=(random.random() > 0.5), d_min=d_min) f_obs = miller_set_f_obs.structure_factors_from_scatterers( xray_structure=structure, algorithm="direct").f_calc() structure_factor_utils.check_phase_restrictions(f_obs, verbose=verbose) if (0 or verbose): f_obs.show_summary() if (0 or verbose): f_obs.show_array() fft_map = f_obs.fft_map(resolution_factor=grid_resolution_factor, symmetry_flags=maptbx.use_space_group_symmetry) p = pickle.dumps(fft_map) l = pickle.loads(p) s1 = StringIO() fft_map.statistics().show_summary(f=s1) s2 = StringIO() l.statistics().show_summary(f=s2) assert not show_diff(s2.getvalue(), s1.getvalue()) # if (not f_obs.anomalous_flag()): maptbx_fft_map = maptbx.fft_to_real_map_unpadded( space_group=fft_map.space_group(), n_real=fft_map.n_real(), miller_indices=f_obs.indices(), data=f_obs.data()) fft_map_unpadded = fft_map.real_map_unpadded(in_place=False) assert approx_equal( flex.linear_correlation(fft_map_unpadded.as_1d(), maptbx_fft_map.as_1d()).coefficient(), 1) assert approx_equal( flex.max(flex.abs(maptbx_fft_map - fft_map_unpadded)), 0) # fft_map.apply_sigma_scaling() real_map = maptbx.copy(fft_map.real_map(), flex.grid(fft_map.real_map().focus())) grid_tags = maptbx.grid_tags(real_map.focus()) grid_tags.build(fft_map.space_group_info().type(), fft_map.symmetry_flags()) assert grid_tags.n_grid_misses() == 0 assert grid_tags.verify(real_map) rms = [] for interpolate in (False, True): peak_list = maptbx.peak_list(data=real_map, tags=grid_tags.tag_array(), peak_search_level=1, max_peaks=2 * n_elements, interpolate=interpolate) assert peak_list.gridding() == real_map.focus() check_peaks(structure, peak_list.sites(), d_min * grid_resolution_factor) crystal_gridding_tags = fft_map.tags() cluster_analysis = maptbx.peak_cluster_analysis( peak_list=peak_list, special_position_settings=structure, general_positions_only=False, effective_resolution=d_min, min_cross_distance=2, max_clusters=n_elements).all() check_peaks( structure, cluster_analysis.sites(), cluster_analysis.min_cross_distance() + d_min * grid_resolution_factor) structure_from_peaks = xray.structure(structure) for site in cluster_analysis.sites(): structure_from_peaks.add_scatterer( xray.scatterer(label="site", scattering_type="", site=site)) emma_matches = emma.model_matches(structure.as_emma_model(), structure_from_peaks.as_emma_model(), tolerance=d_min * 2) rms.append(emma_matches.refined_matches[0].rms) assert len(emma_matches.refined_matches[0].pairs) == n_elements # exercise interpolation vs. summation map_coeffs = f_obs.expand_to_p1() fft_map = f_obs.fft_map(resolution_factor=grid_resolution_factor, symmetry_flags=maptbx.use_space_group_symmetry) fft_map.apply_volume_scaling() real_map = fft_map.real_map_unpadded() sum1 = sum2 = 0 for scatterer in structure.scatterers(): v1 = real_map.eight_point_interpolation(scatterer.site) v2 = real_map.tricubic_interpolation(scatterer.site) v3 = map_coeffs.direct_summation_at_point(scatterer.site) sum1 += abs(v1 - v3.real) sum2 += abs(v2 - v3.real) mean_delta_linear = sum1 / n_elements mean_delta_cubic = sum2 / n_elements assert (mean_delta_cubic < mean_delta_linear) if (0 or verbose): print("emma rms grid, interpolated: %.2f %.2f" % tuple(rms)) assert rms[0] >= rms[1] map_1 = fft_map.real_map_unpadded(in_place=False) map_2 = fft_map.real_map_unpadded(in_place=True) assert (map_1.all_eq(map_2))
def exercise_under_sampled(space_group_info, anomalous_flag, conjugate_flag, under_sampling, d_min=2., resolution_factor=0.5, max_prime=5, verbose=0): structure_factors = random_structure.xray_structure( space_group_info, elements=("N", "C", "C", "O"), random_f_prime_d_min=1, random_f_double_prime=anomalous_flag, use_u_aniso=True, random_u_iso=True, random_occupancy=True ).structure_factors( anomalous_flag=anomalous_flag, d_min=d_min, algorithm="direct") f_calc = structure_factors.f_calc() n_real = maptbx.crystal_gridding( unit_cell=f_calc.unit_cell(), d_min=d_min, resolution_factor=resolution_factor, max_prime=max_prime, mandatory_factors=(under_sampling,)*3).n_real() if (not anomalous_flag): rfft = fftpack.real_to_complex_3d(n_real) n_complex = rfft.n_complex() else: cfft = fftpack.complex_to_complex_3d(n_real) n_complex = cfft.n() map = maptbx.structure_factors.to_map( space_group=f_calc.space_group(), anomalous_flag=anomalous_flag, miller_indices=f_calc.indices(), structure_factors=f_calc.data(), n_real=n_real, map_grid=flex.grid(n_complex), conjugate_flag=conjugate_flag) f_calc_p1 = f_calc.expand_to_p1() map_p1 = maptbx.structure_factors.to_map( space_group=f_calc_p1.space_group(), anomalous_flag=anomalous_flag, miller_indices=f_calc_p1.indices(), structure_factors=f_calc_p1.data(), n_real=n_real, map_grid=flex.grid(n_complex), conjugate_flag=conjugate_flag) assert flex.max(flex.abs(map_p1.complex_map() - map.complex_map())) < 1.e-10 if (not anomalous_flag): real_map = rfft.backward(map.complex_map()) assert real_map.all() == rfft.m_real() else: real_map = cfft.backward(map.complex_map()) assert not real_map.is_padded() if (0 or verbose): if (not anomalous_flag): maptbx.statistics(real_map).show_summary() maptbx.statistics(real_map).show_summary() else: maptbx.statistics(flex.real(real_map)).show_summary() maptbx.statistics(flex.imag(real_map)).show_summary() n_real_under_sampled = [n//under_sampling for n in n_real] if (not anomalous_flag): rfft = fftpack.real_to_complex_3d(n_real_under_sampled) n_complex_under_sampled = rfft.n_complex() else: cfft = fftpack.complex_to_complex_3d(n_real_under_sampled) n_complex_under_sampled = cfft.n() under_sampled_map = maptbx.structure_factors.to_map( space_group=f_calc.space_group(), anomalous_flag=anomalous_flag, miller_indices=f_calc.indices(), structure_factors=f_calc.data(), n_real=n_real_under_sampled, map_grid=flex.grid(n_complex_under_sampled), conjugate_flag=conjugate_flag) under_sampled_map_p1 = maptbx.structure_factors.to_map( space_group=f_calc_p1.space_group(), anomalous_flag=anomalous_flag, miller_indices=f_calc_p1.indices(), structure_factors=f_calc_p1.data(), n_real=n_real_under_sampled, map_grid=flex.grid(n_complex_under_sampled), conjugate_flag=conjugate_flag) assert flex.max(flex.abs(under_sampled_map_p1.complex_map() - under_sampled_map.complex_map())) < 1.e-10 if (not anomalous_flag): under_sampled_map_before_fft = under_sampled_map.complex_map().deep_copy() under_sampled_real_map = rfft.backward(under_sampled_map.complex_map()) assert under_sampled_real_map.all() == rfft.m_real() else: under_sampled_real_map = cfft.backward(under_sampled_map.complex_map()) assert not under_sampled_real_map.is_padded() if (0 or verbose): if (not anomalous_flag): maptbx.statistics(under_sampled_real_map).show_summary() maptbx.statistics(under_sampled_real_map).show_summary() else: maptbx.statistics(flex.real(under_sampled_real_map)).show_summary() maptbx.statistics(flex.imag(under_sampled_real_map)).show_summary() if (0 or verbose): print real_map.all(), n_complex print under_sampled_real_map.all(), n_complex_under_sampled if (not anomalous_flag): x_source = real_map y_source = under_sampled_real_map else: x_source = flex.real(real_map) y_source = flex.real(under_sampled_real_map) x = flex.double() n = x_source.focus() for i in xrange(0, n[0], under_sampling): for j in xrange(0, n[1], under_sampling): for k in xrange(0, n[2], under_sampling): x.append(x_source[(i,j,k)]) y = maptbx.copy(y_source, flex.grid(y_source.focus())).as_1d() if (0 or verbose): print "x:", tuple(x) print "y:", tuple(y) assert flex.max(flex.abs(x-y)) \ < (flex.max(flex.abs(x))+flex.max(flex.abs(y)))/2*1.e-6 if (under_sampling == 1): x = maptbx.copy(x_source, flex.grid(x_source.focus())).as_1d() c = flex.linear_correlation(x, y) assert c.coefficient() >= 0.9999
def __init__(self, map_manager, threshold=0.05, box_cushion=3., get_half_height_width=True, model=None, wrapping=None, model_can_be_outside_bounds=False, log=sys.stdout): self._map_manager = map_manager self._model = model self.model_can_be_outside_bounds = model_can_be_outside_bounds # safeguards assert threshold is not None assert box_cushion is not None assert isinstance(map_manager, iotbx.map_manager.map_manager) assert self._map_manager.map_data().accessor().origin() == (0, 0, 0) if self.map_manager().wrapping(): assert map_manager.unit_cell_grid == map_manager.map_data().all() self._force_wrapping = wrapping if wrapping is None: wrapping = self.map_manager().wrapping() self.basis_for_boxing_string = 'around_density, wrapping = %s' % ( wrapping) # Select box where data are positive (> threshold*max) map_data = map_manager.map_data() origin = list(map_data.origin()) assert origin == [0, 0, 0] all = list(map_data.all()) # Get max value vs x, y, z value_list = flex.double() for i in range(0, all[0]): new_map_data = maptbx.copy(map_data, tuple((i, 0, 0)), tuple((i, all[1], all[2]))) value_list.append( new_map_data.as_1d().as_double().min_max_mean().max) ii = 0 for z in value_list: ii += 1 x_min, x_max = get_range(value_list, threshold=threshold, get_half_height_width=get_half_height_width) value_list = flex.double() for j in range(0, all[1]): new_map_data = maptbx.copy(map_data, tuple((0, j, 0)), tuple((all[0], j, all[2]))) value_list.append( new_map_data.as_1d().as_double().min_max_mean().max) y_min, y_max = get_range(value_list, threshold=threshold, get_half_height_width=get_half_height_width) value_list = flex.double() for j in range(0, all[1]): new_map_data = maptbx.copy(map_data, tuple((0, j, 0)), tuple((all[0], j, all[2]))) value_list.append( new_map_data.as_1d().as_double().min_max_mean().max) y_min, y_max = get_range(value_list, threshold=threshold, get_half_height_width=get_half_height_width) value_list = flex.double() for k in range(0, all[2]): new_map_data = maptbx.copy(map_data, tuple((0, 0, k)), tuple((all[0], all[1], k))) value_list.append( new_map_data.as_1d().as_double().min_max_mean().max) z_min, z_max = get_range(value_list, threshold=threshold, get_half_height_width=get_half_height_width) # Get lower and upper bounds of this region in grid units frac_min = (x_min, y_min, z_min) frac_max = (x_max, y_max, z_max) cs = map_manager.crystal_symmetry() cushion = flex.double(cs.unit_cell().fractionalize( (box_cushion, ) * 3)) all_orig = map_data.all() self.gridding_first = [ max(0, ifloor((f - c) * n)) for c, f, n in zip(cushion, frac_min, all_orig) ] self.gridding_last = [ min(n - 1, iceil((f + c) * n)) for c, f, n in zip(cushion, 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 __init__( self, file_name=None, crystal_symmetry=None, unit_cell=None, space_group=None, map_data=None, labels=None, gridding_first=None, gridding_last=None, unit_cell_grid=None, origin_shift_grid_units=None, # origin shift (grid units) to be applied external_origin=None, # Do not use this unless required output_axis_order=INTERNAL_STANDARD_ORDER, internal_standard_order=INTERNAL_STANDARD_ORDER, verbose=None, ): assert map_data # should never be called without map_data if map_data.is_padded(): # copied from cctbx/miller/__init__.py map_data = maptbx.copy(map_data, flex.grid(map_data.focus())) # Get unit_cell and space_group if crystal_symmetry is supplied: if unit_cell is None: assert crystal_symmetry is not None unit_cell = crystal_symmetry.unit_cell() if space_group is None: # use P1 if not supplied if crystal_symmetry is not None: space_group = crystal_symmetry.space_group() else: from cctbx import sgtbx space_group = sgtbx.space_group_info("P1").group() # Get empty labels if not supplied if not labels: labels = create_output_labels() if gridding_first is not None and gridding_last is not None: # Writing box from gridding_first to gridding_last (inclusive) # NOTE: This is not a common use of this routine assert len(gridding_first) == 3 and len(gridding_last) == 3 assert unit_cell_grid is None assert map_data.origin() == (0, 0, 0) # unshifted maps only nxyz_start = gridding_first nxyz_end = gridding_last unit_cell_grid = map_data.all() new_map_data = maptbx.copy(map_data, tuple(nxyz_start), tuple(nxyz_end)) # NOTE: end point of map is nxyz_end, so size of map (new all()) is # (nxyz_end-nxyz_start+ (1,1,1)) assert tuple(new_map_data.origin()) == tuple(nxyz_start) assert new_map_data.all() == tuple( add_list((1, 1, 1), subtract_list(gridding_last, gridding_first))) new_map_data = new_map_data.shift_origin( ) # this is the map we will pass in else: # This is the recommended way to use this writer # Optionally uses supplied unit_cell_grid. # Allows writing just a part of a map to a file, but retaining # information on size of whole map if unit_cell_grid is supplied. # Takes origin and size of map from the map_data array # Optionally shifts origin based on input "origin_shift_grid_units" assert gridding_first is None and gridding_last is None if unit_cell_grid is None: # Assumes map_data.all() is the entire unit cell unit_cell_grid = map_data.all() # Note: if map_data.origin()==(0,0,0) this grid corresponds to the # box of density that is present. else: assert len(unit_cell_grid) == 3 # Assumes unit_cell_grid is the entire unit cell if origin_shift_grid_units: # Supplied non-zero origin. Input map must be # at (0,0,0). Use supplied origin_shift_grid_units as origin assert map_data.origin() == (0, 0, 0) nxyz_start = origin_shift_grid_units new_map_data = map_data else: nxyz_start = map_data.origin() new_map_data = map_data.deep_copy().shift_origin() # Ready to write the map assert new_map_data.origin() == (0, 0, 0 ) # must not be shifted at this point assert space_group is not None assert unit_cell is not None # Open file for writing mrc = mrcfile.new(file_name, overwrite=True) # Convert flex array to the numpy array required for mrcfile if hasattr(new_map_data, 'as_float'): numpy_data = new_map_data.as_float().as_numpy_array() else: # was float numpy_data = new_map_data.as_numpy_array() # This numpy_data array is always in the order (3,2,1): columns are Z, # rows are Y, sections in X. This comes from the shape of flex arrays. # To write with another order, call with values for output_axis_order if output_axis_order != internal_standard_order: i_order = get_standard_order( output_axis_order[0], output_axis_order[1], output_axis_order[2], internal_standard_order=internal_standard_order, reverse=True) numpy_data_output_axis_order = np.transpose(numpy_data, i_order) else: numpy_data_output_axis_order = numpy_data mrc.header.mapc = output_axis_order[0] mrc.header.mapr = output_axis_order[1] mrc.header.maps = output_axis_order[2] mrc.set_data(numpy_data_output_axis_order) # numpy array # Labels # Keep all limitations labels and other labels up to total of 10 or fewer output_labels = select_output_labels(labels) mrc.header.nlabl = len(output_labels) for i in range(min(10, len(output_labels))): mrc.header.label[i] = output_labels[i] mrc.update_header_from_data( ) # don't move this later as we overwrite values # Unit cell parameters and space group abc = unit_cell.parameters()[:3] angles = unit_cell.parameters()[3:] mrc.header.cella = abc mrc.header.cellb = angles space_group_number = space_group.info().type().number() mrc.header.ispg = space_group_number # Start point of the supplied map in grid units # nxyz_start is the origin (grid units) in XYZ coordinate system. # The mrc header needs the origin along columns, rows, sections which # is represented here as nxstart_nystart_nzstart nxstart_nystart_nzstart = origin_as_crs(origin=nxyz_start, mapc=mrc.header.mapc, mapr=mrc.header.mapr, maps=mrc.header.maps) mrc.header.nxstart = nxstart_nystart_nzstart[0] mrc.header.nystart = nxstart_nystart_nzstart[1] mrc.header.nzstart = nxstart_nystart_nzstart[2] # Size of entire unit cell in grid units # This is ALWAYS along X,Y,Z regardless of the sectioning of the map # Note that this can cause confusion as mrc.header.nx may be a different # axis than mrc.header.mx (mx is always X, nx is whatever axis is # specified by mapc) mrc.header.mx = unit_cell_grid[0] mrc.header.my = unit_cell_grid[1] mrc.header.mz = unit_cell_grid[2] # External origin # NOTE: External origin should rarely be used. It is a poorly-defined # element that refers to the position of a non-defined external model # (PDB file). For origin purposes use instead "origin". if external_origin is None: external_origin = ( 0., 0., 0., ) # This also is ALWAYS along X,Y,Z regardless of the sectioning of the map mrc.header.origin.x = external_origin[0] mrc.header.origin.y = external_origin[1] mrc.header.origin.z = external_origin[2] # Update header mrc.update_header_stats() if verbose: mrc.print_header() # Write the file mrc.close()
def mask_data_whole_uc(self): mask_data = self.asu_mask.mask_data_whole_uc() / \ self.xray_structure.space_group().order_z() return maptbx.copy(mask_data, flex.grid(mask_data.focus()))
def apply_to_map(self, map_manager): ''' Apply boxing to a map_manager that is similar to the one used to generate this around_model object Also apply to its ncs_object, if any ''' assert isinstance(map_manager, iotbx.map_manager.map_manager) # This one should just have similar unit_cell_crystal_symmetry # crystal_symmetry should match self.map_crystal_symmetry_at_initialization assert map_manager.unit_cell_crystal_symmetry().is_similar_symmetry( self._map_manager.unit_cell_crystal_symmetry()) assert map_manager.crystal_symmetry().is_similar_symmetry( self.map_crystal_symmetry_at_initialization) ma1 = map_manager.map_data().accessor() ma2 = self.accessor_at_initialization assert ma1.all() == ma2.all() assert ma1.origin() == ma2.origin() assert ma1.focus() == ma2.focus() map_data = map_manager.map_data() # Check if map is all valid bounds_info = get_bounds_of_valid_region(map_data, self.gridding_first, self.gridding_last) # Allow override of wrapping if isinstance(self._force_wrapping, bool): wrapping = self._force_wrapping else: # Get wrapping from map_manager. If it is not defined and # bounds are outside allowed, try to get the wrapping wrapping = map_manager.wrapping() if wrapping or bounds_info.inside_allowed_bounds: # Just copy everything map_box = maptbx.copy(map_data, self.gridding_first, self.gridding_last) # Note: map_box gridding is self.gridding_first to self.gridding_last elif not bounds_info.some_valid_points: # No valid points, Just copy everything and zero map_box = maptbx.copy(map_data, self.gridding_first, self.gridding_last) map_box = map_box * 0. self._warning_message += "\nWARNING: boxed map is entirely outside map"+\ " and wrapping=%s\n...setting all values to zero" %(wrapping) else: # Need to copy and then zero outside of defined region map_box = copy_and_zero_map_outside_bounds(map_data, bounds_info) self._warning_message += \ "\nWARNING: boxed map goes outside original map"+\ " and wrapping=%s\n...setting unknown values to zero" %(wrapping) # Now reshape map_box to put origin at (0, 0, 0) map_box.reshape(flex.grid(self.box_all)) # Create new map_manager object: # Use original values for: # unit_cell_grid (gridding of original full unit cell) # unit_cell_crystal_symmetry (symmetry of original full unit cell) # input_file_name # Use new (boxed) values for: # map_data # crystal_symmetry (symmetry of the part of the map that is present) # Update: # origin_shift_grid_units (position in the original map of the # (0, 0, 0) grid point in map_box) # labels (add label specifying boxing operation) # # New origin_shift_grid_units: origin_shift_grid_units = [ self.gridding_first[i] + map_manager.origin_shift_grid_units[i] for i in range(3) ] # New labels: new_label = "Boxed %s to %s %s" % (str(tuple( self.gridding_first)), str(tuple( self.gridding_last)), self.basis_for_boxing_string) # Set up new map_manager. This will contain new data and not overwrite # original # NOTE: origin_shift_grid_units is required as bounds have changed new_map_manager = map_manager.customized_copy( map_data=map_box, origin_shift_grid_units=origin_shift_grid_units) if self._force_wrapping: # Set the wrapping of the new map if it is possible if (self._force_wrapping and (new_map_manager.is_full_size())) or \ ( (not self._force_wrapping) and (not new_map_manager.is_full_size())): new_map_manager.set_wrapping(self._force_wrapping) # Add the label new_map_manager.add_label(new_label) return new_map_manager
def run(single_side=False, quick=True): result = flex.bool() periodic_list = [] aperiodic_list = [] if quick: rf_list = [0.33] else: rf_list = [ 0.33, 0.48, ] for resolution_factor in rf_list: for sgn in range(1, 231): kk = random.randint(1, 99999) random.seed(kk) flex.set_random_seed(kk) group = space_group_info(sgn) xrs = random_structure.xray_structure( space_group_info=group, volume_per_atom=25., general_positions_only=False, elements=('C', 'N', 'O', 'H') * 30, min_distance=1.0) sgt = xrs.space_group().type() fc = xrs.structure_factors(d_min=2).f_calc() fft_map = fc.fft_map( symmetry_flags=maptbx.use_space_group_symmetry, resolution_factor=resolution_factor) map_data = fft_map.real_map_unpadded() xx = is_periodic(map_data) periodic_list.append(xx) assert xx in [True, None] # Now cut off edges and should not work: min_size = int(flex.double(map_data.all()).min_max_mean().min) assert min_size >= 12 if quick: range_to_use = [1] k_list = [1] else: range_to_use = list( range(1, max(2, min(10, 1 + min_size // 12)))) k_list = [0, 1] for i in range_to_use: for k in k_list: if single_side: lower_bounds = (k, k, k) upper_bounds = tuple( [x - i - 1 for x in map_data.all()]) else: lower_bounds = (k, k, k) upper_bounds = (map_data.all()[0] - i - 1, map_data.all()[1], map_data.all()[2]) map_box = maptbx.copy(map_data, lower_bounds, upper_bounds) new_map_box = map_box.shift_origin() xx = is_periodic(new_map_box) aperiodic_list.append(xx) assert xx in [False, None] print("For periodic.. True:", periodic_list.count(True), "None:", periodic_list.count(None), " False:", periodic_list.count(False)) print("For aperiodic.. True:", aperiodic_list.count(True), "None:", aperiodic_list.count(None), " False:", aperiodic_list.count(False)) assert periodic_list.count(False) == 0 assert periodic_list.count(None) <= 0.05 * len(periodic_list) assert aperiodic_list.count(True) == 0 assert aperiodic_list.count(None) <= 0.05 * len(aperiodic_list)
def exercise_writer(use_mrcfile=None,output_axis_order=[3,2,1]): from cctbx import uctbx, sgtbx from scitbx.array_family import flex mt = flex.mersenne_twister(0) nxyz = (4,5,6,) grid = flex.grid(nxyz) real_map_data = mt.random_double(size=grid.size_1d()) real_map_data.reshape(grid) unit_cell=uctbx.unit_cell((10,10,10,90,90,90)) if use_mrcfile: from iotbx.mrcfile import create_output_labels labels=create_output_labels( program_name='test', limitations=['extract_unique'], output_labels=['test label'], ) iotbx.mrcfile.write_ccp4_map( file_name="four_five_six.mrc", unit_cell=unit_cell, space_group=sgtbx.space_group_info("P1").group(), map_data=real_map_data, labels=labels, output_axis_order=output_axis_order) input_real_map = iotbx.mrcfile.map_reader(file_name="four_five_six.mrc") for x in input_real_map.labels: print("LABEL: ",x) assert str(input_real_map.labels).find('extract_unique')>-1 else: iotbx.ccp4_map.write_ccp4_map( file_name="four_five_six.map", unit_cell=unit_cell, space_group=sgtbx.space_group_info("P1").group(), map_data=real_map_data, labels=flex.std_string(["iotbx.ccp4_map.tst"])) input_real_map = iotbx.ccp4_map.map_reader(file_name="four_five_six.map") input_map_data=input_real_map.map_data() real_map_mmm = real_map_data.as_1d().min_max_mean() input_map_mmm = input_map_data.as_double().as_1d().min_max_mean() cc=flex.linear_correlation(real_map_data.as_1d(),input_map_data.as_double().as_1d()).coefficient() assert cc > 0.999 print("\nMRCFILE with 4x5x6 map and axis order %s %s" %(output_axis_order,cc)) assert approx_equal(input_real_map.unit_cell().parameters(), unit_cell.parameters()) assert approx_equal(real_map_mmm.min, input_real_map.header_min,eps=0.001) assert approx_equal(real_map_mmm.min, input_map_mmm.min,eps=0.001) # random small maps of different sizes for nxyz in flex.nested_loop((2,1,1),(4,4,4)): mt = flex.mersenne_twister(0) grid = flex.grid(nxyz) real_map = mt.random_double(size=grid.size_1d()) real_map=real_map-0.5 real_map.reshape(grid) if use_mrcfile: iotbx.mrcfile.write_ccp4_map( file_name="random.mrc", unit_cell=uctbx.unit_cell((1,1,1,90,90,90)), space_group=sgtbx.space_group_info("P1").group(), gridding_first=(0,0,0), gridding_last=tuple(grid.last(False)), map_data=real_map, labels=flex.std_string(["iotbx.ccp4_map.tst"])) m = iotbx.mrcfile.map_reader(file_name="random.mrc") else: iotbx.ccp4_map.write_ccp4_map( file_name="random.map", unit_cell=uctbx.unit_cell((1,1,1,90,90,90)), space_group=sgtbx.space_group_info("P1").group(), gridding_first=(0,0,0), gridding_last=tuple(grid.last(False)), map_data=real_map, labels=flex.std_string(["iotbx.ccp4_map.tst"])) m = iotbx.ccp4_map.map_reader(file_name="random.map") mmm = flex.double(list(real_map)).min_max_mean() m1=real_map.as_1d() m2=m.map_data().as_double().as_1d() cc=flex.linear_correlation(m1,m2).coefficient() assert cc > 0.999 assert approx_equal(m.unit_cell().parameters(), (1,1,1,90,90,90)) assert approx_equal(mmm.min, m.header_min) assert approx_equal(mmm.max, m.header_max) # # write unit_cell_grid explicitly to map iotbx.ccp4_map.write_ccp4_map( file_name="random_b.map", unit_cell=uctbx.unit_cell((1,1,1,90,90,90)), space_group=sgtbx.space_group_info("P1").group(), unit_cell_grid=real_map.all(), map_data=real_map, labels=flex.std_string(["iotbx.ccp4_map.tst"])) m = iotbx.ccp4_map.map_reader(file_name="random_b.map") m1=real_map.as_1d() m2=m.map_data().as_double().as_1d() cc=flex.linear_correlation(m1,m2).coefficient() assert cc > 0.999 mmm = flex.double(list(real_map)).min_max_mean() assert approx_equal(m.unit_cell_parameters, (1,1,1,90,90,90)) assert approx_equal(mmm.min, m.header_min) assert approx_equal(mmm.max, m.header_max) # # gridding_first = (0,0,0) gridding_last=tuple(grid.last(False)) map_box = maptbx.copy(real_map, gridding_first, gridding_last) map_box.reshape(flex.grid(map_box.all())) if use_mrcfile: iotbx.mrcfile.write_ccp4_map( file_name="random_box.mrc", unit_cell=uctbx.unit_cell((1,1,1,90,90,90)), space_group=sgtbx.space_group_info("P1").group(), map_data=map_box, labels=flex.std_string(["iotbx.ccp4_map.tst"])) else: iotbx.ccp4_map.write_ccp4_map( file_name="random_box.map", unit_cell=uctbx.unit_cell((1,1,1,90,90,90)), space_group=sgtbx.space_group_info("P1").group(), map_data=map_box, labels=flex.std_string(["iotbx.ccp4_map.tst"])) print("OK")
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 __init__(self, map_manager, wrapping, threshold=0.05, get_half_height_width=True, log=sys.stdout): adopt_init_args(self, locals()) # safeguards assert threshold is not None assert isinstance(wrapping, bool) assert isinstance(map_manager, iotbx.map_manager.map_manager) assert self.map_manager.map_data().accessor().origin() == (0, 0, 0) if wrapping: assert map_manager.unit_cell_grid == map_manager.map_data().all() self.basis_for_boxing_string = 'around_density, wrapping=%s' % ( wrapping) # Select box where data are positive (> threshold*max) map_data = map_manager.map_data() origin = list(map_data.origin()) assert origin == [0, 0, 0] all = list(map_data.all()) # Get max value vs x,y,z value_list = flex.double() for i in range(0, all[0]): new_map_data = maptbx.copy(map_data, tuple((i, 0, 0)), tuple((i, all[1], all[2]))) value_list.append( new_map_data.as_1d().as_double().min_max_mean().max) ii = 0 for z in value_list: ii += 1 x_min, x_max = get_range(value_list, threshold=threshold, get_half_height_width=get_half_height_width) value_list = flex.double() for j in range(0, all[1]): new_map_data = maptbx.copy(map_data, tuple((0, j, 0)), tuple((all[0], j, all[2]))) value_list.append( new_map_data.as_1d().as_double().min_max_mean().max) y_min, y_max = get_range(value_list, threshold=threshold, get_half_height_width=get_half_height_width) value_list = flex.double() for j in range(0, all[1]): new_map_data = maptbx.copy(map_data, tuple((0, j, 0)), tuple((all[0], j, all[2]))) value_list.append( new_map_data.as_1d().as_double().min_max_mean().max) y_min, y_max = get_range(value_list, threshold=threshold, get_half_height_width=get_half_height_width) value_list = flex.double() for k in range(0, all[2]): new_map_data = maptbx.copy(map_data, tuple((0, 0, k)), tuple((all[0], all[1], k))) value_list.append( new_map_data.as_1d().as_double().min_max_mean().max) z_min, z_max = get_range(value_list, threshold=threshold, get_half_height_width=get_half_height_width) # Get lower and upper bounds of this region in grid units frac_min = (x_min, y_min, z_min) frac_max = (x_max, y_max, z_max) 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 map_manager so that self.map_manager is boxed version self.map_manager = self.apply_to_map(self.map_manager)
def exercise_under_sampled(space_group_info, anomalous_flag, conjugate_flag, under_sampling, d_min=2., resolution_factor=0.5, max_prime=5, verbose=0): structure_factors = random_structure.xray_structure( space_group_info, elements=("N", "C", "C", "O"), random_f_prime_d_min=1, random_f_double_prime=anomalous_flag, use_u_aniso=True, random_u_iso=True, random_occupancy=True).structure_factors(anomalous_flag=anomalous_flag, d_min=d_min, algorithm="direct") f_calc = structure_factors.f_calc() n_real = maptbx.crystal_gridding(unit_cell=f_calc.unit_cell(), d_min=d_min, resolution_factor=resolution_factor, max_prime=max_prime, mandatory_factors=(under_sampling, ) * 3).n_real() if (not anomalous_flag): rfft = fftpack.real_to_complex_3d(n_real) n_complex = rfft.n_complex() else: cfft = fftpack.complex_to_complex_3d(n_real) n_complex = cfft.n() map = maptbx.structure_factors.to_map(space_group=f_calc.space_group(), anomalous_flag=anomalous_flag, miller_indices=f_calc.indices(), structure_factors=f_calc.data(), n_real=n_real, map_grid=flex.grid(n_complex), conjugate_flag=conjugate_flag) f_calc_p1 = f_calc.expand_to_p1() map_p1 = maptbx.structure_factors.to_map( space_group=f_calc_p1.space_group(), anomalous_flag=anomalous_flag, miller_indices=f_calc_p1.indices(), structure_factors=f_calc_p1.data(), n_real=n_real, map_grid=flex.grid(n_complex), conjugate_flag=conjugate_flag) assert flex.max( flex.abs(map_p1.complex_map() - map.complex_map())) < 1.e-10 if (not anomalous_flag): real_map = rfft.backward(map.complex_map()) assert real_map.all() == rfft.m_real() else: real_map = cfft.backward(map.complex_map()) assert not real_map.is_padded() if (0 or verbose): if (not anomalous_flag): maptbx.statistics(real_map).show_summary() maptbx.statistics(real_map).show_summary() else: maptbx.statistics(flex.real(real_map)).show_summary() maptbx.statistics(flex.imag(real_map)).show_summary() n_real_under_sampled = [n // under_sampling for n in n_real] if (not anomalous_flag): rfft = fftpack.real_to_complex_3d(n_real_under_sampled) n_complex_under_sampled = rfft.n_complex() else: cfft = fftpack.complex_to_complex_3d(n_real_under_sampled) n_complex_under_sampled = cfft.n() under_sampled_map = maptbx.structure_factors.to_map( space_group=f_calc.space_group(), anomalous_flag=anomalous_flag, miller_indices=f_calc.indices(), structure_factors=f_calc.data(), n_real=n_real_under_sampled, map_grid=flex.grid(n_complex_under_sampled), conjugate_flag=conjugate_flag) under_sampled_map_p1 = maptbx.structure_factors.to_map( space_group=f_calc_p1.space_group(), anomalous_flag=anomalous_flag, miller_indices=f_calc_p1.indices(), structure_factors=f_calc_p1.data(), n_real=n_real_under_sampled, map_grid=flex.grid(n_complex_under_sampled), conjugate_flag=conjugate_flag) assert flex.max( flex.abs(under_sampled_map_p1.complex_map() - under_sampled_map.complex_map())) < 1.e-10 if (not anomalous_flag): under_sampled_map_before_fft = under_sampled_map.complex_map( ).deep_copy() under_sampled_real_map = rfft.backward(under_sampled_map.complex_map()) assert under_sampled_real_map.all() == rfft.m_real() else: under_sampled_real_map = cfft.backward(under_sampled_map.complex_map()) assert not under_sampled_real_map.is_padded() if (0 or verbose): if (not anomalous_flag): maptbx.statistics(under_sampled_real_map).show_summary() maptbx.statistics(under_sampled_real_map).show_summary() else: maptbx.statistics(flex.real(under_sampled_real_map)).show_summary() maptbx.statistics(flex.imag(under_sampled_real_map)).show_summary() if (0 or verbose): print(real_map.all(), n_complex) print(under_sampled_real_map.all(), n_complex_under_sampled) if (not anomalous_flag): x_source = real_map y_source = under_sampled_real_map else: x_source = flex.real(real_map) y_source = flex.real(under_sampled_real_map) x = flex.double() n = x_source.focus() for i in range(0, n[0], under_sampling): for j in range(0, n[1], under_sampling): for k in range(0, n[2], under_sampling): x.append(x_source[(i, j, k)]) y = maptbx.copy(y_source, flex.grid(y_source.focus())).as_1d() if (0 or verbose): print("x:", tuple(x)) print("y:", tuple(y)) assert flex.max(flex.abs(x-y)) \ < (flex.max(flex.abs(x))+flex.max(flex.abs(y)))/2*1.e-6 if (under_sampling == 1): x = maptbx.copy(x_source, flex.grid(x_source.focus())).as_1d() c = flex.linear_correlation(x, y) assert c.coefficient() >= 0.9999
def exercise_copy(): for flex_type in flex_types(): m = flex_type((1,2,3,4)) m.resize(flex.grid(2,2)) c = maptbx.copy(map=m, result_grid=m.accessor()) assert tuple(m) == tuple(c) c = maptbx.copy(map=m, result_grid=flex.grid(2,3).set_focus(2,2)) assert approx_equal(tuple(c), (1,2,0,3,4,0)) n = maptbx.copy(c, result_grid=m.accessor()) assert approx_equal(tuple(m), tuple(n)) c = maptbx.copy(m, flex.grid(3,2).set_focus(2,2)) assert approx_equal(tuple(c), (1,2,3,4,0,0)) n = maptbx.copy(c, m.accessor()) assert approx_equal(tuple(m), tuple(n)) m = flex_type((1,2,3,4,5,6)) m.resize(flex.grid((1,2),(3,5))) c = maptbx.copy(m, m.accessor()) assert approx_equal(tuple(m), tuple(c)) c = maptbx.copy(m, flex.grid((1,2),(3,6)).set_focus(3,5)) assert approx_equal(tuple(c), (1,2,3,0,4,5,6,0)) n = maptbx.copy(c, m.accessor()) assert approx_equal(tuple(m), tuple(n)) c = maptbx.copy(m, flex.grid((1,2),(4,5)).set_focus(3,5)) assert approx_equal(tuple(c), (1,2,3,4,5,6,0,0,0)) n = maptbx.copy(c, m.accessor()) assert approx_equal(tuple(m), tuple(n)) # m = flex_type() for i in xrange(2): for j in xrange(3): for k in xrange(5): m.append(i*100+j*10+k) m.resize(flex.grid(2,3,5).set_focus((2,3,4))) for i in xrange(-5,5): for j in xrange(-5,5): for k in xrange(-5,5): c = maptbx.copy(map_unit_cell=m, first=(i,j,k), last=(i,j,k)) assert c.size() == 1 assert c[(i,j,k)] == m[(i%2,j%3,k%4)] c = maptbx.copy(map_unit_cell=m, first=(-1,1,-2), last=(1,2,0)) assert list(c) == [112, 113, 110, 122, 123, 120, 12, 13, 10, 22, 23, 20, 112, 113, 110, 122, 123, 120] # m2 = m.deep_copy() grid = flex.grid( (-1,-1,-1), (1,2,4) ).set_focus( (1,2,3) ) m2.resize(grid) for i in xrange(-1,1): for j in xrange(-1,2): for k in xrange(-1,3): # aperiodic copy c = maptbx.copy_box(map=m2, first=(i,j,k), last=(i,j,k)) assert c.size() == 1 ind = ((i+1)%2-1,(j+1)%3-1,(k+1)%4-1) assert c[(i,j,k)] == m2[ind] c = maptbx.copy_box(map=m2, first=(-1,0,-1), last=(0,1,2)) assert list(c) == [10, 11, 12, 13, 20, 21, 22, 23, 110, 111, 112, 113, 120, 121, 122, 123] # for n0 in xrange(4): for n1 in xrange(4): for n2 in xrange(4): for d2 in xrange(3): g = flex.grid((n0,n1,n2+d2)).set_focus((n0,n1,n2)) map1 = flex_type(range(1,1+g.size_1d())) map1.resize(g) map2 = map1.deep_copy() maptbx.unpad_in_place(map=map2) assert map2.all() == (n0,n1,n2) assert not map2.is_padded() if (n0*n1*n2 != 0): for i in flex.nested_loop((n0,n1,n2)): assert map2[i] == map1[i] n0,n1,n2,d2 = 2,3,4,1 g = flex.grid((n0,n1,n2+d2)).set_focus((n0,n1,n2)) map1 = flex_type(range(1,1+g.size_1d())) map1.resize(g) map2 = map1.deep_copy() maptbx.unpad_in_place(map=map2) assert map2.all() == (n0,n1,n2) assert not map2.is_padded() assert list(map2) == [ 1, 2, 3, 4, 6, 7, 8, 9, 11,12,13,14, 16,17,18,19, 21,22,23,24, 26,27,28,29]
def run_test(space_group_info, n_elements=5, d_min=1.5, grid_resolution_factor=1./3, max_prime=5, verbose=0): structure = random_structure.xray_structure( space_group_info, elements=["Si"]*n_elements, volume_per_atom=200, min_distance=3., general_positions_only=False) miller_set_f_obs = miller.build_set( crystal_symmetry=structure, anomalous_flag=(random.random()>0.5), d_min=d_min) f_obs = miller_set_f_obs.structure_factors_from_scatterers( xray_structure=structure, algorithm="direct").f_calc() structure_factor_utils.check_phase_restrictions(f_obs, verbose=verbose) if (0 or verbose): f_obs.show_summary() if (0 or verbose): f_obs.show_array() fft_map = f_obs.fft_map( resolution_factor=grid_resolution_factor, symmetry_flags=maptbx.use_space_group_symmetry) p = pickle.dumps(fft_map) l = pickle.loads(p) s1 = StringIO() fft_map.statistics().show_summary(f=s1) s2 = StringIO() l.statistics().show_summary(f=s2) assert not show_diff(s2.getvalue(), s1.getvalue()) # if (not f_obs.anomalous_flag()): maptbx_fft_map = maptbx.fft_to_real_map_unpadded( space_group=fft_map.space_group(), n_real=fft_map.n_real(), miller_indices=f_obs.indices(), data=f_obs.data()) fft_map_unpadded = fft_map.real_map_unpadded(in_place=False) assert approx_equal( flex.linear_correlation( fft_map_unpadded.as_1d(), maptbx_fft_map.as_1d()).coefficient(), 1) assert approx_equal( flex.max(flex.abs(maptbx_fft_map - fft_map_unpadded)), 0) # fft_map.apply_sigma_scaling() real_map = maptbx.copy( fft_map.real_map(), flex.grid(fft_map.real_map().focus())) grid_tags = maptbx.grid_tags(real_map.focus()) grid_tags.build( fft_map.space_group_info().type(), fft_map.symmetry_flags()) assert grid_tags.n_grid_misses() == 0 assert grid_tags.verify(real_map) rms = [] for interpolate in (False,True): peak_list = maptbx.peak_list( data=real_map, tags=grid_tags.tag_array(), peak_search_level=1, max_peaks=2*n_elements, interpolate=interpolate) assert peak_list.gridding() == real_map.focus() check_peaks(structure, peak_list.sites(), d_min * grid_resolution_factor) crystal_gridding_tags = fft_map.tags() cluster_analysis = maptbx.peak_cluster_analysis( peak_list=peak_list, special_position_settings=structure, general_positions_only=False, effective_resolution=d_min, min_cross_distance=2, max_clusters=n_elements).all() check_peaks( structure, cluster_analysis.sites(), cluster_analysis.min_cross_distance() + d_min * grid_resolution_factor) structure_from_peaks = xray.structure(structure) for site in cluster_analysis.sites(): structure_from_peaks.add_scatterer( xray.scatterer(label="site", scattering_type="", site=site)) emma_matches = emma.model_matches( structure.as_emma_model(), structure_from_peaks.as_emma_model(), tolerance=d_min*2) rms.append(emma_matches.refined_matches[0].rms) assert len(emma_matches.refined_matches[0].pairs) == n_elements # exercise interpolation vs. summation map_coeffs = f_obs.expand_to_p1() fft_map = f_obs.fft_map( resolution_factor=grid_resolution_factor, symmetry_flags=maptbx.use_space_group_symmetry) fft_map.apply_volume_scaling() real_map = fft_map.real_map_unpadded() sum1 = sum2 = 0 for scatterer in structure.scatterers() : v1 = real_map.eight_point_interpolation(scatterer.site) v2 = real_map.tricubic_interpolation(scatterer.site) v3 = map_coeffs.direct_summation_at_point(scatterer.site) sum1 += abs(v1 - v3.real) sum2 += abs(v2 - v3.real) mean_delta_linear = sum1 / n_elements mean_delta_cubic = sum2 / n_elements assert (mean_delta_cubic < mean_delta_linear) if (0 or verbose): print "emma rms grid, interpolated: %.2f %.2f" % tuple(rms) assert rms[0] >= rms[1] map_1 = fft_map.real_map_unpadded(in_place=False) map_2 = fft_map.real_map_unpadded(in_place=True) assert (map_1.all_eq(map_2))
def __init__( self, crystal_gridding, fmodel, map_type, max_boxes, box_size_as_fraction=None): sgt = fmodel.f_obs().space_group().type() assert sgt.number() == 1 def get_map(fmodel, map_type, external_complete_set=None): f_map = fmodel.electron_density_map().map_coefficients( map_type = map_type, isotropize = True, fill_missing = False) fft_map = miller.fft_map( crystal_gridding = crystal_gridding, fourier_coefficients = f_map) return fft_map.real_map_unpadded() f_model = fmodel.f_model_scaled_with_k1() fft_map = miller.fft_map( crystal_gridding = crystal_gridding, fourier_coefficients = f_model) f_model_map_data = fft_map.real_map_unpadded() zero_complex_ma = f_model.customized_copy( data = flex.complex_double(f_model.data().size(), 0)) b = maptbx.boxes( fraction = 0.3, n_real = f_model_map_data.focus(), max_boxes=max_boxes, log=sys.stdout) self.map_result = flex.double(flex.grid(b.n_real)) self.r = flex.double() for s,e in zip(b.starts, b.ends): f_model_map_data_omit = maptbx.set_box_copy( value = 0, map_data_to = f_model_map_data, start = s, end = e) f_model_omit = f_model.structure_factors_from_map( map = f_model_map_data_omit, use_scale = True, anomalous_flag = False, use_sg = False) fmodel_ = mmtbx.f_model.manager( f_obs = fmodel.f_obs(), r_free_flags = fmodel.r_free_flags(), f_calc = f_model_omit, f_mask = zero_complex_ma) self.r.append(fmodel_.r_work()) f_map_data = get_map(fmodel=fmodel_, map_type=map_type) etmp = [e[0]-1, e[1]-1, e[2]-1] # because .copy() includes right edge box = maptbx.copy(f_map_data, s, etmp) box.reshape(flex.grid(box.all())) maptbx.set_box( map_data_from = box, map_data_to = self.map_result, start = s, end = e) sd = self.map_result.sample_standard_deviation() self.map_result = self.map_result/sd self.map_coefficients = fmodel.f_obs().structure_factors_from_map( map = self.map_result, use_scale = True, anomalous_flag = False, use_sg = False)