def exercise_fftlib_real_complex_3d_real_imag_w(verbose): mt = flex.mersenne_twister(seed=0) for nu in xrange(1, 9): for nv in xrange(1, 9): for nw in xrange(2, 9, 2): exercise_fftlib_real_complex_3d_real_imag_w_given_dims( mt, nu, nv, nw, verbose)
def compare_times(max_n_power=8): from scitbx.linalg import lapack_dsyev mt = flex.mersenne_twister(seed=0) show_tab_header = True tfmt = "%5.2f" for n_power in xrange(5,max_n_power+1): n = 2**n_power l = mt.random_double(size=n*(n+1)//2) * 2 - 1 a = l.matrix_packed_l_as_symmetric() aes = a.deep_copy() ala = [a.deep_copy(), a.deep_copy()] wla = [flex.double(n, -1e100), flex.double(n, -1e100)] t0 = time.time() es = eigensystem.real_symmetric(aes) tab = [n, tfmt % (time.time() - t0)] for i,use_fortran in enumerate([False, True]): t0 = time.time() info = lapack_dsyev( jobz="V", uplo="U", a=ala[i], w=wla[i], use_fortran=use_fortran) if (info == 99): tab.append(" --- ") else: assert info == 0 tab.append(tfmt % (time.time() - t0)) assert approx_equal(list(reversed(es.values())), wla[i]) if (show_tab_header): print " time [s] eigenvalues" print " n es fem for min max" show_tab_header = False tab.extend([es.values()[-1], es.values()[0]]) print "%3d %s %s %s [%6.2f %6.2f]" % tuple(tab)
def Umats(mos_spread_deg, n_mos_doms, isotropic=True, seed=777, norm_dist_seed=777): import scitbx from scitbx.matrix import col import math UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister(seed=seed) scitbx.random.set_random_seed(norm_dist_seed) rand_norm = scitbx.random.normal_distribution(mean=0, sigma=(mos_spread_deg * math.pi / 180.0)) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(n_mos_doms) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) if mos_spread_deg > 0: UMAT_nm.append( site.axis_and_angle_as_r3_rotation_matrix(m, deg=False)) else: UMAT_nm.append( site.axis_and_angle_as_r3_rotation_matrix(0, deg=False)) if isotropic and mos_spread_deg > 0: UMAT_nm.append( site.axis_and_angle_as_r3_rotation_matrix((-m), deg=False)) return UMAT_nm
def compare_fftpack_with_hermft_1d(): mt = flex.mersenne_twister(seed=0) for n_cmpl in xrange(1, 101): primes = prime_factors_of(n_cmpl) if (n_cmpl != 1 and max(primes) > 19): continue n_real = n_cmpl * 2 m_real = n_real + 2 z = (mt.random_double(size=m_real) * 2 - 1).as_float() # The imaginary parts of the first and last complex values should # be zero, but z has random values in these places, to prove that # they don't change the result. hermft_xy = z.deep_copy() hermft_xy[1] = hermft_xy[-2] # real part of last complex value stored in imaginary part of first # (see ccp4/doc/libfft.doc) hermft_xy[-2] = 253 # random value, for consistency check below d = flex.int((m_real, 2, m_real, m_real, m_real)) ccp4io_dev_ext.fftlib_hermft(xy=hermft_xy, n=n_cmpl, d=d) # consistency check first assert hermft_xy[-2] == 253 assert hermft_xy[-1] == z[-1] # reset to zero for comparision with fftpack result further down hermft_xy[-2] = 0 hermft_xy[-1] = 0 fft = scitbx.fftpack.real_to_complex(n_real) assert fft.m_real() == m_real fftpack_xy = z.as_double() for i in xrange(n_cmpl): fftpack_xy[i * 2 + 1] *= -1 # conjugate fft.backward(fftpack_xy) fftpack_xy = fftpack_xy.as_float() if (flex.max_absolute(hermft_xy - fftpack_xy) > 1e-5): assert approx_equal(hermft_xy, fftpack_xy, eps=1e-5)
def exercise_fftlib_real_complex_3d_real_imag_w(verbose): mt = flex.mersenne_twister(seed=0) for nu in xrange(1,9): for nv in xrange(1,9): for nw in xrange(2,9,2): exercise_fftlib_real_complex_3d_real_imag_w_given_dims( mt, nu, nv, nw, verbose)
def exercise_read_write_defaults(use_mrcfile=True): if not use_mrcfile: return from cctbx import uctbx, sgtbx, crystal 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)) space_group=sgtbx.space_group_info("P1").group() crystal_symmetry=crystal.symmetry(unit_cell=unit_cell,space_group=space_group) iotbx.mrcfile.write_ccp4_map( file_name="simple.mrc", crystal_symmetry=crystal_symmetry, map_data=real_map_data) input_real_map = iotbx.mrcfile.map_reader(file_name="simple.mrc") # check unit cell and space group: cs=input_real_map.crystal_symmetry() assert cs.is_similar_symmetry(crystal_symmetry) # Check writing map with offset origin_shift=(5,6,7) iotbx.mrcfile.write_ccp4_map( file_name="offset.mrc", crystal_symmetry=crystal_symmetry, origin_shift_grid_units=origin_shift, map_data=real_map_data) input_real_map = iotbx.mrcfile.map_reader(file_name="offset.mrc") map_data=input_real_map.map_data() assert map_data.origin()==origin_shift
def check_refine_uc_cr(work_params, image_mdls, unit_cell_perturbation_factor=2, crystal_rotation_perturbation_angle=10): from cctbx import uctbx from scitbx.array_family import flex from scitbx import matrix for i_img,im in enumerate(image_mdls.array): print "Image number:", i_img mt = flex.mersenne_twister(seed=work_params.noise.random_seed+i_img) unit_cell = uctbx.unit_cell([ v + unit_cell_perturbation_factor*(mt.random_double()-0.5) for v in im.unit_cell.parameters()]) crystal_rotation = matrix.sqr(im.crystal_rotation) \ * matrix.col(mt.random_double_point_on_sphere()) \ .axis_and_angle_as_r3_rotation_matrix( angle=crystal_rotation_perturbation_angle, deg=True) refined = refine_uc_cr.refinery( work_params=work_params, spots_xy0=im.spot_positions, miller_indices=image_mdls.miller_indices.select(im.miller_index_i_seqs), unit_cell=unit_cell, crystal_rotation_uq=crystal_rotation .r3_rotation_matrix_as_unit_quaternion()) refined.show_summary().show_distances() print
def compare_fftpack_with_hermft_1d(): mt = flex.mersenne_twister(seed=0) for n_cmpl in xrange(1, 101): primes = prime_factors_of(n_cmpl) if (n_cmpl != 1 and max(primes) > 19): continue n_real = n_cmpl * 2 m_real = n_real + 2 z = (mt.random_double(size=m_real)*2-1).as_float() # The imaginary parts of the first and last complex values should # be zero, but z has random values in these places, to prove that # they don't change the result. hermft_xy = z.deep_copy() hermft_xy[1] = hermft_xy[-2] # real part of last complex value stored in imaginary part of first # (see ccp4/doc/libfft.doc) hermft_xy[-2] = 253 # random value, for consistency check below d = flex.int((m_real,2,m_real,m_real,m_real)) ccp4io_dev_ext.fftlib_hermft(xy=hermft_xy, n=n_cmpl, d=d) # consistency check first assert hermft_xy[-2] == 253 assert hermft_xy[-1] == z[-1] # reset to zero for comparision with fftpack result further down hermft_xy[-2] = 0 hermft_xy[-1] = 0 fft = scitbx.fftpack.real_to_complex(n_real) assert fft.m_real() == m_real fftpack_xy = z.as_double() for i in xrange(n_cmpl): fftpack_xy[i*2+1] *= -1 # conjugate fft.backward(fftpack_xy) fftpack_xy = fftpack_xy.as_float() if (flex.max_absolute(hermft_xy-fftpack_xy) > 1e-5): assert approx_equal(hermft_xy, fftpack_xy, eps=1e-5)
def get_unit_points_on_hemisphere(): mersenne_twister = flex.mersenne_twister(seed=0) sphere_points = [] for m in xrange(20000): sphere_pt = col(mersenne_twister.random_double_point_on_sphere()) sphere_points.append(sphere_pt) return sphere_points
def simulation_zigzag(NB=5): mersenne_twister = flex.mersenne_twister(seed=0) body = six_dof_body(labels=["00", "01", "02"], sites=matrix.col_list([(0.3, -0.5, 0), (0.4, 0.5, 0), (0, 0, 0)]), bonds=[(0, 2), (1, 2)], mersenne_twister=mersenne_twister) body.parent = -1 bodies = [body] vu = matrix.col((0, 1, 0)).rotate_around_origin(axis=matrix.col((1, 0, 0)), angle=75, deg=True) vr = matrix.col((0, 1, 0)) v = vu pivot = matrix.col((0, 0, 0)) for ib in xrange(1, NB): body = revolute_body(labels=[str(ib)], sites=[pivot + v * 0.5], bonds=[(-1, 0)], pivot=pivot, normal=matrix.col((1, 0, 0)), mersenne_twister=mersenne_twister) body.parent = ib - 1 bodies.append(body) pivot += v if (v is vu): v = vr else: v = vu return simulation(bodies=bodies)
def simulation_gly_with_nh(): pdb = """\ ATOM 0 N GLY A 1 10.949 12.815 15.189 0.00 0.00 N ATOM 1 CA GLY A 1 10.405 13.954 15.917 0.00 0.00 C ATOM 2 C GLY A 1 10.779 15.262 15.227 0.00 0.00 C ATOM 3 O GLY A 1 9.916 16.090 14.936 0.00 0.00 O ATOM 4 H GLY A 1 11.792 12.691 15.311 0.00 0.00 H """ labels, sites = pdb_extract(pdb=pdb) mersenne_twister = flex.mersenne_twister(seed=0) body0 = six_dof_body(labels=labels[:3], sites=sites[:3], bonds=[(0, 1), (1, 2)], mersenne_twister=mersenne_twister) body0.parent = -1 body1 = revolute_body(labels=labels[3:4], sites=sites[3:4], bonds=[(-1, 0)], pivot=sites[2], normal=(sites[2] - sites[1]).normalize(), mersenne_twister=mersenne_twister) body1.parent = 0 body2 = revolute_body(labels=labels[4:], sites=sites[4:], bonds=[(-3, 0)], pivot=sites[0], normal=(sites[0] - sites[1]).normalize(), mersenne_twister=mersenne_twister) body2.parent = 0 return simulation(bodies=[body0, body1, body2])
def ersatz_all_orientations(N_total=100000): ori_N_total = N_total # number of items to simulate mt = flex.mersenne_twister(seed=0) random_orientations = [] for iteration in range(ori_N_total): random_orientations.append(mt.random_double_r3_rotation_matrix()) return random_orientations
def exercise_real_to_complex_padding_area(): mt = flex.mersenne_twister(seed=1) for n_real in range(1, 101): fft = fftpack.real_to_complex(n_real) assert fft.n_real() == n_real assert fft.n_complex() == n_real // 2 + 1 assert fft.m_real() == fft.n_complex() * 2 m_real = fft.m_real() z = mt.random_double( size=m_real) * 2 - 1 # non-zero values in padded area c = z.deep_copy() fft.forward(c) if (n_real % 2 == 0): assert approx_equal(c[-1], 0) # imaginary part of last complex value r = c.deep_copy() fft.backward(r) r *= (1 / n_real) assert approx_equal(r[:n_real], z[:n_real]) if (n_real % 2 == 0): assert approx_equal(r[n_real:], [0, 0]) q = c.deep_copy() q[-1] = 123 # random imaginary part (which should be zero) fft.backward(q) q *= (1 / n_real) assert approx_equal(q, r) # obtain zeros in padded area anyway
def exercise_joint_lib_six_dof_aja_simplified(): tc = test_cases_tardy_pdb.test_cases[9] tt = tc.tardy_tree_construct() masses = [1.0]*len(tc.sites) # arbitrary transformation so that the center of mass is not at the origin rt_arbitrary = matrix.col((-0.21,-0.51,0.64)) \ .rt_for_rotation_around_axis_through( point=matrix.col((-0.80, 0.28, -0.89)), angle=-37, deg=True) sites = [rt_arbitrary * site for site in tc.sites] tm = scitbx.rigid_body.essence.tardy.model( labels=tc.labels, sites=sites, masses=masses, tardy_tree=tt, potential_obj=None) assert len(tm.bodies) == 1 assert tm.q_packed_size == 7 mt = flex.mersenne_twister(seed=0) for i_trial in xrange(3): q = mt.random_double(size=tm.q_packed_size)*2-1 tm.unpack_q(q_packed=q) sm = tm.sites_moved() aja = matrix.rt(scitbx.rigid_body.joint_lib_six_dof_aja_simplified( center_of_mass=tuple(flex.vec3_double(sites).mean()), q=q)) sm2 = [aja * site for site in sites] assert approx_equal(sm2, sm)
def exercise_joint_lib_six_dof_aja_simplified(): tc = test_cases_tardy_pdb.test_cases[9] tt = tc.tardy_tree_construct() masses = [1.0] * len(tc.sites) # arbitrary transformation so that the center of mass is not at the origin rt_arbitrary = matrix.col((-0.21,-0.51,0.64)) \ .rt_for_rotation_around_axis_through( point=matrix.col((-0.80, 0.28, -0.89)), angle=-37, deg=True) sites = [rt_arbitrary * site for site in tc.sites] tm = scitbx.rigid_body.essence.tardy.model(labels=tc.labels, sites=sites, masses=masses, tardy_tree=tt, potential_obj=None) assert len(tm.bodies) == 1 assert tm.q_packed_size == 7 mt = flex.mersenne_twister(seed=0) for i_trial in xrange(3): q = mt.random_double(size=tm.q_packed_size) * 2 - 1 tm.unpack_q(q_packed=q) sm = tm.sites_moved() aja = matrix.rt( scitbx.rigid_body.joint_lib_six_dof_aja_simplified( center_of_mass=tuple(flex.vec3_double(sites).mean()), q=q)) sm2 = [aja * site for site in sites] assert approx_equal(sm2, sm)
def get_partiality_response(key, one_index, spectra_simulation, ROI): N_total = 100000 # number of items to simulate spectra = spectra_simulation crystal = microcrystal( Deff_A=4000, length_um=4., beam_diameter_um=1.0) # assume smaller than 10 um crystals mt = flex.mersenne_twister(seed=0) random_orientations = [] for iteration in range(N_total): random_orientations.append(mt.random_double_r3_rotation_matrix()) iterator = spectra.generate_recast_renormalized_image(image=key, energy=7120., total_flux=1e12) file_prefix = "key_slow_nonoise_%06d" % key rand_ori = sqr(random_orientations[key]) pixels = run_sim2smv(ROI, prefix=file_prefix, crystal=crystal, spectra=iterator, rotation=rand_ori, quick=False, rank=0) return pixels
def channel_wavelength_fmodel(create): N_mosaic_domains = 25 mosaic_spread_deg = 0.05 # interpreted by UMAT_nm as a half-width stddev UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister(seed=0) scitbx.random.set_random_seed(1234) rand_norm = scitbx.random.normal_distribution(mean=0, sigma=mosaic_spread_deg * math.pi/180.) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(N_mosaic_domains) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) UMAT_nm.append( site.axis_and_angle_as_r3_rotation_matrix(m,deg=False) ) if create: # write the reference for the first time cPickle.dump(UMAT_nm, open(os.path.join(ls49_big_data,"reference",filename),"wb"),cPickle.HIGHEST_PROTOCOL) else: # read the reference and assert sameness to production run import six if six.PY3: UMAT_ref = cPickle.load(open(os.path.join(ls49_big_data,"reference",filename),"rb"),encoding="bytes") else: UMAT_ref = cPickle.load(open(os.path.join(ls49_big_data,"reference",filename),"rb")) for x in range(len(UMAT_nm)): print(x," ".join( ["%18.15f"%UMAT_ref[x][z] for z in range(9)] )) assert UMAT_nm[x] == UMAT_ref[x] expected_output = """
def simulation_gly_with_nh(): pdb = """\ ATOM 0 N GLY A 1 10.949 12.815 15.189 0.00 0.00 N ATOM 1 CA GLY A 1 10.405 13.954 15.917 0.00 0.00 C ATOM 2 C GLY A 1 10.779 15.262 15.227 0.00 0.00 C ATOM 3 O GLY A 1 9.916 16.090 14.936 0.00 0.00 O ATOM 4 H GLY A 1 11.792 12.691 15.311 0.00 0.00 H """ labels, sites = pdb_extract(pdb=pdb) mersenne_twister = flex.mersenne_twister(seed=0) body0 = six_dof_body( labels=labels[:3], sites=sites[:3], bonds=[(0,1),(1,2)], mersenne_twister=mersenne_twister) body0.parent = -1 body1 = revolute_body( labels=labels[3:4], sites=sites[3:4], bonds=[(-1,0)], pivot=sites[2], normal=(sites[2]-sites[1]).normalize(), mersenne_twister=mersenne_twister) body1.parent = 0 body2 = revolute_body( labels=labels[4:], sites=sites[4:], bonds=[(-3,0)], pivot=sites[0], normal=(sites[0]-sites[1]).normalize(), mersenne_twister=mersenne_twister) body2.parent = 0 return simulation(bodies=[body0, body1, body2])
def simulation_zigzag(NB=5): mersenne_twister = flex.mersenne_twister(seed=0) body = six_dof_body( labels=["00", "01", "02"], sites=matrix.col_list([ (0.3,-0.5,0), (0.4,0.5,0), (0,0,0)]), bonds=[(0,2),(1,2)], mersenne_twister=mersenne_twister) body.parent = -1 bodies = [body] vu = matrix.col((0,1,0)).rotate_around_origin( axis=matrix.col((1,0,0)), angle=75, deg=True) vr = matrix.col((0,1,0)) v = vu pivot = matrix.col((0,0,0)) for ib in xrange(1,NB): body = revolute_body( labels=[str(ib)], sites=[pivot + v*0.5], bonds=[(-1,0)], pivot=pivot, normal=matrix.col((1,0,0)), mersenne_twister=mersenne_twister) body.parent = ib-1 bodies.append(body) pivot += v if (v is vu): v = vr else: v = vu return simulation(bodies=bodies)
def simulation_ala_no_h(): pdb = """\ ATOM 0 N ALA A 1 10.949 12.815 15.189 0.00 0.00 N ATOM 1 CA ALA A 1 10.405 13.954 15.917 0.00 0.00 C ATOM 2 C ALA A 1 10.779 15.262 15.227 0.00 0.00 C ATOM 3 CB ALA A 1 10.908 13.950 17.351 0.00 0.00 C ATOM 4 O ALA A 1 9.916 16.090 14.936 0.00 0.00 O """ labels, sites = pdb_extract(pdb=pdb) mersenne_twister = flex.mersenne_twister(seed=0) body0 = six_dof_body( labels=labels[:4], sites=sites[:4], bonds=[(0,1),(1,2),(1,3)], mersenne_twister=mersenne_twister) body0.parent = -1 body1 = revolute_body( labels=labels[4:], sites=sites[4:], bonds=[(-2,0)], pivot=sites[2], normal=(sites[2]-sites[1]).normalize(), mersenne_twister=mersenne_twister) body1.parent = 0 return simulation(bodies=[body0, body1])
def tst_all(quick=False, prefix="step6"): from LS49.spectra.generate_spectra import spectra_simulation SS = spectra_simulation() iterator = SS.generate_recast_renormalized_images(20, energy=7120., total_flux=1e12) # C = microcrystal( Deff_A=4000, length_um=4., beam_diameter_um=1.0) # assume smaller than 10 um crystals mt = flex.mersenne_twister(seed=0) if quick: prefix_root = prefix + "_%06d" else: prefix_root = prefix + "poly_%06d" Nimages = 1 # 10000 for iteration in range(Nimages): file_prefix = prefix_root % iteration rand_ori = sqr(mt.random_double_r3_rotation_matrix()) run_sim2smv(prefix=file_prefix, crystal=C, spectra=iterator, rotation=rand_ori, quick=quick, rank=0)
def run_uniform(eta_angle, sample_size=20000, verbose=True): UMAT = flex.mat3_double() d_UMAT_d_eta = flex.mat3_double() # the axis is sampled randomly on a sphere. # Alternately it could have been calculated on a regular hemispheric grid # but regular grid is not needed; the only goal is to have the ability to compute gradient mersenne_twister = flex.mersenne_twister( seed=0) # set seed, get reproducible results # for each axis, sample both the + and - angle assert sample_size % 2 == 0 # the angle is sampled uniformly from its distribution mosaic_rotation0 = np.array(range(sample_size // 2)) mosaic_rotation1 = special.erfinv(mosaic_rotation0 / (sample_size // 2)) d_theta_d_eta = math.sqrt(2.0) * flex.double(mosaic_rotation1) mosaic_rotation = (math.pi / 180.) * eta_angle * d_theta_d_eta for m, d in zip(mosaic_rotation, d_theta_d_eta): site = col(mersenne_twister.random_double_point_on_sphere()) UMAT.append(site.axis_and_angle_as_r3_rotation_matrix(m, deg=False)) UMAT.append(site.axis_and_angle_as_r3_rotation_matrix(-m, deg=False)) d_umat = site.axis_and_angle_as_r3_derivative_wrt_angle(m, deg=False) d_UMAT_d_eta.append((math.pi / 180.) * d * d_umat) d_umat = site.axis_and_angle_as_r3_derivative_wrt_angle(-m, deg=False) d_UMAT_d_eta.append((math.pi / 180.) * -d * d_umat) #sanity check on the gaussian distribution if verbose: nm_angles = check_distributions.get_angular_rotation(UMAT) nm_rms_angle = math.sqrt(flex.mean(nm_angles * nm_angles)) print("Normal rms angle is ", nm_rms_angle) return UMAT, d_UMAT_d_eta
def compare_times(max_n_power=8): from scitbx.linalg import lapack_dsyev mt = flex.mersenne_twister(seed=0) show_tab_header = True tfmt = "%5.2f" for n_power in xrange(5, max_n_power + 1): n = 2**n_power l = mt.random_double(size=n * (n + 1) // 2) * 2 - 1 a = l.matrix_packed_l_as_symmetric() aes = a.deep_copy() ala = [a.deep_copy(), a.deep_copy()] wla = [flex.double(n, -1e100), flex.double(n, -1e100)] t0 = time.time() es = eigensystem.real_symmetric(aes) tab = [n, tfmt % (time.time() - t0)] for i, use_fortran in enumerate([False, True]): t0 = time.time() info = lapack_dsyev(jobz="V", uplo="U", a=ala[i], w=wla[i], use_fortran=use_fortran) if (info == 99): tab.append(" --- ") else: assert info == 0 tab.append(tfmt % (time.time() - t0)) assert approx_equal(list(reversed(es.values())), wla[i]) if (show_tab_header): print " time [s] eigenvalues" print " n es fem for min max" show_tab_header = False tab.extend([es.values()[-1], es.values()[0]]) print "%3d %s %s %s [%6.2f %6.2f]" % tuple(tab)
def __init__(self, values, parameterization, data, indices, bins, seed = None, log=None): """ @param values parameterization of the SD terms @param data ISIGI dictionary of unmerged intensities @param indices array of miller indices to refine against @param bins array of flex.bool object specifying the bins to use to calculate the functional @param log Log to print to (none for stdout) """ if log is None: log = sys.stdout self.log = log self.data = data self.intensity_bin_selections = bins self.indices = indices self.parameterization = parameterization self.n = 3 self.x = flex.double([values.SDFAC, values.SDB, values.SDADD]) self.starting_simplex = [] if seed is None: random_func = flex.random_double else: print("Using random seed %d"%seed, file=self.log) mt = flex.mersenne_twister(seed) random_func = mt.random_double for i in range(self.n+1): self.starting_simplex.append(random_func(self.n)) self.optimizer = simplex_opt( dimension = self.n, matrix = self.starting_simplex, evaluator = self, tolerance = 1e-1) self.x = self.optimizer.get_solution()
def process(file_name, clash_threshold=2.0): time_start = time.time() pdb_inp = iotbx.pdb.input(file_name=file_name) pdb_atoms = pdb_inp.atoms() print "Time reading pdb file: %.2f" % (time.time() - time_start) print "Number of atoms:", pdb_atoms.size() pdb_atoms.set_chemical_element_simple_if_necessary() sites_cart = pdb_atoms.extract_xyz() # time_start = time.time() bond_list = extract_edge_list(edge_sets=build_simple_two_way_bond_sets( sites_cart=sites_cart, elements=pdb_atoms.extract_element())) print "Time building bond list: %.2f" % (time.time() - time_start) print "Number of bonds:", len(bond_list) # time_start = time.time() tardy_tree = scitbx.graph.tardy_tree.construct( sites=sites_cart, edge_list=bond_list) print "Time building tardy tree: %.2f" % (time.time() - time_start) # time_start = time.time() tardy_model = scitbx.rigid_body.tardy_model( labels=[atom.id_str() for atom in pdb_atoms], sites=sites_cart, masses=[1]*sites_cart.size(), tardy_tree=tardy_tree, potential_obj=None) q_size_each_joint = tardy_model.q_size_each_joint() q_fixed = tardy_model.pack_q()[:q_size_each_joint[0]] assert q_size_each_joint[1:].all_eq(1) # must all be revolute joints q_size_moving = q_size_each_joint.size() - 1 print "Time building tardy model: %.2f" % (time.time() - time_start) print "Degrees of freedom:", q_size_moving # mt = flex.mersenne_twister() two_pi = 2 * math.pi clash_detector = build_clash_detector( n_sites=sites_cart.size(), bond_list=bond_list, threshold=clash_threshold) time_start = time.time() n_conf = 10000 n_clash_conf = 0 for i_conf in xrange(n_conf): q = q_fixed.deep_copy() q.extend(mt.random_double(size=q_size_moving)*two_pi) tardy_model.unpack_q(q_packed=q) conf_sites_cart = tardy_model.sites_moved() if (clash_detector.has_clash(sites_cart=conf_sites_cart)): n_clash_conf += 1 time_diff = time.time() - time_start print "time / %d conf: %.2f seconds" % (n_conf, time_diff) print "time / conf: %.3f milli seconds" % (time_diff / n_conf * 1000) if (time_diff != 0): print "conf / second: %.2f" % (n_conf / time_diff) print "Fraction of conformations with clashes: %d / %d = %.2f %%" % ( n_clash_conf, n_conf, 100. * n_clash_conf / n_conf)
def add_noise(work_params, pixels): if (work_params.noise.max > 0): from scitbx.array_family import flex mt = flex.mersenne_twister(seed=work_params.noise.random_seed) noise = mt.random_size_t(size=pixels.size(), modulus=work_params.noise.max).as_int() noise.reshape(pixels.accessor()) pixels += noise
def exercise_cholesky(): mt = flex.mersenne_twister(seed=0) for n in range(1,10): a = flex.double(n*n,0) a.resize(flex.grid(n, n)) for i in range(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 range(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 range(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 range(1,10): for i in range(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 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 run(args): assert len(args) == 0 n_trials = 100 from scitbx.math.minimum_covering_ellipsoid import compute as mce_compute from scitbx.array_family import flex from libtbx.test_utils import approx_equal, is_below_limit # XXX point group 222 should be sufficient, but 432 is currently needed point_group_432_rotation_matrices = [(1, 0, 0, 0, 1, 0, 0, 0, 1), (1, 0, 0, 0, 0, -1, 0, 1, 0), (1, 0, 0, 0, 0, 1, 0, -1, 0), (0, 0, 1, 0, 1, 0, -1, 0, 0), (0, 0, -1, 0, 1, 0, 1, 0, 0), (0, -1, 0, 1, 0, 0, 0, 0, 1), (0, 1, 0, -1, 0, 0, 0, 0, 1), (0, 0, 1, 1, 0, 0, 0, 1, 0), (0, 1, 0, 0, 0, 1, 1, 0, 0), (0, -1, 0, 0, 0, -1, 1, 0, 0), (0, 0, 1, -1, 0, 0, 0, -1, 0), (0, -1, 0, 0, 0, 1, -1, 0, 0), (0, 0, -1, -1, 0, 0, 0, 1, 0), (0, 0, -1, 1, 0, 0, 0, -1, 0), (0, 1, 0, 0, 0, -1, -1, 0, 0), (1, 0, 0, 0, -1, 0, 0, 0, -1), (-1, 0, 0, 0, 1, 0, 0, 0, -1), (-1, 0, 0, 0, -1, 0, 0, 0, 1), (0, 1, 0, 1, 0, 0, 0, 0, -1), (0, -1, 0, -1, 0, 0, 0, 0, -1), (0, 0, 1, 0, -1, 0, 1, 0, 0), (0, 0, -1, 0, -1, 0, -1, 0, 0), (-1, 0, 0, 0, 0, 1, 0, 1, 0), (-1, 0, 0, 0, 0, -1, 0, -1, 0)] def check(center, radii, rotation): a, b, c = radii points_principal = flex.vec3_double([(-a, 0, 0), (a, 0, 0), (0, -b, 0), (0, b, 0), (0, 0, -c), (0, 0, c)]) points = rotation * points_principal + center mce = mce_compute(points) assert approx_equal(mce.center, center) assert approx_equal(sorted(mce.radii), sorted(radii)) assert approx_equal(mce.rotation.determinant(), 1) points_mce = mce.rotation.inverse().elems * (points - mce.center) rms = [] for r in point_group_432_rotation_matrices: rp = r * points_mce rms.append(rp.rms_difference(points_principal)) assert is_below_limit(value=min(rms), limit=1e-8, eps=0) mt = flex.mersenne_twister(seed=0) check((0, 0, 0), (1, 2, 3), (1, 0, 0, 0, 1, 0, 0, 0, 1)) for i_trial in xrange(n_trials): center = list(mt.random_double(size=3) * 8 - 4) radii = list(mt.random_double(size=3) * 3 + 0.1) rotation = mt.random_double_r3_rotation_matrix() check(center, radii, rotation) from libtbx.utils import format_cpu_times print format_cpu_times()
def add_noise(work_params, pixels): if (work_params.noise.max > 0): from scitbx.array_family import flex mt = flex.mersenne_twister(seed=work_params.noise.random_seed) noise = mt.random_size_t( size=pixels.size(), modulus=work_params.noise.max).as_int() noise.reshape(pixels.accessor()) pixels += noise
def exercise_simulation( out, n_trials, n_dynamics_steps, delta_t=0.0001, random_seed=0): mersenne_twister = flex.mersenne_twister(seed=random_seed) sim_labels = None relative_ranges_accu = None rms_max_list_accu = None for i_trial in xrange(n_trials): sim_labels_new, e_tots_list, \ relative_ranges, rms_max_list = run_simulations( out=out, mersenne_twister=mersenne_twister, n_dynamics_steps=n_dynamics_steps, delta_t=delta_t) if (sim_labels is None): sim_labels = sim_labels_new else: assert sim_labels == sim_labels_new if (relative_ranges_accu is None): relative_ranges_accu=[flex.double() for i in xrange(len(relative_ranges))] else: assert len(relative_ranges) == len(relative_ranges_accu) for r,a in zip(relative_ranges, relative_ranges_accu): a.append(r) if (rms_max_list_accu is None): rms_max_list_accu = [flex.double() for i in xrange(len(rms_max_list))] else: assert len(rms_max_list) == len(rms_max_list_accu) for r,a in zip(rms_max_list, rms_max_list_accu): a.append(r) if (out is sys.stdout): f = open("tmp_e_tots_%02d_%02d.xy" % (plot_prefix, i_trial), "w") print >> f, "@with g0" for i,l in enumerate(sim_labels): l = l[l.find('"')+1:].replace('"','')[:-1] print >> f, '@ s%d legend "%s"' % (i, l) for es in e_tots_list: for e in es: print >> f, e print >> f, "&" f.close() print >> out, "Accumulated results:" print >> out for sim_label,accu in zip(sim_labels, relative_ranges_accu): print >> out, "relative ranges %s:" % sim_label accu.min_max_mean().show(out=out, prefix=" ") print >> out for sim_label,accu in zip(sim_labels[1:], rms_max_list_accu): print >> out, "rms max %s" % sim_labels[0] print >> out, " vs. %s:" % sim_label accu.min_max_mean().show(out=out, prefix=" ") print >> out if (out is not sys.stdout): for accu in relative_ranges_accu: assert flex.max(accu) < 1.e-4 for i,accu in enumerate(rms_max_list_accu): assert flex.max(accu) < 1.e-4
def exercise_simulation( out, n_trials, n_dynamics_steps, delta_t=0.0001, random_seed=0): mersenne_twister = flex.mersenne_twister(seed=random_seed) sim_labels = None relative_ranges_accu = None rms_max_list_accu = None for i_trial in range(n_trials): sim_labels_new, e_tots_list, \ relative_ranges, rms_max_list = run_simulations( out=out, mersenne_twister=mersenne_twister, n_dynamics_steps=n_dynamics_steps, delta_t=delta_t) if (sim_labels is None): sim_labels = sim_labels_new else: assert sim_labels == sim_labels_new if (relative_ranges_accu is None): relative_ranges_accu=[flex.double() for i in range(len(relative_ranges))] else: assert len(relative_ranges) == len(relative_ranges_accu) for r,a in zip(relative_ranges, relative_ranges_accu): a.append(r) if (rms_max_list_accu is None): rms_max_list_accu = [flex.double() for i in range(len(rms_max_list))] else: assert len(rms_max_list) == len(rms_max_list_accu) for r,a in zip(rms_max_list, rms_max_list_accu): a.append(r) if (out is sys.stdout): f = open("tmp_e_tots_%02d_%02d.xy" % (plot_prefix, i_trial), "w") print("@with g0", file=f) for i,l in enumerate(sim_labels): l = l[l.find('"')+1:].replace('"','')[:-1] print('@ s%d legend "%s"' % (i, l), file=f) for es in e_tots_list: for e in es: print(e, file=f) print("&", file=f) f.close() print("Accumulated results:", file=out) print(file=out) for sim_label,accu in zip(sim_labels, relative_ranges_accu): print("relative ranges %s:" % sim_label, file=out) accu.min_max_mean().show(out=out, prefix=" ") print(file=out) for sim_label,accu in zip(sim_labels[1:], rms_max_list_accu): print("rms max %s" % sim_labels[0], file=out) print(" vs. %s:" % sim_label, file=out) accu.min_max_mean().show(out=out, prefix=" ") print(file=out) if (out is not sys.stdout): for accu in relative_ranges_accu: assert flex.max(accu) < 1.e-4 for i,accu in enumerate(rms_max_list_accu): assert flex.max(accu) < 1.e-4
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 exercise(args): assert len(args) == 0 sites = flex.vec3_double([ (10.949, 12.815, 15.189), (10.405, 13.954, 15.917), (10.779, 15.262, 15.227)]) class energy_cart(object): def __init__(self, nodes, homes): assert nodes.size() == homes.size() self.nodes = nodes self.homes = homes def functional(self): return flex.sum((self.nodes-self.homes).dot()) def gradients(self): return 2*(self.nodes-self.homes) def incr_position(rb, i, delta): assert 0 <= i < 6 if (i < 3): v = list(rb.ea) v[i] += delta rb.ea = matrix.col(v) else: v = list(rb.lt) v[i-3] += delta rb.lt = matrix.col(v) def ea_gradients_fd(rb, energy_cart_function, eps=1.e-6): result = [] for i in xrange(6): fs = [] incr_position(rb=rb, i=i, delta=eps) fs.append(energy_cart_function( nodes=rb.sites_moved(), homes=rb.sites_orig).functional()) incr_position(rb=rb, i=i, delta=-eps) incr_position(rb=rb, i=i, delta=-eps) fs.append(energy_cart_function( nodes=rb.sites_moved(), homes=rb.sites_orig).functional()) incr_position(rb=rb, i=i, delta=eps) result.append((fs[0]-fs[1])/(2*eps)) return result rb = rigid_body(sites=sites) mt = flex.mersenne_twister() n_trials = 4 for i in xrange(n_trials): rb.ea = matrix.col(mt.random_double_point_on_sphere()) * i rb.lt = matrix.col(mt.random_double_point_on_sphere()) * i show_gradients(rb=rb) print "OK"
def initialization(self): self.x0 = self.fit.parameters() self.capital_f_x_star = 0.5*self.f(x=self.x0).norm()**2 if (self.perturb): mersenne_twister = flex.mersenne_twister(seed=0) self.x0 *= 1 + mersenne_twister.random_double( size=self.x0.size(), factor=0.01) self.tau0 = 1e-8 self.delta0 = 10 self.x_star = None
def initialization(self): self.x0 = self.fit.parameters() self.capital_f_x_star = 0.5 * self.f(x=self.x0).norm()**2 if (self.perturb): mersenne_twister = flex.mersenne_twister(seed=0) self.x0 *= 1 + mersenne_twister.random_double(size=self.x0.size(), factor=0.01) self.tau0 = 1e-8 self.delta0 = 10 self.x_star = None
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 exercise_impl(svd_impl_name, use_fortran): import scitbx.linalg svd_impl = getattr(scitbx.linalg, "lapack_%s" % svd_impl_name) from scitbx.array_family import flex from scitbx import matrix from libtbx.test_utils import approx_equal # for diag in [0, 1]: for n in xrange(1, 11): a = flex.double(flex.grid(n, n), 0) for i in xrange(n): a[(i, i)] = diag a_inp = a.deep_copy() svd = svd_impl(a=a, use_fortran=use_fortran) if svd is None: if not use_fortran: print "Skipping tests: lapack_%s not available." % svd_impl_name return assert svd.info == 0 assert approx_equal(svd.s, [diag] * n) assert svd.u.all() == (n, n) assert svd.vt.all() == (n, n) mt = flex.mersenne_twister(seed=0) for m in xrange(1, 11): for n in xrange(1, 11): a = matrix.rec(elems=tuple(mt.random_double(m * n) * 4 - 2), n=(m, n)) svd = svd_impl(a=a.transpose().as_flex_double_matrix(), use_fortran=use_fortran) assert svd.info == 0 sigma = matrix.diag(svd.s) # min(m,n) x min(m,n) # FORTRAN layout, so transpose u = matrix.rec(svd.u, svd.u.all()).transpose() vt = matrix.rec(svd.vt, svd.vt.all()).transpose() assert approx_equal(u * sigma * vt, a) # a = matrix.rec(elems=[0.47, 0.10, -0.21, -0.21, -0.03, 0.35], n=(3, 2)) svd = svd_impl(a=a.transpose().as_flex_double_matrix(), use_fortran=use_fortran) assert svd.info == 0 assert approx_equal(svd.s, [0.55981345199567534, 0.35931726783538481]) # again remember column-major storage assert approx_equal( svd.u, [ 0.81402078804155853, -0.5136261274467826, 0.27121644094748704, -0.42424674329757839, -0.20684171439391938, 0.88160717215094342, ], ) assert approx_equal(svd.vt, [0.8615633693608673, -0.50765003750177129, 0.50765003750177129, 0.8615633693608673])
def tst_all( serial_no ): #emulates the action of step5_pad.py in assigning a coarse orientation to each simulation event mt = flex.mersenne_twister(seed=0) Nimages = 100000 for iteration in range(Nimages): rand_ori = sqr(mt.random_double_r3_rotation_matrix()) if serial_no == iteration: return rand_ori return None
def exercise_revolute(out, n_trials, n_dynamics_steps, delta_t=0.001): mersenne_twister = flex.mersenne_twister(seed=0) for i_trial in range(n_trials): body = revolute_body(mersenne_twister=mersenne_twister) body.parent = -1 sim = simulation(bodies=[body]) print("revolute:", file=out) relative_range = exercise_sim( out=out, n_dynamics_steps=n_dynamics_steps, delta_t=delta_t, sim=sim) if (out is not sys.stdout): assert relative_range < 1.e-4
def exercise_revolute(out, n_trials, n_dynamics_steps, delta_t=0.001): mersenne_twister = flex.mersenne_twister(seed=0) for i_trial in xrange(n_trials): body = revolute_body(mersenne_twister=mersenne_twister) body.parent = -1 sim = simulation(bodies=[body]) print >> out, "revolute:" relative_range = exercise_sim( out=out, n_dynamics_steps=n_dynamics_steps, delta_t=delta_t, sim=sim) if (out is not sys.stdout): assert relative_range < 1.e-4
def run(args): assert len(args) == 0 exercise_cubicles_max_memory() from scitbx.cubicle_neighbors import cubicle_neighbors from scitbx.array_family import flex main_sites_cart = flex.vec3_double() cn = cubicle_neighbors(main_sites_cart=main_sites_cart, cubicle_edge=5) nb = cn.neighbors_of(other_sites_cart=main_sites_cart, distance_cutoff_sq=1) assert nb.size() == 0 for xyz in [(0, 0, 0), (0.1, 0.2, -0.3)]: main_sites_cart = flex.vec3_double([xyz]) cn = cubicle_neighbors(main_sites_cart=main_sites_cart, cubicle_edge=5) nb = cn.neighbors_of(other_sites_cart=main_sites_cart, distance_cutoff_sq=1) assert nb.size() == 1 assert nb.keys() == [0] assert list(nb[0]) == [0] nb = cn.neighbors_of(other_sites_cart=flex.vec3_double([(2, 2, 2)]), distance_cutoff_sq=1) assert nb.size() == 0 nb = cn.neighbors_of(other_sites_cart=flex.vec3_double([(2, 2, 2)]), distance_cutoff_sq=25) assert nb.size() == 1 mt = flex.mersenne_twister(seed=0) for nm in [3, 5, 8]: for no in [1, 7, 9]: main_sites_cart = flex.vec3_double( list( zip( mt.random_double(size=nm) * 2 - 1, mt.random_double(size=nm) * 2 - 1, mt.random_double(size=nm) * 2 - 1))) other_sites_cart = flex.vec3_double( list( zip( mt.random_double(size=no) * 2 - 1, mt.random_double(size=no) * 2 - 1, mt.random_double(size=no) * 2 - 1))) for distance_cutoff in [0.5, 1]: distance_cutoff_sq = distance_cutoff**2 cn = cubicle_neighbors(main_sites_cart=main_sites_cart, cubicle_edge=1) nb = cn.neighbors_of(other_sites_cart=other_sites_cart, distance_cutoff_sq=distance_cutoff_sq) nb_simple = neighbors_simple( main_sites_cart=main_sites_cart, other_sites_cart=other_sites_cart, distance_cutoff_sq=distance_cutoff_sq) assert sorted(nb.keys()) == sorted(nb_simple.keys()) for j_seq, i_seqs_simple in nb_simple.items(): i_seqs = nb[j_seq] assert sorted(i_seqs) == sorted(i_seqs_simple) print("OK")
def exercise_six_dof(out, n_trials, n_dynamics_steps, delta_t=0.001): mersenne_twister = flex.mersenne_twister(seed=0) for n_sites in xrange(1,4): for i_trial in xrange(n_trials): body = six_dof_body(mersenne_twister=mersenne_twister, n_sites=n_sites) body.parent = -1 sim = simulation(bodies=[body]) print >> out, "six_dof number of sites:", n_sites relative_range = exercise_sim( out=out, n_dynamics_steps=n_dynamics_steps, delta_t=delta_t, sim=sim) if (out is not sys.stdout): assert relative_range < 1.e-4
def exercise_six_dof(out, n_trials, n_dynamics_steps, delta_t=0.001): mersenne_twister = flex.mersenne_twister(seed=0) for n_sites in range(1,4): for i_trial in range(n_trials): body = six_dof_body(mersenne_twister=mersenne_twister, n_sites=n_sites) body.parent = -1 sim = simulation(bodies=[body]) print("six_dof number of sites:", n_sites, file=out) relative_range = exercise_sim( out=out, n_dynamics_steps=n_dynamics_steps, delta_t=delta_t, sim=sim) if (out is not sys.stdout): assert relative_range < 1.e-4
def run_sim2smv(fileout): SIM = nanoBragg(detpixels_slowfast=(1000, 1000), pixel_size_mm=0.1, Ncells_abc=(5, 5, 5), verbose=0) SIM.mosaic_spread_deg = MOSAIC_SPREAD # apparently this is half width SIM.mosaic_domains = SAMPLE_SIZE SIM.distance_mm = 100 # this triggers the generation of mosaic distribution UMAT_th = SIM.get_mosaic_blocks() # extract top-hat distributed U-mats #sanity checks on the top hat distribution th_angles = check_distributions.get_angular_rotation(UMAT_th) max_angle = flex.max(th_angles) assert max_angle <= MOSAIC_SPREAD + 0.0000001 # need to allow a small epsilon assert max_angle > 0.99 * MOSAIC_SPREAD # insist that max angle is near the limit we gave it rms_angle = math.sqrt(flex.mean(th_angles * th_angles)) print(rms_angle) assert rms_angle < MOSAIC_SPREAD import scitbx # compute an array of normally-distributed U-mats into the simulator UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister( seed=0) # set seed, get reproducible results scitbx.random.set_random_seed(4321) # set seed, get reproducibe results rand_norm = scitbx.random.normal_distribution(mean=0, sigma=rms_angle * math.pi / 180.) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(SAMPLE_SIZE) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) UMAT_nm.append(site.axis_and_angle_as_r3_rotation_matrix(m, deg=False)) # set the normally-distributed U-mats into the simulator: SIM.set_mosaic_blocks(UMAT_nm) # get them back new_UMAT_nm = SIM.get_mosaic_blocks() #double check that simulator does not alter the UMATs for iumat in range(0, SAMPLE_SIZE, 100): assert UMAT_nm[iumat] == new_UMAT_nm[iumat] #sanity check on the gaussian distribution nm_angles = check_distributions.get_angular_rotation(new_UMAT_nm) nm_rms_angle = math.sqrt(flex.mean(nm_angles * nm_angles)) print(nm_rms_angle) assert approx_equal(rms_angle,nm_rms_angle,eps=1e-03), \ "The top hat and gaussian models should have similar standard deviations" return UMAT_th, new_UMAT_nm
def compare_large_3d_real_imag_w_complete_true_false(verbose): mt = flex.mersenne_twister(seed=0) nu, nv, nw = 50, 52, 54 map_size = nu * nv * (nw+2) map = (mt.random_double(size=map_size)*2-1).as_float() recycled = [] for complete in [True, False]: x = map.deep_copy() ccp4io_dev_ext.fftlib_real_to_complex_3d_real_imag_w( x=x, nu=nu, nv=nv, nw=nw, complete=complete) ccp4io_dev_ext.hermitian_conjugate_3d_real_imag_w(x=x, nu=nu, nv=nv, nw=nw) ccp4io_dev_ext.fftlib_complex_to_real_3d_real_imag_w( x=x, nu=nu, nv=nv, nw=nw, complete=complete) recycled.append(x[:nu*nv*nw]) show_complete_true_false_cc(nu, nv, nw, recycled, verbose)
def compare_fftpack_with_cmplft_1d(): mt = flex.mersenne_twister(seed=0) for n in xrange(1, 101): primes = prime_factors_of(n) if (n != 1 and max(primes) > 19): continue z = (mt.random_double(size=n*2)*2-1).as_float() cmplft_xy = z.deep_copy() d = flex.int((2*n,2,2*n,2*n,2*n)) ccp4io_dev_ext.fftlib_cmplft(xy=cmplft_xy, n=n, d=d) fft = scitbx.fftpack.complex_to_complex(n) fftpack_xy = z.as_double() fft.forward(fftpack_xy) fftpack_xy = fftpack_xy.as_float() if (flex.max_absolute(cmplft_xy-fftpack_xy) > 1e-5): assert approx_equal(cmplft_xy, fftpack_xy, eps=1e-5)
def exercise(): from scitbx.array_family import flex from scitbx import matrix from libtbx.test_utils import approx_equal, show_diff import libtbx.load_env if (libtbx.env.has_module(name="iotbx")): from iotbx.shelx.parsers import decode_variables import iotbx.shelx.errors else: decode_variables = None mt = flex.mersenne_twister(seed=0) for sgi,site,expected_expr,no_fvar in test_case_generator(): sps = sgi.any_compatible_crystal_symmetry(volume=1000) \ .special_position_settings() ss = sps.site_symmetry(site) assert approx_equal(ss.exact_site(), site) sos = ss.special_op_simplified() expr = str(sos) assert not show_diff(expr, expected_expr) def check(site): ns = dict(zip("xyz", site)) expr_site = eval(expr, ns, {}) assert approx_equal(expr_site, site, 1e-4) # shifted_site = ( matrix.col(site) + matrix.col(mt.random_double_point_on_sphere())) ns = dict(zip("xyz", shifted_site)) expr_shifted_site = eval(expr, ns, {}) expr_shifted_site_exact = ss.special_op() * expr_shifted_site assert approx_equal(expr_shifted_site, expr_shifted_site_exact) check(site) for i_trial in xrange(3): shifted_site = ss.special_op() * ( matrix.col(site) + matrix.col(mt.random_double_point_on_sphere())) check(shifted_site) fvars = [None] # placeholder for scale factor if (decode_variables is not None): try: coded_variables = ss.shelx_fvar_encoding(site=site, fvars=fvars) except iotbx.shelx.errors.error: if (not no_fvar): raise else: assert not no_fvar if (not no_fvar): values, behaviors = decode_variables( free_variable=fvars, coded_variables=coded_variables) mismatch = sps.unit_cell().mod_short_distance(site, values) assert mismatch < 1e-10
def run(args): assert len(args) == 0 exercise_cubicles_max_memory() from scitbx.cubicle_neighbors import cubicle_neighbors from scitbx.array_family import flex main_sites_cart = flex.vec3_double() cn = cubicle_neighbors(main_sites_cart=main_sites_cart, cubicle_edge=5) nb = cn.neighbors_of(other_sites_cart=main_sites_cart, distance_cutoff_sq=1) assert nb.size() == 0 for xyz in [(0,0,0), (0.1, 0.2, -0.3)]: main_sites_cart = flex.vec3_double([xyz]) cn = cubicle_neighbors(main_sites_cart=main_sites_cart, cubicle_edge=5) nb = cn.neighbors_of(other_sites_cart=main_sites_cart, distance_cutoff_sq=1) assert nb.size() == 1 assert nb.keys() == [0] assert list(nb[0]) == [0] nb = cn.neighbors_of( other_sites_cart=flex.vec3_double([(2,2,2)]), distance_cutoff_sq=1) assert nb.size() == 0 nb = cn.neighbors_of( other_sites_cart=flex.vec3_double([(2,2,2)]), distance_cutoff_sq=25) assert nb.size() == 1 mt = flex.mersenne_twister(seed=0) for nm in [3,5,8]: for no in [1,7,9]: main_sites_cart = flex.vec3_double(zip( mt.random_double(size=nm)*2-1, mt.random_double(size=nm)*2-1, mt.random_double(size=nm)*2-1)) other_sites_cart = flex.vec3_double(zip( mt.random_double(size=no)*2-1, mt.random_double(size=no)*2-1, mt.random_double(size=no)*2-1)) for distance_cutoff in [0.5, 1]: distance_cutoff_sq = distance_cutoff**2 cn = cubicle_neighbors(main_sites_cart=main_sites_cart, cubicle_edge=1) nb = cn.neighbors_of( other_sites_cart=other_sites_cart, distance_cutoff_sq=distance_cutoff_sq) nb_simple = neighbors_simple( main_sites_cart=main_sites_cart, other_sites_cart=other_sites_cart, distance_cutoff_sq=distance_cutoff_sq) assert sorted(nb.keys()) == sorted(nb_simple.keys()) for j_seq,i_seqs_simple in nb_simple.items(): i_seqs = nb[j_seq] assert sorted(i_seqs) == sorted(i_seqs_simple) print "OK"
def exercise(): mt = flex.mersenne_twister(seed=0) sz = 12 for i_trial in xrange(10): x = mt.random_double(size=sz)*5-1 y = mt.random_double(size=sz)*3-1 for i_w,w in enumerate([flex.double(sz, 1), mt.random_double(size=sz)*7]): cc, d_cc, d2_cc = weighted_correlation( w, x, y, derivatives_wrt_y_depth=2) if (i_w == 0): cc_w1 = flex.linear_correlation(x, y).coefficient() assert approx_equal(cc, cc_w1) d_cc_fd = finite_difference_derivatives(w, x, y, depth=1) assert approx_equal(d_cc, d_cc_fd) d2_cc_fd = finite_difference_derivatives(w, x, y, depth=2) assert approx_equal(d2_cc, d2_cc_fd)
def exercise_revolute(out, n_trials, n_dynamics_steps, delta_t=0.001, NB=3): mersenne_twister = flex.mersenne_twister(seed=0) relative_ranges = flex.double() for i_trial in xrange(n_trials): relative_ranges.append(exercise_revolute_sim( out=out, mersenne_twister=mersenne_twister, n_dynamics_steps=n_dynamics_steps, delta_t=delta_t, NB=[1, NB][min(i_trial, 1)], config=["singular", "zigzag", "random"][min(i_trial, 2)])) print >> out, "relative ranges:" relative_ranges.min_max_mean().show(out=out, prefix=" ") if (out is not sys.stdout): assert flex.max(relative_ranges) < 0.0006 print >> out
def simulation_ala_with_h(): pdb = """\ ATOM 0 N ALA A 1 10.949 12.815 15.189 0.00 0.00 N ATOM 1 CA ALA A 1 10.405 13.954 15.917 0.00 0.00 C ATOM 2 C ALA A 1 10.779 15.262 15.227 0.00 0.00 C ATOM 3 HA ALA A 1 9.428 13.887 15.936 0.00 0.00 H ATOM 4 O ALA A 1 9.916 16.090 14.936 0.00 0.00 O ATOM 5 H ALA A 1 11.792 12.691 15.311 0.00 0.00 H ATOM 6 CB ALA A 1 10.908 13.950 17.351 0.00 0.00 C ATOM 7 HB1 ALA A 1 10.627 13.138 17.778 0.00 0.00 H ATOM 8 HB2 ALA A 1 10.540 14.707 17.813 0.00 0.00 H ATOM 9 HB3 ALA A 1 11.867 14.004 17.346 0.00 0.00 H """ labels, sites = pdb_extract(pdb=pdb) mersenne_twister = flex.mersenne_twister(seed=0) body0 = six_dof_body( labels=labels[:4], sites=sites[:4], bonds=[(0,1),(1,2),(1,3)], mersenne_twister=mersenne_twister) body0.parent = -1 body1 = revolute_body( labels=labels[4:5], sites=sites[4:5], bonds=[(-2,0)], pivot=sites[2], normal=(sites[2]-sites[1]).normalize(), mersenne_twister=mersenne_twister) body1.parent = 0 body2 = revolute_body( labels=labels[5:6], sites=sites[5:6], bonds=[(-4,0)], pivot=sites[0], normal=(sites[0]-sites[1]).normalize(), mersenne_twister=mersenne_twister) body2.parent = 0 body3 = revolute_body( labels=labels[6:], sites=sites[6:], bonds=[(-3,0),(0,1),(0,2),(0,3)], pivot=sites[6], normal=(sites[6]-sites[1]).normalize(), mersenne_twister=mersenne_twister) body3.parent = 0 return simulation(bodies=[body0, body1, body2, body3])
def build_one_image(i_img): mt = flex.mersenne_twister(seed=work_params.noise.random_seed+i_img) scale = int(work_params.signal_max*(0.1+0.9*mt.random_double())) crystal_rotation = mt.random_double_r3_rotation_matrix_arvo_1992() i_perm = mt.random_size_t() % len(i_calc_data_perms) image = image_simple( store_miller_index_i_seqs=True, store_spots=True, store_signals=True, set_pixels=True).compute( unit_cell=i_calc.unit_cell(), miller_indices=i_calc.indices(), spot_intensity_factors=i_calc_data_perms[i_perm], crystal_rotation_matrix=crystal_rotation, ewald_radius=1/work_params.wavelength, ewald_proximity=work_params.ewald_proximity, signal_max=scale, detector_distance=work_params.detector.distance, detector_size=work_params.detector.size, detector_pixels=work_params.detector.pixels, point_spread=work_params.point_spread, gaussian_falloff_scale=work_params.gaussian_falloff_scale) add_noise(work_params, pixels=image.pixels) if (not work_params.index_and_integrate): pixels = None else: pixels = image.pixels miller_index_i_seqs = image.miller_index_i_seqs if (use_mp): # to by-pass portable but slower pickling if (pixels is not None): assert pixels.is_0_based() assert not pixels.is_padded() assert pixels.all() == tuple(work_params.detector.pixels) pixels = pixels.copy_to_byte_str() miller_index_i_seqs = miller_index_i_seqs.copy_to_byte_str() return image_model( pixels=pixels, spot_positions=image.spots, spot_intensities=image.signals, unit_cell=i_calc.unit_cell(), crystal_rotation=crystal_rotation, miller_index_i_seqs=miller_index_i_seqs, scale=scale, i_perm=i_perm)
def compare_fftpack_with_cmplft_3d(): mt = flex.mersenne_twister(seed=0) for nx,ny,nz in [(30,20,40), (7,19,13), (5,11,4)]: z = (mt.random_double(size=2*nx*ny*nz)*2-1).as_float() cmplft_xy = z.deep_copy() d = flex.int([2*nx*ny*nz, 2*nx*ny, 2*nx*ny*nz, 2*nx*ny, 2]) ccp4io_dev_ext.fftlib_cmplft(xy=cmplft_xy, n=nz, d=d) d = flex.int([2*nx*ny*nz, 2*nx, 2*nx*ny, 2*nx, 2]) ccp4io_dev_ext.fftlib_cmplft(xy=cmplft_xy, n=ny, d=d) d = flex.int([2*nx*ny*nz, 2, 2*nx*ny*nz, 2*nx*ny*nz, 2*nx]) ccp4io_dev_ext.fftlib_cmplft(xy=cmplft_xy, n=nx, d=d) fft = scitbx.fftpack.complex_to_complex_3d((nz,ny,nx)) fftpack_xy = z.as_double() fftpack_xy.reshape(flex.grid(nz,ny,2*nx)) fft.forward(fftpack_xy) fftpack_xy = fftpack_xy.as_float().as_1d() if (flex.max_absolute(cmplft_xy-fftpack_xy) > 1e-4): assert approx_equal(cmplft_xy, fftpack_xy, eps=1e-4)
def compare_fftpack_with_realft_1d(): mt = flex.mersenne_twister(seed=0) for n_cmpl in xrange(1, 101): primes = prime_factors_of(n_cmpl) if (n_cmpl != 1 and max(primes) > 19): continue n_real = n_cmpl * 2 m_real = n_real + 2 z = (mt.random_double(size=m_real)*2-1).as_float() realft_xy = z.deep_copy() d = flex.int((m_real,2,m_real,m_real,m_real)) ccp4io_dev_ext.fftlib_realft(xy=realft_xy, n=n_cmpl, d=d) fft = scitbx.fftpack.real_to_complex(n_real) assert fft.m_real() == m_real fftpack_xy = z.as_double() fft.forward(fftpack_xy) fftpack_xy = fftpack_xy.as_float() if (flex.max_absolute(realft_xy-fftpack_xy) > 1e-5): assert approx_equal(realft_xy, fftpack_xy, eps=1e-5)
def run(args): assert len(args) < 3 arg_vals = [int(arg) for arg in args] arg_vals = arg_vals + [3, 2][len(arg_vals) :] n_refl, n_trials = arg_vals assert n_refl > 0 assert n_trials > 0 if len(args) == 0: from libtbx.utils import null_out log = null_out() else: import sys log = sys.stdout mt = flex.mersenne_twister(seed=0) for i_trial in xrange(n_trials): exercise(mt, n_refl, log) print "OK"
def compute_image(work_params): dpx,dpy = work_params.detector.pixels from scitbx.array_family import flex assert work_params.noise.max > 0 mt = flex.mersenne_twister(seed=work_params.noise.random_seed) image = mt.random_size_t( size=dpx*dpy, modulus=work_params.noise.max).as_int() image.reshape(flex.grid(dpx,dpy)) pixels_center = None if (work_params.fill_beam_center): assert (dpx % 2) == (dpy % 2) if (dpx % 2 == 0): pixels_center = """\ OOOO OOOOOO OOOOOO OOOOOO OOOOOO OOOO """ else: pixels_center = """\ O OOOOO OOOOO OOOOOOO OOOOO OOOOO O """ if (pixels_center is not None): lines = pixels_center.splitlines() n = max([len(line) for line in lines]) oi,oj = dpx//2-n//2, dpy//2-n//2 for i,line in enumerate(lines): line = line + " "*(n-len(line)) for j,c in enumerate(line): if (c == "O"): pixel = (oi+i, oj+j) #print "beam center pixel:", pixel image[pixel] = work_params.signal_max return image
def exercise_with_random_arguments(n_arguments, n_iterations): mt = flex.mersenne_twister(seed=0) d = mt.random_double(size=n_arguments) * 100 - 50 f = d.as_float() print "showing wall clock times!" t0 = time.time() for i_iteration in xrange(n_iterations): jef = scitbx.math.jacks_expf(array_of_float=f) print "jacks_expf(): %.2f s" % (time.time() - t0) for i_iteration in xrange(n_iterations): sef = flex.exp(f) print "std::exp(float): %.2f s" % (time.time() - t0) t0 = time.time() for i_iteration in xrange(n_iterations): sed = flex.exp(d) print "std::exp(double): %.2f s" % (time.time() - t0) assert sed.all_gt(0) for ef in [jef, sef]: max_rel_err = flex.max(flex.abs((ef.as_double() - sed) / sed)) assert approx_equal(max_rel_err, 0, eps=1e-5)