def tst_consistent(self): from dxtbx.imageset import ImageSetFactory from glob import glob from os.path import join from dxtbx.model import Scan # Create a sweep sweep_filenames = join(self.path, 'centroid_test_data', 'centroid*.cbf') sweep = ImageSetFactory.new(sorted(glob(sweep_filenames)))[0] # Create experiment with sweep and good scan e = Experiment(imageset=sweep, scan=sweep.get_scan()) assert(e.is_consistent()) # Create experiment with sweep and defective scan scan = sweep.get_scan() scan.set_image_range((1, 1)) e = Experiment(imageset=sweep, scan=scan) #assert(not e.is_consistent()) # FIXME ## Create experiment with imageset and good scan #assert(e.is_consistent()) ## Create experiment with imageset and non-still scan #assert(not e.is_consistent()) ## Create experiment with imageset and scan with more than 1 image #assert(not e.is_consistent()) ## Create experiment with imageset and defective scan #assert(not e.is_consistent()) # Test passed print 'OK'
def generate_spots(crystal_model, detector, beam, goniometer=None, scan=None, sel_fraction=1.0): import math experiment = Experiment(beam=beam, detector=detector, goniometer=goniometer, scan=scan, crystal=crystal_model) # if we don't set the imageset then from_predictions uses the StillsReflectionPredictor :-( from dxtbx.imageset import NullReader, ImageSweep imageset = ImageSweep(NullReader, indices=range(len(scan.get_epochs())), beam=beam, goniometer=goniometer, detector=detector, scan=scan) experiment.imageset = imageset predicted = flex.reflection_table.from_predictions(experiment) sel = flex.random_selection(len(predicted), int(math.floor(sel_fraction*len(predicted)))) predicted = predicted.select(sel) predicted['imageset_id'] = flex.size_t(len(predicted), 0) predicted['xyzobs.px.value'] = predicted['xyzcal.px'] predicted['xyzobs.px.variance'] = flex.vec3_double( len(predicted), (0.5,0.5,0.5)) return predicted
def generate_spots(crystal_model, detector, beam, goniometer=None, scan=None, sel_fraction=1.0): import math experiment = Experiment(beam=beam, detector=detector, goniometer=goniometer, scan=scan, crystal=crystal_model) # if we don't set the imageset then from_predictions uses the StillsReflectionPredictor :-( from dxtbx.imageset import NullReader, ImageSweep imageset = ImageSweep(NullReader, indices=range(len(scan.get_epochs())), beam=beam, goniometer=goniometer, detector=detector, scan=scan) experiment.imageset = imageset predicted = flex.reflection_table.from_predictions(experiment) sel = flex.random_selection(len(predicted), int(math.floor(sel_fraction * len(predicted)))) predicted = predicted.select(sel) predicted['imageset_id'] = flex.size_t(len(predicted), 0) predicted['xyzobs.px.value'] = predicted['xyzcal.px'] predicted['xyzobs.px.variance'] = flex.vec3_double(len(predicted), (0.5, 0.5, 0.5)) return predicted
def predict_reflections(self): from dials.algorithms import shoebox from dials.array_family import flex from dxtbx.model.experiment.experiment_list import ExperimentList from dxtbx.model.experiment.experiment_list import Experiment from dials.algorithms.profile_model.gaussian_rs import Model # Get models from the sweep self.beam = self.sweep.get_beam() self.detector = self.sweep.get_detector() self.gonio = self.sweep.get_goniometer() self.scan = self.sweep.get_scan() sigma_b = self.beam.get_sigma_divergence(deg=True) sigma_m = self.crystal.get_mosaicity(deg=True) exlist = ExperimentList() exlist.append( Experiment(imageset=self.sweep, beam=self.beam, detector=self.detector, goniometer=self.gonio, scan=self.scan, crystal=self.crystal, profile=Model(None, 3, sigma_b, sigma_m, deg=True))) predicted = flex.reflection_table.from_predictions(exlist[0]) predicted['id'] = flex.int(len(predicted), 0) predicted.compute_bbox(exlist) # Find overlapping reflections overlaps = shoebox.find_overlapping(predicted['bbox']) # Return the reflections and overlaps return predicted, overlaps
def predict_once(args): from dxtbx.model.experiment.experiment_list import Experiment U = args[0] A = U * B direct_matrix = A.inverse() cryst_model = crystal_model( direct_matrix[0:3], direct_matrix[3:6], direct_matrix[6:9], space_group=space_group, ) experiment = Experiment( imageset=sweep, beam=sweep.get_beam(), detector=sweep.get_detector(), goniometer=sweep.get_goniometer(), scan=sweep.get_scan(), crystal=cryst_model, ) predicted_reflections = flex.reflection_table.from_predictions(experiment) miller_indices = predicted_reflections["miller_index"] miller_set = miller.set(crystal_symmetry, miller_indices, anomalous_flag=True) if params.d_min is not None: resolution_sel = miller_set.d_spacings().data() > params.d_min predicted_reflections = predicted_reflections.select(resolution_sel) return len(predicted_reflections)
def __init__(self, reflections, crystal, beam, detector, goniometer, scan, min_zeta=0.05): ''' Calculate the profile model. ''' from dxtbx.model.experiment.experiment_list import Experiment from dials.array_family import flex from math import pi # Check input has what we want assert (reflections is not None) assert ("miller_index" in reflections) assert ("s1" in reflections) assert ("shoebox" in reflections) assert ("xyzobs.px.value" in reflections) assert ("xyzcal.mm" in reflections) # Calculate the E.S.D of the beam divergence logger.info('Calculating E.S.D Beam Divergence.') beam_divergence = ComputeEsdBeamDivergence(detector, reflections) # Set the sigma b self._sigma_b = beam_divergence.sigma() # FIXME Calculate properly if goniometer is None or scan is None or scan.get_oscillation( )[1] == 0: self._sigma_m = 0.0 else: # Select by zeta zeta = reflections.compute_zeta( Experiment(crystal=crystal, beam=beam, detector=detector, goniometer=goniometer, scan=scan)) mask = flex.abs(zeta) >= min_zeta reflections = reflections.select(mask) # Calculate the E.S.D of the reflecting range logger.info('Calculating E.S.D Reflecting Range.') reflecting_range = ComputeEsdReflectingRange( crystal, beam, detector, goniometer, scan, reflections) # Set the sigmas self._sigma_m = reflecting_range.sigma() # Print the output logger.info(' sigma b: %f degrees' % (self._sigma_b * 180 / pi)) logger.info(' sigma m: %f degrees' % (self._sigma_m * 180 / pi))
def experiment_list_for_crystal(self, crystal): experiments = ExperimentList() for imageset in self.imagesets: experiments.append( Experiment(imageset=imageset, beam=imageset.get_beam(), detector=imageset.get_detector(), goniometer=imageset.get_goniometer(), scan=imageset.get_scan(), crystal=crystal)) return experiments
def tst_equality(self): from dxtbx.model import Beam, Detector, Goniometer, Scan from dxtbx.model.crystal import crystal_model # Create a load of models b1 = Beam() d1 = Detector() g1 = Goniometer() s1 = Scan() c1 = crystal_model((1, 0, 0), (0, 1, 0), (0, 0, 1), 0) # Create a load of models that look the same but aren't b2 = Beam() d2 = Detector() g2 = Goniometer() s2 = Scan() c2 = crystal_model((1, 0, 0), (0, 1, 0), (0, 0, 1), 0) # Create an experiment e1 = Experiment( beam=b1, detector=d1, goniometer=g1, scan=s1, crystal=c1, imageset=None) # Create an experiment e2 = Experiment( beam=b1, detector=d1, goniometer=g1, scan=s1, crystal=c1, imageset=None) # Create an experiment e3 = Experiment( beam=b2, detector=d2, goniometer=g2, scan=s2, crystal=c2, imageset=None) # Check e1 equals e2 but not e3 assert(e1 == e2) assert(e1 != e3) assert(e2 != e3) # Test passed print 'OK'
class Test(object): def __init__(self): import os import libtbx.load_env from dxtbx.serialize.load import crystal as load_crystal from dials.model.serialize import load from dials.algorithms.profile_model.gaussian_rs import Model from dials.algorithms.profile_model.gaussian_rs import MaskCalculator3D from dxtbx.model.experiment.experiment_list import Experiment, ExperimentList try: dials_regression = libtbx.env.dist_path('dials_regression') except KeyError, e: print 'FAIL: dials_regression not configured' exit(0) # Set the sweep filename and load the sweep sweep_filename = os.path.join(dials_regression, 'centroid_test_data', 'sweep.json') crystal_filename = os.path.join(dials_regression, 'centroid_test_data', 'crystal.json') # Load the sweep self.sweep = load.sweep(sweep_filename) self.crystal = load_crystal(crystal_filename) self.beam = self.sweep.get_beam() self.detector = self.sweep.get_detector() self.goniometer = self.sweep.get_goniometer() self.scan = self.sweep.get_scan() self.delta_d = 3 * self.beam.get_sigma_divergence(deg=False) self.delta_m = 3 * self.crystal.get_mosaicity(deg=False) self.nsigma = 3 self.profile_model = Model(None, self.nsigma, self.beam.get_sigma_divergence(deg=False), self.crystal.get_mosaicity(deg=False)) self.experiment = ExperimentList() self.experiment.append( Experiment(imageset=self.sweep, beam=self.beam, detector=self.detector, goniometer=self.goniometer, scan=self.scan, crystal=self.crystal, profile=self.profile_model)) assert (len(self.detector) == 1) # Get the function object to mask the foreground self.mask_foreground = MaskCalculator3D(self.beam, self.detector, self.goniometer, self.scan, self.delta_d, self.delta_m)
def __init__(self, test_nave_model = False): # Set up experimental models with regular geometry from dxtbx.model.experiment import beam_factory from dxtbx.model.experiment import goniometer_factory from dxtbx.model.experiment import detector_factory from dxtbx.model.crystal import crystal_model # Beam along the Z axis self.beam = beam_factory.make_beam(unit_s0 = matrix.col((0, 0, 1)), wavelength = 1.0) # Goniometer (used only for index generation) along X axis self.goniometer = goniometer_factory.known_axis(matrix.col((1, 0, 0))) # Detector fast, slow along X, -Y; beam in the centre, 200 mm distance dir1 = matrix.col((1, 0, 0)) dir2 = matrix.col((0, -1, 0)) n = matrix.col((0, 0, 1)) centre = matrix.col((0, 0, 200)) npx_fast = npx_slow = 1000 pix_size = 0.2 origin = centre - (0.5 * npx_fast * pix_size * dir1 + 0.5 * npx_slow * pix_size * dir2) self.detector = detector_factory.make_detector("PAD", dir1, dir2, origin, (pix_size, pix_size), (npx_fast, npx_slow), (0, 1.e6)) # Cubic 100 A^3 crystal a = matrix.col((100, 0, 0)) b = matrix.col((0, 100, 0)) c = matrix.col((0, 0, 100)) self.crystal = crystal_model(a, b, c, space_group_symbol = "P 1") if test_nave_model: self.crystal._ML_half_mosaicity_deg = 500 self.crystal._ML_domain_size_ang = 0.2 # Collect these models in an Experiment (ignoring the goniometer) from dxtbx.model.experiment.experiment_list import Experiment self.experiment = Experiment(beam=self.beam, detector=self.detector, goniometer=None, scan=None, crystal=self.crystal, imageset=None) # Generate some reflections self.reflections = self.generate_reflections() return
def find_lattices(self): self.real_space_grid_search() crystal_models = self.candidate_crystal_models experiments = ExperimentList() for cm in crystal_models: for imageset in self.imagesets: experiments.append( Experiment(imageset=imageset, beam=imageset.get_beam(), detector=imageset.get_detector(), goniometer=imageset.get_goniometer(), scan=imageset.get_scan(), crystal=cm)) return experiments
def combine_crystals(experiments): '''Replace all crystals in the experiments list with the first crystal''' from dxtbx.model.experiment.experiment_list import Experiment, ExperimentList new_experiments = ExperimentList() ref_crystal = experiments[0].crystal for exp in experiments: new_experiments.append( Experiment(beam=exp.beam, detector=exp.detector, scan=exp.scan, goniometer=exp.goniometer, crystal=ref_crystal, imageset=exp.imageset)) return new_experiments
def find_lattices(self): experiments = ExperimentList() for cm in self.known_orientations: # indexer expects crystals to be in primitive setting space_group = cm.get_space_group() cb_op_to_primitive \ = space_group.info().change_of_basis_op_to_primitive_setting() cm = cm.change_basis(cb_op_to_primitive) for imageset in self.imagesets: experiments.append( Experiment(imageset=imageset, beam=imageset.get_beam(), detector=imageset.get_detector(), goniometer=imageset.get_goniometer(), scan=imageset.get_scan(), crystal=cm)) return experiments
def tst_index(self): # Check the indices of exisiting experiments assert(self.el.index(self.el[0]) is 0) assert(self.el.index(self.el[1]) is 1) assert(self.el.index(self.el[2]) is 2) assert(self.el.index(self.el[3]) is 1) assert(self.el.index(self.el[4]) is 0) # Check index of non exisiting experiment try: self.el.index(Experiment()) assert(False) except ValueError: pass # Test passed print 'OK'
def create_models(self, cmdline_overrides=None): if cmdline_overrides is None: cmdline_overrides = [] overrides = """geometry.parameters.crystal.a.length.range = 10 50 geometry.parameters.crystal.b.length.range = 10 50 geometry.parameters.crystal.c.length.range = 10 50""" master_phil = parse(""" include scope dials.test.algorithms.refinement.geometry_phil """, process_includes=True) # Extract models models = Extract(master_phil, overrides, cmdline_args = cmdline_overrides) self.detector = models.detector self.goniometer = models.goniometer self.crystal = models.crystal self.beam = models.beam # Make a scan of 1-360 * 0.5 deg images sf = scan_factory() self.scan = sf.make_scan((1,360), 0.5, (0, 0.5), range(360)) # Generate an ExperimentList self.experiments = ExperimentList() self.experiments.append(Experiment( beam=self.beam, detector=self.detector, goniometer=self.goniometer, scan=self.scan, crystal=self.crystal, imageset=None)) # Create a reflection predictor for the experiments self.ref_predictor = ExperimentsPredictor(self.experiments) # Create scan-varying parameterisations of these models, with 5 samples self.det_param = ScanVaryingDetectorParameterisationSinglePanel( self.detector, self.scan.get_array_range(), 5) self.s0_param = ScanVaryingBeamParameterisation( self.beam, self.scan.get_array_range(), 5, self.goniometer) self.xlo_param = ScanVaryingCrystalOrientationParameterisation( self.crystal, self.scan.get_array_range(), 5) self.xluc_param = ScanVaryingCrystalUnitCellParameterisation( self.crystal, self.scan.get_array_range(), 5) return
def generate(self): from dxtbx.model import Beam, Detector, Goniometer, Scan # Initialise a list of experiments experiments = ExperimentList() # Create a few beams b1 = Beam() b2 = Beam() b3 = Beam() # Create a few detectors d1 = Detector() d2 = Detector() d3 = Detector() # Create a few goniometers g1 = Goniometer() g2 = Goniometer() g3 = Goniometer() # Create a few scans s1 = Scan() s2 = Scan() s3 = Scan() # Create a list of models b = [b1, b2, b3, b2, b1] d = [d1, d2, d3, d2, d1] g = [g1, g2, g3, g2, g1] s = [s1, s2, s3, s2, s1] # Populate with various experiments for i in range(5): experiments.append(Experiment( beam=b[i], detector=d[i], goniometer=g[i], scan=s[i])) # Return the list of experiments return experiments
def tst_contains(self): from dxtbx.model import Beam, Detector, Goniometer, Scan from dxtbx.model.crystal import crystal_model # Create a load of models b1 = Beam() d1 = Detector() g1 = Goniometer() s1 = Scan() c1 = crystal_model((1, 0, 0), (0, 1, 0), (0, 0, 1), 0) # Create an experiment e = Experiment( beam=b1, detector=d1, goniometer=g1, scan=s1, crystal=c1, imageset=None) # Check experiment contains model assert(b1 in e) assert(d1 in e) assert(g1 in e) assert(s1 in e) assert(c1 in e) # Create a load of models that look the same but aren't b2 = Beam() d2 = Detector() g2 = Goniometer() s2 = Scan() c2 = crystal_model((1, 0, 0), (0, 1, 0), (0, 0, 1), 0) # Check experiment doesn't contain model assert(b2 not in e) assert(d2 not in e) assert(g2 not in e) assert(s2 not in e) assert(c2 not in e) # Test passed print 'OK'
def prepare_dxtbx_models(self,setting_specific_ai,sg,isoform=None): from dxtbx.model.beam import beam_factory beam = beam_factory.simple(wavelength = self.inputai.wavelength) from dxtbx.model.detector import detector_factory detector = detector_factory.simple( sensor = detector_factory.sensor("PAD"), distance = setting_specific_ai.distance(), beam_centre = [setting_specific_ai.xbeam(), setting_specific_ai.ybeam()], fast_direction = "+x", slow_direction = "+y", pixel_size = [self.pixel_size,self.pixel_size], image_size = [self.inputpd['size1'],self.inputpd['size1']], ) direct = matrix.sqr(setting_specific_ai.getOrientation().direct_matrix()) from dxtbx.model.crystal import crystal_model crystal = crystal_model( real_space_a = matrix.row(direct[0:3]), real_space_b = matrix.row(direct[3:6]), real_space_c = matrix.row(direct[6:9]), space_group_symbol = sg, mosaicity = setting_specific_ai.getMosaicity() ) if isoform is not None: newB = matrix.sqr(isoform.fractionalization_matrix()).transpose() crystal.set_B(newB) from dxtbx.model.experiment.experiment_list import Experiment, ExperimentList experiments = ExperimentList() experiments.append(Experiment(beam=beam, detector=detector, crystal=crystal)) print beam print detector print crystal return experiments
def setup_models(args): """setup the experimental models""" # Setup experimental models master_phil = parse(""" include scope dials.test.algorithms.refinement.geometry_phil """, process_includes=True) models = setup_geometry.Extract(master_phil, cmdline_args=args) detector = models.detector goniometer = models.goniometer crystal = models.crystal beam = models.beam # Build a mock scan for a 180 degree sweep sf = scan_factory() scan = sf.make_scan(image_range=(1, 180), exposure_times=0.1, oscillation=(0, 1.0), epochs=range(180), deg=True) sweep_range = scan.get_oscillation_range(deg=False) im_width = scan.get_oscillation(deg=False)[1] assert sweep_range == (0., pi) assert approx_equal(im_width, 1.0 * pi / 180.) experiments = ExperimentList() experiments.append( Experiment(beam=beam, detector=detector, goniometer=goniometer, scan=scan, crystal=crystal, imageset=None)) return experiments
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(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 find_lattices(self): self.d_min = self.params.refinement_protocol.d_min_start from rstbx.phil.phil_preferences import indexing_api_defs import iotbx.phil hardcoded_phil = iotbx.phil.parse( input_string=indexing_api_defs).extract() sel = (self.reflections['id'] == -1) if self.d_min is not None: sel &= (1 / self.reflections['rlp'].norms() > self.d_min) reflections = self.reflections.select(sel) solutions = candidate_basis_vectors_fft1d( reflections['rlp'], hardcoded_phil, max_cell=self.params.max_cell) self.candidate_basis_vectors = solutions[0] self.debug_show_candidate_basis_vectors() if self.params.debug_plots: self.debug_plot_candidate_basis_vectors() self.candidate_crystal_models = self.find_candidate_orientation_matrices( self.candidate_basis_vectors, max_combinations=self.params.basis_vector_combinations.max_try) crystal_model, n_indexed = self.choose_best_orientation_matrix( self.candidate_crystal_models) if crystal_model is not None: crystal_models = [crystal_model] else: crystal_models = [] experiments = ExperimentList() for cm in crystal_models: for imageset in self.imagesets: experiments.append( Experiment(imageset=imageset, beam=imageset.get_beam(), detector=imageset.get_detector(), goniometer=imageset.get_goniometer(), scan=imageset.get_scan(), crystal=cm)) return experiments
def get_random_predictions(): """Return a DIALS reflection table representing predictions using the given models. Assumes a Ewald proximity model for mosaicity""" # The U matrix to calculate A* rot = flex.random_double_r3_rotation_matrix() A = sqr(rot) * sqr(uc.reciprocal().orthogonalization_matrix()) A_inv = A.inverse() # Use the matrix to create a crystal model a = col(A_inv[:3]) b = col(A_inv[3:6]) c = col(A_inv[6:]) cm = crystal_model(a, b, c, space_group=spgrp) # This DIALS object has no gonio or scan which will identify it as a still expt = Experiment(beam=beam, detector=detector, goniometer=None, scan=None, crystal=cm) # Predict the reflections return flex.reflection_table.from_predictions(expt)
def create_models(self): # build models, with a larger crystal than default in order to get plenty of # reflections on the 'still' image overrides = """ geometry.parameters.crystal.a.length.range=40 50; geometry.parameters.crystal.b.length.range=40 50; geometry.parameters.crystal.c.length.range=40 50; geometry.parameters.random_seed = 42""" master_phil = parse(""" include scope dials.test.algorithms.refinement.geometry_phil """, process_includes=True) models = Extract(master_phil, overrides) # keep track of the models self.detector = models.detector self.gonio = models.goniometer self.crystal = models.crystal self.beam = models.beam # Create a stills ExperimentList self.stills_experiments = ExperimentList() self.stills_experiments.append( Experiment(beam=self.beam, detector=self.detector, crystal=self.crystal, imageset=None)) # keep track of the parameterisation of the models self.det_param = DetectorParameterisationSinglePanel(self.detector) self.s0_param = BeamParameterisation(self.beam, self.gonio) self.xlo_param = CrystalOrientationParameterisation(self.crystal) self.xluc_param = CrystalUnitCellParameterisation(self.crystal)
def predict_reflections(self, imageset, crystal, beam, detector, goniometer=None, scan=None, dmin=None, dmax=None, margin=1, force_static=False, **kwargs): ''' Given an experiment, predict the reflections. :param crystal: The crystal model :param beam: The beam model :param detector: The detector model :param goniometer: The goniometer model :param scan: The scan model ''' from dxtbx.model.experiment.experiment_list import Experiment from dials.algorithms.spot_prediction.reflection_predictor \ import ReflectionPredictor predict = ReflectionPredictor(Experiment(imageset=imageset, crystal=crystal, beam=beam, detector=detector, goniometer=goniometer, scan=scan), dmin=dmin, dmax=dmax, margin=margin, force_static=force_static) return predict()
def split_for_scan_range(self, experiments, reference, scan_range): """ Update experiments when scan range is set. """ from dxtbx.model.experiment.experiment_list import ExperimentList from dxtbx.model.experiment.experiment_list import Experiment from logging import info from dials.array_family import flex # Only do anything is the scan range is set if scan_range is not None and len(scan_range) > 0: # Ensure that all experiments have the same imageset and scan iset = [e.imageset for e in experiments] scan = [e.scan for e in experiments] assert all(x == iset[0] for x in iset) assert all(x == scan[0] for x in scan) # Get the imageset and scan iset = experiments[0].imageset scan = experiments[0].scan # Get the array range if scan is not None: frame10, frame11 = scan.get_array_range() assert scan.get_num_images() == len(iset) else: frame10, frame11 = (0, len(iset)) # Create the new lists new_experiments = ExperimentList() new_reference_all = reference.split_by_experiment_id() new_reference = flex.reflection_table() for i in range(len(new_reference_all) - len(experiments)): new_reference_all.append(flex.reflection_table()) assert len(new_reference_all) == len(experiments) # Loop through all the scan ranges and create a new experiment list with # the requested scan ranges. for frame00, frame01 in scan_range: assert frame01 > frame00 assert frame00 >= frame10 assert frame01 <= frame11 index0 = frame00 - frame10 index1 = index0 + (frame01 - frame00) assert index0 < index1 assert index0 >= 0 assert index1 <= len(iset) new_iset = iset[index0:index1] if scan is None: new_scan = None else: new_scan = scan[index0:index1] for i, e1 in enumerate(experiments): e2 = Experiment() e2.beam = e1.beam e2.detector = e1.detector e2.goniometer = e1.goniometer e2.crystal = e1.crystal e2.imageset = new_iset e2.scan = new_scan new_reference_all[i]["id"] = flex.int(len(new_reference_all[i]), len(new_experiments)) new_reference.extend(new_reference_all[i]) new_experiments.append(e2) experiments = new_experiments reference = new_reference # Print some information info("Modified experiment list to integrate over requested scan range") for frame00, frame01 in scan_range: info(" scan_range = %d -> %d" % (frame00, frame01)) info("") # Return the experiments return experiments, reference
def __call__(self, crystal): return Experiment(beam=self.reference_beam, detector=self.reference_detector, crystal=crystal)
def test1(): dials_regression = libtbx.env.find_in_repositories( relative_path="dials_regression", test=os.path.isdir) # use a datablock that contains a CS-PAD detector description data_dir = os.path.join(dials_regression, "refinement_test_data", "hierarchy_test") datablock_path = os.path.join(data_dir, "datablock.json") assert os.path.exists(datablock_path) # load models from dxtbx.datablock import DataBlockFactory datablock = DataBlockFactory.from_serialized_format(datablock_path, check_format=False) im_set = datablock[0].extract_imagesets()[0] from copy import deepcopy detector = deepcopy(im_set.get_detector()) beam = im_set.get_beam() # we'll invent a crystal, goniometer and scan for this test from dxtbx.model.crystal import crystal_model crystal = crystal_model((40., 0., 0.), (0., 40., 0.), (0., 0., 40.), space_group_symbol="P1") from dxtbx.model.experiment import goniometer_factory goniometer = goniometer_factory.known_axis((1., 0., 0.)) # Build a mock scan for a 180 degree sweep from dxtbx.model.scan import scan_factory sf = scan_factory() scan = sf.make_scan(image_range=(1, 1800), exposure_times=0.1, oscillation=(0, 0.1), epochs=range(1800), deg=True) sweep_range = scan.get_oscillation_range(deg=False) im_width = scan.get_oscillation(deg=False)[1] assert sweep_range == (0., pi) assert approx_equal(im_width, 0.1 * pi / 180.) from dxtbx.model.experiment.experiment_list import ExperimentList, Experiment # Build an experiment list experiments = ExperimentList() experiments.append( Experiment(beam=beam, detector=detector, goniometer=goniometer, scan=scan, crystal=crystal, imageset=None)) # simulate some reflections refs, ref_predictor = generate_reflections(experiments) # move the detector quadrants apart by 2mm both horizontally and vertically from dials.algorithms.refinement.parameterisation \ import DetectorParameterisationHierarchical det_param = DetectorParameterisationHierarchical(detector, level=1) det_p_vals = det_param.get_param_vals() p_vals = list(det_p_vals) p_vals[1] += 2 p_vals[2] -= 2 p_vals[7] += 2 p_vals[8] += 2 p_vals[13] -= 2 p_vals[14] += 2 p_vals[19] -= 2 p_vals[20] -= 2 det_param.set_param_vals(p_vals) # reparameterise the detector at the new perturbed geometry det_param = DetectorParameterisationHierarchical(detector, level=1) # parameterise other models from dials.algorithms.refinement.parameterisation.beam_parameters import \ BeamParameterisation from dials.algorithms.refinement.parameterisation.crystal_parameters import \ CrystalOrientationParameterisation, CrystalUnitCellParameterisation beam_param = BeamParameterisation(beam, goniometer) xlo_param = CrystalOrientationParameterisation(crystal) xluc_param = CrystalUnitCellParameterisation(crystal) # fix beam beam_param.set_fixed([True] * 3) # fix crystal xluc_param.set_fixed([True] * 6) xlo_param.set_fixed([True] * 3) # parameterisation of the prediction equation from dials.algorithms.refinement.parameterisation.prediction_parameters import \ XYPhiPredictionParameterisation from dials.algorithms.refinement.parameterisation.parameter_report import \ ParameterReporter pred_param = XYPhiPredictionParameterisation(experiments, [det_param], [beam_param], [xlo_param], [xluc_param]) param_reporter = ParameterReporter([det_param], [beam_param], [xlo_param], [xluc_param]) # reflection manager and target function from dials.algorithms.refinement.target import \ LeastSquaresPositionalResidualWithRmsdCutoff from dials.algorithms.refinement.reflection_manager import ReflectionManager refman = ReflectionManager(refs, experiments, nref_per_degree=20) # set a very tight rmsd target of 1/10000 of a pixel target = LeastSquaresPositionalResidualWithRmsdCutoff( experiments, ref_predictor, refman, pred_param, restraints_parameterisation=None, frac_binsize_cutoff=0.0001) # minimisation engine from dials.algorithms.refinement.engine \ import LevenbergMarquardtIterations as Refinery refinery = Refinery(target=target, prediction_parameterisation=pred_param, log=None, verbosity=0, track_step=False, track_gradient=False, track_parameter_correlation=False, max_iterations=20) # Refiner from dials.algorithms.refinement.refiner import Refiner refiner = Refiner(reflections=refs, experiments=experiments, pred_param=pred_param, param_reporter=param_reporter, refman=refman, target=target, refinery=refinery, verbosity=0) history = refiner.run() assert history.reason_for_termination == "RMSD target achieved" #compare detector with original detector orig_det = im_set.get_detector() refined_det = refiner.get_experiments()[0].detector from scitbx import matrix import math for op, rp in zip(orig_det, refined_det): # compare the origin vectors by... o1 = matrix.col(op.get_origin()) o2 = matrix.col(rp.get_origin()) # ...their relative lengths assert approx_equal(math.fabs(o1.length() - o2.length()) / o1.length(), 0, eps=1e-5) # ...the angle between them assert approx_equal(o1.accute_angle(o2), 0, eps=1e-5) print "OK" return
sf = scan_factory() myscan = sf.make_scan(image_range = (1,1800), exposure_times = 0.1, oscillation = (0, 0.1), epochs = range(1800), deg = True) sweep_range = myscan.get_oscillation_range(deg=False) im_width = myscan.get_oscillation(deg=False)[1] assert sweep_range == (0., pi) assert approx_equal(im_width, 0.1 * pi / 180.) # Build ExperimentLists experiments_single_panel = ExperimentList() experiments_multi_panel = ExperimentList() experiments_single_panel.append(Experiment( beam=mybeam, detector=single_panel_detector, goniometer=mygonio, scan=myscan, crystal=mycrystal, imageset=None)) experiments_multi_panel.append(Experiment( beam=mybeam, detector=multi_panel_detector, goniometer=mygonio, scan=myscan, crystal=mycrystal, imageset=None)) ########################### # Parameterise the models # ########################### det_param = DetectorParameterisationSinglePanel(single_panel_detector) s0_param = BeamParameterisation(mybeam, mygonio) xlo_param = CrystalOrientationParameterisation(mycrystal) xluc_param = CrystalUnitCellParameterisation(mycrystal) multi_det_param = DetectorParameterisationMultiPanel(multi_panel_detector, mybeam)
(-float(fs_x.rstrip('x')), float(fs_y.rstrip('y')), 0.0)) slow = matrix.col( (-float(ss_x.rstrip('x')), float(ss_y.rstrip('y')), 0.0)) origin = matrix.col( (-float(geom[key]['corner_x']) * params.pixel_size, float(geom[key]['corner_y']) * params.pixel_size, 0.0)) # OBS! you need to set the panel to a root before set local frame... p = root.add_panel() p.set_name('panel-%s' % key) p.set_image_size((512, 1024)) p.set_trusted_range((-1, 1000000)) p.set_pixel_size((params.pixel_size, params.pixel_size)) p.set_local_frame(fast.elems, slow.elems, origin.elems) from dxtbx.model.beam import beam_factory wavelength = params.wavelength beam = beam_factory.simple(wavelength) from dxtbx.model.experiment.experiment_list import Experiment, ExperimentList, ExperimentListDumper experiments = ExperimentList() experiment = Experiment(detector=detector, beam=beam) experiments.append(experiment) dump = ExperimentListDumper(experiments) dump.as_json("geometry.json") if __name__ == "__main__": run(sys.argv[1:])
def run(space_group_info): datablock_json = os.path.join( dials_regression, "indexing_test_data", "i04_weak_data", "datablock_orig.json") datablock = load.datablock(datablock_json, check_format=False)[0] sweep = datablock.extract_imagesets()[0] sweep._indices = sweep._indices[:20] sweep.set_scan(sweep.get_scan()[:20]) import random space_group = space_group_info.group() unit_cell = space_group_info.any_compatible_unit_cell(volume=random.uniform(1e4,1e6)) crystal_symmetry = crystal.symmetry(unit_cell=unit_cell, space_group=space_group) crystal_symmetry.show_summary() # the reciprocal matrix B = matrix.sqr(unit_cell.fractionalization_matrix()).transpose() U = random_rotation() A = U * B direct_matrix = A.inverse() cryst_model = crystal_model(direct_matrix[0:3], direct_matrix[3:6], direct_matrix[6:9], space_group=space_group) experiment = Experiment(imageset=sweep, beam=sweep.get_beam(), detector=sweep.get_detector(), goniometer=sweep.get_goniometer(), scan=sweep.get_scan(), crystal=cryst_model) predicted_reflections = flex.reflection_table.from_predictions( experiment) use_fraction = 0.3 use_sel = flex.random_selection( len(predicted_reflections), int(use_fraction*len(predicted_reflections))) predicted_reflections = predicted_reflections.select(use_sel) miller_indices = predicted_reflections['miller_index'] miller_set = miller.set( crystal_symmetry, miller_indices, anomalous_flag=True) predicted_reflections['xyzobs.mm.value'] = predicted_reflections['xyzcal.mm'] predicted_reflections['id'] = flex.int(len(predicted_reflections), 0) from dials.algorithms.indexing.indexer import indexer_base indexer_base.map_centroids_to_reciprocal_space( predicted_reflections, sweep.get_detector(), sweep.get_beam(), sweep.get_goniometer()) # check that local and global indexing worked equally well in absence of errors result = compare_global_local(experiment, predicted_reflections, miller_indices) assert result.misindexed_local == 0 assert result.misindexed_global == 0 a, b, c = cryst_model.get_real_space_vectors() relative_error = 0.02 a *= (1+relative_error) b *= (1+relative_error) c *= (1+relative_error) cryst_model2 = crystal_model(a, b, c, space_group=space_group) experiment.crystal = cryst_model2 result = compare_global_local(experiment, predicted_reflections, miller_indices) # check that the local indexing did a better job given the errors in the basis vectors #assert result.misindexed_local < result.misindexed_global assert result.misindexed_local == 0 assert result.correct_local > result.correct_global # usually the number misindexed is much smaller than this assert result.misindexed_local < (0.001 * len(result.reflections_local)) # the reciprocal matrix A = cryst_model.get_A() A = random_rotation(angle_max=0.03) * A direct_matrix = A.inverse() cryst_model2 = crystal_model(direct_matrix[0:3], direct_matrix[3:6], direct_matrix[6:9], space_group=space_group) experiment.crystal = cryst_model2 result = compare_global_local(experiment, predicted_reflections, miller_indices) # check that the local indexing did a better job given the errors in the basis vectors assert result.misindexed_local <= result.misindexed_global, ( result.misindexed_local, result.misindexed_global) assert result.misindexed_local < 0.01 * result.correct_local assert result.correct_local > result.correct_global # usually the number misindexed is much smaller than this assert result.misindexed_local < (0.001 * len(result.reflections_local))
def __init__(self, params): import cPickle as pickle from dxtbx.model.beam import beam_factory from dxtbx.model.detector import detector_factory from dxtbx.model.crystal import crystal_model from cctbx.crystal_orientation import crystal_orientation, basis_type from dxtbx.model.experiment.experiment_list import Experiment, ExperimentList from scitbx import matrix self.experiments = ExperimentList() self.unique_file_names = [] self.params = params data = pickle.load( open(self.params.output.prefix + "_frame.pickle", "rb")) frames_text = data.split("\n") for item in frames_text: tokens = item.split(' ') wavelength = float(tokens[order_dict["wavelength"]]) beam = beam_factory.simple(wavelength=wavelength) detector = detector_factory.simple( sensor=detector_factory.sensor( "PAD"), # XXX shouldn't hard code for XFEL distance=float(tokens[order_dict["distance"]]), beam_centre=[ float(tokens[order_dict["beam_x"]]), float(tokens[order_dict["beam_y"]]) ], fast_direction="+x", slow_direction="+y", pixel_size=[self.params.pixel_size, self.params.pixel_size], image_size=[1795, 1795], # XXX obviously need to figure this out ) reciprocal_matrix = matrix.sqr([ float(tokens[order_dict[k]]) for k in [ 'res_ori_1', 'res_ori_2', 'res_ori_3', 'res_ori_4', 'res_ori_5', 'res_ori_6', 'res_ori_7', 'res_ori_8', 'res_ori_9' ] ]) ORI = crystal_orientation(reciprocal_matrix, basis_type.reciprocal) direct = matrix.sqr(ORI.direct_matrix()) crystal = crystal_model( real_space_a=matrix.row(direct[0:3]), real_space_b=matrix.row(direct[3:6]), real_space_c=matrix.row(direct[6:9]), space_group_symbol=self.params.target_space_group.type(). lookup_symbol(), mosaicity=float(tokens[order_dict["half_mosaicity_deg"]]), ) crystal.domain_size = float(tokens[order_dict["domain_size_ang"]]) #if isoform is not None: # newB = matrix.sqr(isoform.fractionalization_matrix()).transpose() # crystal.set_B(newB) self.experiments.append( Experiment( beam=beam, detector=None, #dummy for now crystal=crystal)) self.unique_file_names.append( tokens[order_dict["unique_file_name"]]) self.show_summary()
######################################################################## # Build a mock scan for a 180 degree sweep sf = scan_factory() myscan = sf.make_scan(image_range=(1, 1800), exposure_times=0.1, oscillation=(0, 0.1), epochs=range(1800), deg=True) # Build an ExperimentList experiments = ExperimentList() experiments.append( Experiment(beam=mybeam, detector=mydetector, goniometer=mygonio, scan=myscan, crystal=mycrystal, imageset=None)) # Create the PredictionParameterisation pred_param = XYPhiPredictionParameterisation(experiments, [det_param], [s0_param], [xlo_param], [xluc_param]) ################################ # Apply known parameter shifts # ################################ # shift detector by 1.0 mm each translation and 4 mrad each rotation det_p_vals = det_param.get_param_vals() p_vals = [a + b for a, b in zip(det_p_vals, [1.0, 1.0, 1.0, 4., 4., 4.])]
def load(entry, exp_index): from dxtbx.model.experiment.experiment_list import ExperimentList from dxtbx.model.experiment.experiment_list import Experiment print "Loading NXmx" # Check file contains the feature assert("features" in entry) assert(6 in entry['features'].value) experiment_list = ExperimentList() # Find all the experiments entries = find_nx_mx_entries(entry, ".") if len(entries) > 1: entries = sorted(entries, key=lambda x: x['dials/index'].value) assert(len(entries) == len(exp_index)) for nxmx, name in zip(entries, exp_index): assert(nxmx.name == name) index = [] rotations = [] for name in exp_index: # Get the entry nxmx = entry.file[name] # Get the definition definition = nxmx['definition'] assert(definition.value == 'NXmx') assert(definition.attrs['version'] == 1) # Get dials specific stuff nx_dials = get_nx_dials(nxmx, "dials") # Set index b = nx_dials['index'].attrs['source'] d = nx_dials['index'].attrs['detector'] if "goniometer" in nx_dials['index'].attrs: g = nx_dials['index'].attrs['goniometer'] else: g = None if "scan" in nx_dials['index'].attrs: s = nx_dials['index'].attrs['scan'] else: s = None c = nx_dials['index'].attrs['sample'] index.append((b, d, g, s, c)) # Get the original orientation (dials specific) transformations = get_nx_transformations(nx_dials, "transformations") angle = transformations['angle'].value assert(transformations['angle'].attrs['transformation_type'] == 'rotation') axis = transformations['angle'].attrs['vector'] assert(tuple(transformations['angle'].attrs['offset']) == (0, 0, 0)) assert(transformations['angle'].attrs['offset_units'] == 'mm') assert(transformations['angle'].attrs['depends_on'] == '.') rotations.append((axis, angle)) # Get the tmeplate and imageset try: template = list(nx_dials['template']) image_range = None except Exception: template = nx_dials['template'].value if template == "": template = None if "range" in nx_dials['template'].attrs: image_range = nx_dials['template'].attrs['range'] else: image_range = None # Create the experiment experiment = Experiment() # Read the models experiment.beam = load_beam(nxmx) experiment.detector = load_detector(nxmx) experiment.goniometer = load_goniometer(nxmx) experiment.scan = load_scan(nxmx) experiment.crystal = load_crystal(nxmx) # Set the image range if image_range is not None and experiment.scan is not None: num = image_range[1] - image_range[0] + 1 assert(num == len(experiment.scan)) experiment.scan.set_image_range(image_range) # Return the experiment list experiment_list.append(experiment) # Convert from nexus beam direction experiment_list = convert_from_nexus_beam_direction(experiment_list,rotations) from collections import defaultdict beam = defaultdict(list) detector = defaultdict(list) goniometer = defaultdict(list) scan = defaultdict(list) crystal = defaultdict(list) for i, ind in enumerate(index): beam[ind[0]].append(i) detector[ind[1]].append(i) goniometer[ind[2]].append(i) scan[ind[3]].append(i) crystal[ind[4]].append(i) # Set all the shared beams for key, value in beam.iteritems(): b1 = experiment_list[value[0]].beam assert(all(experiment_list[v].beam == b1 for v in value[1:])) for v in value[1:]: experiment_list[v].beam = b1 # Set all the shared detectors for key, value in detector.iteritems(): d1 = experiment_list[value[0]].detector assert(all(experiment_list[v].detector == d1 for v in value[1:])) for v in value[1:]: experiment_list[v].detector = d1 # Set all the shared goniometer for key, value in goniometer.iteritems(): g1 = experiment_list[value[0]].goniometer assert(all(experiment_list[v].goniometer == g1 for v in value[1:])) for v in value[1:]: experiment_list[v].goniometer = g1 # Set all the shared scans for key, value in scan.iteritems(): s1 = experiment_list[value[0]].scan assert(all(experiment_list[v].scan == s1 for v in value[1:])) for v in value[1:]: experiment_list[v].scan = s1 # Set all the shared crystals for key, value in crystal.iteritems(): c1 = experiment_list[value[0]].crystal assert(all(experiment_list[v].crystal == c1 for v in value[1:])) for v in value[1:]: experiment_list[v].crystal = c1 return experiment_list