def exercise_trigonometric_ff(): from math import cos, sin, pi sgi = sgtbx.space_group_info("P1") cs = sgi.any_compatible_crystal_symmetry(volume=1000) miller_set = miller.build_set(cs, anomalous_flag=False, d_min=1) miller_set = miller_set.select(flex.random_double(miller_set.size()) < 0.2) for i in range(5): sites = flex.random_double(9) x1, x2, x3 = (matrix.col(sites[:3]), matrix.col(sites[3:6]), matrix.col(sites[6:])) xs = xray.structure(crystal.special_position_settings(cs)) for x in (x1, x2, x3): sc = xray.scatterer(site=x, scattering_type="const") sc.flags.set_grad_site(True) xs.add_scatterer(sc) f_sq = structure_factors.f_calc_modulus_squared(xs) for h in miller_set.indices(): h = matrix.col(h) phi1, phi2, phi3 = 2 * pi * h.dot(x1), 2 * pi * h.dot( x2), 2 * pi * h.dot(x3) fc_mod_sq = 3 + 2 * (cos(phi1 - phi2) + cos(phi2 - phi3) + cos(phi3 - phi1)) g = [] g.extend(-2 * (sin(phi1 - phi2) - sin(phi3 - phi1)) * 2 * pi * h) g.extend(-2 * (sin(phi2 - phi3) - sin(phi1 - phi2)) * 2 * pi * h) g.extend(-2 * (sin(phi3 - phi1) - sin(phi2 - phi3)) * 2 * pi * h) grad_fc_mod_sq = g f_sq.linearise(h) assert approx_equal(f_sq.observable, fc_mod_sq) assert approx_equal(f_sq.grad_observable, grad_fc_mod_sq)
def peak_search(self, parameters, map, verify_symmetry=True): if (parameters is None): parameters = peak_search_parameters() if (verify_symmetry and libtbx.env.full_testing): assert self._tags.verify(map) if (map.accessor().is_padded()): map = copy(map, flex.grid(map.focus())) grid_peaks = peak_list( data=map, tags=self._tags.tag_array(), peak_search_level=parameters.peak_search_level(), max_peaks=parameters.max_peaks(), peak_cutoff=parameters.peak_cutoff(), interpolate=parameters.interpolate()) if (parameters.min_distance_sym_equiv() is None): return grid_peaks return peak_cluster_analysis( peak_list=grid_peaks, special_position_settings=crystal.special_position_settings( crystal_symmetry=self.crystal_symmetry(), min_distance_sym_equiv=parameters.min_distance_sym_equiv()), general_positions_only=parameters.general_positions_only(), effective_resolution=parameters.effective_resolution(), significant_height_fraction=parameters.significant_height_fraction(), cluster_height_fraction=parameters.cluster_height_fraction(), min_cross_distance=parameters.min_cross_distance(), max_clusters=parameters.max_clusters(), min_cubicle_edge=parameters.min_cubicle_edge())
def __init__(self, model_id="SBT", n_elements=4): if (model_id is None): return self.model_id = model_id pos = emma.position if (type(model_id) == type("")): if (model_id == "SBT"): emma.model.__init__( self, crystal.special_position_settings( crystal.symmetry((16.8986, 16.8986, 16.8986, 61.1483, 61.1483, 61.1483), "R -3 m :R")), (pos("SI1", (-0.3584, 0.2844, 0.4622)), pos("SI2", (-0.2133, 0.9659, -0.6653)), pos("SI3", (-0.8358, 0.7, 0.3431)), pos("SI4", (0.4799, 1.836, 0.6598)))) else: raise RuntimeError("Unknown model_id: " + model_id) else: structure = random_structure.xray_structure(model_id, elements=["S"] * n_elements, volume_per_atom=50., min_distance=2.0) positions = [] for scatterer in structure.scatterers(): positions.append(emma.position(scatterer.label, scatterer.site)) emma.model.__init__(self, structure, positions)
def get_next(self): if (self.coordinate_format == "generic"): if (self.i_next_model): return None crystal_symmetry = crystal.symmetry( unit_cell=self.get_unit_cell(), space_group_info=self.get_space_group_info()) m = emma.model(crystal.special_position_settings(crystal_symmetry), self.positions) m.label = "Model 2" self.i_next_model += 1 return m if (self.coordinate_format == "pdb"): if (self.i_next_model): return None self.i_next_model += 1 return self.pdb_model if (self.coordinate_format == "sdb"): if (self.i_next_model >= len(self.sdb_files)): return None sdb = self.sdb_files[self.i_next_model] crystal_symmetry = crystal.symmetry( unit_cell=self.get_unit_cell(sdb.unit_cell), space_group_info=self.get_space_group_info( sdb.space_group_info)) if (self.other_symmetry is not None): crystal_symmetry = crystal_symmetry.join_symmetry( other_symmetry=self.other_symmetry, force=False) m = sdb_file_to_emma_model(crystal_symmetry, sdb) self.i_next_model += 1 return m raise RuntimeError("Internal error.")
def exercise_trigonometric_ff(): from math import cos, sin, pi sgi = sgtbx.space_group_info("P1") cs = sgi.any_compatible_crystal_symmetry(volume=1000) miller_set = miller.build_set(cs, anomalous_flag=False, d_min=1) miller_set = miller_set.select(flex.random_double(miller_set.size()) < 0.2) for i in xrange(5): sites = flex.random_double(9) x1, x2, x3 = (matrix.col(sites[:3]), matrix.col(sites[3:6]), matrix.col(sites[6:])) xs = xray.structure(crystal.special_position_settings(cs)) for x in (x1, x2, x3): sc = xray.scatterer(site=x, scattering_type="const") sc.flags.set_grad_site(True) xs.add_scatterer(sc) f_sq = structure_factors.f_calc_modulus_squared(xs) for h in miller_set.indices(): h = matrix.col(h) phi1, phi2, phi3 = 2 * pi * h.dot(x1), 2 * pi * h.dot(x2), 2 * pi * h.dot(x3) fc_mod_sq = 3 + 2 * (cos(phi1 - phi2) + cos(phi2 - phi3) + cos(phi3 - phi1)) g = [] g.extend(-2 * (sin(phi1 - phi2) - sin(phi3 - phi1)) * 2 * pi * h) g.extend(-2 * (sin(phi2 - phi3) - sin(phi1 - phi2)) * 2 * pi * h) g.extend(-2 * (sin(phi3 - phi1) - sin(phi2 - phi3)) * 2 * pi * h) grad_fc_mod_sq = g f_sq.linearise(h) assert approx_equal(f_sq.observable, fc_mod_sq) assert approx_equal(f_sq.grad_observable, grad_fc_mod_sq)
def run(): symmetry = crystal.symmetry(unit_cell=(10.67, 10.67, 4.68, 90, 90, 120), space_group_symbol="P 3") special_position_settings = crystal.special_position_settings( crystal_symmetry=symmetry, min_distance_sym_equiv=0.5) site = (0, 0, 0.236) u_cif = ((0.17, 0.17, 0.19, 0.09, 0, 0)) site_symmetry = special_position_settings.site_symmetry(site) print "Input Ucif:", u_cif u_star = adptbx.u_cif_as_u_star(symmetry.unit_cell(), u_cif) if (not site_symmetry.is_compatible_u_star(u_star)): print "Warning: ADP tensor is incompatible with site symmetry." u_star = site_symmetry.average_u_star(u_star) u_cif = adptbx.u_star_as_u_cif(symmetry.unit_cell(), u_star) print "Averaged Ucif:", u_cif u_cart = adptbx.u_star_as_u_cart(symmetry.unit_cell(), u_star) eigenvalues = adptbx.eigenvalues(u_cart) if (not adptbx.is_positive_definite(eigenvalues)): print "ADP tensor is not positive definite." print "Eigenvectors and values:" eigensystem = adptbx.eigensystem(u_cart) for i in xrange(3): print " v=(%.5f %.5f %.5f) " % eigensystem.vectors(i), print "lambda=%.4f" % (eigensystem.values()[i], )
def special_position_settings_from_inp(inp): return crystal.special_position_settings(crystal.symmetry( unit_cell=uctbx.unit_cell(inp.ucparams), space_group_info=sgtbx.space_group_info(symbol=inp.sgsymbol, table_id=inp.convention)), min_distance_sym_equiv=float( inp.min_distance_sym_equiv))
def peak_search(self, parameters, map, verify_symmetry=True): if (parameters is None): parameters = peak_search_parameters() if (verify_symmetry and libtbx.env.full_testing): assert self._tags.verify(map) if (map.accessor().is_padded()): map = copy(map, flex.grid(map.focus())) grid_peaks = peak_list( data=map, tags=self._tags.tag_array(), peak_search_level=parameters.peak_search_level(), max_peaks=parameters.max_peaks(), peak_cutoff=parameters.peak_cutoff(), interpolate=parameters.interpolate()) if (parameters.min_distance_sym_equiv() is None): return grid_peaks return peak_cluster_analysis( peak_list=grid_peaks, special_position_settings=crystal.special_position_settings( crystal_symmetry=self.crystal_symmetry(), min_distance_sym_equiv=parameters.min_distance_sym_equiv()), general_positions_only=parameters.general_positions_only(), effective_resolution=parameters.effective_resolution(), significant_height_fraction=parameters.significant_height_fraction( ), cluster_height_fraction=parameters.cluster_height_fraction(), min_cross_distance=parameters.min_cross_distance(), max_clusters=parameters.max_clusters(), min_cubicle_edge=parameters.min_cubicle_edge())
def exercise_tensor_constraints_core(crystal_symmetry): from cctbx import crystal from cctbx import adptbx from scitbx import matrix site_symmetry = crystal.special_position_settings( crystal_symmetry).site_symmetry(site=(0,0,0)) unit_cell = crystal_symmetry.unit_cell() group = crystal_symmetry.space_group() assert site_symmetry.n_matrices() == group.order_p() for reciprocal_space in [False, True]: c_tensor_constraints = sgtbx.tensor_rank_2_constraints( space_group=group, reciprocal_space=reciprocal_space).row_echelon_form() p_tensor_constraints = python_tensor_constraints( self=group, reciprocal_space=reciprocal_space) assert c_tensor_constraints.all_eq(p_tensor_constraints) adp_constraints = group.adp_constraints() u_cart_p1 = adptbx.random_u_cart() u_star_p1 = adptbx.u_cart_as_u_star(unit_cell, u_cart_p1) u_star = site_symmetry.average_u_star(u_star_p1) f = unit_cell.volume()**(2/3.) assert approx_equal( list(matrix.col(group.average_u_star(u_star=u_star_p1))*f), list(matrix.col(u_star)*f)) independent_params = adp_constraints.independent_params(u_star) assert adp_constraints.n_independent_params() == len(independent_params) assert adp_constraints.n_independent_params() \ + adp_constraints.n_dependent_params() == 6 u_star_vfy = adp_constraints.all_params(independent_params) u_cart = adptbx.u_star_as_u_cart(unit_cell, u_star) u_cart_vfy = adptbx.u_star_as_u_cart(unit_cell, list(u_star_vfy)) assert approx_equal(u_cart_vfy, u_cart)
def __init__(self, model_id="SBT", n_elements=4): if (model_id is None): return self.model_id = model_id pos = emma.position if (type(model_id) == type("")): if (model_id == "SBT"): emma.model.__init__(self, crystal.special_position_settings(crystal.symmetry( (16.8986, 16.8986, 16.8986, 61.1483, 61.1483, 61.1483), "R -3 m :R")), (pos("SI1", (-0.3584, 0.2844, 0.4622)), pos("SI2", (-0.2133, 0.9659, -0.6653)), pos("SI3", (-0.8358, 0.7, 0.3431)), pos("SI4", (0.4799, 1.836, 0.6598)))) else: raise RuntimeError, "Unknown model_id: " + model_id else: structure = random_structure.xray_structure( model_id, elements=["S"]*n_elements, volume_per_atom=50., min_distance=2.0) positions = [] for scatterer in structure.scatterers(): positions.append(emma.position(scatterer.label, scatterer.site)) emma.model.__init__(self, structure, positions)
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 _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 _process_occupancies(self): def check_if_already_modified(): if(self.top_selection): return if (self._occupancies_modified): raise Sorry("Can't modify occupancies (already modified).") else: self._occupancies_modified = True for occ in self.params.occupancies: if(occ.atom_selection is None): selection = self.top_selection else: asc = self.pdb_hierarchy.atom_selection_cache( special_position_settings=crystal.special_position_settings( crystal_symmetry = self.crystal_symmetry)) sel = asc.selection(occ.atom_selection) selection = flex.smart_selection(flags=sel) if(occ.randomize): self._print_action( text = "Randomizing occupancies", selection = selection) check_if_already_modified() self.xray_structure.shake_occupancies(selection=selection.flags) if(occ.set is not None): self._print_action( text = "Setting occupancies to: %8.3f"%occ.set, selection = selection) check_if_already_modified() self.xray_structure.set_occupancies( value = occ.set, selection = selection.flags)
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 peak_cluster_reduction(crystal_symmetry, peak_list, min_peak_distance, max_reduced_peaks): special_position_settings = crystal.special_position_settings( crystal_symmetry=crystal_symmetry, min_distance_sym_equiv=min_peak_distance) peaks = [] for i,site in enumerate(peak_list.sites()): peaks.append(dicts.easy( site=special_position_settings.site_symmetry(site).exact_site(), height=peak_list.heights()[i])) reduced_peaks = [] for peak in peaks: site_symmetry = special_position_settings.site_symmetry(peak.site) equiv_sites = sgtbx.sym_equiv_sites(site_symmetry) keep = True for reduced_peak in reduced_peaks: dist = sgtbx.min_sym_equiv_distance_info( equiv_sites, reduced_peak.site).dist() if (dist < min_peak_distance): keep = False break if (keep == True): reduced_peaks.append(peak) if (len(reduced_peaks) == max_reduced_peaks): break return reduced_peaks
def exercise_tensor_constraints_core(crystal_symmetry): from cctbx import crystal from cctbx import adptbx from scitbx import matrix site_symmetry = crystal.special_position_settings( crystal_symmetry).site_symmetry(site=(0, 0, 0)) unit_cell = crystal_symmetry.unit_cell() group = crystal_symmetry.space_group() assert site_symmetry.n_matrices() == group.order_p() for reciprocal_space in [False, True]: c_tensor_constraints = sgtbx.tensor_rank_2_constraints( space_group=group, reciprocal_space=reciprocal_space).row_echelon_form() p_tensor_constraints = python_tensor_constraints( self=group, reciprocal_space=reciprocal_space) assert c_tensor_constraints.all_eq(p_tensor_constraints) adp_constraints = group.adp_constraints() u_cart_p1 = adptbx.random_u_cart() u_star_p1 = adptbx.u_cart_as_u_star(unit_cell, u_cart_p1) u_star = site_symmetry.average_u_star(u_star_p1) f = unit_cell.volume()**(2 / 3.) assert approx_equal( list(matrix.col(group.average_u_star(u_star=u_star_p1)) * f), list(matrix.col(u_star) * f)) independent_params = adp_constraints.independent_params(u_star) assert adp_constraints.n_independent_params() == len(independent_params) assert adp_constraints.n_independent_params() \ + adp_constraints.n_dependent_params() == 6 u_star_vfy = adp_constraints.all_params(independent_params) u_cart = adptbx.u_star_as_u_cart(unit_cell, u_star) u_cart_vfy = adptbx.u_star_as_u_cart(unit_cell, list(u_star_vfy)) assert approx_equal(u_cart_vfy, u_cart)
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 get_next(self): if (self.coordinate_format == "generic"): if (self.i_next_model): return None crystal_symmetry = crystal.symmetry( unit_cell=self.get_unit_cell(), space_group_info=self.get_space_group_info()) m = emma.model( crystal.special_position_settings(crystal_symmetry), self.positions) m.label = "Model 2" self.i_next_model += 1 return m if (self.coordinate_format == "pdb"): if (self.i_next_model): return None self.i_next_model += 1 return self.pdb_model if (self.coordinate_format == "sdb"): if (self.i_next_model >= len(self.sdb_files)): return None sdb = self.sdb_files[self.i_next_model] crystal_symmetry = crystal.symmetry( unit_cell=self.get_unit_cell(sdb.unit_cell), space_group_info=self.get_space_group_info(sdb.space_group_info)) if (self.other_symmetry is not None): crystal_symmetry = crystal_symmetry.join_symmetry( other_symmetry=self.other_symmetry, force=False) m = sdb_file_to_emma_model(crystal_symmetry, sdb) self.i_next_model += 1 return m raise RuntimeError("Internal error.")
def _renumber_residues(self): if((self.params.increment_resseq) or (self.params.renumber_residues)): print("Re-numbering residues", file=self.log) renumber_from = self.params.increment_resseq atom_selection = self.params.selection pdb_hierarchy = self.pdb_hierarchy selected_i_seqs = None if (atom_selection is not None): sel_cache = pdb_hierarchy.atom_selection_cache( special_position_settings=crystal.special_position_settings( crystal_symmetry = self.crystal_symmetry)) selected_i_seqs = sel_cache.selection(atom_selection).iselection() for model in pdb_hierarchy.models(): for chain in model.chains(): if (selected_i_seqs is not None): chain_i_seqs = chain.atoms().extract_i_seq() intersection = selected_i_seqs.intersection(chain_i_seqs) if (len(intersection) == 0): continue elif (len(intersection) != len(chain_i_seqs)): print("Warning: chain '%s' is only partially selected (%d out of %d) - will not renumber." % (chain.id, len(intersection), len(chain_i_seqs)), file=self.log) continue if (renumber_from is None): counter = 1 for rg in chain.residue_groups(): rg.resseq=counter counter += 1 else : for rg in chain.residue_groups(): resseq = rg.resseq_as_int() resseq += renumber_from rg.resseq = "%4d" % resseq
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 run(): symmetry = crystal.symmetry( unit_cell=(10.67, 10.67, 4.68, 90, 90, 120), space_group_symbol="P 3") special_position_settings = crystal.special_position_settings( crystal_symmetry=symmetry, min_distance_sym_equiv=0.5) site = (0, 0, 0.236) u_cif = ((0.17, 0.17, 0.19, 0.09, 0, 0)) site_symmetry = special_position_settings.site_symmetry(site) print "Input Ucif:", u_cif u_star = adptbx.u_cif_as_u_star(symmetry.unit_cell(), u_cif) if (not site_symmetry.is_compatible_u_star(u_star)): print "Warning: ADP tensor is incompatible with site symmetry." u_star = site_symmetry.average_u_star(u_star) u_cif = adptbx.u_star_as_u_cif(symmetry.unit_cell(), u_star) print "Averaged Ucif:", u_cif u_cart = adptbx.u_star_as_u_cart(symmetry.unit_cell(), u_star) eigenvalues = adptbx.eigenvalues(u_cart) if (not adptbx.is_positive_definite(eigenvalues)): print "ADP tensor is not positive definite." print "Eigenvectors and values:" eigensystem = adptbx.eigensystem(u_cart) for i in xrange(3): print " v=(%.5f %.5f %.5f) " % eigensystem.vectors(i), print "lambda=%.4f" % (eigensystem.values()[i],)
def run(server_info, inp, status): print "<pre>" # check input to prevent XSS try: unit_cell = uctbx.unit_cell(inp.ucparams) space_group_info = sgtbx.space_group_info(symbol=inp.sgsymbol, table_id=inp.convention) except Exception: print "Please check your inputs." print "</pre>" return io_utils.show_input_symbol(inp.sgsymbol, inp.convention) special_position_settings = crystal.special_position_settings( crystal.symmetry(unit_cell=uctbx.unit_cell(inp.ucparams), space_group_info=sgtbx.space_group_info( symbol=inp.sgsymbol, table_id=inp.convention)), min_distance_sym_equiv=float(inp.min_distance_sym_equiv)) special_position_settings.show_summary() print "Minimum distance between symmetrically equivalent sites:", print special_position_settings.min_distance_sym_equiv() print skip_columns = io_utils.interpret_skip_columns(inp.skip_columns) wyckoff_table = special_position_settings.space_group_info().wyckoff_table( ) unit_cell = special_position_settings.unit_cell() print "</pre><table border=2 cellpadding=2>" status.in_table = True print "<tr>" if (skip_columns): print "<th>" print "<th colspan=3>" + inp.coor_type + " coordinates" print "<th>Multiplicity" print "<th>Wyckoff letter" print "<th>Site symmetry<br>point group type" print "<th>Special position operator" print "</tr>" for line in inp.coordinates: skipped, coordinates = io_utils.interpret_coordinate_line( line, skip_columns) if (inp.coor_type != "Fractional"): coordinates = unit_cell.fractionalize(coordinates) site_symmetry = special_position_settings.site_symmetry(coordinates) exact_site = site_symmetry.exact_site() if (inp.coor_type != "Fractional"): exact_site = unit_cell.orthogonalize(exact_site) wyckoff_mapping = wyckoff_table.mapping(site_symmetry) print "<tr>" if (skip_columns): print "<td>", skipped for x in exact_site: print "<td><tt>%.6g</tt>" % (x, ) print "<td align=center>", wyckoff_mapping.position().multiplicity() print "<td align=center>", wyckoff_mapping.position().letter() print "<td align=center>", site_symmetry.point_group_type() print "<td><tt>" + str(site_symmetry.special_op_simplified()) + "</tt>" print "</tr>" print "</table><pre>" status.in_table = False print "</pre>"
def special_position_settings_from_inp(inp): return crystal.special_position_settings( crystal.symmetry( unit_cell=uctbx.unit_cell(inp.ucparams), space_group_info=sgtbx.space_group_info(symbol=inp.sgsymbol, table_id=inp.convention), ), min_distance_sym_equiv=float(inp.min_distance_sym_equiv), )
def as_xray_structure(self, min_distance_sym_equiv=0.5): result = xray.structure( special_position_settings=crystal.special_position_settings( crystal_symmetry=self.crystal_symmetry(), min_distance_sym_equiv=min_distance_sym_equiv)) for atm in self.atoms: result.add_scatterer(atm.as_xray_scatterer()) return result
def __init__( self, pdb_hierarchy, crystal_symmetry, rotamer_manager, sin_cos_table, mon_lib_srv, map_data_scale=2.5, diff_map_data_threshold=-2.5, rotatable_hd=None, bselection=None, map_data=None, vdw_radii=None, backbone_sample=False, # XXX diff_map_data=None, log=None): adopt_init_args(self, locals()) self.processed = 0 self.total_time_residue_loop = 0 t0 = time.time() self.atoms = self.pdb_hierarchy.atoms() self.cmv = None if (self.map_data is not None): self.cmv = mmtbx.refinement.real_space.common_map_values( pdb_hierarchy=self.pdb_hierarchy, unit_cell=self.crystal_symmetry.unit_cell(), map_data=self.map_data) self.mes = [] if (self.bselection is None): o = mmtbx.refinement.real_space.side_chain_fit_evaluator( pdb_hierarchy=self.pdb_hierarchy, crystal_symmetry=self.crystal_symmetry, rotamer_evaluator=self.rotamer_manager.rotamer_evaluator, map_data=self.map_data, diff_map_data=self.diff_map_data, map_data_scale=self.map_data_scale, diff_map_data_threshold=self.diff_map_data_threshold) self.mes.extend(o.mes) self.bselection = o.sel_all() # or all_possible() ? if (self.log is None): self.log = sys.stdout self.special_position_settings = crystal.special_position_settings( crystal_symmetry=self.crystal_symmetry) # Even better would be to pass it here. Ideally just use model asc = self.pdb_hierarchy.atom_selection_cache() self.selection_water_as_set = \ set(asc.selection(string = "water").iselection()) self.target_map = map_data self.mes.append("outliers start: %d" % self.count_outliers()) # self.loop(function=self.one_residue_iteration) # self.mes.append("outliers final: %d" % self.count_outliers()) # self.mes.append("residues processed: %d" % self.processed) if (self.processed > 0): self.mes.append("average time/residue: %6.4f" % (self.total_time_residue_loop / self.processed)) self.mes.append("time to fit residues: %6.4f" % (time.time() - t0))
def _get_special_position_indices(self): special_position_settings = crystal.special_position_settings( crystal_symmetry = self.crystal_symmetry) site_symmetry_table = \ special_position_settings.site_symmetry_table( sites_cart = self.pdb_hierarchy.atoms().extract_xyz(), unconditional_general_position_flags=( self.pdb_hierarchy.atoms().extract_occ() != 1)) return site_symmetry_table.special_position_indices()
def run(self): # I'm guessing self.data_manager, self.params and self.logger # are already defined here... # this must be mmtbx.model.manager? model = self.data_manager.get_model() atoms = model.get_atoms() all_bsel = flex.bool(atoms.size(), False) for selection_string in self.params.atom_selection_program.inselection: print("Selecting '%s'" % selection_string, file=self.logger) isel = model.iselection(string=selection_string) all_bsel.set_selected(isel, True) if self.params.atom_selection_program.write_pdb_file is None: print(" %d atom%s selected" % plural_s(isel.size()), file=self.logger) for atom in atoms.select(isel): print(" %s" % atom.format_atom_record(), file=self.logger) print("", file=self.logger) if self.params.atom_selection_program.write_pdb_file is not None: print("Writing file:", show_string( self.params.atom_selection_program.write_pdb_file), file=self.logger) ss_ann = model.get_ss_annotation() if not model.crystal_symmetry() or \ (not model.crystal_symmetry().unit_cell()): model = shift_and_box_model(model, shift_model=False) selected_model = model.select(all_bsel) if (ss_ann is not None): selected_model.set_ss_annotation(ss_ann.\ filter_annotation( hierarchy=selected_model.get_hierarchy(), asc=selected_model.get_atom_selection_cache(), remove_short_annotations=False, remove_3_10_helices=False, remove_empty_annotations=True, concatenate_consecutive_helices=False, split_helices_with_prolines=False, filter_sheets_with_long_hbonds=False)) if self.params.atom_selection_program.cryst1_replacement_buffer_layer is not None: box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=selected_model.get_atoms().extract_xyz(), buffer_layer=self.params.atom_selection_program. cryst1_replacement_buffer_layer) sp = crystal.special_position_settings(box.crystal_symmetry()) sites_frac = box.sites_frac() xrs_box = selected_model.get_xray_structure( ).replace_sites_frac(box.sites_frac()) xray_structure_box = xray.structure(sp, xrs_box.scatterers()) selected_model.set_xray_structure(xray_structure_box) pdb_str = selected_model.model_as_pdb() f = open(self.params.atom_selection_program.write_pdb_file, 'w') f.write(pdb_str) f.close() print("", file=self.logger)
def __init__( self, model, # changed in place params=None, log=null_out(), reference_map=None): """ Substitute secondary structure elements in real_h hierarchy with ideal ones _in_place_. Returns reference torsion proxies - the only thing that cannot be restored with little effort outside the procedure. """ self.model = model self.params = params self.ss_annotation = self.model.get_ss_annotation() self.log = log self.reference_map = reference_map self.idealized_counts = None t0 = time() if self.model.get_hierarchy().models_size() > 1: raise Sorry("Multi model files are not supported") for m in self.model.get_hierarchy().models(): for chain in m.chains(): if len(chain.conformers()) > 1: raise Sorry("Alternative conformations are not supported.") self.processed_params = self._process_params(params) if not self.processed_params.enabled: return None if self.ss_annotation is None: return None # ann = ss_annotation if self.model.ncs_constraints_present(): print("Using master NCS to reduce amount of work", file=self.log) expected_n_hbonds = 0 for h in self.ss_annotation.helices: expected_n_hbonds += h.get_n_maximum_hbonds() self.edited_h = self.model.get_hierarchy().deep_copy() # gathering initial special position atoms special_position_settings = crystal.special_position_settings( crystal_symmetry=self.model.crystal_symmetry()) site_symmetry_table = \ special_position_settings.site_symmetry_table( sites_cart = self.model.get_sites_cart(), unconditional_general_position_flags=( self.model.get_atoms().extract_occ() != 1)) self.original_spi = site_symmetry_table.special_position_indices() t1 = time()
def _set_atomic_charge(self): if(self.params.set_charge.charge_selection is not None): print("Setting atomic charge", file=self.log) selection = self.params.set_charge.charge_selection charge = self.params.set_charge.charge sel_cache = self.pdb_hierarchy.atom_selection_cache( special_position_settings=crystal.special_position_settings( crystal_symmetry = self.crystal_symmetry)) isel = sel_cache.selection(selection).iselection() self.pdb_hierarchy.set_atomic_charge(iselection=isel, charge=charge)
def run(args, command_name=libtbx.env.dispatcher_name): parser = argparse.ArgumentParser( prog=command_name, usage='%s pdb_file "atom_selection" [...]' % command_name) parser.add_argument("file_name", nargs=1, help="File name of the model file") parser.add_argument( "inselections", help="Atom selection strings", nargs='+', ) parser.add_argument("--write-pdb-file", action="store", help="write selected atoms to new PDB file", default=None) parser.add_argument( "--cryst1-replacement-buffer-layer", action="store", type=float, help="replace CRYST1 with pseudo unit cell covering the selected" " atoms plus a surrounding buffer layer", default=None) co = parser.parse_args(args) pdb_inp = iotbx.pdb.input(file_name=co.file_name[0]) model = mmtbx.model.manager(model_input=pdb_inp, process_input=True) atoms = model.get_atoms() all_bsel = flex.bool(atoms.size(), False) for selection_string in co.inselections: print selection_string isel = model.iselection(selstr=selection_string) all_bsel.set_selected(isel, True) if (not co.write_pdb_file): print " %d atom%s selected" % plural_s(isel.size()) for atom in atoms.select(isel): print " %s" % atom.format_atom_record() print if (co.write_pdb_file): print "Writing file:", show_string(co.write_pdb_file) selected_model = model.select(all_bsel) if (co.cryst1_replacement_buffer_layer is not None): box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=selected_model.get_atoms().extract_xyz(), buffer_layer=co.cryst1_replacement_buffer_layer) sp = crystal.special_position_settings(box.crystal_symmetry()) sites_frac = box.sites_frac() xrs_box = selected_model.get_xray_structure().replace_sites_frac( box.sites_frac()) xray_structure_box = xray.structure(sp, xrs_box.scatterers()) selected_model.set_xray_structure(xray_structure_box) pdb_str = selected_model.model_as_pdb() f = open(co.write_pdb_file, 'w') f.write(pdb_str) f.close() print
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_special_position_settings(): xs = crystal.symmetry((3, 4, 5), "P 2 2 2") sp = crystal.special_position_settings(xs, 1, 2, False) assert sp.min_distance_sym_equiv() == 1 assert sp.u_star_tolerance() == 2 assert sp.assert_min_distance_sym_equiv() == False assert sp.site_symmetry((0, 0, 0)).multiplicity() == 1 assert sp.site_symmetry(site=(0, 0, 0)).multiplicity() == 1 assert sp.site_symmetry(site_cart=(0, 0, 0)).multiplicity() == 1 assert str(sp.sym_equiv_sites((0, 0, 0)).special_op()) == "0,0,0" sites_cart = flex.vec3_double([(2, 1, 3), (0, 0, 0)]) t = sp.site_symmetry_table(sites_cart=sites_cart) assert list(t.special_position_indices()) == [1] assert approx_equal( t.apply_symmetry_sites(unit_cell=xs.unit_cell(), sites_cart=sites_cart), sites_cart) # for min_distance_sym_equiv, special_op in [(1e-6, "0,0,0"), (0, "x,y,z")]: sp = crystal.special_position_settings( crystal_symmetry=xs, min_distance_sym_equiv=min_distance_sym_equiv) assert str(sp.sym_equiv_sites((0, 0, 0)).special_op()) == special_op # sites_cart = flex.vec3_double([(0, 0, 0)]) sp = xs.special_position_settings() asu_mappings = sp.asu_mappings(buffer_thickness=3, sites_cart=sites_cart) assert list(asu_mappings.site_symmetry_table().special_position_indices()) \ == [0] # pair_generator = sp.pair_generator(distance_cutoff=1, sites_cart=sites_cart) assert pair_generator.count_pairs() == 0 sp0 = xs.special_position_settings(min_distance_sym_equiv=0) pair_generator = sp0.pair_generator(distance_cutoff=1, sites_cart=sites_cart) assert pair_generator.count_pairs() == 3 # pair_asu_table = sp.pair_asu_table(distance_cutoff=1, sites_cart=sites_cart) assert pair_asu_table.table()[0].size() == 0 pair_asu_table = sp0.pair_asu_table(distance_cutoff=1, sites_cart=sites_cart) assert pair_asu_table.table()[0][0].size() == 3
def _apply_keep_remove(self): cn = [self.params.remove, self.params.keep].count(None) if(not cn in [1,2]): raise Sorry("'keep' and 'remove' keywords cannot be used simultaneously.") s1 = self.pdb_hierarchy.atoms_size() if(self.params.remove is not None): asc = self.pdb_hierarchy.atom_selection_cache( special_position_settings=crystal.special_position_settings( crystal_symmetry = self.crystal_symmetry)) sel = ~asc.selection(self.params.remove) self.pdb_hierarchy = self.pdb_hierarchy.select(sel) s2 = self.pdb_hierarchy.atoms_size() print("Size before:", s1, "size after:", s2, file=self.log) if(self.params.keep is not None): asc = self.pdb_hierarchy.atom_selection_cache( special_position_settings=crystal.special_position_settings( crystal_symmetry = self.crystal_symmetry)) sel = asc.selection(self.params.keep) self.pdb_hierarchy = self.pdb_hierarchy.select(sel) s2 = self.pdb_hierarchy.atoms_size() print("Size before:", s1, "size after:", s2, file=self.log)
def __init__(self, xray_structure, params, pdb_hierarchy, log=None): self.log = log self.pdb_hierarchy = pdb_hierarchy self.crystal_symmetry = xray_structure.crystal_symmetry() if (self.log is None): self.log = sys.stdout self.xray_structure = xray_structure self.params = params asc = self.pdb_hierarchy.atom_selection_cache( special_position_settings=crystal.special_position_settings( crystal_symmetry=self.crystal_symmetry)) if (self.params.random_seed is not None): random.seed(self.params.random_seed) flex.set_random_seed(self.params.random_seed) self.top_selection = flex.smart_selection( flags=flex.bool(xray_structure.scatterers().size(), True)) if (self.params.selection is not None): self.top_selection = flex.smart_selection( flags=asc.selection(self.params.selection)) self._rotate_about_axis() self._process_adp() self._process_sites() self._process_occupancies() self._put_in_box() self._change_of_basis() # Up to this point we are done with self.xray_structure self.pdb_hierarchy.adopt_xray_structure(self.xray_structure) # Now only manipulations that use self.pdb_hierarchy are done if (self.params.set_chemical_element_simple_if_necessary or self.params.rename_chain_id.old_id or self.params.renumber_residues or self.params.increment_resseq or self.params.convert_semet_to_met or self.params.convert_met_to_semet or self.params.set_charge.charge or self.params.truncate_to_polyala or self.params.truncate_to_polygly or self.params.remove_alt_confs or self.params.move_waters_last or self.params.remove_fraction or self.params.keep or self.params.remove): del self.xray_structure # it is invalide below this point self._set_chemical_element_simple_if_necessary() self._rename_chain_id() self._renumber_residues() self._convert_semet_to_met() self._convert_met_to_semet() self._set_atomic_charge() self._truncate_to_poly_ala() self._truncate_to_poly_gly() self._remove_alt_confs() self._move_waters() self._remove_atoms() self._apply_keep_remove()
def __init__(self, pdb_hierarchy, crystal_symmetry, rotamer_manager, sin_cos_table, mon_lib_srv, bselection=None, map_data=None, vdw_radii=None, do_all=False, backbone_sample=True, diff_map_data=None, massage_map=True, tune_up_only=False, log=None): adopt_init_args(self, locals()) self.number_of_outliers = None if (self.log is None): self.log = sys.stdout self.sites_cart = self.pdb_hierarchy.atoms().extract_xyz() self.atom_names = flex.std_string( [i.strip() for i in self.pdb_hierarchy.atoms().extract_name()]) self.special_position_settings = None self.special_position_indices = None if (self.crystal_symmetry is not None): self.special_position_settings = crystal.special_position_settings( crystal_symmetry=self.crystal_symmetry) self.special_position_indices = self.get_special_position_indices() # Even better would be to pass it here. Ideally just use model self.atom_selection_cache = self.pdb_hierarchy.atom_selection_cache() self.selection_water_as_set = set(self.atom_selection_cache.\ selection(string = "water").iselection()) if (self.massage_map and self.map_data is not None): self.target_map = self.prepare_target_map() else: self.target_map = map_data print >> self.log, \ "outliers start: %d"%self.count_outliers() # if (not self.tune_up_only): self.loop(function=self.one_residue_iteration) assert approx_equal(self.sites_cart, self.pdb_hierarchy.atoms().extract_xyz()) print >> self.log, \ "outliers after map fit: %d"%self.count_outliers() print >> self.log, "tune up" assert approx_equal(self.sites_cart, self.pdb_hierarchy.atoms().extract_xyz()) self.loop(function=self.one_residue_tune_up) print >> self.log, \ "outliers final: %d"%self.count_outliers() assert approx_equal(self.sites_cart, self.pdb_hierarchy.atoms().extract_xyz())
def assign_wyckoff(self, abc, tol=0.1): #FIXME This needs improvement and to be tested cctbx_name = self.space_group.cctbx_name sg_symbol = sgtbx.space_group_symbols(cctbx_name) sg = sgtbx.space_group(sg_symbol) unit_cell = uctbx.unit_cell(str(self.get_lattice())) symmetry = crystal.symmetry(unit_cell=unit_cell, space_group=sg) special_position_settings = crystal.special_position_settings(symmetry,min_distance_sym_equiv=0.5) site_symmetry = special_position_settings.site_symmetry(abc) wyckoff_table = special_position_settings.space_group_info().wyckoff_table() wyckoff_mapping = wyckoff_table.mapping(site_symmetry) letter = wyckoff_mapping.position().letter() return letter
def expand_to_p1(self): new_model = model( crystal.special_position_settings( crystal.symmetry.cell_equivalent_p1(self))) for pos in self._positions: site_symmetry = self.site_symmetry(pos.site) equiv_sites = sgtbx.sym_equiv_sites(site_symmetry) i = 0 for site in equiv_sites.coordinates(): i += 1 new_model.add_position( position(label=pos.label + "_%03d" % i, site=site)) return new_model
def exercise_special_position_settings(): xs = crystal.symmetry((3,4,5), "P 2 2 2") sp = crystal.special_position_settings(xs, 1, 2, False) assert sp.min_distance_sym_equiv() == 1 assert sp.u_star_tolerance() == 2 assert sp.assert_min_distance_sym_equiv() == False assert sp.site_symmetry((0,0,0)).multiplicity() == 1 assert sp.site_symmetry(site=(0,0,0)).multiplicity() == 1 assert sp.site_symmetry(site_cart=(0,0,0)).multiplicity() == 1 assert str(sp.sym_equiv_sites((0,0,0)).special_op()) == "0,0,0" sites_cart = flex.vec3_double([(2,1,3), (0,0,0)]) t = sp.site_symmetry_table(sites_cart=sites_cart) assert list(t.special_position_indices()) == [1] assert approx_equal( t.apply_symmetry_sites(unit_cell=xs.unit_cell(), sites_cart=sites_cart), sites_cart) # for min_distance_sym_equiv,special_op in [(1e-6, "0,0,0"), (0, "x,y,z")]: sp = crystal.special_position_settings( crystal_symmetry=xs, min_distance_sym_equiv=min_distance_sym_equiv) assert str(sp.sym_equiv_sites((0,0,0)).special_op()) == special_op # sites_cart = flex.vec3_double([(0,0,0)]) sp = xs.special_position_settings() asu_mappings = sp.asu_mappings(buffer_thickness=3, sites_cart=sites_cart) assert list(asu_mappings.site_symmetry_table().special_position_indices()) \ == [0] # pair_generator = sp.pair_generator(distance_cutoff=1, sites_cart=sites_cart) assert pair_generator.count_pairs() == 0 sp0 = xs.special_position_settings(min_distance_sym_equiv=0) pair_generator = sp0.pair_generator(distance_cutoff=1, sites_cart=sites_cart) assert pair_generator.count_pairs() == 3 # pair_asu_table = sp.pair_asu_table(distance_cutoff=1, sites_cart=sites_cart) assert pair_asu_table.table()[0].size() == 0 pair_asu_table = sp0.pair_asu_table(distance_cutoff=1, sites_cart=sites_cart) assert pair_asu_table.table()[0][0].size() == 3
def dummy_structure(space_group_info, volume, n_scatterers): structure = xray.structure( special_position_settings=crystal.special_position_settings( crystal_symmetry=crystal.symmetry( unit_cell=space_group_info.any_compatible_unit_cell(volume=volume), space_group_info=space_group_info))) b_iso = 20 u_iso = adptbx.b_as_u(b_iso) u_star = adptbx.u_iso_as_u_star(structure.unit_cell(), u_iso) scatterer = xray.scatterer(label="C", site=(0.123,0.234,0.345), u=u_star) for i in xrange(n_scatterers): structure.add_scatterer(scatterer) return structure
def as_xray_structure(self, crystal_symmetry=None, force_symmetry=False, min_distance_sym_equiv=0.5): crystal_symmetry = self.crystal_symmetry().join_symmetry( other_symmetry=crystal_symmetry, force=force_symmetry) assert crystal_symmetry.unit_cell() is not None assert crystal_symmetry.space_group_info() is not None structure = xray.structure(crystal.special_position_settings( crystal_symmetry=crystal_symmetry, min_distance_sym_equiv=min_distance_sym_equiv)) for site in self.sites: structure.add_scatterer(site.as_xray_scatterer(structure.unit_cell())) return structure
def run(server_info, inp, status): print "<pre>" io_utils.show_input_symbol(inp.sgsymbol, inp.convention) special_position_settings = crystal.special_position_settings( crystal.symmetry( unit_cell=uctbx.unit_cell(inp.ucparams), space_group_info=sgtbx.space_group_info( symbol=inp.sgsymbol, table_id=inp.convention)), min_distance_sym_equiv=float(inp.min_distance_sym_equiv)) special_position_settings.show_summary() print "Minimum distance between symmetrically equivalent sites:", print special_position_settings.min_distance_sym_equiv() print skip_columns = io_utils.interpret_skip_columns(inp.skip_columns) wyckoff_table=special_position_settings.space_group_info().wyckoff_table() unit_cell = special_position_settings.unit_cell() print "</pre><table border=2 cellpadding=2>" status.in_table = True print "<tr>" if (skip_columns): print "<th>" print "<th colspan=3>" + inp.coor_type + " coordinates" print "<th>Multiplicity" print "<th>Wyckoff letter" print "<th>Site symmetry<br>point group type" print "<th>Special position operator" print "</tr>" for line in inp.coordinates: skipped, coordinates = io_utils.interpret_coordinate_line(line,skip_columns) if (inp.coor_type != "Fractional"): coordinates = unit_cell.fractionalize(coordinates) site_symmetry = special_position_settings.site_symmetry(coordinates) exact_site = site_symmetry.exact_site() if (inp.coor_type != "Fractional"): exact_site = unit_cell.orthogonalize(exact_site) wyckoff_mapping = wyckoff_table.mapping(site_symmetry) print "<tr>" if (skip_columns): print "<td>", skipped for x in exact_site: print "<td><tt>%.6g</tt>" % (x,) print "<td align=center>", wyckoff_mapping.position().multiplicity() print "<td align=center>", wyckoff_mapping.position().letter() print "<td align=center>", site_symmetry.point_group_type() print "<td><tt>" + str(site_symmetry.special_op_simplified()) + "</tt>" print "</tr>" print "</table><pre>" status.in_table = False print "</pre>"
def get_plain_pair_sym_table(crystal_symmetry, sites_frac, plain_pairs_radius=5): asu_mappings = crystal.symmetry.asu_mappings(crystal_symmetry, buffer_thickness = plain_pairs_radius) special_position_settings = crystal.special_position_settings( crystal_symmetry = crystal_symmetry) sites_cart = crystal_symmetry.unit_cell().orthogonalize(sites_frac) site_symmetry_table = special_position_settings.site_symmetry_table( sites_cart = sites_cart) asu_mappings.process_sites_frac( original_sites = sites_frac, site_symmetry_table = site_symmetry_table) pair_asu_table = crystal.pair_asu_table(asu_mappings=asu_mappings) pair_asu_table.add_all_pairs(distance_cutoff = plain_pairs_radius) return pair_asu_table.extract_pair_sym_table()
def expand_to_p1(self): new_model = model( crystal.special_position_settings( crystal.symmetry.cell_equivalent_p1(self))) for pos in self._positions: site_symmetry = self.site_symmetry(pos.site) equiv_sites = sgtbx.sym_equiv_sites(site_symmetry) i = 0 for site in equiv_sites.coordinates(): i += 1 new_model.add_position(position( label=pos.label+"_%03d"%i, site=site)) return new_model
def assign_wyckoff(self, abc, tol=0.1): #FIXME This needs improvement and to be tested cctbx_name = self.space_group.cctbx_name sg_symbol = sgtbx.space_group_symbols(cctbx_name) sg = sgtbx.space_group(sg_symbol) unit_cell = uctbx.unit_cell(str(self.get_lattice())) symmetry = crystal.symmetry(unit_cell=unit_cell, space_group=sg) special_position_settings = crystal.special_position_settings( symmetry, min_distance_sym_equiv=0.5) site_symmetry = special_position_settings.site_symmetry(abc) wyckoff_table = special_position_settings.space_group_info( ).wyckoff_table() wyckoff_mapping = wyckoff_table.mapping(site_symmetry) letter = wyckoff_mapping.position().letter() return letter
def exercise_site_symmetry(space_group_info): special_position_settings = crystal.special_position_settings( crystal_symmetry=space_group_info.any_compatible_crystal_symmetry( volume=1000)) z2p_op = space_group_info.group().z2p_op() special_position_settings_p = crystal.special_position_settings( crystal_symmetry=special_position_settings.change_basis(z2p_op), min_distance_sym_equiv =special_position_settings.min_distance_sym_equiv()*0.99) wyckoff_table = space_group_info.wyckoff_table() for i_position in xrange(wyckoff_table.size()): site_symmetry = wyckoff_table.random_site_symmetry( special_position_settings=special_position_settings, i_position=i_position) s = site_symmetry.special_op() assert s.multiply(s) == s for m in site_symmetry.matrices(): assert m.multiply(s) == s tab = sgtbx.site_symmetry_table() tab.process(site_symmetry) ss_ops = tab.get(0) assert ss_ops.multiplicity() == site_symmetry.multiplicity() assert ss_ops.multiplicity() * ss_ops.n_matrices() \ == site_symmetry.space_group().order_z() site_p = z2p_op.c() * site_symmetry.exact_site() site_symmetry_p = special_position_settings_p.site_symmetry(site_p) ss_ops_p = ss_ops.change_basis(z2p_op) assert ss_ops_p.multiplicity() == site_symmetry_p.multiplicity() assert ss_ops_p.special_op() == site_symmetry_p.special_op() assert ss_ops_p.multiplicity() * ss_ops_p.n_matrices() \ == site_symmetry_p.space_group().order_z() references = [str(m) for m in site_symmetry_p.matrices()] testees = [str(m) for m in ss_ops_p.matrices()] references.sort() testees.sort() assert " ".join(testees) == " ".join(references)
def __init__(self, space_group_info, unit_cell_volume=1000, min_distance_sym_equiv=1, min_cross_distance=1, scattering_type="const", max_trials_per_position=10): adopt_init_args(self, locals()) self.special_position_settings = crystal.special_position_settings( crystal_symmetry=crystal.symmetry( unit_cell=space_group_info.any_compatible_unit_cell( volume=unit_cell_volume), space_group_info=space_group_info), min_distance_sym_equiv=min_distance_sym_equiv) self.wyckoff_table = space_group_info.wyckoff_table()
def __init__(self): sgi = sgtbx.space_group_info("Hall: %s" % self.hall) cs = sgi.any_compatible_crystal_symmetry(volume=1000) xs = xray.structure(crystal.special_position_settings(cs)) for sc in self.scatterers(): sc.flags.set_use_u_iso(False).set_use_u_aniso(False)\ .set_grad_site(True) xs.add_scatterer(sc) self.reference_xs = xs.as_emma_model() self.xray_structure = xs mi = cs.build_miller_set(d_min=0.5, anomalous_flag=False) ma = mi.structure_factors_from_scatterers(xs, algorithm="direct").f_calc() self.fo_sq = ma.norm().customized_copy( sigmas=flex.double(ma.size(), 1.))
def run(): uc = (10,12,14,90,90,90) cs = crystal.symmetry(unit_cell=uc, space_group_symbol="P 1") assert harker.planes_cartesian(cs).count() == 0 assert harker.planes_cartesian(cs).min_distance((0,0,0)) is None cs = crystal.symmetry(unit_cell=uc, space_group_symbol="P 2 2 2") assert harker.planes_cartesian(cs).count() == 3 assert ae(harker.planes_cartesian(cs).min_distance((0.123,0.234,0)), 0) assert ae(harker.planes_cartesian(cs).min_distance((0.123,0,0.234)), 0) assert ae(harker.planes_cartesian(cs).min_distance((0,0.123,0.234)), 0) assert ae(harker.planes_cartesian(cs).min_distance((0.1,0.234,0.345)), 1) assert ae(harker.planes_cartesian(cs).min_distance((0.234,0.1,0.345)), 1.2) assert ae(harker.planes_cartesian(cs).min_distance((0.234,0.345,0.1)), 1.4) assert ae(harker.planes_cartesian(cs).min_distance((0.2,0.2,0.1)), 1.4) assert ae(harker.planes_cartesian(cs).min_distance((0.2,0.1,0.1)), 1.2) assert ae(harker.planes_cartesian(cs).min_distance((0.1,0.2,0.2)), 1) assert ae(harker.planes_cartesian(cs).min_distance((-0.2,0.1,0.1)), 1.2) assert ae(harker.planes_cartesian(cs).min_distance((0.2,-0.1,0.1)), 1.2) assert ae(harker.planes_cartesian(cs).min_distance((0.2,0.1,-0.1)), 1.2) assert ae(harker.planes_cartesian(cs).min_distance((-0.2,-0.1,-0.1)), 1.2) uc = (10,10,12,90,90,120) cs = crystal.symmetry(unit_cell=uc, space_group_symbol="P 3") assert harker.planes_cartesian(cs).count() == 1 assert ae(harker.planes_cartesian(cs).min_distance((0,0,0)), 0) assert ae(harker.planes_cartesian(cs).min_distance((0.1,0.2,1/3.)), 4) assert ae(harker.planes_cartesian(cs).min_distance((0.1,0.2,1/2.)), 6) cs = crystal.symmetry(unit_cell=uc, space_group_symbol="P 31") assert harker.planes_cartesian(cs).count() == 1 assert ae(harker.planes_cartesian(cs).min_distance((0,0,0)), 4) assert ae(harker.planes_cartesian(cs).min_distance((0.1,0.2,1/3.)), 0) assert ae(harker.planes_cartesian(cs).min_distance((0.1,0.2,1/2.)), 2) uc = (10,10,12,90,90,90) cs = crystal.symmetry(unit_cell=uc, space_group_symbol="P 4 2 2") assert harker.planes_cartesian(cs).count() == 5 cs = crystal.symmetry(unit_cell=uc, space_group_symbol="P 41 2 2") assert harker.planes_cartesian(cs).count() == 6 ps = crystal.symmetry(unit_cell=uc, space_group_symbol="P 4/m m m") for x,d,t in (((0.1,0.2,0.3),0.6,"1"), ((0.1,0.2,0.75),0,"1"), ((0.1,0.0,0.3),0,"m")): ss = crystal.special_position_settings(ps).site_symmetry(x) assert ss.point_group_type() == t eq = sgtbx.sym_equiv_sites(ss) for x in eq.coordinates(): assert ae(harker.planes_cartesian(cs).min_distance(x), d) 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 make_special_position_settings(cell, space_group, min_dist_sym_equiv=0.000001): """Takes cell and space group, returns cctbx structure input: cell: (a b c alpha beta gamma) as a tuple space_group: 'space_group' like a string min_dist_sym_equiv: float output: <cctbx.crystal.special_position_settings object> contains cell, space group and special positions """ assert type(cell) == tuple, 'cell must be supplied as a tuple' assert len(cell) == 6, 'expected 6 cell parameters' special_position_settings = crystal.special_position_settings( crystal_symmetry=crystal.symmetry( unit_cell=cell, space_group_symbol=space_group), min_distance_sym_equiv=min_dist_sym_equiv) return special_position_settings
def __init__(self): sgi = sgtbx.space_group_info("Hall: %s" % self.hall) cs = sgi.any_compatible_crystal_symmetry(volume=1000) xs = xray.structure(crystal.special_position_settings(cs)) for i, sc in enumerate(self.scatterers()): sc.flags.set_use_u_iso(False).set_use_u_aniso(True)\ .set_grad_u_aniso(True) xs.add_scatterer(sc) site_symm = xs.site_symmetry_table().get(i) u_cart = adptbx.random_u_cart(u_scale=self.random_u_cart_scale) u_star = adptbx.u_cart_as_u_star(cs.unit_cell(), u_cart) xs.scatterers()[-1].u_star = site_symm.average_u_star(u_star) self.xray_structure = xs mi = cs.build_miller_set(d_min=0.5, anomalous_flag=False) ma = mi.structure_factors_from_scatterers(xs, algorithm="direct").f_calc() self.fo_sq = ma.norm().customized_copy( sigmas=flex.double(ma.size(), 1.))
def __init__(self, pdb_hierarchy, map_data, crystal_symmetry, rotamer_manager, sin_cos_table, mon_lib_srv, do_all=False, backbone_sample=True, diff_map_data=None, massage_map=True, tune_up_only=False, log = None): adopt_init_args(self, locals()) self.number_of_outliers = None if(self.log is None): self.log = sys.stdout self.sites_cart = self.pdb_hierarchy.atoms().extract_xyz() self.special_position_settings = crystal.special_position_settings( crystal_symmetry = self.crystal_symmetry) self.special_position_indices = self.get_special_position_indices() self.selection_water_as_set = set(self.pdb_hierarchy.\ atom_selection_cache().selection(string = "water").iselection()) if(self.massage_map): self.target_map = self.prepare_target_map() else: self.target_map = map_data print >> self.log, \ "outliers start: %d (percent: %6.2f)"%self.count_outliers() # if(not self.tune_up_only): self.loop(function = self.one_residue_iteration) self.pdb_hierarchy.atoms().set_xyz(self.sites_cart) print >> self.log, \ "outliers after map fit: %d (percent: %6.2f)"%self.count_outliers() print >> self.log, "tune up" self.loop(function = self.one_residue_tune_up) print >> self.log, \ "outliers final: %d (percent: %6.2f)"%self.count_outliers()
def __init__(self, symmetry = None, fragments = None, gen_unique_labels = False, min_distance_sym_equiv = 0.0001): """Initialization of the Model's instance with symmetry (should be an istance of cctbx.crystal.symmetry) and list of fragments. Each fragment should be an istance of Fragment. min_distance_sym_equiv - if atoms are located close to the special position(within the given value) some of their coordinates will be rounded. Give this parameter some small value if you want to avoid this.""" self._fragments = fragments self._symmetry = symmetry self._scatterers = flex.xray_scatterer() self._special_position_settings = crystal.special_position_settings( self._symmetry, min_distance_sym_equiv) if fragments: for fragment in fragments: for scatterer in fragment._scatterers: self._scatterers.append(scatterer) if gen_unique_labels == True: self.gen_unique_labels() self._iucr_structure = None
def exercise(): from iotbx import file_reader from cctbx.array_family import flex from cctbx import crystal from cctbx import xray from libtbx import easy_run file_base = "tmp_iotbx_simple_map_coefficients" 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.0, 1 / 2.0, 1 / 3.0), u=0.2, fp=0.255, # from Sasaki table @ 1.54 Angstrom fdp=0.325, ), xray.scatterer(label="O", site=(0.197, -0.197, 0.83333), u=0), ] ), ) fc = quartz_structure.structure_factors(d_min=1.0).f_calc() I = fc.amplitudes().f_as_f_sq() PHI = fc.average_bijvoet_mates().phases(deg=True).set_observation_type(None) FOM = PHI.customized_copy(data=flex.double(PHI.data().size(), 1.0)).set_observation_type(None) mtz = I.as_mtz_dataset(column_root_label="I") mtz.add_miller_array(PHI, column_root_label="PHI", column_types="P") mtz.add_miller_array(FOM, column_root_label="FOM", column_types="W") mtz_file = file_base + ".mtz" mtz.mtz_object().write(mtz_file) map_file = "%s_map.mtz" % file_base # Fo map args = [mtz_file, "output_file=%s" % map_file] cmd = "iotbx.simple_map_coefficients" result = easy_run.fully_buffered("%s %s" % (cmd, " ".join(args))).raise_if_errors() assert "Applying weights in FOM" in result.stdout_lines map_in = file_reader.any_file(map_file).assert_file_type("hkl") map_coeffs = map_in.file_server.miller_arrays[0] real_map = map_coeffs.fft_map().apply_sigma_scaling().real_map_unpadded() site = quartz_structure.sites_frac()[0] assert real_map.eight_point_interpolation(site) > 3 # anomalous map args.append("map_type=anom") result = easy_run.fully_buffered("%s %s" % (cmd, " ".join(args))).raise_if_errors() assert not "Applying weights in FOM" in result.stdout_lines map_in = file_reader.any_file(map_file).assert_file_type("hkl") map_coeffs = map_in.file_server.miller_arrays[0] real_map = map_coeffs.fft_map().apply_sigma_scaling().real_map_unpadded() assert real_map.eight_point_interpolation(site) > 3 # no FOM mtz = I.as_mtz_dataset(column_root_label="I") mtz.add_miller_array(PHI, column_root_label="PHI", column_types="P") mtz.mtz_object().write(mtz_file) args = [mtz_file, "output_file=%s" % map_file] result = easy_run.fully_buffered("%s %s" % (cmd, " ".join(args))).raise_if_errors() assert not "Applying weights in FOM" in result.stdout_lines map_in = file_reader.any_file(map_file).assert_file_type("hkl") map_coeffs = map_in.file_server.miller_arrays[0] real_map = map_coeffs.fft_map().apply_sigma_scaling().real_map_unpadded() site = quartz_structure.sites_frac()[0] assert real_map.eight_point_interpolation(site) > 3 # now check for error when use_weights=True args.append("use_weights=True") result = easy_run.fully_buffered("%s %s" % (cmd, " ".join(args))) assert result.return_code == 1 print "OK"
def test_molecule(space_group_info, use_primitive_setting, flag_f_part, d_min=3., grid_resolution_factor=0.48, max_prime=5, verbose=0): if (use_primitive_setting): space_group_info = space_group_info.primitive_setting() elements = ("N", "C", "C", "O", "N", "C", "C", "O") structure = random_structure.xray_structure( space_group_info, elements=elements, volume_per_atom=50, min_distance=1., general_positions_only=True, random_u_iso=True, random_occupancy=True) if (0 or verbose): structure.show_summary().show_scatterers() miller_set_f_obs = miller.build_set( crystal_symmetry=structure, anomalous_flag=(random.random() < 0.5), d_min=d_min) f_obs = abs(miller_set_f_obs.structure_factors_from_scatterers( xray_structure=structure, algorithm="direct").f_calc()) if (0 or verbose): f_obs.show_summary() if (0 or verbose): f_obs.show_array() miller_set_p1 = miller.set.expand_to_p1(f_obs) special_position_settings_p1 = crystal.special_position_settings( crystal_symmetry=miller_set_p1) structure_p1 = xray.structure( special_position_settings=special_position_settings_p1) structure_fixed = xray.structure(special_position_settings=structure) for scatterer in structure.scatterers(): if (flag_f_part and structure_fixed.scatterers().size() < structure.scatterers().size()//2): structure_fixed.add_scatterer(scatterer) else: structure_p1.add_scatterer(scatterer) if (0 or verbose): if (flag_f_part): structure_fixed.show_summary().show_scatterers() structure_p1.show_summary().show_scatterers() f_calc_fixed = None if (flag_f_part): f_calc_fixed = f_obs.structure_factors_from_scatterers( xray_structure=structure_fixed, algorithm="direct").f_calc() f_calc_p1 = miller_set_p1.structure_factors_from_scatterers( xray_structure=structure_p1, algorithm="direct").f_calc() symmetry_flags = translation_search.symmetry_flags( is_isotropic_search_model=False, have_f_part=flag_f_part) gridding = miller_set_f_obs.crystal_gridding( symmetry_flags=symmetry_flags, resolution_factor=grid_resolution_factor, max_prime=max_prime).n_real() grid_tags = maptbx.grid_tags(gridding) run_fast_terms( structure_fixed, structure_p1, f_obs, f_calc_fixed, f_calc_p1, symmetry_flags, gridding, grid_tags, test_origin=True, verbose=verbose) peak_list = run_fast_nv1995( f_obs, f_calc_fixed, f_calc_p1, symmetry_flags, gridding, grid_tags, verbose) assert peak_list.heights()[0] > 0.99
def test_atom(space_group_info, use_primitive_setting, n_elements=3, d_min=3., grid_resolution_factor=0.48, max_prime=5, verbose=0): if (use_primitive_setting): space_group_info = space_group_info.primitive_setting() structure = random_structure.xray_structure( space_group_info, n_scatterers=n_elements, volume_per_atom=150, min_distance=1., general_positions_only=True) miller_set_f_obs = miller.build_set( crystal_symmetry=structure, anomalous_flag=(random.random() < 0.5), d_min=d_min) symmetry_flags = translation_search.symmetry_flags( is_isotropic_search_model=True, have_f_part=(n_elements>=2)) gridding = miller_set_f_obs.crystal_gridding( symmetry_flags=symmetry_flags, resolution_factor=grid_resolution_factor, max_prime=max_prime).n_real() structure.build_scatterers( elements=["Se"]*n_elements, grid=gridding) if (0 or verbose): structure.show_summary().show_scatterers() f_obs = abs(miller_set_f_obs.structure_factors_from_scatterers( xray_structure=structure, algorithm="direct").f_calc()) if (0 or verbose): f_obs.show_summary() if (0 or verbose): f_obs.show_array() miller_set_p1 = miller.set.expand_to_p1(f_obs) special_position_settings_p1 = crystal.special_position_settings( crystal_symmetry=miller_set_p1) structure_fixed = xray.structure(special_position_settings=structure) for scatterer in structure.scatterers(): structure_p1 = xray.structure( special_position_settings=special_position_settings_p1) scatterer_at_origin = scatterer.customized_copy(site=(0,0,0)) structure_p1.add_scatterer(scatterer_at_origin) if (0 or verbose): structure_p1.show_summary().show_scatterers() f_calc_p1 = miller_set_p1.structure_factors_from_scatterers( xray_structure=structure_p1, algorithm="direct").f_calc() if (0 or verbose): f_calc_p1.show_array() f_calc_fixed = None if (structure_fixed.scatterers().size() > 0): f_calc_fixed = f_obs.structure_factors_from_scatterers( xray_structure=structure_fixed, algorithm="direct").f_calc() symmetry_flags = translation_search.symmetry_flags( is_isotropic_search_model=True, have_f_part=(f_calc_fixed is not None)) if (structure_fixed.scatterers().size() <= 1): gridding = miller_set_f_obs.crystal_gridding( symmetry_flags=symmetry_flags, resolution_factor=grid_resolution_factor, max_prime=max_prime).n_real() grid_tags = maptbx.grid_tags(gridding) run_fast_terms( structure_fixed, structure_p1, f_obs, f_calc_fixed, f_calc_p1, symmetry_flags, gridding, grid_tags, verbose=verbose) peak_list = run_fast_nv1995( f_obs, f_calc_fixed, f_calc_p1, symmetry_flags, gridding, grid_tags, verbose) structure_fixed.add_scatterer(scatterer) if (0 or verbose): structure_fixed.show_summary().show_scatterers() if (structure_fixed.scatterers().size() < n_elements): assert peak_list.heights()[0] < 1 else: assert peak_list.heights()[0] > 0.99 assert peak_list.heights()[0] > 0.99