def as_p1_map(self, map_asu=None): if(map_asu is None): map_asu = self.map_result_asu asu_map_omit = asu_map_ext.asymmetric_map(self.sgt, map_asu, self.n_real) p1_map = asu_map_omit.symmetry_expanded_map() maptbx.unpad_in_place(map=p1_map) sd = p1_map.sample_standard_deviation() if(sd != 0): p1_map = p1_map/sd return p1_map
def __init__(self, map, xray_structure, d_min, box=None, compute_cc_box=False, compute_cc_image=False, compute_cc_mask=True, compute_cc_volume=True, compute_cc_peaks=True): adopt_init_args(self, locals()) if (box is None and xray_structure.crystal_symmetry().space_group(). type().number() == 1): box = True else: box = False # self.cc_box = None self.cc_image = None self.cc_mask = None self.cc_volume = None self.cc_peaks = None # self.crystal_gridding = maptbx.crystal_gridding( unit_cell=xray_structure.unit_cell(), space_group_info=xray_structure.space_group_info(), pre_determined_n_real=map.accessor().all(), symmetry_flags=maptbx.use_space_group_symmetry) self.atom_radius = None bs_mask = masks.mask_from_xray_structure( xray_structure=self.xray_structure, p1=True, for_structure_factors=False, n_real=self.map.accessor().all()).mask_data maptbx.unpad_in_place(map=bs_mask) self.sel_inside = (bs_mask == 0.).iselection() self.n_nodes_inside = self.sel_inside.size() del bs_mask # map_calc = self.get_map_calc() # if (compute_cc_mask): self.cc_mask = from_map_map_selection(map_1=self.map, map_2=map_calc, selection=self.sel_inside) del self.sel_inside if (compute_cc_box): self.cc_box = from_map_map(map_1=self.map, map_2=map_calc) if (compute_cc_image): self.atom_radius = self._atom_radius() self.cc_image = self._cc_image(map_calc=map_calc) if (compute_cc_volume): self.cc_volume = self._cc_volume(map_calc=map_calc) if (compute_cc_peaks): self.cc_peaks = self._cc_peaks(map_calc=map_calc)
def exercise_real_to_complex_3d(): print "real_to_complex_3d" for n_real,n_repeats in [((100,80,90),8), ((200,160,180),2), ((300,240,320),1)]: print " dimensions:", n_real print " repeats:", n_repeats fft = fftpack.real_to_complex_3d(n_real) m_real = fft.m_real() np = n_real[0]*n_real[1]*n_real[2] mp = m_real[0]*m_real[1]*m_real[2] d0 = flex.random_double(size=mp)*2-1 d0.reshape(flex.grid(m_real).set_focus(n_real)) # t0 = time.time() for i_trial in xrange(n_repeats): d = d0.deep_copy() overhead = time.time()-t0 print " overhead: %.2f seconds" % overhead # t0 = time.time() for i_trial in xrange(n_repeats): d = d0.deep_copy() c = fftw3tbx.real_to_complex_3d_in_place(data=d) assert c.all() == fft.n_complex() assert c.focus() == fft.n_complex() assert c.id() == d.id() r = fftw3tbx.complex_to_real_3d_in_place(data=c, n=n_real) assert r.all() == fft.m_real() assert r.focus() == fft.n_real() assert r.id() == d.id() print " fftw: %.2f seconds" % (time.time()-t0-overhead) if (maptbx is not None): maptbx.unpad_in_place(map=d) rw = d / np # t0 = time.time() for i_trial in xrange(n_repeats): d = d0.deep_copy() c = fftpack.real_to_complex_3d(n_real).forward(d) assert c.all() == fft.n_complex() assert c.focus() == fft.n_complex() assert c.id() == d.id() r = fftpack.real_to_complex_3d(n_real).backward(c) assert r.all() == fft.m_real() assert r.focus() == fft.n_real() assert r.id() == d.id() print " fftpack: %.2f seconds" % (time.time()-t0-overhead) sys.stdout.flush() if (maptbx is not None): maptbx.unpad_in_place(map=d) rp = d / np # assert flex.max(flex.abs(rw-rp)) < 1.e-6
def mask_from_xrs_unpadded(self, xray_structure, n_real): mask_params = mmtbx.masks.mask_master_params.extract() mask = mmtbx.masks.mask_from_xray_structure( xray_structure=xray_structure, p1=True, shrink_truncation_radius=mask_params.shrink_truncation_radius, solvent_radius=mask_params.solvent_radius, for_structure_factors=True, n_real=n_real).mask_data maptbx.unpad_in_place(map=mask) return mask
def mask_from_xrs_unpadded(xray_structure, n_real): mask_params = mmtbx.masks.mask_master_params.extract() mask = mmtbx.masks.mask_from_xray_structure( xray_structure = xray_structure, p1 = True, shrink_truncation_radius = mask_params.shrink_truncation_radius, solvent_radius = mask_params.solvent_radius, for_structure_factors = True, n_real = n_real).mask_data maptbx.unpad_in_place(map = mask) return mask
def _compute_mask_in_p1(self): mask = mmtbx.masks.mask_from_xray_structure( xray_structure=self.xray_structure, p1=True, for_structure_factors=True, solvent_radius=self.r_sol, shrink_truncation_radius=self.r_shrink, n_real=self.n_real, in_asu=False).mask_data maptbx.unpad_in_place(map=mask) if (self.write_masks): write_map_file( crystal_symmetry=self. crystal_symmetry, # Is this correct symmetry? map_data=mask, file_name="mask_whole.mrc") return mask
def __init__(self, xray_structure, n_real, rad_smooth, atom_radii=None, solvent_radius=None, shrink_truncation_radius=None): mask_binary = mask_from_xray_structure( xray_structure = xray_structure, p1 = True, for_structure_factors = False, n_real = n_real, atom_radii = atom_radii, solvent_radius = solvent_radius, shrink_truncation_radius = shrink_truncation_radius, rad_extra = rad_smooth).mask_data s = mask_binary>0.5 mask_binary = mask_binary.set_selected(s, 0) mask_binary = mask_binary.set_selected(~s, 1) maptbx.unpad_in_place(map=mask_binary) self.mask_smooth = maptbx.smooth_map( map = mask_binary, crystal_symmetry = xray_structure.crystal_symmetry(), rad_smooth = rad_smooth)
def get_mask_1(fmodel, grid_step_factor): grid_step = fmodel.f_obs().d_min()*(1./grid_step_factor) if(grid_step < 0.15): grid_step = 0.15 grid_step = min(0.8, grid_step) crystal_gridding = maptbx.crystal_gridding( unit_cell = fmodel.xray_structure.unit_cell(), space_group_info = fmodel.xray_structure.space_group_info(), symmetry_flags = maptbx.use_space_group_symmetry, step = grid_step) n_real = crystal_gridding.n_real() # Compute mask in P1 mask_data_p1 = mmtbx.masks.mask_from_xray_structure( xray_structure = fmodel.xray_structure, p1 = True, for_structure_factors = True, n_real = n_real, in_asu = False).mask_data maptbx.unpad_in_place(map=mask_data_p1) return mask_data_p1, n_real, crystal_gridding
def get_mask_1(fmodel, grid_step_factor): grid_step = fmodel.f_obs().d_min() * (1. / grid_step_factor) if (grid_step < 0.15): grid_step = 0.15 grid_step = min(0.8, grid_step) crystal_gridding = maptbx.crystal_gridding( unit_cell=fmodel.xray_structure.unit_cell(), space_group_info=fmodel.xray_structure.space_group_info(), symmetry_flags=maptbx.use_space_group_symmetry, step=grid_step) n_real = crystal_gridding.n_real() # Compute mask in P1 mask_data_p1 = mmtbx.masks.mask_from_xray_structure( xray_structure=fmodel.xray_structure, p1=True, for_structure_factors=True, n_real=n_real, in_asu=False).mask_data maptbx.unpad_in_place(map=mask_data_p1) return mask_data_p1, n_real, crystal_gridding
def get_mask_2(fmodel, grid_step_factor): sgt = fmodel.xray_structure.space_group().type() mask_params = mmtbx.masks.mask_master_params.extract() mask_params.grid_step_factor = grid_step_factor asu_mask_obj = mmtbx.masks.asu_mask(xray_structure=fmodel.xray_structure, d_min=fmodel.f_obs().d_min(), mask_params=mask_params).asu_mask mask_data_p1 = asu_mask_obj.mask_data_whole_uc() maptbx.unpad_in_place(map=mask_data_p1) n_real = mask_data_p1.all() crystal_gridding = maptbx.crystal_gridding( unit_cell=fmodel.xray_structure.unit_cell(), space_group_info=fmodel.xray_structure.space_group_info(), symmetry_flags=maptbx.use_space_group_symmetry, pre_determined_n_real=n_real) #n_real = mask_data_p1.all() #mask_data_p1 = asu_map_ext.asymmetric_map(sgt, mask_data_p1, n_real).symmetry_expanded_map() #maptbx.unpad_in_place(map=mask_data_p1) return mask_data_p1, n_real, crystal_gridding
def get_mask_2(fmodel, grid_step_factor): sgt = fmodel.xray_structure.space_group().type() mask_params = mmtbx.masks.mask_master_params.extract() mask_params.grid_step_factor = grid_step_factor asu_mask_obj = mmtbx.masks.asu_mask( xray_structure = fmodel.xray_structure, d_min = fmodel.f_obs().d_min(), mask_params = mask_params).asu_mask mask_data_p1 = asu_mask_obj.mask_data_whole_uc() maptbx.unpad_in_place(map=mask_data_p1) n_real = mask_data_p1.all() crystal_gridding = maptbx.crystal_gridding( unit_cell = fmodel.xray_structure.unit_cell(), space_group_info = fmodel.xray_structure.space_group_info(), symmetry_flags = maptbx.use_space_group_symmetry, pre_determined_n_real = n_real) #n_real = mask_data_p1.all() #mask_data_p1 = asu_map_ext.asymmetric_map(sgt, mask_data_p1, n_real).symmetry_expanded_map() #maptbx.unpad_in_place(map=mask_data_p1) return mask_data_p1, n_real, crystal_gridding
def exercise_work_in_asu(): pdb_str = """ CRYST1 10.000 10.000 10.000 90.00 90.00 90.00 P 4 HETATM 1 C C 1 2.000 2.000 2.000 1.00 20.00 C HETATM 2 C C 2 4.000 4.000 4.000 1.00 20.00 C END """ from time import time pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_str) xrs = pdb_inp.xray_structure_simple() # xrs.show_summary() d_min = 1 fc = xrs.structure_factors(d_min=d_min).f_calc() symmetry_flags = maptbx.use_space_group_symmetry fftmap = fc.fft_map(symmetry_flags=symmetry_flags) # rmup = fftmap.real_map_unpadded() rm = fftmap.real_map().deep_copy() maptbx.unpad_in_place(rm) mmm = rm.as_1d().min_max_mean() print(mmm.min, mmm.max, mmm.mean) # rmup = fftmap.real_map_unpadded() # print (dir(rm)) print("full size:", fftmap.real_map().accessor().focus()) print(rm[0, 0, 0]) # print (type(rm)) # print (dir(rm)) # STOP() # print(rmup[0,0,0]) amap0 = asymmetric_map(xrs.space_group().type(), rm) # print(dir(amap0)) mmm = amap0.data().as_1d().min_max_mean() print(mmm.min, mmm.max, mmm.mean) amap_data = amap0.data() write_ccp4_map('amap.ccp4', xrs.unit_cell(), xrs.space_group(), amap_data) write_ccp4_map('rm.ccp4', xrs.unit_cell(), xrs.space_group(), rm) # for i in range(50): # print(i, amap_data[i,0,0]) exp_map = amap0.symmetry_expanded_map() print(exp_map[0, 0, 0]) # for i in range(32): # for j in range(32): # for k in range(32): # assert approx_equal(rm[i,j,k], exp_map[i,j,k]) # print(dir(amap0)) # STOP() # This produces 2 separate blobs sg = xrs.space_group() print(dir(sg)) print(sg.all_ops()) print(sg.info()) print("amap0 size:", amap0.data().accessor().focus()) # STOP() print(type(amap0.data())) threshold = 0. preprocess_against_shallow = True print('threshold:', threshold) print('preprocess_against_shallow', preprocess_against_shallow) t0 = time() co_amap = maptbx.connectivity( map_data=amap0.data(), # threshold=threshold, # space_group=xrs.space_group(), # uc_dimensions=exp_map.accessor().focus(), # wrapping=False, preprocess_against_shallow=preprocess_against_shallow) t1 = time() print('amap time:', t1 - t0) original_regions = list(co_amap.regions()) print('start regions:', original_regions) print('max coords', list(co_amap.maximum_coors())) print('max vals', list(co_amap.maximum_values())) # print(dir(exp_map)) print(type(exp_map)) print("exp_map size:", exp_map.accessor().focus()) t0 = time() co_full = maptbx.connectivity( map_data=rm, threshold=threshold, wrapping=False, preprocess_against_shallow=preprocess_against_shallow) t1 = time() print('full time:', t1 - t0) original_regions = list(co_full.regions()) print('start regions:', original_regions) print('max coords', list(co_full.maximum_coors())) print('max vals', list(co_full.maximum_values())) # STOP() # co.experiment_with_symmetry( # space_group=xrs.space_group(), # uc_dims=exp_map.accessor().focus()) co_full.merge_symmetry_related_regions(space_group=xrs.space_group(), uc_dims=exp_map.accessor().focus()) new_regions = list(co_full.regions()) print('new regions:', new_regions) print('max coords', list(co_full.maximum_coors())) print('max vals', list(co_full.maximum_values()))
def _exercise_real_to_complex_3d(sizes, benchmark=True): from cctbx import maptbx from scitbx.array_family import flex from cudatbx import cufft from scitbx import fftpack from libtbx.test_utils import approx_equal import time for n_real, n_repeats, eps in sizes: nx, ny, nz = n_real fft = fftpack.real_to_complex_3d((nx, ny, nz)) mt = flex.mersenne_twister(seed=1) g = flex.grid(fft.m_real()).set_focus(fft.n_real()) map = mt.random_double(size=g.size_1d()) map.reshape(g) sfs = fft.forward(map.deep_copy()) map2 = fft.backward(sfs) fft_cuda = cufft.real_to_complex_3d((nx, ny, nz)) sfs_cuda = fft_cuda.forward( map) #cufft.real_to_complex_3d_in_place(map) map2_cuda = fft_cuda.backward( sfs_cuda) #cufft.complex_to_real_3d_in_place(sfs_cuda, n_real) maptbx.unpad_in_place(map=map2) maptbx.unpad_in_place(map=map2_cuda) map2_values = map2.as_1d() map2_cuda_values = map2_cuda.as_1d() mmm = map2_values.min_max_mean() mmm_cuda = map2_cuda_values.min_max_mean() assert (map2.size() == map2_cuda.size()) assert approx_equal(mmm.min, mmm_cuda.min, eps=eps) assert approx_equal(mmm.max, mmm_cuda.max, eps=eps) assert approx_equal(mmm.mean, mmm_cuda.mean, eps=eps) if (benchmark): map_bak = map.deep_copy() r2c = [fft.forward, fft_cuda.forward] c2r = [fft.backward, fft_cuda.backward] modules = ["fftpack:", "cufft: "] last_real = [None, None] print " dimensions:", n_real print " repeats:", n_repeats k = 0 for (r2c_fn, c2r_fn, name) in zip(r2c, c2r, modules): t_forward = 0 t_backward = 0 map = map_bak.deep_copy() for i in range(n_repeats): t1 = time.time() sfs = r2c_fn(map) t2 = time.time() map2 = c2r_fn(sfs) t3 = time.time() t_forward += t2 - t1 t_backward += t3 - t2 if (i == n_repeats - 1): last_real[k] = map2.deep_copy() k += 1 print " %s %7.3fs (forward) %7.3fs (backward)" % ( name, t_forward / n_repeats, t_backward / n_repeats) last_fftpack, last_cufft = last_real maptbx.unpad_in_place(map=last_fftpack) maptbx.unpad_in_place(map=last_cufft) mmm = last_fftpack.as_1d().min_max_mean() mmm_cuda = last_cufft.as_1d().min_max_mean() # FIXME why doesn't this work? #assert approx_equal(mmm.min, mmm_cuda.min, eps=eps) assert approx_equal(mmm.max, mmm_cuda.max, eps=eps) assert approx_equal(mmm.mean, mmm_cuda.mean, eps=eps) print ""
def _exercise_real_to_complex_3d (sizes, benchmark=True) : from cctbx import maptbx from scitbx.array_family import flex from cudatbx import cufft from scitbx import fftpack from libtbx.test_utils import approx_equal import time for n_real, n_repeats, eps in sizes : nx, ny, nz = n_real fft = fftpack.real_to_complex_3d((nx,ny,nz)) mt = flex.mersenne_twister(seed=1) g = flex.grid(fft.m_real()).set_focus(fft.n_real()) map = mt.random_double(size=g.size_1d()) map.reshape(g) sfs = fft.forward(map.deep_copy()) map2 = fft.backward(sfs) fft_cuda = cufft.real_to_complex_3d((nx,ny,nz)) sfs_cuda = fft_cuda.forward(map)#cufft.real_to_complex_3d_in_place(map) map2_cuda = fft_cuda.backward(sfs_cuda)#cufft.complex_to_real_3d_in_place(sfs_cuda, n_real) maptbx.unpad_in_place(map=map2) maptbx.unpad_in_place(map=map2_cuda) map2_values = map2.as_1d() map2_cuda_values = map2_cuda.as_1d() mmm = map2_values.min_max_mean() mmm_cuda = map2_cuda_values.min_max_mean() assert (map2.size() == map2_cuda.size()) assert approx_equal(mmm.min, mmm_cuda.min, eps=eps) assert approx_equal(mmm.max, mmm_cuda.max, eps=eps) assert approx_equal(mmm.mean, mmm_cuda.mean, eps=eps) if (benchmark) : map_bak = map.deep_copy() r2c = [ fft.forward, fft_cuda.forward ] c2r = [ fft.backward, fft_cuda.backward ] modules = ["fftpack:", "cufft: "] last_real = [None, None] print " dimensions:", n_real print " repeats:", n_repeats k = 0 for (r2c_fn, c2r_fn, name) in zip(r2c, c2r, modules) : t_forward = 0 t_backward = 0 map = map_bak.deep_copy() for i in range(n_repeats) : t1 = time.time() sfs = r2c_fn(map) t2 = time.time() map2 = c2r_fn(sfs) t3 = time.time() t_forward += t2 - t1 t_backward += t3 - t2 if (i == n_repeats - 1) : last_real[k] = map2.deep_copy() k += 1 print " %s %7.3fs (forward) %7.3fs (backward)" % (name, t_forward / n_repeats, t_backward / n_repeats) last_fftpack,last_cufft = last_real maptbx.unpad_in_place(map=last_fftpack) maptbx.unpad_in_place(map=last_cufft) mmm = last_fftpack.as_1d().min_max_mean() mmm_cuda = last_cufft.as_1d().min_max_mean() # FIXME why doesn't this work? #assert approx_equal(mmm.min, mmm_cuda.min, eps=eps) assert approx_equal(mmm.max, mmm_cuda.max, eps=eps) assert approx_equal(mmm.mean, mmm_cuda.mean, eps=eps) print ""
def run_group(symbol): group = space_group_info(symbol) print("\n==") elements = ('C', 'N', 'O', 'H') * 11 struc = random_structure.xray_structure(space_group_info=group, volume_per_atom=25., general_positions_only=False, elements=elements, min_distance=1.0) struc.show_summary() d_min = 2. fc = struc.structure_factors(d_min=d_min).f_calc() symmetry_flags = maptbx.use_space_group_symmetry fftmap = fc.fft_map(symmetry_flags=symmetry_flags) grid_size = fftmap.real_map().accessor().focus() ### rm = fftmap.real_map().deep_copy() amap0 = asymmetric_map(struc.space_group().type(), rm) p1_map00 = amap0.symmetry_expanded_map() assert approx_equal(p1_map00, rm) # maptbx.unpad_in_place(rm) amap1 = asymmetric_map(struc.space_group().type(), rm) p1_map10 = amap1.symmetry_expanded_map() assert approx_equal(p1_map00, p1_map10) ### grid_tags = maptbx.grid_tags(grid_size) grid_tags.build(fftmap.space_group_info().type(), fftmap.symmetry_flags()) grid_tags.verify(fftmap.real_map()) print("FFT grid_size = ", grid_size) amap = asymmetric_map(struc.space_group().type(), fftmap.real_map()) afc = amap.structure_factors(fc.indices()) afftmap = amap.map_for_fft() print("whole cell map size: ", afftmap.accessor().focus()) adata = amap.data() acc = adata.accessor() print("Asu map size: ", acc.origin(), " ", acc.last(), " ", acc.focus(), \ " ", acc.all()) df = flex.abs(afc - fc.data()) r1 = flex.sum(df) / flex.sum(flex.abs(fc.data())) print("R1: ", r1) assert r1 < 1.e-5 # just to prove to myself that I can shift origin to 000 and then reshape back adata = adata.shift_origin() adata.reshape(acc) # adata2 = adata.deep_copy() * 2. amap2 = asymmetric_map(struc.space_group().type(), adata2, grid_size) afc2 = amap2.structure_factors(fc.indices()) df2 = flex.abs(afc2 * .5 - fc.data()) r12 = flex.sum(df2) / flex.sum(flex.abs(fc.data())) print("R1 again: ", r12) assert r12 < 1.e-5 p1_map = amap.symmetry_expanded_map() assert p1_map.accessor().focus() == grid_size rel_tol = 1.e-6 n = 0 mean_rel_dif = 0. for (m1, m2) in zip(fftmap.real_map(), p1_map): dif = abs(m1 - m2) av = 0.5 * (abs(m1) + abs(m2)) assert dif <= rel_tol * av, "%f not <= %f * %f" % (dif, rel_tol, av) if av != 0: mean_rel_dif = mean_rel_dif + dif / av n = n + 1 mean_rel_dif = mean_rel_dif / n print("mean rel err: ", mean_rel_dif) assert mean_rel_dif < 1.e-6
def __init__(self, xray_structure, step, volume_cutoff, f_obs, f_calc=None, log=sys.stdout, write_masks=False): adopt_init_args(self, locals()) # self.dsel = f_obs.d_spacings().data() >= 0 self.miller_array = f_obs.select(self.dsel) # self.crystal_symmetry = self.xray_structure.crystal_symmetry() # compute mask in p1 (via ASU) self.crystal_gridding = maptbx.crystal_gridding( unit_cell=xray_structure.unit_cell(), space_group_info=xray_structure.space_group_info(), symmetry_flags=maptbx.use_space_group_symmetry, step=step) self.n_real = self.crystal_gridding.n_real() # XXX Where do we want to deal with H and occ==0? mask_p1 = mmtbx.masks.mask_from_xray_structure( xray_structure=xray_structure, p1=True, for_structure_factors=True, n_real=self.n_real, in_asu=False).mask_data maptbx.unpad_in_place(map=mask_p1) self.solvent_content = 100. * mask_p1.count(1) / mask_p1.size() if (write_masks): write_map_file(crystal_symmetry=xray_structure.crystal_symmetry(), map_data=mask_p1, file_name="mask_whole.mrc") # conn analysis co = maptbx.connectivity(map_data=mask_p1, threshold=0.01, preprocess_against_shallow=True, wrapping=True) co.merge_symmetry_related_regions( space_group=xray_structure.space_group()) del mask_p1 self.conn = co.result().as_double() z = zip(co.regions(), range(0, co.regions().size())) sorted_by_volume = sorted(z, key=lambda x: x[0], reverse=True) f_mask_data_0 = flex.complex_double(f_obs.data().size(), 0) FM = OrderedDict() self.FV = OrderedDict() self.mc = None diff_map = None mean_diff_map = None self.regions = OrderedDict() print( " volume_p1 uc(%) volume_asu id mFo-DFc: min,max,mean,sd", file=log) # Check if self.anomaly self.anomaly = False if (len(sorted_by_volume) > 2): uc_fractions = [ round(p[0] * 100. / self.conn.size(), 0) for p in sorted_by_volume[1:] ] if (uc_fractions[0] / 4 < uc_fractions[1]): self.anomaly = True # for i_seq, p in enumerate(sorted_by_volume): v, i = p # skip macromolecule if (i == 0): continue # skip small volume volume = v * step**3 uc_fraction = v * 100. / self.conn.size() if (volume_cutoff is not None): if volume < volume_cutoff: continue selection = self.conn == i mask_i_asu = self.compute_i_mask_asu(selection=selection, volume=volume) volume_asu = (mask_i_asu > 0).count(True) * step**3 if (i_seq == 1 or uc_fraction > 5): f_mask_i = self.compute_f_mask_i(mask_i_asu) if (not self.anomaly): f_mask_data_0 += f_mask_i.data() if (uc_fraction < 5 and diff_map is None and not self.anomaly): diff_map = self.compute_diff_map(f_mask_data=f_mask_data_0) mi, ma, me, sd = None, None, None, None if (diff_map is not None): blob = diff_map.select(selection.iselection()) mean_diff_map = flex.mean( diff_map.select(selection.iselection())) mi, ma, me = flex.min(blob), flex.max(blob), flex.mean(blob) sd = blob.sample_standard_deviation() print("%12.3f" % volume, "%8.4f" % round(uc_fraction, 4), "%12.3f" % volume_asu, "%3d" % i, "%7s" % str(None) if diff_map is None else "%7.3f %7.3f %7.3f %7.3f" % (mi, ma, me, sd), file=log) if (uc_fraction < 1 and mean_diff_map is not None and mean_diff_map <= 0): continue self.regions[i_seq] = group_args(id=i, i_seq=i_seq, volume=volume, uc_fraction=uc_fraction, diff_map=group_args(mi=mi, ma=ma, me=me, sd=sd)) if (not (i_seq == 1 or uc_fraction > 5)): f_mask_i = self.compute_f_mask_i(mask_i_asu) FM.setdefault(round(volume, 3), []).append(f_mask_i.data()) self.FV[f_mask_i] = [round(volume, 3), round(uc_fraction, 1)] # f_mask_0 = f_obs.customized_copy(data=f_mask_data_0) # self.f_mask_0 = None if (not self.anomaly): self.f_mask_0 = f_obs.customized_copy(data=f_mask_data_0) self.do_mosaic = False if (len(self.FV.keys()) > 1): self.do_mosaic = True
def get_f_mask(xrs, ma, step, option=2): crystal_gridding = maptbx.crystal_gridding( unit_cell=xrs.unit_cell(), space_group_info=xrs.space_group_info(), symmetry_flags=maptbx.use_space_group_symmetry, step=step) n_real = crystal_gridding.n_real() atom_radii = vdw_radii_from_xray_structure(xray_structure=xrs) mask_params = masks.mask_master_params.extract() grid_step_factor = ma.d_min() / step # 1 if (option == 1): asu_mask = ext.atom_mask( unit_cell=xrs.unit_cell(), group=xrs.space_group(), resolution=ma.d_min(), grid_step_factor=grid_step_factor, solvent_radius=mask_params.solvent_radius, shrink_truncation_radius=mask_params.shrink_truncation_radius) asu_mask.compute(xrs.sites_frac(), atom_radii) fm_asu = asu_mask.structure_factors(ma.indices()) f_mask = ma.set().array(data=fm_asu) # 2 elif (option == 2): asu_mask = ext.atom_mask( unit_cell=xrs.unit_cell(), space_group=xrs.space_group(), gridding_n_real=n_real, solvent_radius=mask_params.solvent_radius, shrink_truncation_radius=mask_params.shrink_truncation_radius) asu_mask.compute(xrs.sites_frac(), atom_radii) fm_asu = asu_mask.structure_factors(ma.indices()) f_mask = ma.set().array(data=fm_asu) # 3 elif (option == 3): mask_params.grid_step_factor = grid_step_factor mask_manager = masks.manager(miller_array=ma, miller_array_twin=None, mask_params=mask_params) f_mask = mask_manager.shell_f_masks(xray_structure=xrs, force_update=True)[0] # 4 elif (option == 4): mask_p1 = mmtbx.masks.mask_from_xray_structure( xray_structure=xrs, p1=True, for_structure_factors=True, n_real=n_real, in_asu=False).mask_data maptbx.unpad_in_place(map=mask_p1) mask = asu_map_ext.asymmetric_map( xrs.crystal_symmetry().space_group().type(), mask_p1).data() f_mask = ma.structure_factors_from_asu_map(asu_map_data=mask, n_real=n_real) elif (option == 5): o = mmtbx.masks.bulk_solvent( xray_structure=xrs, ignore_zero_occupancy_atoms=False, solvent_radius=mask_params.solvent_radius, shrink_truncation_radius=mask_params.shrink_truncation_radius, ignore_hydrogen_atoms=False, gridding_n_real=n_real, atom_radii=atom_radii) f_mask = o.structure_factors(ma) else: assert 0 # return f_mask
def __init__(self, xray_structure, step, volume_cutoff=None, mean_diff_map_threshold=None, compute_whole=False, largest_only=False, wrapping=True, f_obs=None, r_sol=1.1, r_shrink=0.9, f_calc=None, log=None, write_masks=False): adopt_init_args(self, locals()) # self.d_spacings = f_obs.d_spacings().data() self.sel_3inf = self.d_spacings >= 3 self.miller_array = f_obs.select(self.sel_3inf) # self.crystal_symmetry = self.xray_structure.crystal_symmetry() # compute mask in p1 (via ASU) self.crystal_gridding = maptbx.crystal_gridding( unit_cell=xray_structure.unit_cell(), space_group_info=xray_structure.space_group_info(), symmetry_flags=maptbx.use_space_group_symmetry, step=step) self.n_real = self.crystal_gridding.n_real() # XXX Where do we want to deal with H and occ==0? mask_p1 = mmtbx.masks.mask_from_xray_structure( xray_structure=xray_structure, p1=True, for_structure_factors=True, solvent_radius=r_sol, shrink_truncation_radius=r_shrink, n_real=self.n_real, in_asu=False).mask_data maptbx.unpad_in_place(map=mask_p1) self.f_mask_whole = None if (compute_whole): mask = asu_map_ext.asymmetric_map( xray_structure.crystal_symmetry().space_group().type(), mask_p1).data() self.f_mask_whole = self._inflate( self.miller_array.structure_factors_from_asu_map( asu_map_data=mask, n_real=self.n_real)) self.solvent_content = 100. * mask_p1.count(1) / mask_p1.size() if (write_masks): write_map_file(crystal_symmetry=xray_structure.crystal_symmetry(), map_data=mask_p1, file_name="mask_whole.mrc") # conn analysis co = maptbx.connectivity(map_data=mask_p1, threshold=0.01, preprocess_against_shallow=False, wrapping=wrapping) co.merge_symmetry_related_regions( space_group=xray_structure.space_group()) del mask_p1 self.conn = co.result().as_double() z = zip(co.regions(), range(0, co.regions().size())) sorted_by_volume = sorted(z, key=lambda x: x[0], reverse=True) # f_mask_data_0 = flex.complex_double(f_obs.data().size(), 0) f_mask_data = flex.complex_double(f_obs.data().size(), 0) self.FV = OrderedDict() self.mc = None diff_map = None mean_diff_map = None self.regions = OrderedDict() self.f_mask_0 = None self.f_mask = None # if (log is not None): print(" # volume_p1 uc(%) mFo-DFc: min,max,mean,sd", file=log) # for i_seq, p in enumerate(sorted_by_volume): v, i = p # skip macromolecule if (i == 0): continue # skip small volume volume = v * step**3 uc_fraction = v * 100. / self.conn.size() if (volume_cutoff is not None): if volume < volume_cutoff: continue self.regions[i_seq] = group_args(id=i, i_seq=i_seq, volume=volume, uc_fraction=uc_fraction) selection = self.conn == i mask_i_asu = self.compute_i_mask_asu(selection=selection, volume=volume) volume_asu = (mask_i_asu > 0).count(True) * step**3 if (uc_fraction >= 1): f_mask_i = self.compute_f_mask_i(mask_i_asu) f_mask_data_0 += f_mask_i.data() elif (largest_only): break if (uc_fraction < 1 and diff_map is None): diff_map = self.compute_diff_map(f_mask_data=f_mask_data_0) mi, ma, me, sd = None, None, None, None if (diff_map is not None): blob = diff_map.select(selection.iselection()) mean_diff_map = flex.mean( diff_map.select(selection.iselection())) mi, ma, me = flex.min(blob), flex.max(blob), flex.mean(blob) sd = blob.sample_standard_deviation() if (log is not None): print("%3d" % i_seq, "%12.3f" % volume, "%8.4f" % round(uc_fraction, 4), "%7s" % str(None) if diff_map is None else "%7.3f %7.3f %7.3f %7.3f" % (mi, ma, me, sd), file=log) if (mean_diff_map_threshold is not None and mean_diff_map is not None and mean_diff_map <= mean_diff_map_threshold): continue f_mask_i = self.compute_f_mask_i(mask_i_asu) f_mask_data += f_mask_i.data() self.FV[f_mask_i] = [round(volume, 3), round(uc_fraction, 1)] # self.f_mask_0 = f_obs.customized_copy(data=f_mask_data_0) self.f_mask = f_obs.customized_copy(data=f_mask_data) self.do_mosaic = False # Determine number of secondary regions self.n_regions = len(self.FV.values()) if (self.n_regions > 1): self.do_mosaic = True
def remove_model_density(map_data, xrs, rad_inside=2): # map_data = map_data - flex.mean(map_data) map_data = map_data.set_selected(map_data < 0, 0) sd = map_data.sample_standard_deviation() assert sd != 0 map_data = map_data / sd # map_at_atoms = flex.double() for site_frac in xrs.sites_frac(): mv = map_data.tricubic_interpolation(site_frac) map_at_atoms.append( mv ) print (flex.mean(map_at_atoms), flex.max(map_at_atoms)) mmax = flex.max(map_at_atoms) cut = 0 print (dir(map_data)) while cut<mmax: map_data_ = map_data.deep_copy() map_data_ = map_data_.set_selected(map_data<cut, 0) map_data_ = map_data_.set_selected(map_data>=cut, 1) cut+=1 zz = flex.double() for site_frac in xrs.sites_frac(): mv = map_data_.value_at_closest_grid_point(site_frac) zz.append( mv ) print(cut, (zz==1).count(True)/zz.size()*100. ) # #radii = flex.double(xrs.sites_frac().size(), rad_inside) #mask = cctbx_maptbx_ext.mask( # sites_frac = xrs.sites_frac(), # unit_cell = xrs.unit_cell(), # n_real = map_data.all(), # mask_value_inside_molecule = 0, # mask_value_outside_molecule = 1, # radii = radii) mask = mmtbx.masks.mask_from_xray_structure( xray_structure = xrs, p1 = True, for_structure_factors = True, solvent_radius = None, shrink_truncation_radius = None, n_real = map_data.accessor().all(), in_asu = False).mask_data maptbx.unpad_in_place(map=mask) map_data = map_data * mask map_data = map_data.set_selected(map_data < flex.mean(map_at_atoms)/6, 0) # n = map_data.accessor().all() abc = xrs.unit_cell().parameters()[:3] print(abc[0]/n[0], abc[1]/n[1], abc[2]/n[2]) step = abc[0]/n[0] co = maptbx.connectivity( map_data = map_data.deep_copy(), threshold = 0.0, preprocess_against_shallow = True, wrapping = False) conn = co.result().as_double() z = zip(co.regions(),range(0,co.regions().size())) sorted_by_volume = sorted(z, key=lambda x: x[0], reverse=True) mask_ = flex.double(flex.grid(n), 0) for i_seq, p in enumerate(sorted_by_volume): v, i = p if i_seq==0: continue volume = v*step**3 print(v, volume) if 1:#(volume<3): sel = conn==i mask_ = mask_.set_selected(sel, 1) # return map_data*mask_
def get_f_mask(xrs, ma, step, option=2, r_shrink=None, r_sol=None): # result = ma.deep_copy() sel = ma.d_spacings().data() >= 3 ma = ma.select(sel) # crystal_gridding = maptbx.crystal_gridding( unit_cell=xrs.unit_cell(), space_group_info=xrs.space_group_info(), symmetry_flags=maptbx.use_space_group_symmetry, step=step) n_real = crystal_gridding.n_real() atom_radii = vdw_radii_from_xray_structure(xray_structure=xrs) mask_params = masks.mask_master_params.extract() grid_step_factor = ma.d_min() / step if (r_shrink is not None): mask_params.shrink_truncation_radius = r_shrink if (r_sol is not None): mask_params.solvent_radius = r_sol mask_params.grid_step_factor = grid_step_factor # 1 if (option == 1): asu_mask = ext.atom_mask( unit_cell=xrs.unit_cell(), group=xrs.space_group(), resolution=ma.d_min(), grid_step_factor=grid_step_factor, solvent_radius=mask_params.solvent_radius, shrink_truncation_radius=mask_params.shrink_truncation_radius) asu_mask.compute(xrs.sites_frac(), atom_radii) fm_asu = asu_mask.structure_factors(ma.indices()) f_mask = ma.set().array(data=fm_asu) # 2 elif (option == 2): asu_mask = ext.atom_mask( unit_cell=xrs.unit_cell(), space_group=xrs.space_group(), gridding_n_real=n_real, solvent_radius=mask_params.solvent_radius, shrink_truncation_radius=mask_params.shrink_truncation_radius) asu_mask.compute(xrs.sites_frac(), atom_radii) fm_asu = asu_mask.structure_factors(ma.indices()) f_mask = ma.set().array(data=fm_asu) # 3 elif (option == 3): mask_p1 = mmtbx.masks.mask_from_xray_structure( xray_structure=xrs, p1=True, for_structure_factors=True, solvent_radius=mask_params.solvent_radius, shrink_truncation_radius=mask_params.shrink_truncation_radius, n_real=n_real, in_asu=False).mask_data maptbx.unpad_in_place(map=mask_p1) mask = asu_map_ext.asymmetric_map( xrs.crystal_symmetry().space_group().type(), mask_p1).data() f_mask = ma.structure_factors_from_asu_map(asu_map_data=mask, n_real=n_real) # 4 elif (option == 4): f_mask = masks.bulk_solvent( xray_structure=xrs, ignore_zero_occupancy_atoms=False, solvent_radius=mask_params.solvent_radius, shrink_truncation_radius=mask_params.shrink_truncation_radius, ignore_hydrogen_atoms=False, grid_step=step, atom_radii=atom_radii).structure_factors(miller_set=ma) elif (option == 5): o = mmtbx.masks.bulk_solvent( xray_structure=xrs, ignore_zero_occupancy_atoms=False, solvent_radius=mask_params.solvent_radius, shrink_truncation_radius=mask_params.shrink_truncation_radius, ignore_hydrogen_atoms=False, gridding_n_real=n_real, atom_radii=atom_radii) assert approx_equal(n_real, o.data.accessor().all()) f_mask = o.structure_factors(ma) elif (option == 6): # XXX No control over n_real, so results with others don't match mask_manager = masks.manager(miller_array=ma, miller_array_twin=None, mask_params=mask_params) f_mask = mask_manager.shell_f_masks(xray_structure=xrs, force_update=True)[0] else: assert 0 # data = flex.complex_double(result.indices().size(), 0) data = data.set_selected(sel, f_mask.data()) result = result.array(data=data) return result
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_group(symbol, preprocess_against_shallow): group = space_group_info(symbol) print("\n== space group %d"%symbol) xrs = random_structure.xray_structure( space_group_info = group, volume_per_atom = 15., general_positions_only = False, elements = ('C', 'N', 'O', 'H')*31, min_distance = 1.0) sgt = xrs.space_group().type() # cg = maptbx.crystal_gridding( unit_cell = xrs.unit_cell(), space_group_info = xrs.space_group_info(), symmetry_flags = maptbx.use_space_group_symmetry, step = 0.4) n_real = cg.n_real() mask_p1 = mmtbx.masks.mask_from_xray_structure( xray_structure = xrs, p1 = True, for_structure_factors = True, n_real = n_real, in_asu = False).mask_data maptbx.unpad_in_place(map=mask_p1) assert flex.min(mask_p1)==0 assert flex.max(mask_p1)==1 # co = maptbx.connectivity( map_data = mask_p1, threshold = 0.01, preprocess_against_shallow = preprocess_against_shallow, wrapping = True) # print("Regions in P1") regions_p1 = list(co.regions()) s1 = flex.sum(flex.int(regions_p1)) print(regions_p1, s1) conn_map_p1 = co.result().as_double() print(flex.min(conn_map_p1), flex.max(conn_map_p1)) # print("Merge symmetry related") co.merge_symmetry_related_regions(space_group = xrs.space_group()) conn_map_p1_merged = co.result().as_double() regions_p1_merged = list(co.regions()) s2 = flex.sum(flex.int(regions_p1_merged)) print(list(regions_p1_merged), s2) amap = asu_map_ext.asymmetric_map(sgt, conn_map_p1_merged) conn_map_asu = amap.data() conn_map_p1_restored = amap.symmetry_expanded_map() print(flex.min(conn_map_asu), flex.max(conn_map_asu)) # mask_p1_1 = conn_map_p1_restored.set_selected(conn_map_p1_restored>0.01, 1) maptbx.unpad_in_place(map=mask_p1_1) co = maptbx.connectivity( map_data = mask_p1_1, threshold = 0.01, preprocess_against_shallow = preprocess_against_shallow, wrapping = True) print("Restored") regions_p1_restored = list(co.regions()) s3 = flex.sum(flex.int(regions_p1_restored)) print(regions_p1_restored, s3) conn_map_p1_restored = co.result().as_double() print(flex.min(conn_map_p1_restored), flex.max(conn_map_p1_restored)) assert regions_p1 == regions_p1_restored # assert s1 == s2 assert s2 == s3
def __init__(self, miller_array, xray_structure, step, volume_cutoff, f_obs=None, r_free_flags=None, f_calc=None, write_masks=False): adopt_init_args(self, locals()) assert [f_obs, f_calc, r_free_flags].count(None) in [0, 3] self.crystal_symmetry = self.xray_structure.crystal_symmetry() # compute mask in p1 (via ASU) self.crystal_gridding = maptbx.crystal_gridding( unit_cell=xray_structure.unit_cell(), space_group_info=xray_structure.space_group_info(), symmetry_flags=maptbx.use_space_group_symmetry, step=step) self.n_real = self.crystal_gridding.n_real() mask_p1 = mmtbx.masks.mask_from_xray_structure( xray_structure=xray_structure, p1=True, for_structure_factors=True, n_real=self.n_real, in_asu=False).mask_data maptbx.unpad_in_place(map=mask_p1) solvent_content = 100. * mask_p1.count(1) / mask_p1.size() if (write_masks): write_map_file(crystal_symmetry=xray_structure.crystal_symmetry(), map_data=mask_p1, file_name="mask_whole.mrc") # conn analysis co = maptbx.connectivity(map_data=mask_p1, threshold=0.01, preprocess_against_shallow=True, wrapping=True) del mask_p1 self.conn = co.result().as_double() z = zip(co.regions(), range(0, co.regions().size())) sorted_by_volume = sorted(z, key=lambda x: x[0], reverse=True) f_mask_data = flex.complex_double(miller_array.data().size(), 0) f_mask_data_0 = flex.complex_double(miller_array.data().size(), 0) #f_masks = [] FM = OrderedDict() diff_map = None mean_diff_map = None print(" volume_p1 uc(%) volume_asu id <mFo-DFc>") for p in sorted_by_volume: v, i = p volume = v * step**3 uc_fraction = v * 100. / self.conn.size() if (volume_cutoff is not None): if volume < volume_cutoff: continue if (i == 0): continue selection = self.conn == i mask_i_asu = self.compute_i_mask_asu(selection=selection, volume=volume) volume_asu = (mask_i_asu > 0).count(True) * step**3 if (volume_asu < 1.e-6): continue if (i == 1 or uc_fraction > 5): f_mask_i = miller_array.structure_factors_from_asu_map( asu_map_data=mask_i_asu, n_real=self.n_real) f_mask_data_0 += f_mask_i.data() f_mask_data += f_mask_i.data() if (uc_fraction < 5 and diff_map is None): diff_map = self.compute_diff_map(f_mask_data=f_mask_data_0) if (diff_map is not None): mean_diff_map = flex.mean( diff_map.select(selection.iselection())) print( "%12.3f" % volume, "%8.4f" % round(uc_fraction, 4), "%12.3f" % volume_asu, "%3d" % i, "%7s" % str(None) if diff_map is None else "%7.3f" % mean_diff_map) #if(mean_diff_map is not None and mean_diff_map<=0): continue if (not (i == 1 or uc_fraction > 5)): f_mask_i = miller_array.structure_factors_from_asu_map( asu_map_data=mask_i_asu, n_real=self.n_real) f_mask_data += f_mask_i.data() FM.setdefault(round(volume, 3), []).append(f_mask_i.data()) # group asu pices corresponding to the same region in P1 F_MASKS = [] for k, v in zip(FM.keys(), FM.values()): tmp = flex.complex_double(miller_array.data().size(), 0) for v_ in v: tmp += v_ F_MASKS.append(miller_array.customized_copy(data=tmp)) # f_mask = miller_array.customized_copy(data=f_mask_data) # self.f_mask = f_mask self.f_masks = F_MASKS