def test_detector(): """A test class for the detector class.""" assert DetectorFactory.simple( "CCD", 100.0, (45.0, 52.0), "+x", "-y", (0.172, 0.172), (516, 590), (0, 1024), [], ) assert DetectorFactory.two_theta( "CCD", 60.0, (35.0, 34.0), "+x", "+y", "+x", 30, (0.07, 0.07), (1042, 1042), (0, 1024), [], ) image = Path(__file__).parent / "phi_scan_001.cbf" assert DetectorFactory.imgCIF(str(image), "CCD")
def test_detector(): """A test class for the detector class.""" assert DetectorFactory.simple( "CCD", 100.0, (45.0, 52.0), "+x", "-y", (0.172, 0.172), (516, 590), (0, 1024), [], ) assert DetectorFactory.two_theta( "CCD", 60.0, (35.0, 34.0), "+x", "+y", "+x", 30, (0.07, 0.07), (1042, 1042), (0, 1024), [], ) dxtbx_dir = libtbx.env.dist_path("dxtbx") image = os.path.join(dxtbx_dir, "tests", "phi_scan_001.cbf") # xparm = os.path.join(dxtbx_dir, "tests", "example-xparm.xds") assert DetectorFactory.imgCIF(image, "CCD")
def get_values(invert_y): beam = BeamFactory.simple(wavelength=1) if invert_y: y_direction = "-y" else: y_direction = "+y" detector = DetectorFactory.simple( sensor=DetectorFactory.sensor("PAD"), distance=100, beam_centre=[50, 50], fast_direction="+x", slow_direction=y_direction, pixel_size=[0.1, 0.1], image_size=[1000, 1000], )[0] wavelength = beam.get_wavelength() thickness = 0.5 table = attenuation_coefficient.get_table("Si") mu = table.mu_at_angstrom(wavelength) / 10.0 t0 = thickness for panel in detector: panel.set_px_mm_strategy(ParallaxCorrectedPxMmStrategy(mu, t0)) v1 = detector.pixel_to_millimeter((0, 0)) v2 = detector.pixel_to_millimeter((1000, 1000)) return v1, v2
def __init__(self): import dxtbx detector_lib = os.path.join( os.path.split(dxtbx.__file__)[0], 'data', 'detectors.lib') if not os.path.exists(detector_lib): raise RuntimeError, 'detector library not found' self._detectors = {} for record in open(detector_lib): if 'Sensor' in record[:6]: continue if '------' in record[:6]: continue text = record.split('#')[0].strip() if not text: continue tokens = text.split() assert (len(tokens) == 6) sensor = DetectorFactory.sensor(tokens[0]) fast, slow, df, ds = map(int, tokens[1:5]) self._detectors[(sensor, fast, slow, df, ds)] = tokens[5] return
def make_images(data, tag): pixel_size = 0.1 # mm/pixel detector = DetectorFactory.simple( 'PAD', 100, (pixel_size * data.focus()[1] / 2, pixel_size * data.focus()[2] / 2), '+x', '-y', (pixel_size, pixel_size), (data.focus()[2], data.focus()[1]), (-1, 1e6 - 1), [], None) beam = BeamFactory.simple(1.0) sf = ScanFactory() scan = sf.make_scan(image_range=(1, 180), exposure_times=0.1, oscillation=(0, 1.0), epochs=range(180), deg=True) # write images in each of three directions for slice_id in [0, 1, 2]: for idx in xrange(data.focus()[slice_id]): if slice_id == 0: # slow data_slice = data[idx:idx + 1, :, :] data_slice.reshape(flex.grid(data.focus()[1], data.focus()[2])) filename = "fft_frame_%s_mf_%04d.cbf" % (tag, idx) elif slice_id == 1: # med data_slice = data[:, idx:idx + 1, :] data_slice.reshape(flex.grid(data.focus()[0], data.focus()[2])) filename = "fft_frame_%s_sf_%04d.cbf" % (tag, idx) elif slice_id == 2: # fast data_slice = data[:, :, idx:idx + 1] data_slice.reshape(flex.grid(data.focus()[0], data.focus()[1])) filename = "fft_frame_%s_sm_%04d.cbf" % (tag, idx) print['slow', 'med', 'fast'][slice_id], idx FormatCBFMini.as_file(detector, beam, None, scan, data_slice, filename)
def make_images(data, tag): pixel_size = 0.1 detector = DetectorFactory.simple( 'PAD', 100, (pixel_size * data.focus()[1] / 2, pixel_size * data.focus()[2] / 2), '+x', '-y', (pixel_size, pixel_size), (data.focus()[2], data.focus()[1]), (-1, 1e6 - 1), [], None) beam = BeamFactory.simple(1.0) for slice_id in [0, 1, 2]: for idx in xrange(data.focus()[slice_id]): if slice_id == 0: # slow data_slice = data[idx:idx + 1, :, :] data_slice.reshape(flex.grid(data.focus()[1], data.focus()[2])) filename = "fft_frame_%s_mf_%04d.cbf" % (tag, idx) elif slice_id == 1: # med data_slice = data[:, idx:idx + 1, :] data_slice.reshape(flex.grid(data.focus()[0], data.focus()[2])) filename = "fft_frame_%s_sf_%04d.cbf" % (tag, idx) elif slice_id == 2: # fast data_slice = data[:, :, idx:idx + 1] data_slice.reshape(flex.grid(data.focus()[0], data.focus()[1])) filename = "fft_frame_%s_sm_%04d.cbf" % (tag, idx) print['slow', 'med', 'fast'][slice_id], idx FormatCBFMini.as_file(detector, beam, None, None, data_slice, filename)
def get(self, sensor, fast, slow, df, ds): """Look up a name for a detector with this sensor type (listed in detector_helpers) these image dimensions in the fast and slow directions, these corresponding pixel sizes, in microns (integers). If the sensor is unknown, all sensor types will be tested - be warned if there are duplicates.""" sensor = DetectorFactory.sensor(sensor) if sensor == detector_helper_sensors.SENSOR_UNKNOWN: for s in detector_helper_sensors.all(): try: return self.get(s, fast, slow, df, ds) except ValueError: pass raise ValueError("detector %s %d %d %d %d unknown" % (sensor, fast, slow, df, ds)) if (sensor, fast, slow, df, ds) in self._detectors: return self._detectors[(sensor, fast, slow, df, ds)] # OK allow for small variations in the recorded pixel dimensions for ddf in -2, -1, 1, 2: for dds in -2, -1, 1, 2: if (sensor, fast, slow, df + ddf, ds + dds) in self._detectors: return self._detectors[(sensor, fast, slow, df + ddf, ds + dds)] raise ValueError("detector %s %d %d %d %d unknown" % (sensor, fast, slow, df, ds))
def __init__(self): detector_lib = os.path.join( os.path.split(dxtbx.__file__)[0], "data", "detectors.lib") if not os.path.exists(detector_lib): raise RuntimeError("detector library not found") self._detectors = {} for record in open(detector_lib): if "Sensor" in record[:6]: continue if "------" in record[:6]: continue text = record.split("#")[0].strip() if not text: continue tokens = text.split() assert len(tokens) == 6 sensor = DetectorFactory.sensor(tokens[0]) fast, slow, df, ds = map(int, tokens[1:5]) self._detectors[(sensor, fast, slow, df, ds)] = tokens[5]
def __init__(self): #unit cell and space group for lysozyme known_symmetry = crystal.symmetry("78,78,37,90,90,90", "P43212") data = two_color_still_sim.two_color_still_sim(symm=known_symmetry, rot=None) self.data = data wavelength1 = 12398 / 7400 #wavelength for 2 color experiment in Angstroms wavelength2 = 12398 / 7500 #wavelength for 2 color experiment in Angstroms #get detector with a single panel detector = detector_factory.simple('SENSOR_UNKNOWN', 125, (97.075, 97.075), '+x', '-y', (0.11, 0.11), (1765, 1765)) self.detector = detector beam1 = beam_factory.simple_directional((0, 0, 1), wavelength1) beam2 = beam_factory.simple_directional((0, 0, 1), wavelength2) beams = [beam1, beam2] self.beams = beams hkl_list = data.hkl_list self.hkl_list = hkl_list A = data.A self.A = A two_color_sim = data.ewald_proximity_test(beams, hkl_list, A, detector) self.two_color_sim = two_color_sim
def __init__(self): detector_lib = os.path.join( os.path.split(dxtbx.__file__)[0], "data", "detectors.lib") if not os.path.exists(detector_lib): raise RuntimeError("detector library not found") self._detectors = {} with io.open(detector_lib, "r", encoding="ascii") as fh: for record in fh: if record.startswith(("Sensor", "-----")): continue text = record.split("#")[0].strip() if not text: continue tokens = text.split() assert len(tokens) == 6 sensor = DetectorFactory.sensor(tokens[0]) fast, slow, df, ds = map(int, tokens[1:5]) self._detectors[(sensor, fast, slow, df, ds)] = tokens[5]
def test_unique_hkl(): '''tests the uniqueness of hkl values associated with each experiment for 100 simulated randomly oriented thermolysin diffraction images prior to indexing.''' flex.set_random_seed(42) # the meaning of life known_symmetry = crystal.symmetry("78,78,37,90,90,90", "P43212") detector = detector_factory.simple('SENSOR_UNKNOWN', 125, (97.075, 97.075), '+x', '-y', (0.11, 0.11), (1765, 1765)) wavelength1 = 12398 / 7400 #wavelength for 2 color experiment in Angstroms wavelength2 = 12398 / 7500 #wavelength for 2 color experiment in Angstroms beam1 = beam_factory.simple_directional((0, 0, 1), wavelength1) beam2 = beam_factory.simple_directional((0, 0, 1), wavelength2) beams = [beam1, beam2] for i in range(100): data = two_color_still_sim.two_color_still_sim(known_symmetry, rot=None) hkl_list = data.hkl_list A = data.A sim_data = data.ewald_proximity_test(beams, hkl_list, A, detector) refl = sim_data.get('reflection_table') refl1 = refl.select(refl['set_id'] == 0) refl2 = refl.select(refl['set_id'] == 1) # unit test to make sure all miller indices are unique for each experiment id assert len(refl1['miller_index']) == len(set(refl1['miller_index'])) assert len(refl2['miller_index']) == len(set(refl2['miller_index'])) print "ok"
def _detector(self): """ Create the detector model """ from scitbx import matrix from dxtbx.model.detector import DetectorFactory configuration = self.header["configuration"] info = self.header["info"] # from pprint import pprint # pprint(configuration) # Set the trusted range # trusted_range = 0, configuration['countrate_correction_count_cutoff'] trusted_range = 0, 2**configuration["bit_depth_readout"] - 1 # Get the sensor material and thickness sensor_material = str(configuration["sensor_material"]) sensor_thickness = configuration["sensor_thickness"] beam_center = configuration["beam_center_x"], configuration[ "beam_center_y"] distance = configuration["detector_distance"] # Get the pixel and image sizes pixel_size = (configuration["x_pixel_size"], configuration["y_pixel_size"]) # Image size is not x/y_pixels_in_detector, which are likely the physical dimensions image_size = (info["shape"][0], info["shape"][1]) # Get the detector axes # TODO Spec doesn't have detector_orientation # TODO THIS NEEDS FIXING # fast_axis = (1, 0, 0) # slow_axis = (0, 1, 0) # origin = (0, 0, -1) fast_axis = configuration["detector_orientation"][0:3] slow_axis = configuration["detector_orientation"][3:6] origin = matrix.col( configuration["detector_translation"]) + matrix.col( (0, 0, -distance)) # Create the detector model return DetectorFactory.make_detector( "SENSOR_PAD", fast_axis, slow_axis, origin, pixel_size, image_size, trusted_range, px_mm=None, name="Panel", thickness=sensor_thickness, material=sensor_material, mu=0.0, )
def test_detector(): '''A test class for the detector class.''' d = DetectorFactory.simple('CCD', 100.0, (45.0, 52.0), '+x', '-y', (0.172, 0.172), (516, 590), (0, 1024), []) t = DetectorFactory.two_theta( 'CCD', 60.0, (35.0, 34.0), '+x', '+y', '+x', 30, (0.07, 0.07), (1042, 1042), (0, 1024), []) import libtbx.load_env import os dxtbx_dir = libtbx.env.dist_path('dxtbx') image = os.path.join(dxtbx_dir, 'tests', 'phi_scan_001.cbf') xparm = os.path.join(dxtbx_dir, 'tests', 'example-xparm.xds') c = DetectorFactory.imgCIF(image, 'CCD')
def __init__(self, image_file, **kwargs): from dxtbx import IncorrectFormatError if not self.understand(image_file): raise IncorrectFormatError(self, image_file) FormatHDF5.__init__(self, image_file, **kwargs) self.DET64 = DetectorFactory.from_dict(multi_det_dict.D) self._h5_handle = h5py.File(self.get_image_file(), 'r') self._geometry_define()
def test_cbf_buffer(dials_regression): filename = os.path.join(dials_regression, "image_examples", "dials-190", "whatev1_01_00001.cbf") with open(filename, "rb") as f: contents = f.read() handle = pycbf.cbf_handle_struct() cbf_read_buffer(handle, contents, pycbf.MSG_DIGEST) det = DetectorFactory.imgCIF_H(handle, "unknown") assert det
def _construct_detector(distance): return DetectorFactory.simple( sensor="PAD", distance=distance, beam_centre=(41.20, 51.69), fast_direction="+x", slow_direction="-y", pixel_size=(0.172, 0.172), image_size=(487, 619), trusted_range=(-1, 1e8), )
def __init__(self, start, num): self.start = start self.num = num assert self.start > 0 and self.num > 1 # Set up detector distance = 1590.00 pixel_size = 0.055 image_size = (1024, 1024) beam_centre_mm = ( pixel_size * image_size[0] / 2, pixel_size * image_size[1] / 2, ) self.detector = DetectorFactory().simple( "PAD", distance, beam_centre_mm, "+x", "-y", (pixel_size, pixel_size), image_size, trusted_range=(-1, 1000000), ) # Set up unpolarized 200 keV beam wavelength = 0.02508 self.beam = BeamFactory().make_polarized_beam( sample_to_source=(0.0, 0.0, 1.0), wavelength=wavelength, polarization=(0, 1, 0), polarization_fraction=0.5, ) # Set up simulated structure factors self.sfall = self.fcalc_from_pdb(resolution=2.0) self._unit_cell = self.cell_from_pdb() a, b, c, aa, bb, cc = self._unit_cell.parameters() self.experiments = ExperimentList() for _ in range(self.num): # Set up crystal - does not need to be correct, it is overwritten anyway crystal = Crystal( real_space_a=(a, 0, 0), real_space_b=(0, b, 0), real_space_c=(0, 0, c), space_group_symbol="P 43 21 2", ) self.experiments.append( Experiment(beam=self.beam, detector=self.detector, crystal=crystal))
def _construct_detector(distance): return DetectorFactory.simple( sensor="PAD", distance=distance, beam_centre=(216.87, 211.32), fast_direction="+x", slow_direction="-y", pixel_size=(0.172, 0.172), image_size=(2463, 2527), trusted_range=(-1, 1e8), )
def simple_detector(detector_distance_mm, pixelsize_mm, image_shape, fast=(1, 0, 0), slow=(0, -1, 0)): from dxtbx.model.detector import DetectorFactory import numpy as np trusted_range = (0, 200000000000000.0) detsize_s = image_shape[0] * pixelsize_mm detsize_f = image_shape[1] * pixelsize_mm cent_s = (detsize_s + pixelsize_mm * 2) / 2.0 cent_f = (detsize_f + pixelsize_mm * 2) / 2.0 beam_axis = np.cross(fast, slow) origin = -np.array(fast) * cent_f - np.array(slow) * cent_s + beam_axis * detector_distance_mm return DetectorFactory.make_detector('', fast, slow, origin, ( pixelsize_mm, pixelsize_mm), image_shape, trusted_range)
def _detector(self): ''' Create the detector model ''' from scitbx import matrix from dxtbx.model.detector import DetectorFactory configuration = self.header['configuration'] # Set the trusted range trusted_range = 0, configuration['countrate_correction_count_cutoff'] # Get the sensor material and thickness sensor_material = str(configuration['sensor_material']) sensor_thickness = configuration['sensor_thickness'] beam_center = configuration['beam_center_x'], configuration[ 'beam_center_y'] distance = configuration['detector_distance'] # Get the pixel and image sizes pixel_size = (configuration['x_pixel_size'], configuration['y_pixel_size']) image_size = (configuration['x_pixels_in_detector'], configuration['y_pixels_in_detector']) # Get the detector axes # TODO Spec doesn't have detector_orientation # TODO THIS NEEDS FIXING fast_axis = (1, 0, 0) slow_axis = (0, 1, 0) origin = (0, 0, -1) # fast_axis = configuration['detector_orientation'][0:3] # slow_axis = configuration['detector_orientation'][3:6] #origin = matrix.col(configuration['detector_translation']) + matrix.col((0,0,-distance)) # Create the detector model return DetectorFactory.make_detector('SENSOR_PAD', fast_axis, slow_axis, origin, pixel_size, image_size, trusted_range, px_mm=None, name='Panel', thickness=sensor_thickness, material=sensor_material, mu=0.0)
def _detector(self): """ Create the detector model """ configuration = self.header["configuration"] info = self.header["info"] # from pprint import pprint # pprint(configuration) # Set the trusted range trusted_range = 0, 2**configuration["bit_depth_readout"] - 1 # Get the sensor material and thickness sensor_material = str(configuration["sensor_material"]) sensor_thickness = configuration["sensor_thickness"] distance = configuration["detector_distance"] # Get the pixel and image sizes pixel_size = (configuration["x_pixel_size"], configuration["y_pixel_size"]) # Image size is not x/y_pixels_in_detector, which are likely the physical dimensions image_size = (info["shape"][0], info["shape"][1]) # Get the detector axes fast_axis = configuration["detector_orientation"][0:3] slow_axis = configuration["detector_orientation"][3:6] origin = matrix.col( configuration["detector_translation"]) + matrix.col( (0, 0, -distance)) # Create the detector model return DetectorFactory.make_detector( "SENSOR_PAD", fast_axis, slow_axis, origin, pixel_size, image_size, trusted_range, px_mm=None, name="Panel", thickness=sensor_thickness, material=sensor_material, mu=0.0, )
def get_basis(): '''gets the input basis vectors of 100 simulated diffraction images''' flex.set_random_seed(42) known_symmetry = crystal.symmetry("78,78,37,90,90,90", "P43212") detector = detector_factory.simple('SENSOR_UNKNOWN', 125, (97.075, 97.075), '+x', '-y', (0.11, 0.11), (1765, 1765)) wavelength1 = 12398 / 7400 #wavelength for 2 color experiment in Angstroms wavelength2 = 12398 / 7500 #wavelength for 2 color experiment in Angstroms beam1 = beam_factory.simple_directional((0, 0, 1), wavelength1) beam2 = beam_factory.simple_directional((0, 0, 1), wavelength2) a_basis = [] b_basis = [] c_basis = [] unique_vectors = [] # refiner resets random number seed so in order to get the same 100 images #generated each time the random seed is set # the implementation is as follows sims = [merge_close_spots.merge_close_spots() for i in range(2)] for data in sims: A = data.A A_inv = A.inverse() a = col(A_inv[:3]) b = col(A_inv[3:6]) c = col(A_inv[6:]) a_basis.append(a) b_basis.append(b) c_basis.append(c) res = data.two_color_sim info = data.spot_proximity(res) refl = info[0] candidate_basis_vectors = index(refl, detector, known_symmetry, [beam1, beam2]) unique_vectors.append(candidate_basis_vectors) return a_basis, b_basis, c_basis, unique_vectors
def basic_detector( ): # from development, not actually used here but useful for reference # make a detector panel # monolithic camera description print("Make a dxtbx detector") detdist = 141.7 pixsize = 0.088 # Rayonix MX340-XFEL, 2x2 binning mode im_shape = 3840, 3840 det_descr = { 'panels': [{ 'fast_axis': (1.0, 0.0, 0.0), 'slow_axis': (0.0, -1.0, 0.0), 'gain': 1.0, 'identifier': '', 'image_size': im_shape, 'mask': [], 'material': '', 'mu': 0.0, 'name': 'Panel', 'origin': (-im_shape[0] * pixsize / 2., im_shape[1] * pixsize / 2., -detdist), 'pedestal': 0.0, 'pixel_size': (pixsize, pixsize), 'px_mm_strategy': { 'type': 'SimplePxMmStrategy' }, 'raw_image_offset': (0, 0), 'thickness': 0.0, 'trusted_range': (-1e7, 1e7), 'type': '' }] } return DetectorFactory.from_dict(det_descr)
def basic_detector(): # make a detector panel # monolithic camera description print("Make a dxtbx detector") detdist = 100. pixsize = 0.1 im_shape = 1536, 1536 det_descr = { 'panels': [{ 'fast_axis': (1.0, 0.0, 0.0), 'slow_axis': (0.0, -1.0, 0.0), 'gain': 1.0, 'identifier': '', 'image_size': im_shape, 'mask': [], 'material': '', 'mu': 0.0, 'name': 'Panel', 'origin': (-im_shape[0] * pixsize / 2., im_shape[1] * pixsize / 2., -detdist), 'pedestal': 0.0, 'pixel_size': (pixsize, pixsize), 'px_mm_strategy': { 'type': 'SimplePxMmStrategy' }, 'raw_image_offset': (0, 0), 'thickness': 0.0, 'trusted_range': (-1e7, 1e7), 'type': '' }] } return DetectorFactory.from_dict(det_descr)
'mask': [], 'material': '', 'mu': 0.0, 'name': 'Panel', 'origin': (-im_shape[0]*pixsize/2., im_shape[1]*pixsize/2., -detdist), 'pedestal': 0.0, 'pixel_size': (pixsize, pixsize), 'px_mm_strategy': {'type': 'SimplePxMmStrategy'}, 'raw_image_offset': (0, 0), 'thickness': 0.0, 'trusted_range': (-1e7, 1e7), 'type': ''}]} # make the dxtbx objects BEAM = BeamFactory.from_dict(beam_descr) DETECTOR = DetectorFactory.from_dict(det_descr) CRYSTAL = CrystalFactory.from_dict(cryst_descr) # make a dummie HKL table with constant HKL intensity # this is just to make spots DEFAULT_F = 1e2 symbol = CRYSTAL.get_space_group().info().type().lookup_symbol() # this is just P43212 sgi = sgtbx.space_group_info(symbol) symm = symmetry(unit_cell=CRYSTAL.get_unit_cell(), space_group_info=sgi) miller_set = symm.build_miller_set(anomalous_flag=True, d_min=1.6, d_max=999) Famp = flex.double(np.ones(len(miller_set.indices())) * DEFAULT_F) Famp = miller.array(miller_set=miller_set, data=Famp).set_observation_type_xray_amplitude() Ncells_abc = 20, 20, 20 oversmaple = 2
def test_indexed_hkl(): '''tests the uniqueness of hkl values associated with each experiment for 100 simulated randomly oriented thermolysin diffraction images indexed using two color indexer''' flex.set_random_seed(42) known_symmetry = crystal.symmetry("78,78,37,90,90,90", "P43212") detector = detector_factory.simple('SENSOR_UNKNOWN', 125, (97.075, 97.075), '+x', '-y', (0.11, 0.11), (1765, 1765)) wavelength1 = 12398 / 7400 #wavelength for 2 color experiment in Angstroms wavelength2 = 12398 / 7500 #wavelength for 2 color experiment in Angstroms beam1 = beam_factory.simple_directional((0, 0, 1), wavelength1) beam2 = beam_factory.simple_directional((0, 0, 1), wavelength2) a_basis = [] b_basis = [] c_basis = [] # refiner resets random number seed so in order to get the same 100 images #generated each time the random seed is set # the implementation is as follows # gets simulated images sims = [merge_close_spots.merge_close_spots() for i in range(2)] for data in sims: A = data.A A_inv = A.inverse() a = col(A_inv[:3]) b = col(A_inv[3:6]) c = col(A_inv[6:]) crystinp = Crystal(a, b, c, space_group=known_symmetry.space_group()) a_basis.append(a) b_basis.append(b) c_basis.append(c) res = data.two_color_sim info = data.spot_proximity(res) refl = info[0] result = index(refl, detector, known_symmetry, [beam1, beam2]) cm = result.refined_experiments.crystals()[0] R, best_axis, best_angle, change_of_basis = difference_rotation_matrix_axis_angle( crystal_a=cm, crystal_b=crystinp) # cmd_line = command_line.argument_interpreter(master_params=master_phil_scope) # working_phil = cmd_line.process_and_fetch(args=[]) params = master_phil_scope.extract() params.refinement.parameterisation.beam.fix = "all" params.refinement.parameterisation.detector.fix = "all" params.indexing.known_symmetry.space_group = known_symmetry.space_group_info( ) params.refinement.verbosity = 3 params.indexing.refinement_protocol.d_min_start = 3 params.indexing.refinement_protocol.n_macro_cycles = 1 params.indexing.known_symmetry.unit_cell = known_symmetry.unit_cell() params.indexing.multiple_lattice_search.max_lattices = 1 params.indexing.debug = True params.indexing.known_symmetry.absolute_angle_tolerance = 5.0 params.indexing.known_symmetry.relative_length_tolerance = 0.3 params.indexing.stills.rmsd_min_px = 3.5 expts = copy.deepcopy(result.refined_experiments) expts.crystals()[0].change_basis(change_of_basis) reflections_exp0 = result.refined_reflections.select( result.refined_reflections['id'] == 0) reflections_exp1 = result.refined_reflections.select( result.refined_reflections['id'] == 1) assert len(reflections_exp0['miller_index']) == len( set(reflections_exp0['miller_index'])) assert len(reflections_exp1['miller_index']) == len( set(reflections_exp1['miller_index'])) print "OK"
def test_from_phil(): from dxtbx.model.detector import detector_phil_scope from dxtbx.model.detector import DetectorFactory, ParallaxCorrectedPxMmStrategy from libtbx.phil import parse from dxtbx.model import Beam beam = Beam((0, 0, 1)) params = detector_phil_scope.fetch( parse(''' detector { panel { id = 0 origin = (1, 1, 1) pixel_size = (0.001,0.001) image_size = (1000,1000) trusted_range = (-1, 1000) material = "Si" thickness = 0.01 parallax_correction = True } panel { id = 1 origin = (2, 2, 2) pixel_size = (0.001,0.001) image_size = (1000,1000) trusted_range = (-1, 1000) } panel { id = 2 origin = (3, 3, 3) pixel_size = (0.001,0.001) image_size = (1000,1000) trusted_range = (-1, 1000) } panel { id = 3 origin = (4, 4, 4) pixel_size = (0.001,0.001) image_size = (1000,1000) trusted_range = (-1, 1000) } hierarchy { name = "Root" origin = (100, 100, 100) group { id = 0 origin = (10, 10, 10) } group { id = 0,0 origin = (1, 1, 1) panel = 0 } group { id = 0,1 origin = (2, 2, 2) panel = 1 } group { id = 1 origin = (20, 20, 20) } group { id = 1,0 origin = (1, 1, 1) panel = 2 } group { id = 1,1 origin = (2, 2, 2) panel = 3 } } } ''')).extract() # Test create model d1 = DetectorFactory.from_phil(params, beam=beam) root = d1.hierarchy() # Check hierarchy origins assert root.get_origin() == (100, 100, 100) assert root[0].get_origin() == (110, 110, 110) assert root[1].get_origin() == (120, 120, 120) assert root[0][0].get_origin() == (111, 111, 111) assert root[0][1].get_origin() == (112, 112, 112) assert root[1][0].get_origin() == (121, 121, 121) assert root[1][1].get_origin() == (122, 122, 122) assert root[0][0][0].get_origin() == (112, 112, 112) assert root[0][1][0].get_origin() == (114, 114, 114) assert root[1][0][0].get_origin() == (124, 124, 124) assert root[1][1][0].get_origin() == (126, 126, 126) # Check panels are correct in hierarchy assert root[0][0][0].is_(d1[0]) assert root[0][1][0].is_(d1[1]) assert root[1][0][0].is_(d1[2]) assert root[1][1][0].is_(d1[3]) # Check panel attributes assert d1[0].get_image_size() == (1000, 1000) assert d1[0].get_pixel_size() == (0.001, 0.001) assert d1[0].get_trusted_range() == (-1, 1000) assert d1[0].get_material() == "Si" assert d1[0].get_thickness() == 0.01 assert isinstance(d1[0].get_px_mm_strategy(), ParallaxCorrectedPxMmStrategy) assert d1[1].get_image_size() == (1000, 1000) assert d1[1].get_pixel_size() == (0.001, 0.001) assert d1[1].get_trusted_range() == (-1, 1000) assert d1[2].get_image_size() == (1000, 1000) assert d1[2].get_pixel_size() == (0.001, 0.001) assert d1[2].get_trusted_range() == (-1, 1000) assert d1[3].get_image_size() == (1000, 1000) assert d1[3].get_pixel_size() == (0.001, 0.001) assert d1[3].get_trusted_range() == (-1, 1000) params = detector_phil_scope.fetch( parse(''' detector { panel { id = 0 parallax_correction = False } panel { id = 1 material = "Si" thickness = 0.01 parallax_correction = True } hierarchy { name = "Root" origin = (200, 200, 200) group { id = 0 origin = (20, 20, 20) } group { id = 0,0 origin = (2, 2, 2) } group { id = 0,1 origin = (3, 3, 3) } group { id = 1 origin = (30, 30, 30) } group { id = 1,0 origin = (2, 2, 2) } group { id = 1,1 origin = (3, 3, 3) } } } ''')).extract() # Test overwrite model d2 = DetectorFactory.from_phil(params, reference=d1, beam=beam) root = d2.hierarchy() # Check hierarchy origins assert root.get_origin() == (200, 200, 200) assert root[0].get_origin() == (220, 220, 220) assert root[1].get_origin() == (230, 230, 230) assert root[0][0].get_origin() == (222, 222, 222) assert root[0][1].get_origin() == (223, 223, 223) assert root[1][0].get_origin() == (232, 232, 232) assert root[1][1].get_origin() == (233, 233, 233) assert root[0][0][0].get_origin() == (223, 223, 223) assert root[0][1][0].get_origin() == (225, 225, 225) assert root[1][0][0].get_origin() == (235, 235, 235) assert root[1][1][0].get_origin() == (237, 237, 237) # Check panels are correct in hierarchy assert root[0][0][0].is_(d2[0]) assert root[0][1][0].is_(d2[1]) assert root[1][0][0].is_(d2[2]) assert root[1][1][0].is_(d2[3]) # Check panel attributes assert not isinstance(d2[0].get_px_mm_strategy(), ParallaxCorrectedPxMmStrategy) assert d2[1].get_material() == "Si" assert d2[1].get_thickness() == 0.01 assert isinstance(d2[1].get_px_mm_strategy(), ParallaxCorrectedPxMmStrategy)
# ------------------------ if lab_geom == "canonical": s = 1 # scale factor, divide pixel size by this factor pixsize = .10992/s # mm detdist = 125 # mm wavelen = 1.385 orig = col((-s*1536*pixsize/2., s*1536*pixsize/2., -detdist)) # Initialise detector frame fast = col((1.0, 0.0, 0.0)) slow = col((0.0, -1.0, 0.0)) det = DetectorFactory.make_detector( "", fast, slow, orig, (pixsize, pixsize), (s*1536,s*1536)) #, trusted_range=(0, 10000000)) beam_descr = { 'direction': (7.010833160725592e-06, -3.710515413340211e-06, 0.9999999999685403), 'divergence': 0.0, 'flux': 0.0, 'polarization_fraction': 0.999, 'polarization_normal': (0.0, 1.0, 0.0), 'sigma_divergence': 0.0, 'transmission': 1.0, 'wavelength': 1.385} #beam = BeamFactory.simple(wavelen) beam = BeamFactory.from_dict(beam_descr) elif lab_geom == "cspad": det = DetectorFactory.from_dict(dxtbx_cspad.cspad)
def main(): from cxid9114.sim import sim_utils from dxtbx.model.crystal import CrystalFactory from dxtbx_model_ext import flex_Beam from dxtbx.model.detector import DetectorFactory from dxtbx.model.beam import BeamFactory from simtbx.nanoBragg.tst_nanoBragg_basic import fcalc_from_pdb import numpy as np from cxid9114.parameters import ENERGY_CONV energies = np.arange(8920, 8930) fluxes = np.ones(len(energies)) * 5e11 patt_args = {"Ncells_abc": (20, 20, 20), "profile": "square", "verbose": 0} beam_descr = { 'direction': (0.0, 0.0, 1.0), 'divergence': 0.0, 'flux': 5e11, 'polarization_fraction': 1., 'polarization_normal': (0.0, 1.0, 0.0), 'sigma_divergence': 0.0, 'transmission': 1.0, 'wavelength': ENERGY_CONV / energies[0] } cryst_descr = { '__id__': 'crystal', 'real_space_a': (79, 0, 0), 'real_space_b': (0, 79, 0), 'real_space_c': (0, 0, 38), 'space_group_hall_symbol': '-P 4 2' } det_descr = { 'panels': [{ 'fast_axis': (-1.0, 0.0, 0.0), 'gain': 1.0, 'identifier': '', 'image_size': (196, 196), 'mask': [], 'material': '', 'mu': 0.0, 'name': 'Panel', 'origin': (19.6, -19.6, -550), 'pedestal': 0.0, 'pixel_size': (0.1, 0.1), 'px_mm_strategy': { 'type': 'SimplePxMmStrategy' }, 'raw_image_offset': (0, 0), 'slow_axis': (0.0, 1.0, 0.0), 'thickness': 0.0, 'trusted_range': (0.0, 65536.0), 'type': '' }] } DET = DetectorFactory.from_dict(det_descr) BEAM = BeamFactory.from_dict(beam_descr) crystal = CrystalFactory.from_dict(cryst_descr) Patt = sim_utils.PatternFactory(crystal=crystal, detector=DET, beam=BEAM, **patt_args) img = None Fens = [] xrbeams = flex_Beam() for fl, en in zip(fluxes, energies): wave = ENERGY_CONV / en F = fcalc_from_pdb(resolution=4, algorithm="fft", wavelength=wave) Patt.primer(crystal, energy=en, flux=fl, F=F) if img is None: img = Patt.sim_rois(reset=True) # defaults to full detector else: img += Patt.sim_rois(reset=True) Fens.append(F) xrb = BeamFactory.from_dict(beam_descr) xrb.set_wavelength(wave * 1e-10) # need to fix the necessity to do this.. xrb.set_flux(fl) xrb.set_direction(BEAM.get_direction()) xrbeams.append(xrb) #import pylab as plt #def plot_img(ax,img): # m = img[img >0].mean() # s = img[img > 0].std() # vmax = m+5*s # vmin = 0 # ax.imshow(img, vmin=vmin, vmax=vmax, cmap='gnuplot') print("\n\n\n") print("<><><><><><><><><><>") print("NEXT TRIAL") print("<><><><><><><><><><>") # patt2 = sim_utils.PatternFactory(crystal=crystal, detector=DET, beam=xrbeams, **patt_args) patt2.prime_multi_Fhkl(multisource_Fhkl=Fens) img2 = patt2.sim_rois(reset=True) #plt.figure() #ax1 = plt.gca() #plt.figure() #ax2 = plt.gca() #plot_img(ax1, img) #plot_img(ax2, img2) #plt.show() assert (np.allclose(img, img2))
'material': '', 'mu': 0.0, 'name': 'Panel', 'origin': (-99.165, 99.05499999999999, -125.0), 'pedestal': 0.0, 'pixel_size': (0.11, 0.11), 'px_mm_strategy': { 'type': 'SimplePxMmStrategy' }, 'raw_image_offset': (0, 0), 'slow_axis': (0.0, -1.0, 0.0), 'thickness': 0.0, 'trusted_range': (-29.0, 65505.0), 'type': 'SENSOR_CCD' }] } beamDict = { 'direction': (0.0, 0.0, 1.0), 'divergence': 0.0, 'flux': 0.0, 'polarization_fraction': 0.999, 'polarization_normal': (0.0, 1.0, 0.0), 'sigma_divergence': 0.0, 'transmission': 1.0, 'wavelength': 1.37095 } BEAM = BeamFactory.from_dict(beamDict) DET = DetectorFactory.from_dict(detDict)