def test_real_to_complex_3d(verbose): for nx in [3,4]: for ny in [4,5]: for nz in [7,8]: fft = fftpack.real_to_complex_3d((nx,ny,nz)) m = fft.m_real() vd = flex.double(flex.grid(m)) vc = flex.complex_double(flex.grid((m[0], m[1], m[2]//2))) assert vd.size() == 2 * vc.size() for i in xrange(vd.size()): vd[i] = random.random()*2-1 vd_orig = vd.deep_copy() for i in xrange(vc.size()): vc[i] = complex(vd[2*i], vd[2*i+1]) vdt = fft.forward(vd) vct = fft.forward(vc) for t in (vdt, vct): assert t.origin() == (0,0,0) assert t.all() == fft.n_complex() assert t.focus() == fft.n_complex() if (verbose): show_rseq_3d(vd, fft.m_real(), fft.m_real()) assert_complex_eq_real(vc, vd) vdt = fft.backward(vd) vct = fft.backward(vc) for t in (vdt, vct): assert t.origin() == (0,0,0) assert t.all() == fft.m_real() assert t.focus() == fft.n_real() if (verbose): show_rseq_3d(vd, fft.m_real(), fft.n_real()) assert_complex_eq_real(vc, vd) f = nx*ny*nz for ix in xrange(nx): for iy in xrange(ny): for iz in xrange(nz): assert approx_equal(vdt[(ix,iy,iz)], vd_orig[(ix,iy,iz)]*f)
def tst_larger_output(self): from scitbx.array_family import flex # Set the size of the grid height = 10 width = 10 # Create the grid data value = 13 grid = flex.double([value for i in range(height * width)]) grid.reshape(flex.grid(height, width)) # Create the grid coordinates xy = [] for j in range(height + 1): for i in range(width + 1): xy.append((i * 2, j * 2)) gridxy = flex.vec2_double(xy) gridxy.reshape(flex.grid(height + 1, width + 1)) # Get the output grid output = regrid_irregular_grid_to_grid(grid, gridxy, (height * 2, width * 2)) # Check that each each pixel has a value of 0.25 the input eps = 1e-7 for j in range(1, height): for i in range(1, width): assert abs(output[j, i] - 0.25 * value) <= eps # Test passed print "OK"
def test_complex_to_complex_3d(verbose): fft = fftpack.complex_to_complex_3d((3,4,5)) n = fft.n() vc = flex.complex_double(flex.grid(n)) vd = flex.double(flex.grid((n[0], n[1], 2 * n[2]))) for i in xrange(vc.size()): vc[i] = complex(2*i, 2*i+1) for i in xrange(vd.size()): vd[i] = i vct = fft.forward(vc) vdt = fft.forward(vd) for t in (vct, vdt): assert t.origin() == (0,0,0) assert t.all() == fft.n() assert t.focus() == fft.n() if (verbose): show_cseq(vc) assert_complex_eq_real(vc, vd) vct = fft.backward(vc) vdt = fft.backward(vd) for t in (vct, vdt): assert t.origin() == (0,0,0) assert t.all() == fft.n() assert t.focus() == fft.n() if (verbose): show_cseq(vc) assert_complex_eq_real(vc, vd)
def exercise_expand_mask(): # case 1: standard cmap = flex.double(flex.grid(30,30,30)) cmap.fill(1) for i in range(10,20): for j in range(10,20): for k in range(10,20): cmap[i,j,k] = 10 co = maptbx.connectivity(map_data=cmap, threshold=5) new_mask = co.expand_mask(id_to_expand=1, expand_size=1) for i in range(30): for j in range(30): for k in range(30): assert new_mask[i,j,k] == (i in range(9,21) and j in range(9,21) and k in range(9,21)) # case 2: over boundaries cmap = flex.double(flex.grid(30,30,30)) cmap.fill(1) cmap[1,1,1] = 10 co = maptbx.connectivity(map_data=cmap, threshold=5) new_mask = co.expand_mask(id_to_expand=1, expand_size=2) for i in range(30): for j in range(30): for k in range(30): assert new_mask[i,j,k] == (i in [29,0,1,2,3] and j in [29,0,1,2,3] and k in [29,0,1,2,3])
def run(self): from scitbx.array_family import flex data_list = [] mask_list = [] for i in range(10): data = flex.random_int_gaussian_distribution( self.size[0] * self.size[1], 100, 10) data.reshape(flex.grid(self.size)) mask = flex.random_bool(self.size[0] * self.size[1], 0.1) mask.reshape(flex.grid(self.size)) data_list.append(data) mask_list.append(mask) for i in range(10): self.label_images.add_image(data_list[i], mask_list[i]) labels = self.label_images.labels() coords = self.label_images.coords() values = self.label_images.values() assert(len(labels) > 0) assert(len(labels) == len(coords)) assert(len(labels) == len(values)) self.tst_coords_are_valid(mask_list, coords) self.tst_values_are_valid(data_list, mask_list, values) self.tst_labels_are_valid(data_list, mask_list, coords, labels)
def get_mask(self, goniometer=None): '''Creates a mask merging untrusted pixels with active areas.''' from scitbx.array_family import flex detector_base = self.detectorbase # get effective active area coordinates tile_manager = detector_base.get_tile_manager(detector_base.horizons_phil_cache) tiling = tile_manager.effective_tiling_as_flex_int(reapply_peripheral_margin = True) # get the raw data to get the size of the mask data = self.get_raw_data() if tiling is None or len(tiling) == 0: return None # set the mask to the same dimensions as the data mask = flex.bool(flex.grid(data.focus())) # set active areas to True so they are not masked for i in xrange(len(tiling)//4): x1,y1,x2,y2=tiling[4*i:(4*i)+4] sub_array = flex.bool(flex.grid(x2-x1,y2-y1),True) mask.matrix_paste_block_in_place(sub_array,x1,y1) # create untrusted pixel mask detector = self.get_detector() assert len(detector) == 1 trusted_mask = detector[0].get_trusted_range_mask(data) # returns merged untrusted pixels and active areas using bitwise AND (pixels are accepted # if they are inside of the active areas AND inside of the trusted range) return (mask & trusted_mask,)
def _to_array_all(self, panel=0): """ Get the array from all the sweep elements. """ from scitbx.array_family import flex # Get the image dimensions size_z = len(self) size_y = self.reader().get_image_size(panel)[1] size_x = self.reader().get_image_size(panel)[0] # Check sizes are valid if size_z <= 0 or size_y <= 0 or size_x <= 0: raise RuntimeError("Invalid dimensions") # Allocate the array array = flex.int(flex.grid(size_z, size_y, size_x)) # Loop through all the images and set the image data for k, image in enumerate(self): if not isinstance(image, tuple): image = (image,) im = image[panel] im.reshape(flex.grid(1, *im.all())) array[k : k + 1, :, :] = im # Return the array return array
def _to_array_w_range(self, item, panel=0): """ Get the array from the user specified range. """ from scitbx.array_family import flex # Get the range from the given index item z0, z1, y0, y1, x0, x1 = self._get_data_range(item, panel) # Get the image dimensions size_z = z1 - z0 size_y = y1 - y0 size_x = x1 - x0 # Check sizes are valid if size_z <= 0 or size_y <= 0 or size_x <= 0: raise RuntimeError("Invalid dimensions") # Allocate the array array = flex.int(flex.grid(size_z, size_y, size_x)) # Loop through all the images and set the image data for k, index in enumerate(self.indices()[z0:z1]): image = self.reader().read(index) if not isinstance(image, tuple): image = (image,) im = image[panel] im.reshape(flex.grid(1, *im.all())) array[k : k + 1, :, :] = im[0:1, y0:y1, x0:x1] # Return the array return array
def tst_with_flat_background_partial(self): from dials.algorithms.integration.fit import fit_profile from scitbx.array_family import flex from tst_profile_helpers import gaussian # Create profile p = gaussian((9, 9, 9), 1, (4, 4, 4), (2, 2, 2)) s = flex.sum(p) p = p / s # Copy profile c0 = gaussian((9, 9, 9), 1, (4, 4, 4), (2, 2, 2)) b = flex.double(flex.grid(9, 9, 9), 5) m = flex.bool(flex.grid(9,9,9), True) c = c0 + b # Get the partial profiles pp = p[0:5,:,:] mp = m[0:5,:,:] cp = c[0:5,:,:] bp = b[0:5,:,:] c0p = c0[0:5,:,:] # Fit fit = fit_profile(pp, mp, cp, bp) I = fit.intensity() V = fit.variance() # Test intensity is the same eps = 1e-7 assert(abs(I - flex.sum(c0)) < eps) assert(abs(V - (flex.sum(c0p) + flex.sum(bp))) < eps) print 'OK'
def exercise_int(): fa = flex.int_range(1,7) na = fa.as_numpy_array() assert na.tolist() == list(fa) fna = flex.int(na) assert fna.all() == (6,) assert fna.origin() == (0,) assert fna.focus() == (6,) assert fna.all_eq(fa) fa[0] = 99 assert na[0] == 1 fa[0] = 1 # fa.reshape(flex.grid(2,3)) na = fa.as_numpy_array() assert na.tolist() == [[1, 2, 3], [4, 5, 6]] fna = flex.int(na) assert fna.all() == (2,3) assert fna.origin() == (0,0) assert fna.focus() == (2,3) assert fna.all_eq(fa) # fa = flex.int_range(4*2*3) + 1 fa.reshape(flex.grid(4,2,3)) na = fa.as_numpy_array() assert na.tolist() == [ [[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]], [[13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24]]] fna = flex.int(na) assert fna.all() == (4,2,3) assert fna.origin() == (0,0,0) assert fna.focus() == (4,2,3) assert fna.all_eq(fa)
def tst_with_flat_background(self): from dials.algorithms.integration.fit import fit_profile from scitbx.array_family import flex from tst_profile_helpers import gaussian # Create profile p = gaussian((9, 9, 9), 1, (4, 4, 4), (2, 2, 2)) s = flex.sum(p) p = p / s # Copy profile c0 = gaussian((9, 9, 9), 1, (4, 4, 4), (2, 2, 2)) b = flex.double(flex.grid(9, 9, 9), 5) m = flex.bool(flex.grid(9,9,9), True) c = c0 + b # Fit fit = fit_profile(p, m, c, b) I = fit.intensity() V = fit.variance() # Test intensity is the same eps = 1e-7 assert(abs(I - flex.sum(c0)) < eps) assert(abs(V - (flex.sum(c0) + flex.sum(b))) < eps) print 'OK'
def exercise_inverse(): #standard 2x2 matrix a = flex.double( flex.grid(2,2), 0.0 ) a[(0,0)] = 1 a[(0,1)] = 2 a[(1,0)] = 3 a[(1,1)] = 4 result,sigma = scitbx.linalg.svd.inverse_via_svd(a) assert approx_equal(result[(0,0)],-2.0,eps=1e-6) assert approx_equal(result[(0,1)], 1.0,eps=1e-6) assert approx_equal(result[(1,0)], 1.5,eps=1e-6) assert approx_equal(result[(1,1)],-0.5,eps=1e-6) uu = a.matrix_multiply(result) for ii in range(10): n = 30 # random matrix a = flex.double( flex.grid(n,n),0 ) for aa in range(n): for bb in range(aa,n): tmp = random.random() a[(aa,bb)]=tmp a[(bb,aa)]=tmp result,sigma = scitbx.linalg.svd.inverse_via_svd(a.deep_copy(), 1e-6) uu = a.matrix_multiply(result) for aa in range(n): for bb in range(n): tmp=0 if aa==bb: tmp=1.0 assert approx_equal( uu[(aa,bb)], tmp,1e-3 )
def tst_larger_input(self): from scitbx.array_family import flex # Set the size of the grid input_height = 20 input_width = 20 output_height = 10 output_width = 10 # Create the grid data value = 13 grid = flex.double([value for i in range(input_height * input_width)]) grid.reshape(flex.grid(input_height, input_width)) # Create the grid coordinates xy = [] for j in range(input_height + 1): for i in range(input_width + 1): xy.append((i / 2.0, j / 2.0)) gridxy = flex.vec2_double(xy) gridxy.reshape(flex.grid(input_height + 1, input_width + 1)) # Get the output grid output = regrid_irregular_grid_to_grid(grid, gridxy, (output_height, output_width)) # Check that each each pixel has a value of 4 times the input eps = 1e-7 for j in range(1, output_height): for i in range(1, output_width): assert abs(output[j, i] - 4 * value) <= eps # Test passed print "OK"
def tst_robust_glm(): from scitbx.glmtbx import robust_glm from scitbx.array_family import flex from numpy.random import poisson, seed from math import exp seed(0) n_obs = 100 for c in range(1, 100): # Test for a constant value X = flex.double([1 for i in range(n_obs)]) X.reshape(flex.grid(n_obs, 1)) Y = flex.double(list(poisson(c, n_obs))) B = flex.double([0]) result = robust_glm(X, Y, B, family="poisson", max_iter=100) assert(abs(c - exp(result.parameters()[0])) < 0.1*c) # Now test with a massive outlier for c in range(1, 100): # Test for a constant value X = flex.double([1 for i in range(n_obs)]) X.reshape(flex.grid(n_obs, 1)) Y = flex.double(list(poisson(c, n_obs))) Y[n_obs//2] = c * 100 B = flex.double([0]) result = robust_glm(X, Y, B, family="poisson", max_iter=100) assert(abs(c - exp(result.parameters()[0])) < 0.1*c) print 'OK'
def generate_linear_background_2d(self, size, bmin, bmax): from random import uniform from scitbx.array_family import flex from scitbx import matrix slice_size = (1, size[1], size[2]) data = flex.double(flex.grid(size), 0) mask = flex.bool(flex.grid(size), True) params = [] for k in range(size[0]): a00 = uniform(bmin, bmax) a01 = uniform(bmin, bmax) a10 = uniform(bmin, bmax) p00 = matrix.col((0.5, 0.5, a00)) p01 = matrix.col((8.5, 0.5, a01)) p10 = matrix.col((0.5, 8.5, a10)) n = (p01 - p00).cross(p10 - p00) b = n[0] c = n[1] d = n[2] a = -(b * 0.5 + c * 0.5 + d * a00) a /= -d b /= -d c /= -d for j in range(size[1]): for i in range(size[2]): data[k, j, i] = a + b * (i + 0.5) + c * (j + 0.5) eps = 1e-7 assert abs(data[k, 0, 0] - a00) < eps assert abs(data[k, 8, 0] - a10) < eps assert abs(data[k, 0, 8] - a01) < eps params.append((a, b, c)) return params, data, mask
def tst_identical(self): from dials.algorithms.integration.fit import fit_profile from scitbx.array_family import flex from tst_profile_helpers import gaussian # Create profile p = gaussian((9, 9, 9), 1, (4, 4, 4), (2, 2, 2)) s = flex.sum(p) p = p / s # Copy profile c = p.deep_copy() b = flex.double(flex.grid(9, 9, 9), 0) m = flex.bool(flex.grid(9,9,9), True) # Fit fit = fit_profile(p, m, c, b) I = fit.intensity() V = fit.variance() # Test intensity is the same eps = 1e-7 assert(abs(I - flex.sum(p)) < eps) assert(abs(V - I) < eps) print 'OK'
def run(self): from dials.algorithms.image.fill_holes import simple_fill from scitbx.array_family import flex from random import randint from math import sqrt import sys mask = flex.bool(flex.grid(100, 100), True) data = flex.double(flex.grid(100, 100), True) for j in range(100): for i in range(100): data[j,i] = 10 + j * 0.01 + i * 0.01 if sqrt((j - 50)**2 + (i - 50)**2) <= 10.5: mask[j,i] = False data[j,i] = 0 result = simple_fill(data, mask) known = data.as_1d().select(mask.as_1d()) filled = result.as_1d().select(mask.as_1d() == False) assert flex.max(filled) <= flex.max(known) assert flex.min(filled) >= flex.min(known) # Test passed print 'OK'
def exercise_c_grid_conversions(verbose=0): if (verbose): print 'Checking flex->ref_c_grid conversions' a = flex.double(flex.grid((2, 3))) assert a.accessor() == rt.use_const_ref_c_grid_2(a) assert a.all() == rt.use_const_ref_c_grid_2(a).all() assert a.accessor().all() == rt.use_const_ref_c_grid_padded_2(a).all() assert a.accessor().all() == rt.use_const_ref_c_grid_padded_2(a).focus() a = flex.double(flex.grid((2, 3, 4))) assert a.accessor() == rt.use_const_ref_c_grid_3(a) assert a.all() == rt.use_const_ref_c_grid_3(a).all() assert a.accessor().all() == rt.use_const_ref_c_grid_padded_3(a).all() assert a.accessor().all() == rt.use_const_ref_c_grid_padded_3(a).focus() a = flex.double(flex.grid((2, 3, 5)).set_focus((2, 3, 4))) assert a.accessor().all() == rt.use_const_ref_c_grid_padded_3(a).all() assert a.accessor().focus() == rt.use_const_ref_c_grid_padded_3(a).focus() assert a.is_0_based() assert a.is_padded() b = flex.double(flex.grid((1,2,3), (4,6,8))) assert not b.is_0_based() assert not b.is_padded() for c in [a,b]: try: rt.use_const_ref_c_grid_3(c) except KeyboardInterrupt: raise except Exception, e: assert str(e).startswith("Python argument types in") else: raise RuntimeError("Boost.Python.ArgumentError expected.")
def tst_identical(self): from scitbx.array_family import flex from random import uniform # Set the size of the grid height = 10 width = 10 # Create the grid data grid = flex.double([uniform(0, 100) for i in range(height * width)]) grid.reshape(flex.grid(height, width)) # Create the grid coordinates xy = [] for j in range(height + 1): for i in range(width + 1): xy.append((i, j)) gridxy = flex.vec2_double(xy) gridxy.reshape(flex.grid(height + 1, width + 1)) # Get the output grid output = regrid_grid_to_irregular_grid(grid, gridxy) # Check that each pixel is identical eps = 1e-7 for j in range(height): for i in range(width): assert abs(output[j, i] - grid[j, i]) <= eps # Test passed print "OK"
def generate_constant_background_3d(self, size, bmin, bmax): from random import uniform from scitbx.array_family import flex c = uniform(bmin, bmax) data = flex.double(flex.grid(size), c) mask = flex.bool(flex.grid(size), True) return c, data, mask
def exercise_cholesky(): mt = flex.mersenne_twister(seed=0) for n in xrange(1,10): a = flex.double(n*n,0) a.resize(flex.grid(n, n)) for i in xrange(n): a[(i,i)] = 1 c = cholesky_decomposition(a) assert c is not None assert approx_equal(c.matrix_multiply(c.matrix_transpose()), a) b = mt.random_double(size=n, factor=4)-2 x = cholesky_solve(c, b) assert approx_equal(a.matrix_multiply(x), b) d = flex.random_size_t(size=n, modulus=10) for i in xrange(n): a[(i,i)] = d[i]+1 c = cholesky_decomposition(a) assert c is not None assert approx_equal(c.matrix_multiply(c.matrix_transpose()), a) b = mt.random_double(size=n, factor=4)-2 x = cholesky_solve(c, b) assert approx_equal(a.matrix_multiply(x), b) # a = flex.double([8, -6, 0, -6, 9, -2, 0, -2, 8]) a.resize(flex.grid(3,3)) c = cholesky_decomposition(a) assert c is not None assert approx_equal(c.matrix_multiply(c.matrix_transpose()), a) assert approx_equal(c, [ 2.828427125, 0, 0, -2.121320344, 2.121320343, 0, 0., -0.9428090418, 2.666666667]) # a0 = matrix.sym(sym_mat3=[3,5,7,1,2,-1]) for i_trial in xrange(100): r = scitbx.math.euler_angles_as_matrix( mt.random_double(size=3,factor=360), deg=True) a = flex.double(r * a0 * r.transpose()) a.resize(flex.grid(3,3)) c = cholesky_decomposition(a) assert c is not None assert approx_equal(c.matrix_multiply(c.matrix_transpose()), a) for b in [(0.1,-0.5,2), (-0.3,0.7,-1), (1.3,2.9,4), (-10,-20,17)]: b = flex.double(b) x = cholesky_solve(c, b) assert approx_equal(a.matrix_multiply(x), b) # for n in xrange(1,10): for i in xrange(10): r = mt.random_double(size=n*n, factor=10)-5 r.resize(flex.grid(n,n)) a = r.matrix_multiply(r.matrix_transpose()) c = cholesky_decomposition(a) assert c is not None b = mt.random_double(size=n, factor=4)-2 x = cholesky_solve(c, b) assert approx_equal(a.matrix_multiply(x), b) a[(i%n,i%n)] *= -1 c = cholesky_decomposition(a) assert c is None
def initialization(self): self.a = flex.double(flex.grid(self.n, self.n), -2./self.m) self.a.matrix_diagonal_add_in_place(value=1) self.a.resize(flex.grid(self.m,self.n), -2./self.m) self.x0 = flex.double(self.n, 1) self.tau0 = 1.e-8 self.delta0 = 10 self.x_star = flex.double(self.n, -1) self.capital_f_x_star = 0.5 * (self.m - self.n)
def exercise_svd_basic(): a = flex.double(xrange(1,19)) sigma = [ 45.8945322027251, 1.6407053035305987, 0 ] a.resize(flex.grid(6,3)) svd = scitbx.linalg.svd.real( a.deep_copy(), accumulate_u=True, accumulate_v=True) assert approx_equal(svd.sigma, sigma) a1 = svd.reconstruct() assert matrix_equality_ratio(a, a1) < 10 assert matrix_normality_ratio(svd.u) < 10 assert matrix_normality_ratio(svd.v) < 10 svd = scitbx.linalg.svd.real(a.deep_copy(), accumulate_u=False, accumulate_v=False) assert approx_equal(svd.sigma, sigma) assert not svd.u and not svd.v try: svd.reconstruct() raise Exception_expected except AssertionError: pass a = a.matrix_transpose() svd = scitbx.linalg.svd.real( a.deep_copy(), accumulate_u=True, accumulate_v=True) assert approx_equal(svd.sigma, sigma) a1 = svd.reconstruct() assert matrix_equality_ratio(a, a1) < 10 assert matrix_normality_ratio(svd.u) < 10 assert matrix_normality_ratio(svd.v) < 10 a = flex.double(xrange(1,13)) sigma = [25.436835633480246818, 1.7226122475210637387, 0] a.reshape(flex.grid(3,4)) svd = scitbx.linalg.svd.real( a.deep_copy(), accumulate_u=True, accumulate_v=True) assert approx_equal(svd.sigma, sigma) a1 = svd.reconstruct() assert matrix_equality_ratio(a, a1) < 10 assert matrix_normality_ratio(svd.u) < 10 assert matrix_normality_ratio(svd.v) < 10 a = a.matrix_transpose() svd = scitbx.linalg.svd.real( a.deep_copy(), accumulate_u=True, accumulate_v=True) assert approx_equal(svd.sigma, sigma) a1 = svd.reconstruct() assert matrix_equality_ratio(a, a1) < 10 assert matrix_normality_ratio(svd.u) < 10 assert matrix_normality_ratio(svd.v) < 10
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 run(): print __doc__ g = grid((3,4,6)) show(g) g.set_focus((3,4,5)) show(g) g = grid((-2,-3,-4), (3,4,6)) show(g) g.set_focus((3,4,5)) show(g) print "OK"
def generate_dials_corrections(image_filename, sensor_thickness_mm, energy_ev = None, method=compute_absolute_offset): '''Generate equivalent correction tables equivalent to those from XDS, but using the equations above.''' from dxtbx import load from scitbx import matrix from scitbx.array_family import flex import math import random import os image = load(image_filename) beam = matrix.col(image.get_beam().get_s0()).normalize() if energy_ev: energy_kev = energy_ev * 0.001 else: wavelength = image.get_beam().get_wavelength() energy_kev = 12.3985 / wavelength mu = derive_absorption_coefficient_Si(energy_kev) d = image.get_detector()[0] fast = matrix.col(d.get_fast_axis()) slow = matrix.col(d.get_slow_axis()) normal = matrix.col(d.get_normal()) origin = matrix.col(d.get_origin()) distance = origin.dot(normal) offset = distance * normal - origin offset_fast = offset.dot(fast) offset_slow = offset.dot(slow) pixel_size = d.get_pixel_size() # this is in order slow, fast i.e. C order image_size = image.get_raw_data().focus() F = fast * pixel_size[0] S = slow * pixel_size[1] fast_parallax = flex.double(flex.grid(image_size)) slow_parallax = flex.double(flex.grid(image_size)) for i in range(image_size[0]): for j in range(image_size[1]): p = (origin + i * S + j * F).normalize() theta = p.angle(normal) dot_f = - p.dot(fast) dot_s = - p.dot(slow) offset = method(sensor_thickness_mm, theta, mu) fast_parallax[i, j] = dot_f * offset slow_parallax[i, j] = dot_s * offset return fast_parallax, slow_parallax
def slice_callback_with_high_performance_http_data(self): BYU = self.object.read() linearintdata = flex.int_from_byte_str(BYU) provisional_size = linearintdata.size() if provisional_size==480285: linearintdata.reshape(flex.grid((195,2463))) elif provisional_size==6224001: linearintdata.reshape(flex.grid((2527,2463))) else: raise ImageException("wrong number of pixels for Pilatus image") del self.object #once the data are copied, close the stream return linearintdata
def __init__(self): from scitbx.array_family import flex # Create an image self.image = flex.random_double(2000 * 2000) self.image.reshape(flex.grid(2000, 2000)) self.mask = flex.random_bool(2000 * 2000, 0.99) self.mask.reshape(flex.grid(2000, 2000)) self.gain = flex.random_double(2000 * 2000) + 0.5 self.gain.reshape(flex.grid(2000, 2000)) self.size = (3, 3) self.min_count = 2
def __init__(O, points, epsilon=1e-2): """\ Computation of Minimum-Volume Covering Ellipsoid using the Khachiyan Algorithm. Based on a Python implementation by Raj Rajashankar (ANL, Nov 2011), which in turn was based on a Matlab script by Nima Moshtagh (2009, http://stackoverflow.com/questions/1768197/bounding-ellipse/1768440#1768440). Caveats: - center and radii are correct, but rotation may permute axes - scales with the square of the number of points """ d = 3 # d is the dimension n = points.size() assert n > 0 # from scitbx.array_family import flex p = points.as_double() p.reshape(flex.grid(n, 3)) p = p.matrix_transpose() q = p.deep_copy() q.resize(flex.grid(4, n), 1) # u = flex.double(n, 1/n) umx = flex.double(flex.grid(n, n), 0) # err = epsilon + 1 while (err > epsilon): umx.matrix_diagonal_set_in_place(u) x_inv = q.matrix_multiply(umx).matrix_multiply_transpose( q).matrix_inversion() m = q.matrix_transpose_multiply( x_inv).matrix_multiply(q).matrix_diagonal() j = flex.max_index(m) maximum = m[j] ascent_step_size = (maximum-d-1)/((d+1)*(maximum-1)) new_u = (1 - ascent_step_size) * u new_u[j] += ascent_step_size err = flex.sum_sq(new_u - u)**0.5 u = new_u # center = p.matrix_multiply(u) umx.matrix_diagonal_set_in_place(u) t1 = p.matrix_multiply(umx).matrix_multiply_transpose(p) t2 = center.matrix_outer_product(center) a = (t1 - t2).matrix_inversion() / d # import scitbx.linalg.svd svd = scitbx.linalg.svd.real(a, accumulate_u=False, accumulate_v=True) size = 1.0/flex.sqrt(svd.sigma) from scitbx import matrix O.center = matrix.col(center) O.radii = matrix.col(size) O.rotation = matrix.sqr(svd.v)
def psana_mask_to_dials_mask(self, psana_mask): if psana_mask.dtype == np.bool: psana_mask = flex.bool(psana_mask) else: psana_mask = flex.bool(psana_mask == 1) assert psana_mask.focus() == (32, 185, 388) dials_mask = [] for i in xrange(32): dials_mask.append(psana_mask[i:i+1,:,:194]) dials_mask[-1].reshape(flex.grid(185,194)) dials_mask.append(psana_mask[i:i+1,:,194:]) dials_mask[-1].reshape(flex.grid(185,194)) return dials_mask
def _average_transformation(matrices, keys): """The _average_transformation() function determines the average rotation and translation from the transformation matrices in @p matrices with keys matching @p keys. The function returns a two-tuple of the average rotation in quaternion representation and the average translation. XXX Alternative: use average of normals, weighted by element size, to determine average orientation. """ from scitbx.array_family import flex from tntbx import svd # Sum all rotation matrices and translation vectors. sum_R = flex.double(flex.grid(3, 3)) sum_t = flex.double(flex.grid(3, 1)) nmemb = 0 for key in keys: T = matrices[key][1] sum_R += flex.double((T(0, 0), T(0, 1), T(0, 2), T(1, 0), T(1, 1), T(1, 2), T(2, 0), T(2, 1), T(2, 2))) sum_t += flex.double((T(0, 3), T(1, 3), T(2, 3))) nmemb += 1 if nmemb == 0: # Return zero-rotation and zero-translation. return (matrix.col((1, 0, 0, 0)), matrix.zeros((3, 1))) # Calculate average rotation matrix as U * V^T where sum_R = U * S * # V^T and S diagonal (Curtis et al. (1993) 377-385 XXX proper # citation, repeat search), and convert to quaternion. svd = svd(sum_R) R_avg = matrix.sqr(list(svd.u().matrix_multiply_transpose(svd.v()))) o_avg = R_avg.r3_rotation_matrix_as_unit_quaternion() t_avg = matrix.col(list(sum_t / nmemb)) return (o_avg, t_avg)
def test_experimentlist_dumper_dump_scan_varying(dials_regression, tmpdir): tmpdir.chdir() os.environ['DIALS_REGRESSION'] = dials_regression # Get all the filenames filename1 = os.path.join(dials_regression, 'experiment_test_data', 'experiment_1.json') # Read the experiment list in elist1 = ExperimentListFactory.from_json_file(filename1) # Make trivial scan-varying models crystal = elist1[0].crystal beam = elist1[0].beam goniometer = elist1[0].goniometer crystal.set_A_at_scan_points([crystal.get_A()] * 5) from scitbx.array_family import flex cov_B = flex.double([1e-5] * 9 * 9) crystal.set_B_covariance(cov_B) cov_B.reshape(flex.grid(1, 9, 9)) cov_B_array = flex.double(flex.grid(5, 9, 9)) for i in range(5): cov_B_array[i:(i + 1), :, :] = cov_B crystal.set_B_covariance_at_scan_points(cov_B_array) beam.set_s0_at_scan_points([beam.get_s0()] * 5) goniometer.set_setting_rotation_at_scan_points( [goniometer.get_setting_rotation()] * 5) # Create the experiment list dumper dump = ExperimentListDumper(elist1) # Dump as JSON file and reload filename = 'temp.json' dump.as_json(filename) elist2 = ExperimentListFactory.from_json_file(filename) check(elist1, elist2)
def test_with_no_background_partial(): from dials.algorithms.integration.fit import ProfileFitter from scitbx.array_family import flex from numpy.random import seed seed(0) # Create profile p = gaussian((9, 9, 9), 1, (4, 4, 4), (2, 2, 2)) s = flex.sum(p) p = p / s # Copy profile c = add_poisson_noise(100 * p) b = flex.double(flex.grid(9, 9, 9), 0) m = flex.bool(flex.grid(9, 9, 9), True) # Get the partial profiles pp = p[0:5, :, :] mp = m[0:5, :, :] cp = c[0:5, :, :] bp = b[0:5, :, :] # Fit fit = ProfileFitter(cp, bp, mp, pp) I = fit.intensity() V = fit.variance() assert fit.niter() < fit.maxiter() Iknown = 94.67151440319306 Vknown = 94.67151440319306 # Test intensity is the same eps = 1e-7 assert abs(I[0] - Iknown) < eps assert abs(V[0] - Vknown) < eps
def test_masked_mean_and_variance_filter(): from scitbx.array_family import flex from dials.algorithms.image.filter import mean_and_variance_filter # Create an image image = flex.random_double(2000 * 2000) image.reshape(flex.grid(2000, 2000)) mask = flex.random_bool(2000 * 2000, 0.99).as_int() mask.reshape(flex.grid(2000, 2000)) # Calculate the summed area table mask2 = mask.deep_copy() mv = mean_and_variance_filter(image, mask2, (3, 3), 2) mean = mv.mean() var = mv.sample_variance() # For a selection of random points, ensure that the value is the # sum of the area under the kernel eps = 1e-7 for i in range(10000): i = random.randint(10, 1990) j = random.randint(10, 1990) m1 = mean[j, i] v1 = var[j, i] p = image[j - 3:j + 4, i - 3:i + 4] m = mask[j - 3:j + 4, i - 3:i + 4] if mask[j, i] == 0: m2 = 0.0 v2 = 0.0 else: p = flex.select(p, flags=m) mv = flex.mean_and_variance(flex.double(p)) m2 = mv.mean() v2 = mv.unweighted_sample_variance() assert m1 == pytest.approx(m2, abs=eps) assert v1 == pytest.approx(v2, abs=eps)
def exercise_complex_to_complex_3d(): from scitbx.array_family import flex from cudatbx import cufft from scitbx import fftpack import time import sys print "" print "complex_to_complex_3d" for n_complex, n_repeats in [((100, 80, 90), 16), ((200, 160, 180), 16)]: print " dimensions:", n_complex print " repeats:", n_repeats np = n_complex[0] * n_complex[1] * n_complex[2] d0 = flex.polar( flex.random_double(size=np) * 2 - 1, flex.random_double(size=np) * 2 - 1) d0.reshape(flex.grid(n_complex)) # t0 = time.time() for i_trial in xrange(n_repeats): d = d0.deep_copy() overhead = time.time() - t0 print " overhead: %.2f seconds" % overhead # # XXX extra CuFFT to initialize device - can we avoid this somehow? d = d0.deep_copy() cufft.complex_to_complex_3d(n_complex).forward(d) cufft.complex_to_complex_3d(n_complex).backward(d) # benchmarking run t0 = time.time() for i_trial in xrange(n_repeats): d = d0.deep_copy() cufft.complex_to_complex_3d(n_complex).forward(d) cufft.complex_to_complex_3d(n_complex).backward(d) print " cufft: %6.2f seconds" % ( (time.time() - t0 - overhead) / n_repeats) rw = d / np # t0 = time.time() for i_trial in xrange(n_repeats): d = d0.deep_copy() fftpack.complex_to_complex_3d(n_complex).forward(d) fftpack.complex_to_complex_3d(n_complex).backward(d) print " fftpack: %6.2f seconds" % ( (time.time() - t0 - overhead) / n_repeats) sys.stdout.flush() rp = d / np # print "" assert flex.max(flex.abs(rw - rp)) < 1.e-6
def gaussian(size, a, x0, sx): from scitbx.array_family import flex result = flex.double(flex.grid(size)) index = [0] * len(size) while True: result[index] = evaluate_gaussian(index, a, x0, sx) for j in range(len(size)): index[j] += 1 if index[j] < size[j]: break index[j] = 0 if j == len(size) - 1: return result
def constrain_jacobian(self, jacobian): # set up result matrix nrow = jacobian.all()[0] ncol = self._n_unconstrained_params + len(self._constraints) constrained_jacobian = flex.double(flex.grid(nrow, ncol)) # create constrained columns constr_block = flex.double(flex.grid(nrow, len(self._constraints))) for i, gp in enumerate(self._constrained_gps): cols = [jacobian.matrix_copy_column(j) for j in gp] sum_col = reduce(lambda x, y: x + y, cols) constr_block.matrix_paste_column_in_place(sum_col, i) # copy unconstrained columns into the result for i, j in enumerate(self._unconstrained_idx): col = jacobian.matrix_copy_column(j) constrained_jacobian.matrix_paste_column_in_place(col, i) # copy the constrained block into the result constrained_jacobian.matrix_paste_block_in_place( constr_block, 0, self._n_unconstrained_params) return constrained_jacobian
def test_dispersion_extended_threshold(self): from dials.algorithms.image.threshold import ( DispersionExtendedThreshold, DispersionExtendedThresholdDebug, ) from dials.array_family import flex nsig_b = 3 nsig_s = 3 algorithm = DispersionExtendedThreshold( self.image.all(), self.size, nsig_b, nsig_s, 0, self.min_count ) result1 = flex.bool(flex.grid(self.image.all())) result2 = flex.bool(flex.grid(self.image.all())) algorithm(self.image, self.mask, result1) algorithm(self.image, self.mask, self.gain, result2) debug = DispersionExtendedThresholdDebug( self.image, self.mask, self.size, nsig_b, nsig_s, 0, self.min_count ) result3 = debug.final_mask() assert result1.all_eq(result3) debug = DispersionExtendedThresholdDebug( self.image, self.mask, self.gain, self.size, nsig_b, nsig_s, 0, self.min_count, ) result4 = debug.final_mask() assert result2 == result4
def exercise_singular_matrix(klass): n = 20 m = 3 * n tol = 10 * scitbx.math.double_numeric_limits.epsilon rows = [flex.random_double(m) for i in range(n - 2)] rows.append(rows[n // 2] + rows[n // 3]) rows.append(rows[n // 4] - rows[n // 5]) random.shuffle(rows) a = flex.double() for r in rows: a.extend(r) a.reshape(flex.grid(n, m)) a = a.matrix_transpose() svd = klass(a.deep_copy(), accumulate_u=True, accumulate_v=True) assert svd.numerical_rank(svd.sigma[0] * tol) == n - 2
def jacobian_analytical(self, x): x1,x2,x3,x4 = x result = flex.double() for ui in kowalik_and_osborne_function.us: denominator = ui*(ui+x3)+x4 assert denominator != 0 denominator_sq = denominator**2 assert denominator_sq != 0 result.extend(flex.double([ -ui*(ui+x2)/denominator, -ui*x1/denominator, ui**2*x1*(ui+x2)/denominator_sq, ui*x1*(ui+x2)/denominator_sq])) result.resize(flex.grid(self.m, self.n)) return result
def _construct_grad_block(self, param_grads, i): """helper function to construct a block of gradients. The length of param_grads is the number of columns of the block. i selects a row of interest from the block corresponding to the residual for a particular unit cell""" mean_grads = param_grads * self._meangradfac param_grads *= self._gradfac block = sparse.matrix(self._nxls, len(param_grads)) for j, (g, mg) in enumerate(zip(param_grads, mean_grads)): if abs(mg) > 1e-20: # skip gradients close to zero col = flex.double(flex.grid(self._nxls, 1), -1.0 * mg) block.assign_block(col, 0, j) if abs(g) > 1e-20: # skip gradient close to zero block[i, j] = g return block
def cov(*args): """Calculate covariance matrix between the arguments (should be flex.double arrays of equal length)""" lens = [len(e) for e in args] assert all(e == lens[0] for e in lens) ncols = len(args) cov = flex.double(flex.grid(ncols, ncols)) for i in range(ncols): for j in range(i, ncols): cov[i, j] = sample_covariance(args[i], args[j]) cov.matrix_copy_upper_to_lower_triangle_in_place() return cov
def run(self): from dxtbx.format.image import ImageTileInt from scitbx.array_family import flex data = flex.int(flex.grid(10, 10)) name = "TileName" tile = ImageTileInt(data, name) assert tile.data().all_eq(data) assert tile.name() == name assert tile.empty() == False print "OK"
def test_conservation_of_counts(): from scitbx.array_family import flex from scitbx import matrix from math import sin, cos, pi # Set the size of the grid input_height = 10 input_width = 10 output_height = 50 output_width = 50 # Create the grid data grid = flex.double([ random.uniform(0, 100) for i in range(input_height * input_width) ]) grid.reshape(flex.grid(input_height, input_width)) # Create the grid coordinates xy = [] angle = random.uniform(0, pi) R = matrix.sqr((cos(angle), -sin(angle), sin(angle), cos(angle))) for j in range(output_height + 1): for i in range(output_width + 1): ij = R * matrix.col((i, j)) xy.append((ij[0], ij[1])) gridxy = flex.vec2_double(xy) gridxy.reshape(flex.grid(output_height + 1, output_width + 1)) off = gridxy[output_height // 2, output_width // 2] for i in range(len(gridxy)): gridxy[i] = (gridxy[i][0] - off[0], gridxy[i][1] - off[1]) # Get the output grid output = regrid_grid_to_irregular_grid(grid, gridxy) # Check that the sum of the counts is conserved eps = 1e-7 assert abs(flex.sum(output) - flex.sum(grid)) <= eps
def test_known_orientation(): from scitbx.array_family import flex from scitbx import matrix from math import sin, cos, pi, sqrt # Set the size of the grid input_height = 4 input_width = 4 output_height = 4 output_width = 4 # Create the grid data value = 13 grid = flex.double([value for i in range(input_height * input_width)]) grid.reshape(flex.grid(input_height, input_width)) # Create the grid coordinates xy = [] R = matrix.sqr((cos(pi / 4), -sin(pi / 4), sin(pi / 4), cos(pi / 4))) for j in range(output_height + 1): for i in range(output_width + 1): ij = R * matrix.col((i * sqrt(8) / 2, j * sqrt(8) / 2)) xy.append((ij[0] + 2, ij[1] - 2)) gridxy = flex.vec2_double(xy) gridxy.reshape(flex.grid(output_height + 1, output_width + 1)) # Get the output grid output = regrid_grid_to_irregular_grid(grid, gridxy) expected = [[0, 1, 1, 0], [1, 2, 2, 1], [1, 2, 2, 1], [0, 1, 1, 0]] # Check that each each pixel has a value of the input eps = 1e-7 for j in range(1, output_height): for i in range(1, output_width): assert abs(output[j, i] - expected[j][i] * value) <= eps
def tst_with_noisy_flat_background_partial(self): from dials.algorithms.integration.fit import fit_profile from scitbx.array_family import flex from tst_profile_helpers import gaussian # Create profile p = gaussian((9, 9, 9), 1, (4, 4, 4), (2, 2, 2)) s = flex.sum(p) p = p / s # Copy profile c0 = gaussian((9, 9, 9), 1, (4, 4, 4), (2, 2, 2)) n = flex.random_double(9 * 9 * 9) b = flex.double(flex.grid(9, 9, 9), 5) + n m = flex.bool(flex.grid(9,9,9), True) c = c0 + b # Get the partial profiles pp = p[0:5,:,:] mp = m[0:5,:,:] cp = c[0:5,:,:] bp = b[0:5,:,:] c0p = c0[0:5,:,:] # Fit fit = fit_profile(pp, mp, cp, bp) I = fit.intensity() V = fit.variance() # Test intensity is the same eps = 1e-7 assert(abs(I - flex.sum(c0)) < eps) assert(abs(V - (flex.sum(c0p) + flex.sum(bp))) < eps) print 'OK'
def test_pickle(): from dials.model.data import PixelList from scitbx.array_family import flex size = (100, 100) sf = 10 image = flex.double(flex.grid(size)) mask = flex.bool(flex.grid(size)) for i in range(len(image)): image[i] = random.randint(0, 100) mask[i] = bool(random.randint(0, 1)) pl = PixelList(sf, image, mask) assert pl.size() == size assert pl.frame() == sf import six.moves.cPickle as pickle obj = pickle.dumps(pl) pl2 = pickle.loads(obj) assert pl2.size() == size assert pl2.frame() == sf assert len(pl2) == len(pl) assert pl2.index().all_eq(pl.index()) assert pl2.value().all_eq(pl.value())
def _get_endianic_raw_data(self, size): big_endian = self._header_dictionary["BYTE_ORDER"] == "big_endian" with self.open_file(self._image_file, "rb") as fh: fh.seek(self._header_size) if big_endian == is_big_endian(): raw_data = read_uint16(streambuf(fh), int(size[0] * size[1])) else: raw_data = read_uint16_bs(streambuf(fh), int(size[0] * size[1])) # note that x and y are reversed here raw_data.reshape(flex.grid(size[1], size[0])) return raw_data
def ball(np, radius, val=1.0): result = flex.double(flex.grid(np, np), 0) assert radius < np o1 = np / 2.0 - radius / 1.5 o2 = np / 2.0 + radius / 1.5 for ii in range(np): for jj in range(np): dd = (ii - o1)**2.0 + (jj - o1)**2.0 if dd <= radius**2.0: result[(ii, jj)] = val dd = (ii - o2)**2.0 + (jj - o2)**2.0 if dd <= radius**2.0: result[(ii, jj)] = val return result
def test_plot_coords(): coords = flex.double([0.5, 0.5, 0, 1, 0, 1, 1, 0, 1, 0]) coords.reshape(flex.grid((5, 2))) labels = flex.int([-1, 0, 0, 1, 1]) d = plots.plot_coords(coords, labels=labels) assert "cosym_coordinates" in d assert set(d["cosym_coordinates"]) == {"data", "help", "layout"} assert (d["cosym_coordinates"]["data"][0]["marker"]["color"] == "rgb(0.000000,0.000000,0.000000)") assert d["cosym_coordinates"]["data"][0]["x"] == [0.5] assert d["cosym_coordinates"]["data"][0]["y"] == [0.5] assert d["cosym_coordinates"]["data"][1]["x"] == [0.0, 0.0] assert d["cosym_coordinates"]["data"][1]["y"] == [1.0, 1.0] assert d["cosym_coordinates"]["data"][2]["x"] == [1.0, 1.0] assert d["cosym_coordinates"]["data"][2]["y"] == [0.0, 0.0]
def tst_masked_mean_filter(self): from dials.algorithms.image.filter import mean_filter from scitbx.array_family import flex from random import randint # Create an image image = flex.random_double(2000 * 2000) image.reshape(flex.grid(2000, 2000)) mask = flex.random_bool(2000 * 2000, 0.99).as_int() mask.reshape(flex.grid(2000, 2000)) # Calculate the summed area table mask2 = mask.deep_copy() mean = mean_filter(image, mask2, (3, 3), 1) # For a selection of random points, ensure that the value is the # sum of the area under the kernel eps = 1e-7 for i in range(10000): i = randint(10, 1990) j = randint(10, 1990) m1 = mean[j, i] p = image[j - 3:j + 4, i - 3:i + 4] m = mask[j - 3:j + 4, i - 3:i + 4] if mask[j, i] == 0: m2 = 0.0 else: p = flex.select(p, flags=m) mv = flex.mean_and_variance(flex.double(p)) m2 = mv.mean() s1 = flex.sum(flex.double(p)) s2 = flex.sum(m.as_1d()) assert (abs(m1 - m2) <= eps) # Test passed print 'OK'
def test_external_lookup(): import dxtbx.format.image from dxtbx.imageset import ExternalLookup from scitbx.array_family import flex mask = flex.bool(flex.grid(10, 10), True) gain = flex.double(flex.grid(10, 10), 1) pedestal = flex.double(flex.grid(10, 10), 2) lookup = ExternalLookup() lookup.mask.data = dxtbx.format.image.ImageBool( dxtbx.format.image.ImageTileBool(mask)) lookup.gain.data = dxtbx.format.image.ImageDouble( dxtbx.format.image.ImageTileDouble(gain)) lookup.pedestal.data = dxtbx.format.image.ImageDouble( dxtbx.format.image.ImageTileDouble(pedestal)) mask2 = lookup.mask.data.tile(0).data() gain2 = lookup.gain.data.tile(0).data() pedestal2 = lookup.pedestal.data.tile(0).data() assert mask2.all_eq(mask) assert gain2.all_eq(gain) assert pedestal2.all_eq(pedestal)
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 get_raw_data(self): # Not intended for production; simply a means to marshall all same-size tile # data together to report it out as a single array; used for testing dxtbx. keys = self._tiles.keys() keys.sort() raw = flex.double( flex.grid( len(keys) * self._tiles[keys[0]].focus()[0], self._tiles[keys[0]].focus()[1])) slowstride = self._tiles[keys[0]].focus()[0] for ik, k in enumerate(keys): raw.matrix_paste_block_in_place(block=self._tiles[k], i_row=slowstride * ik, i_column=0) return raw
def get_3D_transform(): with mrcfile.open("new.mrc") as mrc: # coerce to double realpart = flex.double(mrc.data.astype(np.float64)) # in-place resize to a good multiple of 2 realpart.resize(flex.grid(imax, imax, imax)) complpart = flex.double(flex.grid(imax, imax, imax)) #from IPython import embed; embed() C3D = flex.complex_double(realpart, complpart) from matplotlib import pyplot as plt from scitbx import fftpack #plt.imshow(S2D) #plt.show() #from IPython import embed; embed() print "C3Dfocus", C3D.focus() print C3D FFT = fftpack.complex_to_complex_3d( (C3D.focus()[0], C3D.focus()[1], C3D.focus()[2])) c = FFT.forward(C3D) print c.focus() print c return c
def test_real_to_complex_3d(verbose): for nx in [3, 4]: for ny in [4, 5]: for nz in [7, 8]: fft = fftpack.real_to_complex_3d((nx, ny, nz)) m = fft.m_real() vd = flex.double(flex.grid(m)) vc = flex.complex_double(flex.grid((m[0], m[1], m[2] // 2))) assert vd.size() == 2 * vc.size() for i in range(vd.size()): vd[i] = random.random() * 2 - 1 vd_orig = vd.deep_copy() for i in range(vc.size()): vc[i] = complex(vd[2 * i], vd[2 * i + 1]) vdt = fft.forward(vd) vct = fft.forward(vc) for t in (vdt, vct): assert t.origin() == (0, 0, 0) assert t.all() == fft.n_complex() assert t.focus() == fft.n_complex() if (verbose): show_rseq_3d(vd, fft.m_real(), fft.m_real()) assert_complex_eq_real(vc, vd) vdt = fft.backward(vd) vct = fft.backward(vc) for t in (vdt, vct): assert t.origin() == (0, 0, 0) assert t.all() == fft.m_real() assert t.focus() == fft.n_real() if (verbose): show_rseq_3d(vd, fft.m_real(), fft.n_real()) assert_complex_eq_real(vc, vd) f = nx * ny * nz for ix in range(nx): for iy in range(ny): for iz in range(nz): assert approx_equal(vdt[(ix, iy, iz)], vd_orig[(ix, iy, iz)] * f)
def jacobian_analytical(self, x): x1,x2,x3 = x result = flex.double() for ti in meyer_function.ts: denominator = ti + x3 assert denominator != 0 denominator_sq = denominator**2 assert denominator_sq != 0 term = math.exp(x2/denominator) result.extend(flex.double([ term, x1*term/denominator, -x1*term*x2/denominator_sq])) result.resize(flex.grid(self.m, self.n)) return result
def build_up(self, objective_only=False): mu, sigma, tau = self.x residuals = self.exgauss_cdf_array(self.t, mu, sigma, tau) residuals -= self.y self.reset() if objective_only: self.add_residuals(residuals, weights=None) else: grad = self.get_residual_grad(mu, sigma, tau) grad_r = (grad[0], grad[1], grad[2]) jacobian = flex.double(flex.grid(self.n_data, self.n_parameters)) for j, der_r in enumerate(grad_r): jacobian.matrix_paste_column_in_place(der_r, j) self.add_equations(residuals, jacobian, weights=None)
def get_raw_data(self): '''Read the data - assuming it is streaming 4-byte unsigned ints following the header...''' from boost.python import streambuf from dxtbx import read_int32 from scitbx.array_family import flex assert (len(self.get_detector()) == 1) size = self.get_detector()[0].get_image_size() f = self.open_file(self._image_file) f.read(int(self._header_dictionary['HEADER_BYTES'])) raw_data = read_int32(streambuf(f), int(size[0] * size[1])) raw_data.reshape(flex.grid(size[1], size[0])) return raw_data
def tst_known_offset(self): from scitbx.array_family import flex # Set the size of the grid height = 10 width = 10 # Create the grid data grid = flex.double([1 for i in range(height * width)]) grid.reshape(flex.grid(height, width)) # Create the grid coordinates xy = [] for j in range(height + 1): for i in range(width + 1): xy.append((i + 0.5, j + 0.5)) gridxy = flex.vec2_double(xy) gridxy.reshape(flex.grid(height + 1, width + 1)) # Get the output grid output = rebin_pixels(grid, gridxy, (height, width)) # Check that each each pixel along the left and bottom has a value # of 0.5 and that everything else is 1 eps = 1e-7 assert (abs(output[0, 0] - 0.25) <= eps) for i in range(1, width): assert (abs(output[0, i] - 0.5) <= eps) for j in range(1, height): assert (abs(output[j, 0] - 0.5) <= eps) for j in range(1, height): for i in range(1, width): assert (abs(output[j, i] - 1.0) <= eps) # Test passed print 'OK'