def space_group(self,space_group=None,format='symbol'): # format can be 'number', 'symbol' (Hermann-Mauguin) # As a setter method, no need to specify the format; always converts to symbol to store in self._space_group # and presumes standard setting if number is given # As a getter method, 'symbol' is the default if space_group is not None: sgs = space_group_symbols(space_group) self._space_group = sgs.universal_hermann_mauguin() # self._space_group = sgs.universal_hall() needs reading with sgs = space_group_symbols(self._space_group,table_id = "Hall") else: sgs = space_group_symbols(self._space_group) if format=='number': return sgs.number() elif format=='symbol': return sgs.universal_hermann_mauguin()
def map_sites_to_asu(spacegroup, pdb_in, pdb_out, invert=False): '''Map sites to asu of input spacegroup (as sites from shelxd claim P1 in CRYST1 record) inverting if necessary. N.B. if inverting sites also need to invert spacegroup.''' from cctbx.crystal import symmetry, direct_space_asu from iotbx.pdb import hierarchy from scitbx.array_family import flex sg = space_group(space_group_symbols(spacegroup).hall()) coords = hierarchy.input(file_name=pdb_in) cs = coords.input.crystal_symmetry() uc = cs.unit_cell() cs2 = symmetry(unit_cell=uc, space_group=sg) xs = coords.xray_structure_simple().customized_copy(crystal_symmetry=cs2) if invert: xs = xs.change_hand() am = xs.crystal_symmetry().asu_mappings(0.0) xyz = xs.sites_cart() am.process_sites_cart(xyz) xyz = flex.vec3_double() for m in am.mappings(): xyz.append(m[0].mapped_site()) xs.set_sites_cart(xyz) open(pdb_out, 'w').write(xs.as_pdb_file()) return
def generate_enantiomorph_unique_spacegroups(pointgroup): '''Generate an enantiomorph unique list of chiral spacegroups which share a pointgroup with this pointgroup.''' sg = space_group(space_group_symbols(pointgroup).hall()) pg = sg.build_derived_patterson_group() eu_list = [] for j in space_group_symbol_iterator(): sg_test = space_group(j) if not sg_test.is_chiral(): continue pg_test = sg_test.build_derived_patterson_group() if pg_test == pg: enantiomorph = sg_test.change_basis( sg_test.type().change_of_hand_op()) if not sg_test in eu_list and not \ enantiomorph in eu_list: eu_list.append(sg_test) return [ sg_test.type().lookup_symbol().replace(' ', '') \ for sg_test in eu_list]
def ref_gen_static(experiments): """Generate some reflections using the static predictor""" beam = experiments[0].beam crystal = experiments[0].crystal goniometer = experiments[0].goniometer detector = experiments[0].detector scan = experiments[0].scan # All indices to the detector max resolution dmin = detector.get_max_resolution(beam.get_s0()) index_generator = IndexGenerator(crystal.get_unit_cell(), space_group(space_group_symbols(1).hall()).type(), dmin) indices = index_generator.to_array() # Predict rays within the sweep range sweep_range = scan.get_oscillation_range(deg=False) ray_predictor = ScansRayPredictor(experiments, sweep_range) refs = ray_predictor(indices) # Take only those rays that intersect the detector intersects = ray_intersection(detector, refs) refs = refs.select(intersects) # Make a reflection predictor and re-predict for these reflections. The # result is the same, but we gain also the flags and xyzcal.px columns ref_predictor = ExperimentsPredictor(experiments) refs['id'] = flex.int(len(refs), 0) refs = ref_predictor(refs) return refs
def __init__(self, sg_nr): """Initialize with SG number""" self._nr = sg_nr self._sg_hall = sgtbx.space_group_symbols(sg_nr).hall() super(SpaceGroup, self).__init__(self._sg_hall) self._order = self.order_z() self._symops = []
def modify_ins_text(_ins_text, _spacegroup, _nsites, _rlimit): '''Update the text in a SHELXD .ins file to handle the correct number of sites and spacegroup symmetry operations.''' new_text = [] symm = [ op.as_xyz().upper() for op in space_group(space_group_symbols(_spacegroup).hall()).smx() ] for record in _ins_text: if 'SYMM' in record: if not symm: continue for op in symm: if op == 'X,Y,Z': continue new_text.append(('SYMM %s' % op)) symm = None elif 'FIND' in record: new_text.append(('FIND %d' % _nsites)) elif 'SHEL' in record: new_text.append(('SHEL 999 %.1f' % _rlimit)) else: new_text.append(record.strip()) return new_text
def to_crystal(filename): ''' Get the crystal model from the xparm file Params: filename The xparm/or integrate filename Return: The crystal model ''' from rstbx.cftbx.coordinate_frame_converter import \ coordinate_frame_converter from dxtbx.model.crystal import crystal_model from cctbx.sgtbx import space_group, space_group_symbols # Get the real space coordinate frame cfc = coordinate_frame_converter(filename) real_space_a = cfc.get('real_space_a') real_space_b = cfc.get('real_space_b') real_space_c = cfc.get('real_space_c') sg = cfc.get('space_group_number') space_group = space_group(space_group_symbols(sg).hall()) mosaicity = cfc.get('mosaicity') # Return the crystal model return crystal_model( real_space_a=real_space_a, real_space_b=real_space_b, real_space_c=real_space_c, space_group=space_group, mosaicity=mosaicity)
def to_crystal(filename): ''' Get the crystal model from the xparm file Params: filename The xparm/or integrate filename Return: The crystal model ''' from rstbx.cftbx.coordinate_frame_converter import \ coordinate_frame_converter from dxtbx.model.crystal import crystal_model from cctbx.sgtbx import space_group, space_group_symbols # Get the real space coordinate frame cfc = coordinate_frame_converter(filename) real_space_a = cfc.get('real_space_a') real_space_b = cfc.get('real_space_b') real_space_c = cfc.get('real_space_c') sg = cfc.get('space_group_number') space_group = space_group(space_group_symbols(sg).hall()) mosaicity = cfc.get('mosaicity') # Return the crystal model return crystal_model(real_space_a=real_space_a, real_space_b=real_space_b, real_space_c=real_space_c, space_group=space_group, mosaicity=mosaicity)
def run(server_info, inp, status): print "<pre>" symbols_inp = None lookup_symbol = inp.sgsymbol if (lookup_symbol == ""): lookup_symbol = "P 1" if (inp.convention == "Hall"): hall_symbol = lookup_symbol else: symbols_inp = sgtbx.space_group_symbols(lookup_symbol, inp.convention) hall_symbol = symbols_inp.hall() if (symbols_inp.number() == 0): symbols_inp = None inp.convention = "Hall" else: print "Result of symbol lookup:" show_symbols(symbols_inp) print try: ps = sgtbx.parse_string(hall_symbol) sg = sgtbx.space_group(ps) except RuntimeError, e: print "-->" + ps.string() + "<--" print("-" * (ps.where() + 3)) + "^" raise
def generate_reflections(self): # Build a mock scan for a 3 degree sweep from dxtbx.model import ScanFactory sf = ScanFactory() self.scan = sf.make_scan(image_range=(1, 1), exposure_times=0.1, oscillation=(0, 3.0), epochs=range(1), deg=True) sweep_range = self.scan.get_oscillation_range(deg=False) # Create a scans ExperimentList, only for generating reflections experiments = ExperimentList() experiments.append( Experiment(beam=self.beam, detector=self.detector, goniometer=self.gonio, scan=self.scan, crystal=self.crystal, imageset=None)) # Create a ScansRayPredictor ray_predictor = ScansRayPredictor(experiments, sweep_range) # Generate rays - only to work out which hkls are predicted resolution = 2.0 index_generator = IndexGenerator( self.crystal.get_unit_cell(), space_group(space_group_symbols(1).hall()).type(), resolution) indices = index_generator.to_array() rays = ray_predictor(indices) # Make a standard reflection_table and copy in the ray data self.reflections = flex.reflection_table.empty_standard(len(rays)) self.reflections.update(rays)
def generate_reflections(self): # Build a mock scan for a 3 degree sweep from dxtbx.model.scan import scan_factory sf = scan_factory() self.scan = sf.make_scan(image_range = (1,1), exposure_times = 0.1, oscillation = (0, 3.0), epochs = range(1), deg = True) sweep_range = self.scan.get_oscillation_range(deg=False) # Create a scans ExperimentList, only for generating reflections experiments = ExperimentList() experiments.append(Experiment( beam=self.beam, detector=self.detector, goniometer=self.gonio, scan=self.scan, crystal=self.crystal, imageset=None)) # Create a ScansRayPredictor ray_predictor = ScansRayPredictor(experiments, sweep_range) # Generate rays - only to work out which hkls are predicted resolution = 2.0 index_generator = IndexGenerator(self.crystal.get_unit_cell(), space_group(space_group_symbols(1).hall()).type(), resolution) indices = index_generator.to_array() rays = ray_predictor.predict(indices) # Make a standard reflection_table and copy in the ray data self.reflections = flex.reflection_table.empty_standard(len(rays)) self.reflections.update(rays) return
def get_and_check_file(): if ( not os.path.isfile(html_file) or open(html_file).read().lower().find("not found") >= 0): print "Skipping exercise(): input file not available" return table_lines = open(html_file).read().splitlines()[11:-4] assert len(table_lines) == 530, "%d != 530" % len(table_lines) space_group_symbol_iterator = sgtbx.space_group_symbol_iterator() for line in table_lines: flds = line.split() assert len(flds) == 3 nc, hm, hall = flds assert hall.lower() == hall symbols = sgtbx.space_group_symbols(symbol=hm) hm_sgtbx = symbols.universal_hermann_mauguin().replace(" ", "_") \ .replace("_:",":") \ .replace(":H",":h") \ .replace(":R",":r") hall_sgtbx = symbols.hall().lower().replace(" ", "_") if (hall_sgtbx[0] == "_"): hall_sgtbx = hall_sgtbx[1:] assert hm_sgtbx == hm assert hall_sgtbx == hall symbols_i = space_group_symbol_iterator.next() assert symbols_i.universal_hermann_mauguin() \ == symbols.universal_hermann_mauguin()
def run(server_info, inp, status): print "<pre>" symbols_inp = None lookup_symbol = inp.sgsymbol if (lookup_symbol == ""): lookup_symbol = "P 1" if (inp.convention == "Hall"): hall_symbol = lookup_symbol else: symbols_inp = sgtbx.space_group_symbols(lookup_symbol, inp.convention) hall_symbol = symbols_inp.hall() if (symbols_inp.number() == 0): symbols_inp = None inp.convention = "Hall" else: print "Result of symbol lookup:" show_symbols(symbols_inp) print try: ps = sgtbx.parse_string(hall_symbol) sg = sgtbx.space_group(ps) except RuntimeError, e: print "-->" + ps.string() + "<--" print ("-" * (ps.where() + 3)) + "^" raise
def reindex_old(self): self.set_executable(os.path.join(os.environ.get('CBIN', ''), 'reindex')) self.check_hklin() self.check_hklout() if not self._spacegroup and not self._operator: raise RuntimeError, 'reindex requires spacegroup or operator' self.start() # look up the space group number to cope with complex symbols # that old fashioned CCP4 reindex does not understand... from cctbx.sgtbx import space_group, space_group_symbols sg_t = space_group(space_group_symbols(str(self._spacegroup))).type() if self._operator: self.input('reindex %s' % str(self._operator)) if self._spacegroup: self.input('symmetry %d' % sg_t.number()) self.close_wait() # check for errors try: self.check_for_errors() except RuntimeError, e: try: os.remove(self.get_hklout()) except: pass raise e
def get_test_space_group_symbols(flag_AllSpaceGroups, flag_ChiralSpaceGroups, flag_AllSettings, flag_UnusualSettings): if (flag_UnusualSettings): namespace = {} execfile(os.path.join( libtbx.env.find_in_repositories( "phenix_regression"), "settings.py"), namespace) return namespace["settings"] if (flag_AllSettings): return [symbols.universal_hermann_mauguin() for symbols in sgtbx.space_group_symbol_iterator()] if (flag_AllSpaceGroups): sg_numbers = xrange(1, 231) elif (flag_ChiralSpaceGroups): sg_numbers = (1, 3, 4, 5, 16, 17, 18, 19, 20, 21, 22, 23, 24, 75, 76, 77, 78, 79, 80, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 143, 144, 145, 146, 149, 150, 151, 152, 153, 154, 155, 168, 169, 170, 171, 172, 173, 177, 178, 179, 180, 181, 182, 195, 196, 197, 198, 199, 207, 208, 209, 210, 211, 212, 213, 214) else: sg_numbers = (1,2,3,15,16,74,75,76,142,143,144,157,167,168,194,195,230) return [sgtbx.space_group_symbols(n).universal_hermann_mauguin() for n in sg_numbers] + ["Hall: -F 4 21 (1,5,3)"]
def generate_primitive_cell(unit_cell_constants, space_group_name): '''For a given set of unit cell constants and space group, determine the corresponding primitive unit cell...''' uc = unit_cell(unit_cell_constants) sg = space_group(space_group_symbols(space_group_name).hall()) cs = symmetry(unit_cell=uc, space_group=sg) csp = cs.change_basis(cs.change_of_basis_op_to_primitive_setting()) return csp.unit_cell()
def is_centred(space_group_number): '''Test if space group # corresponds to a centred space group.''' sg_hall = sgtbx.space_group_symbols(space_group_number).hall() sg = sgtbx.space_group(sg_hall) if (sg.n_ltr() - 1): return True return False
def test_ersatz_pointgroup(acentric_space_groups): for sg in acentric_space_groups: symbol = sg.type().lookup_symbol() symbol = symbol.split(":")[0] if symbol.count(" 1") == 2: symbol = symbol.replace(" 1", "") symbol = symbol.replace(" ", "") assert (cell_spacegroup.ersatz_pointgroup(symbol) == sgtbx.space_group_symbols( ersatz_pointgroup_old(symbol)).hermann_mauguin())
def number_residues_estimate(cell, pointgroup): '''Guess the number of residues in the ASU, assuming 50% solvent etc.''' sg = space_group(space_group_symbols(pointgroup).hall()) uc = unit_cell(cell) n_ops = len(sg.all_ops()) v_asu = uc.volume() / n_ops return int(round(v_asu / (2.7 * 128)))
def remove_sys_absences(reflection_list, space_group_name): sg = space_group(space_group_symbols(space_group_name).hall()) present_reflections = [] for hkl in reflection_list: if not sg.is_sys_absent(hkl): present_reflections.append(hkl) return present_reflections
def regression_test(): """Perform a regression test by comparing to indices generating by the brute force method used in the Use Case.""" from rstbx.diffraction import rotation_angles from rstbx.diffraction import full_sphere_indices from cctbx.sgtbx import space_group, space_group_symbols from cctbx.uctbx import unit_cell # cubic, 50A cell, 1A radiation, 1 deg osciillation, everything ideal a = 50.0 ub_beg = matrix.sqr( (1.0 / a, 0.0, 0.0, 0.0, 1.0 / a, 0.0, 0.0, 0.0, 1.0 / a)) axis = matrix.col((0, 1, 0)) r_osc = matrix.sqr( scitbx.math.r3_rotation_axis_and_angle_as_matrix(axis=axis, angle=1.0, deg=True)) ub_end = r_osc * ub_beg uc = unit_cell((a, a, a, 90, 90, 90)) sg = space_group(space_group_symbols('P23').hall()) s0 = matrix.col((0, 0, 1)) wavelength = 1.0 dmin = 1.5 indices = full_sphere_indices(unit_cell=uc, resolution_limit=dmin, space_group=sg) ra = rotation_angles(dmin, ub_beg, wavelength, axis) obs_indices, obs_angles = ra.observed_indices_and_angles_from_angle_range( phi_start_rad=0.0 * pi / 180.0, phi_end_rad=1.0 * pi / 180.0, indices=indices) r = reeke_model(ub_beg, ub_end, axis, s0, dmin, 1.0) reeke_indices = r.generate_indices() #r.visualize_with_rgl() for oi in obs_indices: assert (tuple(map(int, oi)) in reeke_indices) #TODO Tests for an oblique cell print "OK"
def symopSymList(sgNr): """For a S.G. Returns list of symmetry operations in symbolic form""" sg_hall = sgtbx.space_group_symbols(sgNr).hall() sg = sgtbx.space_group(sg_hall) print "\nGENERATING LIST OF SYMMETRY OPERATIONS FOR S.G. %d..." % (sgNr) symop_list = [] sg_order = sg.order_z() for i in range(0, sg_order): symop_list.append(sg(i).as_xyz()) print "A LIST OF %d SYMMETRY OPERATIONS WAS CREATED!\n" % (sg_order) return symop_list
def exercise_monoclinic_cell_choices_core(space_group_number, verbose): # transformation matrices for cell choices # columns are basis vectors "new in terms of old" # see Int. Tab. Vol. A, p. 22, Fig. 2.2.6.4. b1 = (1, 0, 0, 0, 1, 0, 0, 0, 1) b2 = (-1, 0, 1, 0, 1, 0, -1, 0, 0) b3 = (0, 0, -1, 0, 1, 0, 1, 0, -1) flip = (0, 0, 1, 0, -1, 0, 1, 0, 0) p3s = sgtbx.space_group("P 3*") done = {} ref = sgtbx.space_group_info(number=space_group_number) ref_uhm = ref.type().universal_hermann_mauguin_symbol() for i_fl,fl in enumerate([b1, flip]): rfl = sgtbx.rot_mx(fl) cfl = sgtbx.change_of_basis_op(sgtbx.rt_mx(rfl)) for i_rt,rt in enumerate(p3s): rp3 = rt.r() cp3 = sgtbx.change_of_basis_op(sgtbx.rt_mx(rp3)) for i_cs,cs in enumerate([b1,b2,b3]): rcs = sgtbx.rot_mx(cs).inverse() ccs = sgtbx.change_of_basis_op(sgtbx.rt_mx(rcs)) cb_all = cp3 * cfl * ccs refcb = ref.change_basis(cb_all) refcb2 = sgtbx.space_group_info(symbol=ref_uhm+"("+str(cb_all.c())+")") assert refcb2.group() == refcb.group() s = sgtbx.space_group_symbols(str(refcb)) q = s.qualifier() hm = str(refcb) if (0 or verbose): print hm, q, cb_all.c() if (i_fl == 0): assert q[0] == "bca"[i_rt] if (len(q) == 2): assert q[1] == "123"[i_cs] elif (q[0] == "-"): assert q[1] == "bca"[i_rt] if (len(q) == 3): assert q[2] == "123"[i_cs] else: assert q[0] == "bca"[i_rt] if (len(q) == 2 and q[1] != "123"[i_cs]): assert done[hm] == 1 done.setdefault(hm, 0) done[hm] += 1 assert len(done) in [3, 9, 18] assert done.values() == [18/len(done)]*len(done) if (0 or verbose): print return done
def generate_reflections(self): from cctbx.sgtbx import space_group, space_group_symbols from dials.algorithms.spot_prediction import IndexGenerator, ray_intersection sequence_range = self.scan.get_oscillation_range(deg=False) resolution = 2.0 index_generator = IndexGenerator( self.crystal.get_unit_cell(), space_group(space_group_symbols(1).hall()).type(), resolution, ) indices = index_generator.to_array() # Predict rays within the sequence range ray_predictor = ScansRayPredictor(self.experiments, sequence_range) obs_refs = ray_predictor(indices) # Take only those rays that intersect the detector intersects = ray_intersection(self.detector, obs_refs) obs_refs = obs_refs.select(intersects) # Re-predict using the Experiments predictor for all these reflections. The # result is the same, but we gain also the flags and xyzcal.px columns obs_refs["id"] = flex.int(len(obs_refs), 0) obs_refs = self.ref_predictor(obs_refs) # Set 'observed' centroids from the predicted ones obs_refs["xyzobs.mm.value"] = obs_refs["xyzcal.mm"] # Invent some variances for the centroid positions of the simulated data im_width = 0.1 * pi / 180.0 px_size = self.detector[0].get_pixel_size() var_x = flex.double(len(obs_refs), (px_size[0] / 2.0)**2) var_y = flex.double(len(obs_refs), (px_size[1] / 2.0)**2) var_phi = flex.double(len(obs_refs), (im_width / 2.0)**2) obs_refs["xyzobs.mm.variance"] = flex.vec3_double( var_x, var_y, var_phi) # set the flex random seed to an 'uninteresting' number flex.set_random_seed(12407) # take 10 random reflections for speed reflections = obs_refs.select(flex.random_selection(len(obs_refs), 10)) # use a BlockCalculator to calculate the blocks per image from dials.algorithms.refinement.reflection_manager import BlockCalculator block_calculator = BlockCalculator(self.experiments, reflections) reflections = block_calculator.per_image() return reflections
def number_sites_estimate(cell, pointgroup): '''Guess # heavy atoms likely to be in here (as a floating point number) based on Matthews coefficient, average proportion of methionine in protein sequences and typical mass of an amino acid.''' sg = space_group(space_group_symbols(pointgroup).hall()) uc = unit_cell(cell) n_ops = len(sg.all_ops()) v_asu = uc.volume() / n_ops return 0.023 * v_asu / (2.7 * 128)
def get_space_group_type_from_xparm(handle): """Get the space group tyoe object from an xparm file handle Params: handle The file handle Returns: The space group type object """ from cctbx import sgtbx return sgtbx.space_group_type(sgtbx.space_group( sgtbx.space_group_symbols(handle.space_group).hall()))
def Py_remove_absent_indices(indices, space_group_number): '''From the given list of indices, remove those reflections which should be systematic absences according to the given space group.''' sg = space_group(space_group_symbols(space_group_number).hall()) present = [] for hkl in indices: if not sg.is_sys_absent(hkl): present.append(hkl) return present
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 generate_all_spacegroups(pointgroup): '''Generate an enantiomorph unique list of chiral spacegroups which share a pointgroup with this pointgroup.''' sg = space_group(space_group_symbols(pointgroup).hall()) pg = sg.build_derived_patterson_group() eu_list = [] for j in range(1, 231): sg_test = space_group(space_group_symbols(j).hall()) if not sg_test.is_chiral(): continue pg_test = sg_test.build_derived_patterson_group() if pg_test == pg: if not sg_test in eu_list: eu_list.append(sg_test) return [ sg_test.type().universal_hermann_mauguin_symbol().replace(' ', '') \ for sg_test in eu_list]
def reduce_reflections_to_asu(space_group_number, indices): """Reduce reflection indices to asymmetric unit.""" from cctbx.sgtbx import space_group, space_group_symbols from cctbx.array_family import flex from cctbx.miller import map_to_asu sg = space_group(space_group_symbols(space_group_number).hall()) miller = flex.miller_index(indices) map_to_asu(sg.type(), False, miller) return [hkl for hkl in miller]
def reduce_reflections_to_asu(space_group_number, indices): '''Reduce reflection indices to asymmetric unit.''' from cctbx.sgtbx import space_group, space_group_symbols from cctbx.array_family import flex from cctbx.miller import map_to_asu sg = space_group(space_group_symbols(space_group_number).hall()) miller = flex.miller_index(indices) map_to_asu(sg.type(), False, miller) return [hkl for hkl in miller]
def __init__( self, real_space_a, real_space_b, real_space_c, space_group_symbol=None, space_group=None, mosaicity=None, deg=True, ): # Set the space group assert [space_group_symbol, space_group].count(None) == 1 if space_group_symbol: self._sg = SG(space_group_symbols(space_group_symbol)) else: self._sg = space_group # Set the mosaicity if mosaicity is not None: self.set_mosaicity(mosaicity, deg=deg) else: self._mosaicity = 0.0 # setting matrix at initialisation real_space_a = matrix.col(real_space_a) real_space_b = matrix.col(real_space_b) real_space_c = matrix.col(real_space_c) A = matrix.sqr(real_space_a.elems + real_space_b.elems + real_space_c.elems).inverse() # unit cell self.set_unit_cell(real_space_a, real_space_b, real_space_c) # reciprocal space orthogonalisation matrix (is the transpose of the # real space fractionalisation matrix, see http://goo.gl/H3p1s) self._update_B() # initial orientation matrix self._U = A * self._B.inverse() # set up attributes for scan-varying model self.reset_scan_points() # set up attributes for unit cell errors self.reset_unit_cell_errors() return
def regression_test(): """Perform a regression test by comparing to indices generating by the brute force method used in the Use Case.""" from rstbx.diffraction import rotation_angles from rstbx.diffraction import full_sphere_indices from cctbx.sgtbx import space_group, space_group_symbols from cctbx.uctbx import unit_cell # cubic, 50A cell, 1A radiation, 1 deg osciillation, everything ideal a = 50.0 ub_beg = matrix.sqr((1.0 / a, 0.0, 0.0, 0.0, 1.0 / a, 0.0, 0.0, 0.0, 1.0 / a)) axis = matrix.col((0, 1, 0)) r_osc = matrix.sqr(scitbx.math.r3_rotation_axis_and_angle_as_matrix(axis=axis, angle=1.0, deg=True)) ub_end = r_osc * ub_beg uc = unit_cell((a, a, a, 90, 90, 90)) sg = space_group(space_group_symbols("P23").hall()) s0 = matrix.col((0, 0, 1)) wavelength = 1.0 dmin = 1.5 indices = full_sphere_indices(unit_cell=uc, resolution_limit=dmin, space_group=sg) ra = rotation_angles(dmin, ub_beg, wavelength, axis) obs_indices, obs_angles = ra.observed_indices_and_angles_from_angle_range( phi_start_rad=0.0 * pi / 180.0, phi_end_rad=1.0 * pi / 180.0, indices=indices ) r = reeke_model(ub_beg, ub_end, axis, s0, dmin, 1.0) reeke_indices = r.generate_indices() # r.visualize_with_rgl() for oi in obs_indices: assert tuple(map(int, oi)) in reeke_indices # TODO Tests for an oblique cell print "OK"
def __init__(self, real_space_a, real_space_b, real_space_c, sg=1): self._sg = space_group(space_group_symbols(sg).hall()) # setting matrix at initialisation A = matrix.sqr(real_space_a.elems + real_space_b.elems + real_space_c.elems).inverse() # unit cell self.set_unit_cell(real_space_a, real_space_b, real_space_c) # reciprocal space orthogonalisation matrix (is the transpose of the # real space fractionalisation matrix, see http://goo.gl/H3p1s) self._update_B() # initial orientation matrix self._U = A * self._B.inverse()
def test_versus_brute_force(): """Perform a regression test by comparing to indices generated by the brute force method""" # cubic, 50A cell, 1A radiation, 1 deg osciillation, everything ideal a = 50.0 ub_beg = matrix.sqr( (1.0 / a, 0.0, 0.0, 0.0, 1.0 / a, 0.0, 0.0, 0.0, 1.0 / a)) axis = matrix.col((0, 1, 0)) r_osc = matrix.sqr( r3_rotation_axis_and_angle_as_matrix(axis=axis, angle=1.0, deg=True)) ub_end = r_osc * ub_beg uc = unit_cell((a, a, a, 90, 90, 90)) sg = space_group(space_group_symbols("P23").hall()) s0 = matrix.col((0, 0, 1)) wavelength = 1.0 dmin = 1.5 # get the full set of indices indices = full_sphere_indices(unit_cell=uc, resolution_limit=dmin, space_group=sg) # find the observed indices ra = rotation_angles(dmin, ub_beg, wavelength, axis) obs_indices, obs_angles = ra.observed_indices_and_angles_from_angle_range( phi_start_rad=0.0 * math.pi / 180.0, phi_end_rad=1.0 * math.pi / 180.0, indices=indices, ) # r = reeke_model(ub_beg, ub_end, axis, s0, dmin, 1.0) # reeke_indices = r.generate_indices() # now try the Reeke method to generate indices r = ReekeIndexGenerator(ub_beg, ub_end, sg.type(), axis, s0, dmin, margin=1) reeke_indices = r.to_array() for oi in obs_indices: assert tuple(map(int, oi)) in reeke_indices
def exercise_monoclinic_cell_choices_core(space_group_number, verbose): # transformation matrices for cell choices # columns are basis vectors "new in terms of old" # see Int. Tab. Vol. A, p. 22, Fig. 2.2.6.4. b1 = (1, 0, 0, 0, 1, 0, 0, 0, 1) b2 = (-1, 0, 1, 0, 1, 0, -1, 0, 0) b3 = (0, 0, -1, 0, 1, 0, 1, 0, -1) flip = (0, 0, 1, 0, -1, 0, 1, 0, 0) p3s = sgtbx.space_group("P 3*") done = {} ref = sgtbx.space_group_info(number=space_group_number) ref_uhm = ref.type().universal_hermann_mauguin_symbol() for i_fl, fl in enumerate([b1, flip]): rfl = sgtbx.rot_mx(fl) cfl = sgtbx.change_of_basis_op(sgtbx.rt_mx(rfl)) for i_rt, rt in enumerate(p3s): rp3 = rt.r() cp3 = sgtbx.change_of_basis_op(sgtbx.rt_mx(rp3)) for i_cs, cs in enumerate([b1, b2, b3]): rcs = sgtbx.rot_mx(cs).inverse() ccs = sgtbx.change_of_basis_op(sgtbx.rt_mx(rcs)) cb_all = cp3 * cfl * ccs refcb = ref.change_basis(cb_all) refcb2 = sgtbx.space_group_info(symbol=ref_uhm + "(" + str(cb_all.c()) + ")") assert refcb2.group() == refcb.group() s = sgtbx.space_group_symbols(str(refcb)) q = s.qualifier() hm = str(refcb) if (0 or verbose): print(hm, q, cb_all.c()) if (i_fl == 0): assert q[0] == "bca"[i_rt] if (len(q) == 2): assert q[1] == "123"[i_cs] elif (q[0] == "-"): assert q[1] == "bca"[i_rt] if (len(q) == 3): assert q[2] == "123"[i_cs] else: assert q[0] == "bca"[i_rt] if (len(q) == 2 and q[1] != "123"[i_cs]): assert done[hm] == 1 done.setdefault(hm, 0) done[hm] += 1 assert len(done) in [3, 9, 18] assert list(done.values()) == [18 / len(done)] * len(done) if (0 or verbose): print() return done
def __init__(self, real_space_a, real_space_b, real_space_c, sg = 1): self._sg = space_group(space_group_symbols(sg).hall()) # setting matrix at initialisation A = matrix.sqr(real_space_a.elems + real_space_b.elems + \ real_space_c.elems).inverse() # unit cell self.set_unit_cell(real_space_a, real_space_b, real_space_c) # reciprocal space orthogonalisation matrix (is the transpose of the # real space fractionalisation matrix, see http://goo.gl/H3p1s) self._update_B() # initial orientation matrix self._U = A * self._B.inverse()
def generate_reflections(experiments): from dials.algorithms.spot_prediction import IndexGenerator from dials.algorithms.refinement.prediction import \ ScansRayPredictor, ExperimentsPredictor from dials.algorithms.spot_prediction import ray_intersection from cctbx.sgtbx import space_group, space_group_symbols from scitbx.array_family import flex detector = experiments[0].detector crystal = experiments[0].crystal # All indices in a 2.0 Angstrom sphere resolution = 2.0 index_generator = IndexGenerator(crystal.get_unit_cell(), space_group(space_group_symbols(1).hall()).type(), resolution) indices = index_generator.to_array() # Predict rays within the sweep range scan = experiments[0].scan sweep_range = scan.get_oscillation_range(deg=False) ray_predictor = ScansRayPredictor(experiments, sweep_range) obs_refs = ray_predictor(indices) # Take only those rays that intersect the detector intersects = ray_intersection(detector, obs_refs) obs_refs = obs_refs.select(intersects) # Make a reflection predictor and re-predict for all these reflections. The # result is the same, but we gain also the flags and xyzcal.px columns ref_predictor = ExperimentsPredictor(experiments) obs_refs['id'] = flex.int(len(obs_refs), 0) obs_refs = ref_predictor(obs_refs) # Set 'observed' centroids from the predicted ones obs_refs['xyzobs.mm.value'] = obs_refs['xyzcal.mm'] # Invent some variances for the centroid positions of the simulated data im_width = 0.1 * pi / 180. px_size = detector[0].get_pixel_size() var_x = flex.double(len(obs_refs), (px_size[0] / 2.)**2) var_y = flex.double(len(obs_refs), (px_size[1] / 2.)**2) var_phi = flex.double(len(obs_refs), (im_width / 2.)**2) obs_refs['xyzobs.mm.variance'] = flex.vec3_double(var_x, var_y, var_phi) return obs_refs, ref_predictor
def doohicky(integrate_hkl, space_group_name, symop): present = [] absent = [] sg = space_group(space_group_symbols(space_group_name).hall()) r = change_of_basis_op(symop) for hkl, isig in read_integrate_hkl(integrate_hkl): rhkl = tuple(map(int, r.c() * hkl)) if sg.is_sys_absent(rhkl): absent.append(isig[0]) else: present.append(isig[0]) print "Present: %.2e %.2e %.2e" % mean_variance(present), "%.2e %.2e %.2e" % quartiles(present) print "Absent: %.2e %.2e %.2e" % mean_variance(absent), "%.2e %.2e %.2e" % quartiles(absent)
def generate_reflections(self): sweep_range = self.scan.get_oscillation_range(deg=False) resolution = 2.0 index_generator = IndexGenerator(self.crystal.get_unit_cell(), space_group(space_group_symbols(1).hall()).type(), resolution) indices = index_generator.to_array() # Predict rays within the sweep range ray_predictor = ScansRayPredictor(self.experiments, sweep_range) obs_refs = ray_predictor(indices) # Take only those rays that intersect the detector intersects = ray_intersection(self.detector, obs_refs) obs_refs = obs_refs.select(intersects) # Re-predict using the Experiments predictor for all these reflections. The # result is the same, but we gain also the flags and xyzcal.px columns obs_refs['id'] = flex.int(len(obs_refs), 0) obs_refs = self.ref_predictor(obs_refs) # Set 'observed' centroids from the predicted ones obs_refs['xyzobs.mm.value'] = obs_refs['xyzcal.mm'] # Invent some variances for the centroid positions of the simulated data im_width = 0.1 * pi / 180. px_size = self.detector[0].get_pixel_size() var_x = flex.double(len(obs_refs), (px_size[0] / 2.)**2) var_y = flex.double(len(obs_refs), (px_size[1] / 2.)**2) var_phi = flex.double(len(obs_refs), (im_width / 2.)**2) obs_refs['xyzobs.mm.variance'] = flex.vec3_double(var_x, var_y, var_phi) # set the flex random seed to an 'uninteresting' number flex.set_random_seed(12407) # take 5 random reflections for speed reflections = obs_refs.select(flex.random_selection(len(obs_refs), 5)) # use a BlockCalculator to calculate the blocks per image from dials.algorithms.refinement.reflection_manager import BlockCalculator block_calculator = BlockCalculator(self.experiments, reflections) reflections = block_calculator.per_image() return reflections
def read_xds_integrate(xds_integrate_file): # N.B. in here need to reduce indices to asymmetric unit sg_num = 0 r = 0.0 for record in open(xds_integrate_file): if not '!' in record[:1]: break if 'SPACE_GROUP_NUMBER' in record: sg_num = int(record.split()[-1]) if 'OSCILLATION_RANGE' in record: r = float(record.split()[-1]) if not sg_num: raise RuntimeError, 'spacegroup missing' if not r: raise RuntimeError, 'rotation missing' sg = space_group(space_group_symbols(sg_num).hall()) observations = [] hkls = flex.miller_index() xyzs = [] isigmas = [] for record in open(xds_integrate_file): if '!' in record[:1]: continue values = record.split() hkls.append(map(int, values[:3])) xyzs.append((float(values[5]), float(values[6]), float(values[7]))) isigmas.append(map(float, values[3:5])) map_to_asu(sg.type(), False, hkls) for hkl, xyz, isigma in zip(hkls, xyzs, isigmas): observations.append((hkl, xyz, isigma)) return observations
def exercise_orthorhombic_hm_qualifier_as_cb_symbol(): cb_symbols = { "cab": ["c,a,b", "z,x,y"], "a-cb": ["a,-c,b", "x,-z,y"], "-cba": ["-c,b,a", "-z,y,x"], "bca": ["b,c,a", "y,z,x"], "ba-c": ["b,a,-c", "y,x,-z"]} for sgsyms1 in sgtbx.space_group_symbol_iterator(): n = sgsyms1.number() if (n < 16 or n > 74): continue q = sgsyms1.qualifier() if (len(q) == 0): continue e = sgsyms1.extension() if (e == "\0"): e = "" ehm = sgtbx.space_group_symbols( space_group_number=n, extension=e).universal_hermann_mauguin() cabc, cxyz = cb_symbols[q] assert sgtbx.change_of_basis_op(cxyz).as_abc() == cabc assert sgtbx.change_of_basis_op(cabc).as_xyz() == cxyz uhm_xyz = ehm + " ("+cxyz+")" sgsyms2 = sgtbx.space_group_symbols(symbol=uhm_xyz) assert sgsyms2.change_of_basis_symbol() == cxyz assert sgsyms2.extension() == sgsyms1.extension() assert sgsyms2.universal_hermann_mauguin() == uhm_xyz g1 = sgtbx.space_group(space_group_symbols=sgsyms1) g2 = sgtbx.space_group(space_group_symbols=sgsyms2) assert g2 == g1 g2 = sgtbx.space_group( sgtbx.space_group_symbols(symbol=ehm)).change_basis( sgtbx.change_of_basis_op(sgtbx.rt_mx(cxyz))) assert g2 == g1 for c in [cxyz, cabc]: g2 = sgtbx.space_group_info( group=sgtbx.space_group( sgtbx.space_group_symbols(symbol=ehm))).change_basis(c).group() assert g2 == g1 cit = sgtbx.rt_mx(cxyz).r().inverse().transpose() cit_xyz = cit.as_xyz() g2 = sgtbx.space_group_info( group=sgtbx.space_group( sgtbx.space_group_symbols(symbol=ehm))).change_basis(cit_xyz).group() assert g2 == g1 assert cit.as_xyz(False, "abc") == cabc uhm_abc = ehm + " ("+cabc+")" sgsyms2 = sgtbx.space_group_symbols(symbol=uhm_abc) assert sgsyms2.change_of_basis_symbol() == cxyz assert sgsyms2.extension() == sgsyms1.extension() assert sgsyms2.universal_hermann_mauguin() == uhm_xyz g2 = sgtbx.space_group(space_group_symbols=sgsyms2) assert g2 == g1
def get_sgtype_cb_ops(argv): sgtype = None cb_ops = [] for arg in argv: if not sgtype: try: from cctbx.sgtbx import space_group, space_group_symbols sgtype = space_group(space_group_symbols(arg)).type() continue except RuntimeError, e: pass try: from cctbx import sgtbx cb_op = sgtbx.change_of_basis_op(arg) cb_ops.append(cb_op) continue except ValueError, e: pass
def measure(hklin, spacegroup): '''Look at HKLIN, see how strong the absences (according to the given spacegroup) are... looking for IPR / SIGIPR.''' mtz_obj = mtz.object(hklin) sg = sgtbx.space_group(sgtbx.space_group_symbols(spacegroup).hall()) mi = mtz_obj.extract_miller_indices() sg_m = mtz_obj.space_group() ipr_column = None sigipr_column = None for crystal in mtz_obj.crystals(): for dataset in crystal.datasets(): for column in dataset.columns(): if column.label() == 'IPR': ipr_column = column elif column.label() == 'SIGIPR': sigipr_column = column assert(ipr_column != None) assert(sigipr_column != None) ipr_values = ipr_column.extract_values(not_a_number_substitute = 0.0) sigipr_values = sigipr_column.extract_values(not_a_number_substitute = 0.0) present = [] absent = [] for j in range(mi.size()): hkl = mi[j] if sg.is_sys_absent(hkl): absent.append(ipr_values[j] / sigipr_values[j]) else: present.append(ipr_values[j] / sigipr_values[j]) print 'A: %f' % (sum(absent) / len(absent)) print 'P: %f' % (sum(present) / len(present))
def __init__(self, real_space_a, real_space_b, real_space_c, space_group_symbol=None, space_group=None, mosaicity=None, deg=True): # Set the space group assert [space_group_symbol, space_group].count(None) == 1 if space_group_symbol: self._sg = SG(space_group_symbols(space_group_symbol)) else: self._sg = space_group # Set the mosaicity if mosaicity is not None: self.set_mosaicity(mosaicity, deg=deg) else: self._mosaicity = 0.0 # setting matrix at initialisation real_space_a = matrix.col(real_space_a) real_space_b = matrix.col(real_space_b) real_space_c = matrix.col(real_space_c) A = matrix.sqr(real_space_a.elems + real_space_b.elems + \ real_space_c.elems).inverse() # unit cell self.set_unit_cell(real_space_a, real_space_b, real_space_c) # reciprocal space orthogonalisation matrix (is the transpose of the # real space fractionalisation matrix, see http://goo.gl/H3p1s) self._update_B() # initial orientation matrix self._U = A * self._B.inverse() # set up attributes for scan-varying model self.reset_scan_points() # set up attributes for unit cell errors self.reset_unit_cell_errors() return
def exercise_change_of_basis_between_arbitrary_space_groups(): from random import randint from scitbx import matrix as mat g = sgtbx.space_group_info('hall: P 2') h = sgtbx.space_group_info('hall: P 2c') assert g.change_of_basis_op_to(h) is None g = sgtbx.space_group_info('hall: C 2c 2 (x+y,x-y,z)') h = g.change_basis(sgtbx.change_of_basis_op(sgtbx.rt_mx('-y,x,z'))) cb_op = g.change_of_basis_op_to(h) assert cb_op.as_xyz() == 'x,y,z+1/4' assert g.change_basis(cb_op).group() == h.group() g = sgtbx.space_group_info('hall: I 4 2 3') z2p_op = g.change_of_basis_op_to_primitive_setting() h = g.change_basis(z2p_op) cb_op = g.change_of_basis_op_to(h) assert cb_op.c() == z2p_op.c(), (cb_op.as_xyz(), z2p_op.as_xyz()) for i in xrange(1, 231): s = sgtbx.space_group_symbols(space_group_number=i) g = sgtbx.space_group_info(group=sgtbx.space_group(s, t_den=24)) o = tuple([ randint(0, 23) for j in xrange(3) ]) cb_op = sgtbx.change_of_basis_op(sgtbx.rt_mx(sgtbx.tr_vec(o, 24))) h = g.change_basis(cb_op) cb_op_1 = g.change_of_basis_op_to(h) assert cb_op_1.c().r().is_unit_mx() delta = (mat.col(cb_op_1.c().t().as_double()) - mat.col(cb_op.c().t().as_double())) assert h.is_allowed_origin_shift(delta, tolerance=1e-12) z2p_op = g.change_of_basis_op_to_primitive_setting() h = g.change_basis(z2p_op) cb_op = g.change_of_basis_op_to(h) h1 = g.change_basis(cb_op) assert (h.as_reference_setting().group() == h1.as_reference_setting().group())
def mmSpaceGroupFromSymbol(symbol): """Construct SpaceGroup instance from a string symbol using sgtbx data. """ sginfo = sgtbx.space_group_info(symbol) symop_list = [] unique_rotations = set() symop_list = getSymOpList(sginfo.group()) sgtype = sginfo.type() uhm = sgtype.lookup_symbol() sgsmbls = sgtbx.space_group_symbols(uhm) kw = {} kw['number'] = sgtype.number() kw['num_sym_equiv'] = len(symop_list) kw['num_primitive_sym_equiv'] = countUniqueRotations(symop_list) kw['short_name'] = sgsmbls.hermann_mauguin().replace(' ', '') pgt = sgsmbls.point_group_type() pgn = "PG" + re.sub('-(\d)', '\\1bar', pgt) kw['point_group_name'] = pgn kw['crystal_system'] = sgsmbls.crystal_system().upper() kw['pdb_name'] = sgsmbls.hermann_mauguin() kw['symop_list'] = symop_list mmsg = SpaceGroup(**kw) return mmsg
def tst_map_to_asu_isym(anomalous_flag): from cctbx import sgtbx from cctbx.miller import map_to_asu_isym from cctbx.array_family import flex mi = flex.miller_index() i = flex.int() import random nhkl = 1000 for j in range(nhkl): hkl = [random.randint(-10, 10) for j in range(3)] mi.append(hkl) i.append(0) spacegroup = sgtbx.space_group_symbols(195).hall() sg = sgtbx.space_group(spacegroup) mi_, isym_ = reference_map(sg, mi) map_to_asu_isym(sg.type(), anomalous_flag, mi, i) for j in range(nhkl): assert(i[j] == isym_[j])