def exercise_extract_u_cart_plus_u_iso(): from cctbx import uctbx, sgtbx, xray uc = uctbx.unit_cell((1, 1, 1)) sg = sgtbx.space_group_info("P 1") a = flex.xray_scatterer() assert a.size() == 0 s1 = xray.scatterer(label="C", u=0.1) s2 = xray.scatterer(label="C", u=0.1) s2.flags.set_use_u_iso(False) s3 = xray.scatterer(label="C", u=(1, 1, 1, 1, 1, 1)) s4 = xray.scatterer(label="C", u=(1, 1, 1, 1, 1, 1)) s4.flags.set_use_u_aniso(False) s5 = xray.scatterer(label="C", u=0.1) s5.u_star = (1, 1, 1, 1, 1, 1) s5.flags.set_use_u_aniso(True) s6 = xray.scatterer(label="C", u=0.1) s6.u_star = (1, 1, 1, 1, 1, 1) s7 = xray.scatterer(label="C", u=(1, 1, 1, 1, 1, 1)) s7.u_iso = 0.1 s8 = xray.scatterer(label="C", u=(1, 1, 1, 1, 1, 1)) s8.u_iso = 0.1 s8.flags.set_use_u_iso(True) s9 = xray.scatterer(label="C") s10 = xray.scatterer(label="C") s10.flags.set_use_u_iso(False) a = flex.xray_scatterer((s1, s2, s3, s4, s5, s6, s7, s8, s9, s10)) u_cart_total = a.extract_u_cart_plus_u_iso(uc) assert approx_equal(u_cart_total, [(0.1, 0.1, 0.1, 0, 0, 0), (0, 0, 0, 0, 0, 0), (1, 1, 1, 1, 1, 1), (0, 0, 0, 0, 0, 0), (1.1, 1.1, 1.1, 1, 1, 1), (0.1, 0.1, 0.1, 0, 0, 0), (1, 1, 1, 1, 1, 1), (1.1, 1.1, 1.1, 1, 1, 1), (0, 0, 0, 0, 0, 0), (0, 0, 0, 0, 0, 0)])
def add_new_solvent(self): if (self.params.b_iso is None): sol_sel = self.model.solvent_selection() xrs_mac_h = self.model.get_xray_structure().select(~sol_sel) hd_mac = self.model.get_hd_selection().select(~sol_sel) xrs_mac = xrs_mac_h.select(~hd_mac) b = xrs_mac.extract_u_iso_or_u_equiv() * math.pi**2 * 8 b_solv = flex.mean_default(b, None) if (b_solv is not None and b_solv < self.params.b_iso_min or b_solv > self.params.b_iso_max): b_solv = (self.params.b_iso_min + self.params.b_iso_max) / 2. else: b_solv = self.params.b_iso if (self.params.new_solvent == "isotropic"): new_scatterers = flex.xray_scatterer( self.sites.size(), xray.scatterer(occupancy=self.params.occupancy, b=b_solv, scattering_type=self.params.scattering_type)) elif (self.params.new_solvent == "anisotropic"): u_star = adptbx.u_iso_as_u_star( self.model.get_xray_structure().unit_cell(), adptbx.b_as_u(b_solv)) new_scatterers = flex.xray_scatterer( self.sites.size(), xray.scatterer(occupancy=self.params.occupancy, u=u_star, scattering_type=self.params.scattering_type)) else: raise RuntimeError new_scatterers.set_sites(self.sites) solvent_xray_structure = xray.structure( special_position_settings=self.model.get_xray_structure(), scatterers=new_scatterers) xrs_sol = self.model.get_xray_structure().select( self.model.solvent_selection()) xrs_mac = self.model.get_xray_structure().select( ~self.model.solvent_selection()) xrs_sol = xrs_sol.concatenate(other=solvent_xray_structure) sol_sel = flex.bool(xrs_mac.scatterers().size(), False) sol_sel.extend(flex.bool(xrs_sol.scatterers().size(), True)) self.model.add_solvent( solvent_xray_structure=solvent_xray_structure, residue_name=self.params.output_residue_name, atom_name=self.params.output_atom_name, chain_id=self.params.output_chain_id, refine_occupancies=self.params.refine_occupancies, refine_adp=self.params.new_solvent) self.fmodel.update_xray_structure( xray_structure=self.model.get_xray_structure(), update_f_calc=True)
def add_new_solvent(self): if(self.params.b_iso is None): sol_sel = self.model.solvent_selection() xrs_mac_h = self.model.xray_structure.select(~sol_sel) hd_mac = self.model.xray_structure.hd_selection().select(~sol_sel) xrs_mac = xrs_mac_h.select(~hd_mac) b = xrs_mac.extract_u_iso_or_u_equiv() * math.pi**2*8 b_solv = flex.mean_default(b, None) if(b_solv is not None and b_solv < self.params.b_iso_min or b_solv > self.params.b_iso_max): b_solv = (self.params.b_iso_min + self.params.b_iso_max) / 2. else: b_solv = self.params.b_iso if(self.params.new_solvent == "isotropic"): new_scatterers = flex.xray_scatterer( self.sites.size(), xray.scatterer(occupancy = self.params.occupancy, b = b_solv, scattering_type = self.params.scattering_type)) elif(self.params.new_solvent == "anisotropic"): u_star = adptbx.u_iso_as_u_star(self.model.xray_structure.unit_cell(), adptbx.b_as_u(b_solv)) new_scatterers = flex.xray_scatterer( self.sites.size(), xray.scatterer( occupancy = self.params.occupancy, u = u_star, scattering_type = self.params.scattering_type)) else: raise RuntimeError new_scatterers.set_sites(self.sites) solvent_xray_structure = xray.structure( special_position_settings = self.model.xray_structure, scatterers = new_scatterers) xrs_sol = self.model.xray_structure.select(self.model.solvent_selection()) xrs_mac = self.model.xray_structure.select(~self.model.solvent_selection()) xrs_sol = xrs_sol.concatenate(other = solvent_xray_structure) sol_sel = flex.bool(xrs_mac.scatterers().size(), False) sol_sel.extend( flex.bool(xrs_sol.scatterers().size(), True) ) self.model.add_solvent( solvent_xray_structure = solvent_xray_structure, residue_name = self.params.output_residue_name, atom_name = self.params.output_atom_name, chain_id = self.params.output_chain_id, refine_occupancies = self.params.refine_occupancies, refine_adp = self.params.new_solvent) self.fmodel.update_xray_structure( xray_structure = self.model.xray_structure, update_f_calc = True)
def __init__(self,unitcell,spacegroup,scatterers): self.sg=sgtbx.space_group_info(spacegroup) self.uc=uctbx.unit_cell(unitcell) self.scatt=scatterers self.cctbx_scatterers=flex.xray_scatterer() for s in self.scatt: self.cctbx_scatterers.append(xray.scatterer(label=s.label,site=s.site,occupancy=s.occupancy,u=s.u_iso)) try: #old cctbx version xray.add_scatterers_ext(unit_cell=self.uc, space_group=self.sg.group(), scatterers=self.cctbx_scatterers, site_symmetry_table=sgtbx.site_symmetry_table(), site_symmetry_table_for_new=sgtbx.site_symmetry_table(), min_distance_sym_equiv=0.5, u_star_tolerance=0, assert_min_distance_sym_equiv=True) except: # cctbx version >= 2011_04_06_0217 #print "Whoops, cctbx version 2011" xray.add_scatterers_ext(unit_cell=self.uc, space_group=self.sg.group(), scatterers=self.cctbx_scatterers, site_symmetry_table=sgtbx.site_symmetry_table(), site_symmetry_table_for_new=sgtbx.site_symmetry_table(), min_distance_sym_equiv=0.5, u_star_tolerance=0, assert_min_distance_sym_equiv=True, non_unit_occupancy_implies_min_distance_sym_equiv_zero=False) cs=crystal.symmetry(self.uc,spacegroup) sp=crystal.special_position_settings(cs) self.structure=xray.structure(sp,self.cctbx_scatterers) self.structure_as_P1=self.structure.expand_to_p1()
def exercise_intersection(): sites_frac = flex.vec3_double([ (0.02,0.10,0.02), (0.10,0.02,0.40), (0.98,0.10,0.60), (0.10,0.98,0.80), (0.20,0.50,0.98)]) from cctbx import xray xray_structure = xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=(30,30,50,90,90,120), space_group_symbol="P1"), scatterers=flex.xray_scatterer([ xray.scatterer(label=str(i), scattering_type="Si", site=site_frac) for i,site_frac in enumerate(sites_frac)])) d_min = 0.7 f_calc = xray_structure.structure_factors(d_min=d_min).f_calc() fft_map = f_calc.fft_map(resolution_factor=1/6.) fft_map.apply_sigma_scaling() density_map = fft_map.real_map_unpadded() # cm1 = xray_structure.center_of_mass() cm2 = maptbx.center_of_mass(map_data=density_map, unit_cell=xray_structure.unit_cell(), cutoff=20) #large cutoff to make map look like point scattereres assert approx_equal(cm1, cm2, 0.1)
def demo(): """ Result of ICSD query: N * -Cr2O3-[R3-CH] Baster, M.;Bouree, F.;Kowalska, A.;Latacz, Z(2000) C 4.961950 4.961950 13.597400 90.000000 90.000000 120.000000 S GRUP R -3 C A Cr1 0.000000 0.000000 0.347570 0.000000 A O1 0.305830 0.000000 0.250000 """ crystal_symmetry = crystal.symmetry( unit_cell="4.961950 4.961950 13.597400 90.000000 90.000000 120.000000", space_group_symbol="R -3 C") scatterers = flex.xray_scatterer() scatterers.append(xray.scatterer( label="Cr1", site=(0.000000,0.000000,0.347570))) scatterers.append(xray.scatterer( label="O1", site=(0.305830,0.000000,0.250000))) icsd_structure = xray.structure( crystal_symmetry=crystal_symmetry, scatterers=scatterers) icsd_structure.show_summary().show_scatterers() print icsd_structure.show_distances(distance_cutoff=2.5) print primitive_structure = icsd_structure.primitive_setting() primitive_structure.show_summary().show_scatterers() print p1_structure = primitive_structure.expand_to_p1() p1_structure.show_summary().show_scatterers() print print "OK"
def mg_structure_dict_to_cctbx_crystal_structure(d): """ Compatible with pymatgen Structure.to_dict() format to a cctbx crystal structure object """ params = " ".join([ str(o) for o in [ d['lattice']['a'], d['lattice']['b'], d['lattice']['c'], d['lattice']['alpha'], d['lattice']['beta'], d['lattice']['gamma'] ] ]) unit_cell = uctbx.unit_cell(params) symbol = 'P 1' crystal_symmetry = crystal.symmetry(unit_cell=unit_cell, space_group_symbol=symbol) """ site = tuple([0.0, 0.20, 0.3]) scatterers.append(xray.scatterer(label=lable, site=site, occupancy=occupancy) crystal_structure = xray.structure(crystal_symmetry=crystal_symmetry, scatterers=scatterers) """ scatterers = flex.xray_scatterer() for site in d['sites']: abc = tuple(site['abc']) for specie in site['species']: label = specie['element'].encode('utf8') occupancy = float(specie['occu']) scatterers.append( xray.scatterer(label=label, site=abc, occupancy=occupancy)) crystal_structure = xray.structure(crystal_symmetry=crystal_symmetry, scatterers=scatterers) return crystal_structure
def exercise_is_simple_interaction(): for space_group_symbol in ["P1", "P41"]: for shifts in flex.nested_loop((-2, -2, -2), (2, 2, 2), False): shifts = matrix.col(shifts) structure = xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=(10, 10, 20, 90, 90, 90), space_group_symbol=space_group_symbol), scatterers=flex.xray_scatterer([ xray.scatterer(label="O", site=shifts + matrix.col((0, 0, 0))), xray.scatterer(label="N", site=shifts + matrix.col((0.5, 0.5, 0))), xray.scatterer(label="C", site=shifts + matrix.col((0.25, 0.25, 0))) ])) asu_mappings = structure.asu_mappings(buffer_thickness=7) pair_generator = crystal.neighbors_simple_pair_generator( asu_mappings=asu_mappings, distance_cutoff=7) simple_interactions = {} for i_pair, pair in enumerate(pair_generator): if (asu_mappings.is_simple_interaction(pair)): assert asu_mappings_is_simple_interaction_emulation( asu_mappings, pair) key = (pair.i_seq, pair.j_seq) assert simple_interactions.get(key, None) is None simple_interactions[key] = 1 else: assert not asu_mappings_is_simple_interaction_emulation( asu_mappings, pair) assert len(simple_interactions) == 2 assert simple_interactions[(0, 2)] == 1 assert simple_interactions[(1, 2)] == 1
def exercise_symmetry_equivalent(): xs = xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=(1, 2, 3), space_group_symbol='hall: P 2x'), scatterers=flex.xray_scatterer(( xray.scatterer("C", site=(0.1, 0.2, 0.3)), ))) xs.scatterers()[0].flags.set_grad_site(True) connectivity_table = smtbx.utils.connectivity_table(xs) reparametrisation = constraints.reparametrisation( xs, [], connectivity_table) site_0 = reparametrisation.add(constraints.independent_site_parameter, scatterer=xs.scatterers()[0]) g = sgtbx.rt_mx('x,-y,-z') symm_eq = reparametrisation.add( constraints.symmetry_equivalent_site_parameter, site=site_0, motion=g) reparametrisation.finalise() assert approx_equal(symm_eq.original.scatterers[0].site, (0.1, 0.2, 0.3), eps=1e-15) assert str(symm_eq.motion) == 'x,-y,-z' assert symm_eq.is_variable reparametrisation.linearise() assert approx_equal(symm_eq.value, g*site_0.value, eps=1e-15) reparametrisation.store() assert approx_equal(symm_eq.value, (0.1, -0.2, -0.3), eps=1e-15) assert approx_equal(site_0.value, (0.1, 0.2, 0.3), eps=1e-15)
def test_addition_scatterers(): ''' Test overlaps when adding and moving scatterers Test water scatterers with and without labels ''' clashes = get_clashes_result(raw_records=raw_records_3) results = clashes.get_results() assert(results.n_clashes == 3) assert approx_equal(results.clashscore, 1000, eps=0.1) # Add water scatterers model = clashes.model xrs = model.get_xray_structure() new_scatterers = flex.xray_scatterer( xrs.scatterers().size(), xray.scatterer(occupancy = 1, b = 10, scattering_type = "O")) new_sites_frac = xrs.unit_cell().fractionalize(xrs.sites_cart()+[0.5,0,0]) new_scatterers.set_sites(new_sites_frac) new_xrs = xray.structure( special_position_settings = xrs, scatterers = new_scatterers) model.add_solvent( solvent_xray_structure = new_xrs, refine_occupancies = False, refine_adp = "isotropic") pnps = pnp.manager(model = model) clashes = pnps.get_clashes() results = clashes.get_results() assert(results.n_clashes == 15) assert approx_equal(results.clashscore, 2500, eps=5)
def add_new_solvent(self): b_solv = self.params.b_iso new_scatterers = flex.xray_scatterer( self.sites.size(), xray.scatterer(occupancy = self.params.occupancy, b = b_solv, scattering_type = self.params.scattering_type, label = 'HOH')) new_scatterers.set_sites(self.sites) solvent_xray_structure = xray.structure( special_position_settings = self.model.xray_structure, scatterers = new_scatterers) xrs_sol = self.model.xray_structure.select(self.model.solvent_selection()) xrs_mac = self.model.xray_structure.select(~self.model.solvent_selection()) xrs_sol = xrs_sol.concatenate(other = solvent_xray_structure) sol_sel = flex.bool(xrs_mac.scatterers().size(), False) sol_sel.extend( flex.bool(xrs_sol.scatterers().size(), True) ) self.model.add_solvent( solvent_xray_structure = solvent_xray_structure, residue_name = self.params.output_residue_name, atom_name = self.params.output_atom_name, chain_id = self.params.output_chain_id, refine_occupancies = self.params.refine_occupancies, refine_adp = self.params.new_solvent) self.fmodel.update_xray_structure( xray_structure = self.model.xray_structure, update_f_calc = False)
def test_spacegroup_tidy_pickling(): quartz_structure = xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=(5.01,5.01,5.47,90,90,120), space_group_symbol="P6222"), scatterers=flex.xray_scatterer( [ xray.scatterer(label="Si", site=(1/2.,1/2.,1/3.), u=0.2), xray.scatterer(label="O", site=(0.197,-0.197,0.83333), u=0) ]) ) asu_mappings = quartz_structure.asu_mappings(buffer_thickness=2) pair_asu_table = crystal.pair_asu_table(asu_mappings=asu_mappings) pair_asu_table.add_all_pairs(distance_cutoff=1.7) pair_sym_table = pair_asu_table.extract_pair_sym_table() new_asu_mappings = quartz_structure.asu_mappings(buffer_thickness=5) new_pair_asu_table = crystal.pair_asu_table(asu_mappings=new_asu_mappings) new_pair_asu_table.add_pair_sym_table(sym_table=pair_sym_table) spg = new_pair_asu_table.asu_mappings().space_group() pspg = pickle.loads(pickle.dumps(spg)) mstr = "" pmstr = "" for rt in spg.all_ops(): mstr += rt.r().as_xyz() + "\n" for rt in pspg.all_ops(): pmstr += rt.r().as_xyz() + "\n" assert mstr == pmstr
def __init__(self, n_runs, **kwds): libtbx.adopt_optional_init_args(self, kwds) self.n_runs = n_runs self.crystal_symmetry = crystal.symmetry( unit_cell=uctbx.unit_cell((5.1534, 5.1534, 8.6522, 90, 90, 120)), space_group_symbol='Hall: P 6c') self.structure = xray.structure( self.crystal_symmetry.special_position_settings(), flex.xray_scatterer(( xray.scatterer('K1', site=(0, 0, -0.00195), u=self.u_cif_as_u_star((0.02427, 0.02427, 0.02379, 0.01214, 0.00000, 0.00000))), xray.scatterer('S1', site=(1/3, 2/3, 0.204215), u=self.u_cif_as_u_star((0.01423, 0.01423, 0.01496, 0.00712, 0.00000, 0.00000 ))), xray.scatterer('Li1', site=(1/3, 2/3, 0.815681), u=self.u_cif_as_u_star((0.02132, 0.02132, 0.02256, 0.01066, 0.00000, 0.00000 ))), xray.scatterer('O1', site=(1/3, 2/3, 0.035931), u=self.u_cif_as_u_star((0.06532, 0.06532, 0.01669, 0.03266, 0.00000, 0.00000 ))), xray.scatterer('O2', site=(0.343810, 0.941658, 0.258405), u=self.u_cif_as_u_star((0.02639, 0.02079, 0.05284, 0.01194, -0.00053,-0.01180 ))) ))) mi = self.crystal_symmetry.build_miller_set(anomalous_flag=False, d_min=0.5) fo_sq = mi.structure_factors_from_scatterers( self.structure, algorithm="direct").f_calc().norm() self.fo_sq = fo_sq.customized_copy(sigmas=flex.double(fo_sq.size(), 1))
def exercise_symmetry_equivalent(): xs = xray.structure(crystal_symmetry=crystal.symmetry( unit_cell=(1, 2, 3), space_group_symbol='hall: P 2x'), scatterers=flex.xray_scatterer( (xray.scatterer("C", site=(0.1, 0.2, 0.3)), ))) xs.scatterers()[0].flags.set_grad_site(True) connectivity_table = smtbx.utils.connectivity_table(xs) reparametrisation = constraints.reparametrisation(xs, [], connectivity_table) site_0 = reparametrisation.add(constraints.independent_site_parameter, scatterer=xs.scatterers()[0]) g = sgtbx.rt_mx('x,-y,-z') symm_eq = reparametrisation.add( constraints.symmetry_equivalent_site_parameter, site=site_0, motion=g) reparametrisation.finalise() assert approx_equal(symm_eq.original.scatterers[0].site, (0.1, 0.2, 0.3), eps=1e-15) assert str(symm_eq.motion) == 'x,-y,-z' assert symm_eq.is_variable reparametrisation.linearise() assert approx_equal(symm_eq.value, g * site_0.value, eps=1e-15) reparametrisation.store() assert approx_equal(symm_eq.value, (0.1, -0.2, -0.3), eps=1e-15) assert approx_equal(site_0.value, (0.1, 0.2, 0.3), eps=1e-15)
def quartz(): return xray.structure( crystal_symmetry=crystal.symmetry( (5.01,5.01,5.47,90,90,120), "P6222"), scatterers=flex.xray_scatterer([ xray.scatterer("Si", (1/2.,1/2.,1/3.)), xray.scatterer("O", (0.197,-0.197,0.83333))]))
def add_new_solvent(self): b_solv = self.params.b_iso new_scatterers = flex.xray_scatterer( self.sites.size(), xray.scatterer(occupancy=self.params.occupancy, b=b_solv, scattering_type=self.params.scattering_type, label='HOH')) new_scatterers.set_sites(self.sites) solvent_xray_structure = xray.structure( special_position_settings=self.model.xray_structure, scatterers=new_scatterers) xrs_sol = self.model.xray_structure.select( self.model.solvent_selection()) xrs_mac = self.model.xray_structure.select( ~self.model.solvent_selection()) xrs_sol = xrs_sol.concatenate(other=solvent_xray_structure) sol_sel = flex.bool(xrs_mac.scatterers().size(), False) sol_sel.extend(flex.bool(xrs_sol.scatterers().size(), True)) self.model.add_solvent( solvent_xray_structure=solvent_xray_structure, residue_name=self.params.output_residue_name, atom_name=self.params.output_atom_name, chain_id=self.params.output_chain_id, refine_occupancies=self.params.refine_occupancies, refine_adp=self.params.new_solvent) self.fmodel.update_xray_structure( xray_structure=self.model.xray_structure, update_f_calc=False)
def _find_peaks(self, min_peak_peak_distance=1.5): cg = maptbx.crystal_gridding( space_group_info=self.model.crystal_symmetry().space_group_info(), symmetry_flags=maptbx.use_space_group_symmetry, unit_cell=self.unit_cell, pre_determined_n_real=self.map_data.accessor().all()) cgt = maptbx.crystal_gridding_tags(gridding=cg) peak_search_parameters = maptbx.peak_search_parameters( peak_search_level=3, max_peaks=0, peak_cutoff=self.cutoff, interpolate=True, min_distance_sym_equiv=0, general_positions_only=False, # ???????XXXXXXXXXXXXXX min_cross_distance=min_peak_peak_distance, min_cubicle_edge=5) psr = cgt.peak_search(parameters=peak_search_parameters, map=self.map_data).all(max_clusters=99999999) # Convert peaks into water xray.structure mean_b = flex.mean(self.model.get_hierarchy().atoms().extract_b()) sp = crystal.special_position_settings(self.model.crystal_symmetry()) scatterers = flex.xray_scatterer() for site_frac in psr.sites(): sc = xray.scatterer(label="O", site=site_frac, u=adptbx.b_as_u(mean_b), occupancy=1.0) scatterers.append(sc) self.xrs_water = xray.structure(sp, scatterers) # self.ma.add(" total peaks found: %d" % self.xrs_water.scatterers().size()) self.ma.add(" B factors set to : %8.3f" % mean_b) if (self.debug): self._write_pdb_file(file_name_prefix="hoh_all_peaks")
def loop(self): for i_position in xrange(self.wyckoff_table.size()): site_symmetry_i = self.wyckoff_table.random_site_symmetry( special_position_settings=self.special_position_settings, i_position=i_position) equiv_sites_i = sgtbx.sym_equiv_sites(site_symmetry_i) for j_position in xrange(self.wyckoff_table.size()): for n_trial in xrange(self.max_trials_per_position): site_j = self.wyckoff_table.random_site_symmetry( special_position_settings=self. special_position_settings, i_position=j_position).exact_site() dist_info = sgtbx.min_sym_equiv_distance_info( equiv_sites_i, site_j) if (dist_info.dist() > self.min_cross_distance): structure = xray.structure( special_position_settings=self. special_position_settings, scatterers=flex.xray_scatterer([ xray.scatterer( scattering_type=self.scattering_type, site=site) for site in [site_symmetry_i.exact_site(), site_j] ])) yield structure, dist_info.dist() break
def _append_to_model(self): mean_b = flex.mean(self.model.get_hierarchy().atoms().extract_b()) self.ma.add(" new water B factors will be set to mean B: %8.3f" % mean_b) sp = crystal.special_position_settings(self.model.crystal_symmetry()) scatterers = flex.xray_scatterer() for site_frac in self.sites_frac_water: sc = xray.scatterer(label="O", site=site_frac, u=adptbx.b_as_u(mean_b), occupancy=1.0) scatterers.append(sc) xrs_water = xray.structure(sp, scatterers) # chain_ids_taken = [] for chain in self.model.get_hierarchy().chains(): chain_ids_taken.append(chain.id) unique_taken = list(set(chain_ids_taken)) if (len(unique_taken) == 1): solvent_chain = unique_taken[0] else: for solvent_chain in all_chain_ids(): if (not solvent_chain in chain_ids_taken): break self.ma.add(" new water will have chain ID: '%s'" % solvent_chain) # self.model.add_solvent(solvent_xray_structure=xrs_water, atom_name="O", residue_name="HOH", chain_id=solvent_chain, refine_adp="isotropic")
def compare_with_cctbx_structure_factors(n_scatt, n_refl, output_lines): from cctbx import xray from cctbx import miller from cctbx import crystal from cctbx.array_family import flex crystal_symmetry = crystal.symmetry(unit_cell=(11, 12, 13, 90, 90, 90), space_group_symbol="P1") scatterers = flex.xray_scatterer() miller_indices = flex.miller_index() f_calc = flex.complex_double() for line in output_lines: flds = line.split() assert len(flds) in [4, 5] if (len(flds) == 4): x, y, z, b_iso = [float(s) for s in flds] scatterers.append( xray.scatterer(site=(x, y, z), b=b_iso, scattering_type="const")) else: miller_indices.append([int(s) for s in flds[:3]]) f_calc.append(complex(float(flds[3]), float(flds[4]))) assert scatterers.size() == n_scatt assert miller_indices.size() == n_refl xs = xray.structure(crystal_symmetry=crystal_symmetry, scatterers=scatterers) fc = miller_array = miller.set(crystal_symmetry=crystal_symmetry, indices=miller_indices, anomalous_flag=False).array(data=f_calc) fc2 = fc.structure_factors_from_scatterers(xray_structure=xs, algorithm="direct", cos_sin_table=False).f_calc() for f1, f2 in zip(fc.data(), fc2.data()): assert approx_equal(f1, f2, eps=1e-5)
def extract_structure(self, phase_nr=1): """This method tries to extract the crystal structure from the parsed pcrfile. :returns: the extracted structure :rtype: cctbx.xray.structure """ from cctbx import xray from cctbx import crystal from cctbx.array_family import flex p = self.cfg['phases'][str(phase_nr)] atoms = p['atoms'] unit_cell = [p['a'], p['b'], p['c'], p['alpha'], p['beta'], p['gamma']] special_position_settings = crystal.special_position_settings( crystal_symmetry=crystal.symmetry(unit_cell=unit_cell, space_group_symbol=p['SYMB'])) scatterers = [] for k, a in atoms.iteritems(): scatterers.append( xray.scatterer(label=a['LABEL'], scattering_type=a['NTYP'], site=(a['X'], a['Y'], a['Z']), b=a['B'])) scatterers_flex = flex.xray_scatterer(scatterers) structure = xray.structure( special_position_settings=special_position_settings, scatterers=scatterers_flex) return structure.as_py_code()
def extract_structure(self, phase_nr=1): """This method tries to extract the crystal structure from the parsed pcrfile. :returns: the extracted structure :rtype: cctbx.xray.structure """ from cctbx import xray from cctbx import crystal from cctbx.array_family import flex p = self.cfg['phases'][str(phase_nr)] atoms = p['atoms'] unit_cell = [ p['a'], p['b'], p['c'], p['alpha'], p['beta'], p['gamma'] ] special_position_settings=crystal.special_position_settings( crystal_symmetry=crystal.symmetry( unit_cell=unit_cell, space_group_symbol=p['SYMB'])) scatterers = [] for k, a in atoms.iteritems(): scatterers.append(xray.scatterer(label=a['LABEL'], scattering_type=a['NTYP'], site=(a['X'], a['Y'], a['Z']), b=a['B'])) scatterers_flex=flex.xray_scatterer(scatterers) structure = xray.structure(special_position_settings=special_position_settings, scatterers=scatterers_flex) return structure.as_py_code()
def exercise_is_simple_interaction(): for space_group_symbol in ["P1", "P41"]: for shifts in flex.nested_loop((-2,-2,-2),(2,2,2),False): shifts = matrix.col(shifts) structure = xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=(10,10,20,90,90,90), space_group_symbol=space_group_symbol), scatterers=flex.xray_scatterer([ xray.scatterer(label="O", site=shifts+matrix.col((0,0,0))), xray.scatterer(label="N", site=shifts+matrix.col((0.5,0.5,0))), xray.scatterer(label="C", site=shifts+matrix.col((0.25,0.25,0)))])) asu_mappings = structure.asu_mappings(buffer_thickness=7) pair_generator = crystal.neighbors_simple_pair_generator( asu_mappings=asu_mappings, distance_cutoff=7) simple_interactions = {} for i_pair,pair in enumerate(pair_generator): if (asu_mappings.is_simple_interaction(pair)): assert asu_mappings_is_simple_interaction_emulation( asu_mappings, pair) key = (pair.i_seq,pair.j_seq) assert simple_interactions.get(key, None) is None simple_interactions[key] = 1 else: assert not asu_mappings_is_simple_interaction_emulation( asu_mappings, pair) assert len(simple_interactions) == 2 assert simple_interactions[(0,2)] == 1 assert simple_interactions[(1,2)] == 1
def exercise_rigid_pivoted_rotatable(): uc = uctbx.unit_cell((1, 1, 1)) xs = xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=uc, space_group_symbol='hall: P 2x 2y'), scatterers=flex.xray_scatterer(( #triangle xray.scatterer('C0', site=(0,0,0)), xray.scatterer('C1', site=(0,2,0)), xray.scatterer('C2', site=(1,1,0)), ))) r = constraints.ext.reparametrisation(xs.unit_cell()) sc = xs.scatterers() pivot = r.add(constraints.independent_site_parameter, sc[0]) pivot_neighbour = r.add(constraints.independent_site_parameter, sc[1]) azimuth = r.add(constraints.independent_scalar_parameter, value=pi/2, variable=True) size = r.add(constraints.independent_scalar_parameter, value=1, variable=False) rg = r.add(constraints.rigid_pivoted_rotatable_group, pivot=pivot, pivot_neighbour=pivot_neighbour, azimuth=azimuth, size=size, scatterers=(sc[1], sc[2])) site_proxy = r.add(constraints.rigid_site_proxy, rg, 1) r.finalise() r.linearise() r.store() #check that proxy and the final results are the same... assert approx_equal( uc.distance(col(site_proxy.value), col(sc[2].site)), 0, eps=1e-15) #rotation happens around the center of gravity assert approx_equal( uc.distance(col((0,1,1)), col(sc[2].site)), 0, eps=1e-15)
def __init__(self, space_group=SpaceGroup('P 1'), lattice=Lattice(1.0, 1.0, 1.0, 90.0, 90.0, 90.0), sites=[]): """ Crystal object. Functions as a wrapper to a cctbx xray.structure object, but adds additional variables and functionality. Core object of this package. Input: SpaceGroup space_group space group for the current crystal List of Site objects sites List of Site objects. Warning: 'crystal_structure' must be given, or 'space_group', 'lattice', and 'sites' must be given, or creation of the crystal will fail. """ try: crystal_symmetry = crystal.symmetry( unit_cell=str(lattice), space_group_symbol=space_group.cctbx_name) except Exception as e: raise SymmetryError( "SpaceGroup {s} is incompatible with Lattice -> {l} cctbx error {e}" .format(l=str(lattice), s=SpaceGroup.cctbx_name, e=e)) scatterers = flex.xray_scatterer() for i, site in enumerate(sites): # the element name can be pulled from scatterer via the s.element_symbol() method (if it's an element!!!) # example: 'atom-b-12',or 'vacancy-c-3' # we need to set the scattering_type so we can freely use the label to store metadata #scattering_type = something #scatterers.append(xray.scatterer(label=atom.name, site=tuple(atom.abc), occupancy=atom.occupancy), scattering_type=atom.name) #Method #2 # explicitly add metadata to _meta st_temp, dash, num = site.label.partition("-") if dash == "-": k = site.label else: k = "-".join([site.label, str(i)]) # problems here not sure what's up k = str(k) # print "label = ", k, ' type of label = ', type(k) # print "site = ", tuple(site.abc) # print "occupancy = ", site.occupancy scatterers.append( xray.scatterer(label=k, site=tuple(site.abc), occupancy=site.occupancy)) # Test for coherency of Lattice and SpaceGroup self.crystal_structure = xray.structure( crystal_symmetry=crystal_symmetry, scatterers=scatterers)
def merge(Cls, *others): """Returns new instance of the Fragment. The scatterers in the new fragment are obtained by merging two frag""" scatterers = flex.xray_scatterer() for other in others: for scatterer in other.scatterers: scatterers.append(scatterer) return Cls(scatterers)
def get_xrs(): crystal_symmetry = crystal.symmetry( unit_cell=(10,10,10,90,90,90), space_group_symbol="P 1") return xray.structure( crystal_symmetry=crystal_symmetry, scatterers=flex.xray_scatterer([ xray.scatterer(label="C", site=(0,0,0))]))
def exercise_real_space_refinement(verbose): if (verbose): out = sys.stdout else: out = StringIO() out_of_bounds_clamp = maptbx.out_of_bounds_clamp(0) out_of_bounds_raise = maptbx.out_of_bounds_raise() crystal_symmetry = crystal.symmetry(unit_cell=(10, 10, 10, 90, 90, 90), space_group_symbol="P 1") xray_structure = xray.structure(crystal_symmetry=crystal_symmetry, scatterers=flex.xray_scatterer([ xray.scatterer(label="C", site=(0, 0, 0)) ])) miller_set = miller.build_set(crystal_symmetry=crystal_symmetry, anomalous_flag=False, d_min=1) f_calc = miller_set.structure_factors_from_scatterers( xray_structure=xray_structure).f_calc() fft_map = f_calc.fft_map() fft_map.apply_sigma_scaling() real_map = fft_map.real_map_unpadded() #### unit_cell test delta_h = .005 basic_map = maptbx.basic_map( maptbx.basic_map_unit_cell_flag(), real_map, real_map.focus(), crystal_symmetry.unit_cell().orthogonalization_matrix(), out_of_bounds_clamp.as_handle(), crystal_symmetry.unit_cell()) testing_function_for_rsfit(basic_map, delta_h, xray_structure, out) ### non_symmetric test # minfrac = crystal_symmetry.unit_cell().fractionalize((-5, -5, -5)) maxfrac = crystal_symmetry.unit_cell().fractionalize((5, 5, 5)) gridding_first = [ifloor(n * b) for n, b in zip(fft_map.n_real(), minfrac)] gridding_last = [iceil(n * b) for n, b in zip(fft_map.n_real(), maxfrac)] data = maptbx.copy(real_map, gridding_first, gridding_last) # basic_map = maptbx.basic_map( maptbx.basic_map_non_symmetric_flag(), data, fft_map.n_real(), crystal_symmetry.unit_cell().orthogonalization_matrix(), out_of_bounds_clamp.as_handle(), crystal_symmetry.unit_cell()) testing_function_for_rsfit(basic_map, delta_h, xray_structure, out) ### asu test # minfrac = crystal_symmetry.unit_cell().fractionalize((0, 0, 0)) maxfrac = crystal_symmetry.unit_cell().fractionalize((10, 10, 10)) gridding_first = [ifloor(n * b) for n, b in zip(fft_map.n_real(), minfrac)] gridding_last = [iceil(n * b) for n, b in zip(fft_map.n_real(), maxfrac)] data = maptbx.copy(real_map, gridding_first, gridding_last) # basic_map = maptbx.basic_map( maptbx.basic_map_asu_flag(), data, crystal_symmetry.space_group(), crystal_symmetry.direct_space_asu().as_float_asu(), real_map.focus(), crystal_symmetry.unit_cell().orthogonalization_matrix(), out_of_bounds_clamp.as_handle(), crystal_symmetry.unit_cell(), 0.5, True) testing_function_for_rsfit(basic_map, delta_h, xray_structure, out)
def __init__(self, xray_structure, solvent_radius, shrink_truncation_radius, ignore_hydrogen_atoms=False, crystal_gridding=None, grid_step=None, d_min=None, resolution_factor=1 / 4, atom_radii_table=None, use_space_group_symmetry=False): self.xray_structure = xray_structure if crystal_gridding is None: self.crystal_gridding = maptbx.crystal_gridding( unit_cell=xray_structure.unit_cell(), space_group_info=xray_structure.space_group_info(), step=grid_step, d_min=d_min, resolution_factor=resolution_factor, symmetry_flags=sgtbx.search_symmetry_flags( use_space_group_symmetry=use_space_group_symmetry)) else: self.crystal_gridding = crystal_gridding if use_space_group_symmetry: atom_radii = cctbx.masks.vdw_radii( xray_structure, table=atom_radii_table).atom_radii asu_mappings = xray_structure.asu_mappings( buffer_thickness=flex.max(atom_radii) + solvent_radius) scatterers_asu_plus_buffer = flex.xray_scatterer() frac = xray_structure.unit_cell().fractionalize for sc, mappings in zip(xray_structure.scatterers(), asu_mappings.mappings()): for mapping in mappings: scatterers_asu_plus_buffer.append( sc.customized_copy(site=frac(mapping.mapped_site()))) xs = xray.structure(crystal_symmetry=xray_structure, scatterers=scatterers_asu_plus_buffer) else: xs = xray_structure.expand_to_p1() self.vdw_radii = cctbx.masks.vdw_radii(xs, table=atom_radii_table) self.mask = cctbx.masks.around_atoms( unit_cell=xs.unit_cell(), space_group_order_z=xs.space_group().order_z(), sites_frac=xs.sites_frac(), atom_radii=self.vdw_radii.atom_radii, gridding_n_real=self.crystal_gridding.n_real(), solvent_radius=solvent_radius, shrink_truncation_radius=shrink_truncation_radius) if use_space_group_symmetry: tags = self.crystal_gridding.tags() tags.tags().apply_symmetry_to_mask(self.mask.data) self.flood_fill = cctbx.masks.flood_fill(self.mask.data, xray_structure.unit_cell()) self.exclude_void_flags = [False] * self.flood_fill.n_voids() self.solvent_accessible_volume = self.n_solvent_grid_points() \ / self.mask.data.size() * xray_structure.unit_cell().volume()
def exercise_unmerged () : quartz_structure = xray.structure( special_position_settings=crystal.special_position_settings( crystal_symmetry=crystal.symmetry( unit_cell=(5.01,5.01,5.47,90,90,120), space_group_symbol="P6222")), scatterers=flex.xray_scatterer([ xray.scatterer( label="Si", site=(1/2.,1/2.,1/3.), u=0.2), xray.scatterer( label="O", site=(0.197,-0.197,0.83333), u=0.1)])) quartz_structure.set_inelastic_form_factors( photon=1.54, table="sasaki") fc = abs(quartz_structure.structure_factors(d_min=1.0).f_calc()) symm = fc.crystal_symmetry() icalc = fc.expand_to_p1().f_as_f_sq().set_observation_type_xray_intensity() # generate 'unmerged' data i_obs = icalc.customized_copy(crystal_symmetry=symm) # now make up sigmas and some (hopefully realistic) error flex.set_random_seed(12345) n_refl = i_obs.size() sigmas = flex.random_double(n_refl) * flex.mean(fc.data()) sigmas = icalc.customized_copy(data=sigmas).apply_debye_waller_factors( u_iso=0.15) err = (flex.double(n_refl, 0.5) - flex.random_double(n_refl)) * 2 i_obs = i_obs.customized_copy( sigmas=sigmas.data(), data=i_obs.data() + err) # check for unmerged acentrics assert i_obs.is_unmerged_intensity_array() i_obs_centric = i_obs.select(i_obs.centric_flags().data()) i_obs_acentric = i_obs.select(~(i_obs.centric_flags().data())) i_mrg_acentric = i_obs_acentric.merge_equivalents().array() i_mixed = i_mrg_acentric.concatenate(i_obs_centric) assert not i_mixed.is_unmerged_intensity_array() # XXX These results of these functions are heavily dependent on the # behavior of the random number generator, which is not consistent across # platforms - therefore we can only check for very approximate values. # Exact numerical results are tested with real data (stored elsewhere). # CC1/2, etc. assert approx_equal(i_obs.cc_one_half(), 0.9998, eps=0.001) assert i_obs.resolution_filter(d_max=1.2).cc_one_half() > 0 assert i_obs.cc_anom() > 0.1 r_ano = i_obs.r_anom() assert approx_equal(r_ano, 0.080756, eps=0.0001) # merging stats i_mrg = i_obs.merge_equivalents() assert i_mrg.r_merge() < 0.1 assert i_mrg.r_meas() < 0.1 assert i_mrg.r_pim() < 0.05
def exercise_lbfgs(test_case, use_geo, out, d_min=2): sites_cart, geo_manager = cctbx.geometry_restraints.manager.\ construct_non_crystallographic_conserving_bonds_and_angles( sites_cart=flex.vec3_double(test_case.sites), edge_list_bonds=test_case.bonds, edge_list_angles=test_case.angles()) scatterers = flex.xray_scatterer(sites_cart.size(), xray.scatterer(scattering_type="C", b=20)) for sc, lbl in zip(scatterers, test_case.labels): sc.label = lbl structure = xray.structure(crystal_symmetry=geo_manager.crystal_symmetry, scatterers=scatterers) structure.set_sites_cart(sites_cart=sites_cart) f_calc = structure.structure_factors(d_min=d_min, anomalous_flag=False).f_calc() fft_map = f_calc.fft_map() fft_map.apply_sigma_scaling() if (use_geo): axis = matrix.col(flex.random_double_point_on_sphere()) rot = scitbx.math.r3_rotation_axis_and_angle_as_matrix(axis=axis, angle=25, deg=True) trans = matrix.col(flex.random_double_point_on_sphere()) * 1.0 structure.apply_rigid_body_shift(rot=rot, trans=trans) geo_manager.energies_sites(sites_cart=structure.sites_cart()).show( f=out) minimized = real_space_refinement_simple.lbfgs( sites_cart=structure.sites_cart(), density_map=fft_map.real_map(), geometry_restraints_manager=geo_manager, gradients_method="fd", real_space_target_weight=1, real_space_gradients_delta=d_min / 3) geo_manager.energies_sites(sites_cart=minimized.sites_cart).show(f=out) else: minimized = real_space_refinement_simple.lbfgs( sites_cart=structure.sites_cart(), density_map=fft_map.real_map(), unit_cell=structure.unit_cell(), gradients_method="fd", real_space_gradients_delta=d_min / 3) rmsd_start = sites_cart.rms_difference(structure.sites_cart()) rmsd_final = sites_cart.rms_difference(minimized.sites_cart) print("RMSD start, final:", rmsd_start, rmsd_final, file=out) if (use_geo): assert rmsd_start >= 1 - 1e-6 assert rmsd_final < 0.2 def show_f_g(label, f, g): print(label, "f, |g|:", f, flex.mean_sq(g)**0.5, file=out) show_f_g(label="start", f=minimized.f_start, g=minimized.g_start) show_f_g(label="final", f=minimized.f_final, g=minimized.g_final) assert minimized.f_final <= minimized.f_start return minimized
def exercise_u_iso_proportional_to_pivot_u_iso(): # Test working constraint xs = xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=(), space_group_symbol='hall: P 2x 2y'), scatterers=flex.xray_scatterer(( xray.scatterer('C0', u=0.12), xray.scatterer('C1'), ))) r = constraints.ext.reparametrisation(xs.unit_cell()) sc = xs.scatterers() u_iso = r.add(constraints.independent_u_iso_parameter, sc[0]) u_iso_1 = r.add(constraints.u_iso_proportional_to_pivot_u_iso, pivot_u_iso=u_iso, multiplier=2, scatterer=sc[1]) r.finalise() r.linearise() assert approx_equal(u_iso_1.value, 0.24, eps=1e-15) # Test conflicting constraints xs = xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=(), space_group_symbol='hall: P 2x 2y'), scatterers=flex.xray_scatterer(( xray.scatterer('C0', u=0.12), xray.scatterer('C1', u=0.21), xray.scatterer('C2') ))) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") r = constraints.reparametrisation( structure=xs, constraints=[constraints.adp.shared_u((0, 2)), constraints.adp.shared_u((1, 2))], connectivity_table=smtbx.utils.connectivity_table(xs)) assert len(w) == 1 assert w[-1].category == constraints.ConflictingConstraintWarning assert w[-1].message.conflicts == set(((2, 'U'),))
def demo(): """ Result of ICSD query: N * -Cr2O3-[R3-CH] Baster, M.;Bouree, F.;Kowalska, A.;Latacz, Z(2000) C 4.961950 4.961950 13.597400 90.000000 90.000000 120.000000 S GRUP R -3 C A Cr1 0.000000 0.000000 0.347570 0.000000 A O1 0.305830 0.000000 0.250000 """ crystal_symmetry = crystal.symmetry( unit_cell="4.961950 4.961950 13.597400 90.000000 90.000000 120.000000", space_group_symbol="R -3 C") scatterers = flex.xray_scatterer() scatterers.append(xray.scatterer( label="Cr1", site=(0.000000,0.000000,0.347570))) scatterers.append(xray.scatterer( label="O1", site=(0.305830,0.000000,0.250000))) icsd_structure = xray.structure( crystal_symmetry=crystal_symmetry, scatterers=scatterers) icsd_structure.show_summary().show_scatterers() print icsd_pairs = icsd_structure.show_distances( distance_cutoff=2.5, keep_pair_asu_table=True) print primitive_structure = icsd_structure.primitive_setting() primitive_structure.show_summary().show_scatterers() print p1_structure = primitive_structure.expand_to_p1() p1_structure.show_summary().show_scatterers() print p1_pairs = p1_structure.show_distances( distance_cutoff=2.5, keep_pair_asu_table=True) print for label,structure,pairs in [("ICSD", icsd_structure,icsd_pairs), ("P1", p1_structure,p1_pairs)]: print "Coordination sequences for", label, "structure" term_table = crystal.coordination_sequences.simple( pair_asu_table=pairs.pair_asu_table, max_shell=10) crystal.coordination_sequences.show_terms( structure=structure, term_table=term_table) print icsd_f_calc = icsd_structure.structure_factors( d_min=1, algorithm="direct").f_calc() icsd_f_calc_in_p1 = icsd_f_calc.primitive_setting().expand_to_p1() p1_f_calc = icsd_f_calc_in_p1.structure_factors_from_scatterers( xray_structure=p1_structure, algorithm="direct").f_calc() for h,i,p in zip(icsd_f_calc_in_p1.indices(), icsd_f_calc_in_p1.data(), p1_f_calc.data()): print h, abs(i), abs(p)*3 print "OK"
def __init__( self, xray_structure, solvent_radius, shrink_truncation_radius, ignore_hydrogen_atoms=False, crystal_gridding=None, grid_step=None, d_min=None, resolution_factor=1 / 4, atom_radii_table=None, use_space_group_symmetry=False, ): self.xray_structure = xray_structure if crystal_gridding is None: self.crystal_gridding = maptbx.crystal_gridding( unit_cell=xray_structure.unit_cell(), space_group_info=xray_structure.space_group_info(), step=grid_step, d_min=d_min, resolution_factor=resolution_factor, symmetry_flags=sgtbx.search_symmetry_flags(use_space_group_symmetry=use_space_group_symmetry), ) else: self.crystal_gridding = crystal_gridding if use_space_group_symmetry: atom_radii = cctbx.masks.vdw_radii(xray_structure, table=atom_radii_table).atom_radii asu_mappings = xray_structure.asu_mappings(buffer_thickness=flex.max(atom_radii) + solvent_radius) scatterers_asu_plus_buffer = flex.xray_scatterer() frac = xray_structure.unit_cell().fractionalize for sc, mappings in zip(xray_structure.scatterers(), asu_mappings.mappings()): for mapping in mappings: scatterers_asu_plus_buffer.append(sc.customized_copy(site=frac(mapping.mapped_site()))) xs = xray.structure(crystal_symmetry=xray_structure, scatterers=scatterers_asu_plus_buffer) else: xs = xray_structure.expand_to_p1() self.vdw_radii = cctbx.masks.vdw_radii(xs, table=atom_radii_table) self.mask = cctbx.masks.around_atoms( unit_cell=xs.unit_cell(), space_group_order_z=xs.space_group().order_z(), sites_frac=xs.sites_frac(), atom_radii=self.vdw_radii.atom_radii, gridding_n_real=self.crystal_gridding.n_real(), solvent_radius=solvent_radius, shrink_truncation_radius=shrink_truncation_radius, ) if use_space_group_symmetry: tags = self.crystal_gridding.tags() tags.tags().apply_symmetry_to_mask(self.mask.data) self.flood_fill = cctbx.masks.flood_fill(self.mask.data, xray_structure.unit_cell()) self.exclude_void_flags = [False] * self.flood_fill.n_voids() self.solvent_accessible_volume = ( self.n_solvent_grid_points() / self.mask.data.size() * xray_structure.unit_cell().volume() )
def exercise_covariance(): xs = xray.structure( crystal_symmetry=crystal.symmetry( (5.01,5.01,5.47,90,90,120), "P6222"), scatterers=flex.xray_scatterer([ xray.scatterer("Si", (1/2.,1/2.,1/3.)), xray.scatterer("O", (0.197,-0.197,0.83333))])) uc = xs.unit_cell() flags = xs.scatterer_flags() for f in flags: f.set_grad_site(True) xs.set_scatterer_flags(flags) cov = flex.double((1e-8,1e-9,2e-9,3e-9,4e-9,5e-9, 2e-8,1e-9,2e-9,3e-9,4e-9, 3e-8,1e-9,2e-9,3e-9, 2e-8,1e-9,2e-9, 3e-8,1e-9, 4e-8)) param_map = xs.parameter_map() assert approx_equal(cov, covariance.extract_covariance_matrix_for_sites(flex.size_t([0,1]), cov, param_map)) cov_cart = covariance.orthogonalize_covariance_matrix(cov, uc, param_map) O = matrix.sqr(uc.orthogonalization_matrix()) for i in range(param_map.n_scatterers): cov_i = covariance.extract_covariance_matrix_for_sites(flex.size_t([i]), cov, param_map) cov_i_cart = covariance.extract_covariance_matrix_for_sites(flex.size_t([i]), cov_cart, param_map) assert approx_equal( O * matrix.sym(sym_mat3=cov_i) * O.transpose(), matrix.sym(sym_mat3=cov_i_cart).as_mat3()) for f in flags: f.set_grads(False) flags[0].set_grad_u_aniso(True) flags[0].set_use_u_aniso(True) flags[1].set_grad_u_iso(True) flags[1].set_use_u_iso(True) xs.set_scatterer_flags(flags) param_map = xs.parameter_map() cov = flex.double(7*7, 0) cov.reshape(flex.grid(7,7)) cov.matrix_diagonal_set_in_place(flex.double([i for i in range(7)])) cov = cov.matrix_symmetric_as_packed_u() assert approx_equal([i for i in range(6)], covariance.extract_covariance_matrix_for_u_aniso( 0, cov, param_map).matrix_packed_u_diagonal()) assert covariance.variance_for_u_iso(1, cov, param_map) == 6 try: covariance.variance_for_u_iso(0, cov, param_map) except RuntimeError: pass else: raise Exception_expected try: covariance.extract_covariance_matrix_for_u_aniso(1, cov, param_map) except RuntimeError: pass else: raise Exception_expected approx_equal(covariance.extract_covariance_matrix_for_sites( flex.size_t([1]), cov, param_map), (0,0,0,0,0,0))
def exercise_u_iso_proportional_to_pivot_u_iso(): # Test working constraint xs = xray.structure(crystal_symmetry=crystal.symmetry( unit_cell=(), space_group_symbol='hall: P 2x 2y'), scatterers=flex.xray_scatterer(( xray.scatterer('C0', u=0.12), xray.scatterer('C1'), ))) r = constraints.ext.reparametrisation(xs.unit_cell()) sc = xs.scatterers() u_iso = r.add(constraints.independent_u_iso_parameter, sc[0]) u_iso_1 = r.add(constraints.u_iso_proportional_to_pivot_u_iso, pivot_u_iso=u_iso, multiplier=2, scatterer=sc[1]) r.finalise() r.linearise() assert approx_equal(u_iso_1.value, 0.24, eps=1e-15) # Test conflicting constraints xs = xray.structure( crystal_symmetry=crystal.symmetry(unit_cell=(), space_group_symbol='hall: P 2x 2y'), scatterers=flex.xray_scatterer( (xray.scatterer('C0', u=0.12), xray.scatterer('C1', u=0.21), xray.scatterer('C2')))) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") r = constraints.reparametrisation( structure=xs, constraints=[ constraints.adp.shared_u((0, 2)), constraints.adp.shared_u((1, 2)) ], connectivity_table=smtbx.utils.connectivity_table(xs)) assert len(w) == 1 assert w[-1].category == constraints.ConflictingConstraintWarning assert w[-1].message.conflicts == set(((2, 'U'), ))
def exercise_extract_u_cart_plus_u_iso(): from cctbx import uctbx, sgtbx, xray uc = uctbx.unit_cell((1,1,1)) sg = sgtbx.space_group_info("P 1") a = flex.xray_scatterer() assert a.size() == 0 s1 = xray.scatterer(label = "C", u = 0.1) s2 = xray.scatterer(label = "C", u = 0.1) s2.flags.set_use_u_iso(False) s3 = xray.scatterer(label = "C", u = (1,1,1,1,1,1)) s4 = xray.scatterer(label = "C", u = (1,1,1,1,1,1)) s4.flags.set_use_u_aniso(False) s5 = xray.scatterer(label = "C", u = 0.1) s5.u_star=(1,1,1,1,1,1) s5.flags.set_use_u_aniso(True) s6 = xray.scatterer(label = "C", u = 0.1) s6.u_star=(1,1,1,1,1,1) s7 = xray.scatterer(label = "C", u = (1,1,1,1,1,1)) s7.u_iso=0.1 s8 = xray.scatterer(label = "C", u = (1,1,1,1,1,1)) s8.u_iso=0.1 s8.flags.set_use_u_iso(True) s9 = xray.scatterer(label = "C") s10 = xray.scatterer(label = "C") s10.flags.set_use_u_iso(False) a = flex.xray_scatterer((s1,s2,s3,s4,s5,s6,s7,s8,s9,s10)) u_cart_total = a.extract_u_cart_plus_u_iso(uc) assert approx_equal(u_cart_total, [(0.1,0.1,0.1,0,0,0), (0,0,0,0,0,0), (1,1,1,1,1,1), (0,0,0,0,0,0), (1.1,1.1,1.1,1,1,1), (0.1,0.1,0.1,0,0,0), (1,1,1,1,1,1), (1.1,1.1,1.1,1,1,1), (0,0,0,0,0,0), (0,0,0,0,0,0)])
def exercise_lbfgs(test_case, use_geo, out, d_min=2): sites_cart, geo_manager = cctbx.geometry_restraints.manager.construct_non_crystallographic_conserving_bonds_and_angles( sites_cart=flex.vec3_double(test_case.sites), edge_list_bonds=test_case.bonds, edge_list_angles=test_case.angles()) scatterers = flex.xray_scatterer( sites_cart.size(), xray.scatterer(scattering_type="C", b=20)) for sc,lbl in zip(scatterers, test_case.labels): sc.label = lbl structure = xray.structure( crystal_symmetry=geo_manager.crystal_symmetry, scatterers=scatterers) structure.set_sites_cart(sites_cart=sites_cart) f_calc = structure.structure_factors( d_min=d_min, anomalous_flag=False).f_calc() fft_map = f_calc.fft_map() fft_map.apply_sigma_scaling() if (use_geo): axis = matrix.col(flex.random_double_point_on_sphere()) rot = scitbx.math.r3_rotation_axis_and_angle_as_matrix( axis=axis, angle=25, deg=True) trans = matrix.col(flex.random_double_point_on_sphere()) * 1.0 structure.apply_rigid_body_shift(rot=rot, trans=trans) geo_manager.energies_sites(sites_cart=structure.sites_cart()).show(f=out) minimized = real_space_refinement_simple.lbfgs( sites_cart=structure.sites_cart(), density_map=fft_map.real_map(), geometry_restraints_manager=geo_manager, real_space_target_weight=1, real_space_gradients_delta=d_min/3) geo_manager.energies_sites(sites_cart=minimized.sites_cart).show(f=out) else: minimized = real_space_refinement_simple.lbfgs( sites_cart=structure.sites_cart(), density_map=fft_map.real_map(), unit_cell=structure.unit_cell(), real_space_gradients_delta=d_min/3) rmsd_start = sites_cart.rms_difference(structure.sites_cart()) rmsd_final = sites_cart.rms_difference(minimized.sites_cart) print >> out, "RMSD start, final:", rmsd_start, rmsd_final if (use_geo): assert rmsd_start >= 1-1e-6 assert rmsd_final < 0.2 def show_f_g(label, f, g): print >> out, label, "f, |g|:", f, flex.mean_sq(g)**0.5 show_f_g(label="start", f=minimized.f_start, g=minimized.g_start) show_f_g(label="final", f=minimized.f_final, g=minimized.g_final) assert minimized.f_final <= minimized.f_start return minimized
def limit_to_range(self, **kwargs): """Returns a copy of object with its scatterers falling into coordina te ranges specified by **kwargs. For example kwargs could be: x = (0,0.5), z = (0, 0.8)""" map_kwargs = {'x':0, 'y':1, 'z':2} init_scatterers = flex.xray_scatterer() for scatterer in self._scatterers: check_list =[[scatterer.site[map_kwargs[key]], kwargs[key]] for key in kwargs] cond = all([ all([item[0] >= item[1][0], item[0] <= item[1][1]]) for item in check_list]) if cond: init_scatterers.append(scatterer) return Fragment(init_scatterers)
def scatterers(O, u_iso=0): assert O.types is not None from cctbx import xray from cctbx.array_family import flex result = flex.xray_scatterer() sites = iter(O.sites) for type,count in zip(O.types, O.type_counts): for _ in range(count): result.append(xray.scatterer( label="%s%d"%(type, len(result)+1), scattering_type=type, site=next(sites), u=u_iso)) assert len(result) == len(O.sites) return result
def scatterers(O, u_iso=0): assert O.types is not None from cctbx import xray from cctbx.array_family import flex result = flex.xray_scatterer() sites = iter(O.sites) for type,count in zip(O.types, O.type_counts): for _ in xrange(count): result.append(xray.scatterer( label="%s%d"%(type, len(result)+1), scattering_type=type, site=sites.next(), u=u_iso)) assert len(result) == len(O.sites) return result
def exercise_unmerged(): quartz_structure = xray.structure( special_position_settings=crystal.special_position_settings( crystal_symmetry=crystal.symmetry(unit_cell=(5.01, 5.01, 5.47, 90, 90, 120), space_group_symbol="P6222")), scatterers=flex.xray_scatterer([ xray.scatterer(label="Si", site=(1 / 2., 1 / 2., 1 / 3.), u=0.2), xray.scatterer(label="O", site=(0.197, -0.197, 0.83333), u=0.1) ])) quartz_structure.set_inelastic_form_factors(photon=1.54, table="sasaki") fc = abs(quartz_structure.structure_factors(d_min=1.0).f_calc()) symm = fc.crystal_symmetry() icalc = fc.expand_to_p1().f_as_f_sq().set_observation_type_xray_intensity() # generate 'unmerged' data i_obs = icalc.customized_copy(crystal_symmetry=symm) # now make up sigmas and some (hopefully realistic) error flex.set_random_seed(12345) n_refl = i_obs.size() sigmas = flex.random_double(n_refl) * flex.mean(fc.data()) sigmas = icalc.customized_copy(data=sigmas).apply_debye_waller_factors( u_iso=0.15) err = (flex.double(n_refl, 0.5) - flex.random_double(n_refl)) * 2 i_obs = i_obs.customized_copy(sigmas=sigmas.data(), data=i_obs.data() + err) # check for unmerged acentrics assert i_obs.is_unmerged_intensity_array() i_obs_centric = i_obs.select(i_obs.centric_flags().data()) i_obs_acentric = i_obs.select(~(i_obs.centric_flags().data())) i_mrg_acentric = i_obs_acentric.merge_equivalents().array() i_mixed = i_mrg_acentric.concatenate(i_obs_centric) assert not i_mixed.is_unmerged_intensity_array() # XXX These results of these functions are heavily dependent on the # behavior of the random number generator, which is not consistent across # platforms - therefore we can only check for very approximate values. # Exact numerical results are tested with real data (stored elsewhere). # CC1/2, etc. assert approx_equal(i_obs.cc_one_half(), 0.9999, eps=0.001) assert approx_equal(i_obs.cc_one_half_sigma_tau(), 0.9999, eps=0.001) assert i_obs.resolution_filter(d_max=1.2).cc_one_half() > 0 assert i_obs.cc_anom() > 0.1 r_ano = i_obs.r_anom() assert approx_equal(r_ano, 0.080756, eps=0.0001) # merging stats i_mrg = i_obs.merge_equivalents() assert i_mrg.r_merge() < 0.1 assert i_mrg.r_meas() < 0.1 assert i_mrg.r_pim() < 0.05
def __init__(self, space_group = SpaceGroup('P 1'), lattice = Lattice(1.0, 1.0, 1.0, 90.0, 90.0, 90.0), sites=[]): """ Crystal object. Functions as a wrapper to a cctbx xray.structure object, but adds additional variables and functionality. Core object of this package. Input: SpaceGroup space_group space group for the current crystal List of Site objects sites List of Site objects. Warning: 'crystal_structure' must be given, or 'space_group', 'lattice', and 'sites' must be given, or creation of the crystal will fail. """ try: crystal_symmetry = crystal.symmetry(unit_cell=str(lattice), space_group_symbol=space_group.cctbx_name) except Exception as e: raise SymmetryError("SpaceGroup {s} is incompatible with Lattice -> {l} cctbx error {e}".format(l=str(lattice), s=SpaceGroup.cctbx_name, e=e)) scatterers = flex.xray_scatterer() for i, site in enumerate(sites): # the element name can be pulled from scatterer via the s.element_symbol() method (if it's an element!!!) # example: 'atom-b-12',or 'vacancy-c-3' # we need to set the scattering_type so we can freely use the label to store metadata #scattering_type = something #scatterers.append(xray.scatterer(label=atom.name, site=tuple(atom.abc), occupancy=atom.occupancy), scattering_type=atom.name) #Method #2 # explicitly add metadata to _meta st_temp, dash, num = site.label.partition("-") if dash == "-": k = site.label else: k = "-".join([site.label, str(i)]) # problems here not sure what's up k = str(k) # print "label = ", k, ' type of label = ', type(k) # print "site = ", tuple(site.abc) # print "occupancy = ", site.occupancy scatterers.append(xray.scatterer(label=k, site=tuple(site.abc), occupancy=site.occupancy)) # Test for coherency of Lattice and SpaceGroup self.crystal_structure = xray.structure(crystal_symmetry=crystal_symmetry, scatterers=scatterers)
def to_xray_structure(atoms, symmetry): """ A utility function to convert atoms into cctbx.xray.structure """ from cctbx import xray from cctbx.array_family import flex cell = symmetry.unit_cell() return xray.structure(crystal_symmetry=symmetry, scatterers=flex.xray_scatterer([ xray.scatterer( label=a.pdb_label_columns(), site=cell.fractionalize(a.xyz), ) for a in atoms ]))
def _initialize_from_XYZ(self, **kwargs): coordinates_list = read_XYZ(self.fname, **kwargs) self.scatterers = flex.xray_scatterer() for line in coordinates_list: line_list = line.strip().split() self.scatterers.append( xray.scatterer( label = line_list[1], scattering_type = line_list[0], site = ( float(line_list[2]), float(line_list[3]), float(line_list[4]), ), **kwargs ))
def get_cctbx_structure(self,cctbx_atoms=None,cctbx_symm=None): if cctbx_atoms is None: cctbx_atoms = [] for site_label in self.structure.site().keys(): cctbx_atoms.append(cctbx.xray.scatterer(label=str(site_label), site=(self.structure.site()[site_label]['coordinates']), u=self.structure.site()[site_label]['u_isotropic'], occupancy=self.structure.site()[site_label]['occupancy'], scattering_type=str(self.structure.site()[site_label]['atom_type']))) if cctbx_symm is None: cctbx_symm = cctbx.crystal.symmetry(unit_cell=self.lattice.parameters(), space_group_symbol=self.structure.space_group()) settings = cctbx.crystal.special_position_settings(crystal_symmetry=cctbx_symm) cctbx_struct = cctbx.xray.structure(special_position_settings=settings, scatterers = flex.xray_scatterer(cctbx_atoms)) return cctbx_struct
def exercise_cc_peak(): def get_map(): av = [random.random() for i in xrange(10*20*30)] m = flex.double(av) m = m-flex.min(m) m = m/flex.max(m) m.resize(flex.grid((10,20,30))) return m m1 = get_map() m2 = get_map() for t in range(0,11): t=t/10. ccp=maptbx.cc_peak(map_1=m1, map_2=m2, cutoff=t) # sites_frac = flex.vec3_double([ (0.50,0.50,0.50)]) from cctbx import xray xray_structure = xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=(5,5,5,90,90,90), space_group_symbol="P1"), scatterers=flex.xray_scatterer([ xray.scatterer(label=str(i), scattering_type="C", site=site_frac) for i,site_frac in enumerate(sites_frac)])) fc1 = xray_structure.structure_factors(d_min=1.6).f_calc() fc2 = xray_structure.structure_factors(d_min=1.7).f_calc() for t in range(0,11): t=t/10. ccp=maptbx.cc_peak(map_coeffs_1=fc1, map_coeffs_2=fc2, cutoff=t) # m1_he = maptbx.volume_scale(map = m1, n_bins = 10000).map_data() m2_he = maptbx.volume_scale(map = m2, n_bins = 10000).map_data() cutoffs = flex.double([i/20. for i in range(1,20)]) df = maptbx.discrepancy_function(map_1=m1_he, map_2=m2_he, cutoffs=cutoffs) # fc1 = xray_structure.structure_factors(d_min=2.2).f_calc() fc2 = xray_structure.structure_factors(d_min=2.2).f_calc() for t in range(0,10): t=t/10. ccp=maptbx.cc_peak(map_coeffs_1=fc1, map_coeffs_2=fc2, cutoff=t) assert approx_equal(ccp, 1) # 1D case m1_he_1d = maptbx.volume_scale_1d(map = m1.as_1d(), n_bins = 10000).map_data() m2_he_1d = maptbx.volume_scale_1d(map = m2.as_1d(), n_bins = 10000).map_data() df_1d = maptbx.discrepancy_function( map_1=m1_he_1d, map_2=m2_he_1d, cutoffs=cutoffs) assert approx_equal(df, df_1d)
def quartz_p1(metrical_matrix=None): if metrical_matrix is not None: unit_cell = uctbx.unit_cell(metrical_matrix=metrical_matrix) else: unit_cell = uctbx.unit_cell(parameters=(5.01,5.01,5.47,90,90,120)) return xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=unit_cell, space_group_symbol='hall: P 1'), scatterers=flex.xray_scatterer(( xray.scatterer( #0 label='Si', site=(0.500000, 0.500000, 0.333333), u=0.000000), xray.scatterer( #1 label='Si', site=(0.000000, 0.500000, 0.666667), u=0.000000), xray.scatterer( #2 label='Si', site=(0.500000, 0.000000, 0.000000), u=0.000000), xray.scatterer( #3 label='O', site=(0.197000, 0.803000, 0.833333), u=0.000000), xray.scatterer( #4 label='O', site=(0.394000, 0.197000, 0.166667), u=0.000000), xray.scatterer( #5 label='O', site=(0.803000, 0.606000, 0.500000), u=0.000000), xray.scatterer( #6 label='O', site=(0.197000, 0.394000, 0.500000), u=0.000000), xray.scatterer( #7 label='O', site=(0.606000, 0.803000, 0.166667), u=0.000000), xray.scatterer( #8 label='O', site=(0.803000, 0.197000, 0.833333), u=0.000000) )))
def exercise(args): verbose = "--verbose" in args if (not verbose): out = StringIO() else: out = sys.stdout crystal_symmetry = crystal.symmetry( unit_cell=(8,9,10,83,97,113), space_group_symbol="P1") miller_set = miller.set( crystal_symmetry=crystal_symmetry, indices=flex.miller_index([(1,2,3), (2,3,4), (-1,3,-2)]), anomalous_flag=False) for n_scatterers in xrange(2,2+5): for i_trial in xrange(5): scatterers = flex.xray_scatterer() for i in xrange(n_scatterers): scatterers.append(xray.scatterer( site=[random.random() for i in xrange(3)], u=random.random()*0.1, occupancy=random.random(), scattering_type="const", fp=(random.random()-0.5)*2, fdp=(random.random()-0.5)*2)) xray_structure = xray.structure( crystal_symmetry=crystal_symmetry, scatterers=scatterers) sf = structure_factors( xray_structure=xray_structure, miller_set=miller_set) f_calc = miller_set.structure_factors_from_scatterers( xray_structure=xray_structure, algorithm="direct", cos_sin_table=False).f_calc() assert approx_equal(sf.fs(), f_calc.data()) f_obs = miller_set.array(data=flex.abs(sf.fs())) compare_analytical_and_finite( f_obs=f_obs, xray_structure=xray_structure, out=out) compare_analytical_and_finite( f_obs=f_obs.customized_copy( data=f_obs.data()*(flex.random_double(size=f_obs.size())+0.5)), xray_structure=xray_structure, out=out) print "OK"
def run(): quartz_structure = xray.structure( special_position_settings=crystal.special_position_settings( crystal_symmetry=crystal.symmetry( unit_cell=(5.01,5.01,5.47,90,90,120), space_group_symbol="P6222")), scatterers=flex.xray_scatterer([ xray.scatterer( label="Si", site=(1/2.,1/2.,1/3.), u=0.2), xray.scatterer( label="O", site=(0.197,-0.197,0.83333), u=0)])) quartz_structure.show_summary().show_scatterers() from libtbx import easy_pickle easy_pickle.dump("beach", quartz_structure) from libtbx import easy_pickle quartz_structure = easy_pickle.load("beach") for scatterer in quartz_structure.scatterers(): print "%s:" % scatterer.label, "%8.4f %8.4f %8.4f" % scatterer.site site_symmetry = quartz_structure.site_symmetry(scatterer.site) print " point group type:", site_symmetry.point_group_type() print " special position operator:", site_symmetry.special_op_simplified() for table in ["xray", "electron"]: print "Scattering type table:", table reg = quartz_structure.scattering_type_registry(table=table) reg.show_summary() f_calc = quartz_structure.structure_factors(d_min=2).f_calc() f_calc.show_summary().show_array() f_calc.d_spacings().show_array() low_resolution_only = f_calc.select(f_calc.d_spacings().data() > 2.5) low_resolution_only.show_array() print
def exercise_with_fixed_structure(): structure = xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=(46.7058, 46.7058, 79.3998, 90, 90, 120), space_group_symbol="P 31"), scatterers=flex.xray_scatterer( [xray.scatterer(scattering_type="const", site=site) for site in [ (0.0169, 0.8953, 0.1115), (0.9395, 0.1282, 0.1780), (0.2998, 0.3497, 0.0593), (0.8220, 0.8814, 0.1601), (0.6478, 0.4879, 0.3141)]])) sfweight = exercise_SFweight_spline_core( structure=structure, d_min=5, verbose="--Verbose" in sys.argv[1:]) assert approx_equal(flex.mean(flex.abs(sfweight.fb())), 1.7545459) assert approx_equal(flex.mean(flex.abs(sfweight.fd())), 1.8437204) assert approx_equal(flex.mean(sfweight.centroid_phases()), -0.033979132) assert approx_equal(flex.mean(sfweight.figures_of_merit()), 0.018943642)
def exercise_u_iso_proportional_to_pivot_u_eq(): xs = xray.structure( crystal_symmetry=crystal.symmetry( unit_cell=(), space_group_symbol='hall: P 2x 2y'), scatterers=flex.xray_scatterer(( xray.scatterer('C0', u=(1, 1, 1, 0, 0, 0)), xray.scatterer('C1'), xray.scatterer('C2', site=(0.1, 0.2, 0.3), u=(1, 2, 3, 0, 0, 0)), xray.scatterer('C3'), ))) r = constraints.ext.reparametrisation(xs.unit_cell()) sc = xs.scatterers() sc[0].flags.set_grad_u_aniso(True) sc[2].flags.set_grad_u_aniso(True) u_0 = r.add(constraints.special_position_u_star_parameter, site_symmetry=xs.site_symmetry_table().get(0), scatterer=sc[0]) u_iso_1 = r.add(constraints.u_iso_proportional_to_pivot_u_eq, pivot_u=u_0, multiplier=3, scatterer=sc[1]) u_2 = r.add(constraints.independent_u_star_parameter, sc[2]) u_iso_3 = r.add(constraints.u_iso_proportional_to_pivot_u_eq, pivot_u=u_2, multiplier=2, scatterer=sc[3]) r.finalise() m = 3 + 6 n = m + 6 + 1 + 1 r.linearise() assert approx_equal(u_iso_1.value, 3, eps=1e-15) assert approx_equal(u_iso_3.value, 4, eps=1e-15) jt0 = sparse.matrix(m, n) for i in xrange(m): jt0[i, i] = 1 p, q = u_0.argument(0).index, u_0.index jt0[p, q] = jt0[p+1, q+1] = jt0[p+2, q+2] = 1 q = u_iso_1.index jt0[p, q] = jt0[p+1, q] = jt0[p+2, q] = 1 p, q = u_2.index, u_iso_3.index jt0[p, q] = jt0[p+1, q] = jt0[p+2, q] = 2/3 assert sparse.approx_equal(tolerance=1e-15)(r.jacobian_transpose, jt0)
def loop(self): for i_position in xrange(self.wyckoff_table.size()): site_symmetry_i = self.wyckoff_table.random_site_symmetry( special_position_settings=self.special_position_settings, i_position=i_position) equiv_sites_i = sgtbx.sym_equiv_sites(site_symmetry_i) for j_position in xrange(self.wyckoff_table.size()): for n_trial in xrange(self.max_trials_per_position): site_j = self.wyckoff_table.random_site_symmetry( special_position_settings=self.special_position_settings, i_position=j_position).exact_site() dist_info = sgtbx.min_sym_equiv_distance_info(equiv_sites_i, site_j) if (dist_info.dist() > self.min_cross_distance): structure = xray.structure( special_position_settings=self.special_position_settings, scatterers=flex.xray_scatterer( [xray.scatterer(scattering_type=self.scattering_type, site=site) for site in [site_symmetry_i.exact_site(), site_j]])) yield structure, dist_info.dist() break
def run(): print __doc__ crystal_symmetry = crystal.symmetry( unit_cell=(5, 5, 6, 90, 90, 120), space_group_symbol="P 31") distance_cutoff = 2.5 scatterers = flex.xray_scatterer() for i,site in enumerate([(0.7624, 0.5887, 0.3937), (0.2813, 0.9896, 0.9449), (0.4853, 0.8980, 0.4707)]): scatterers.append(xray.scatterer( label="Se%d"%(i+1), site=site)) given_structure = xray.structure( crystal_symmetry=crystal_symmetry, scatterers=scatterers) print "==================" print "Original structure" print "==================" given_structure.show_summary().show_scatterers() print "Interatomic distances:" given_structure.show_distances(distance_cutoff=distance_cutoff) print print print "=====================================================" print "Other hand with sites flipped and space group changed" print "=====================================================" other_hand = given_structure.change_hand() other_hand.show_summary().show_scatterers() print "Interatomic distances:" other_hand.show_distances(distance_cutoff=distance_cutoff) print print "==================================" print "Other hand with sites flipped only" print "==================================" other_sites_orig_symmetry = xray.structure( crystal_symmetry=crystal_symmetry, scatterers=other_hand.scatterers()) other_sites_orig_symmetry.show_summary().show_scatterers() print "Interatomic distances:" other_sites_orig_symmetry.show_distances(distance_cutoff=distance_cutoff) print