def test_experimentlist_with_identifiers(): # Initialise a list of experiments experiments = ExperimentList() experiments.append( Experiment(beam=Beam(s0=(0, 0, -1)), detector=Detector(), identifier="bacon")) experiments.append( Experiment(beam=Beam(s0=(0, 0, -1)), detector=Detector(), identifier="sausage")) with pytest.raises(Exception): experiments.append( Experiment(beam=Beam(), detector=Detector(), identifier="bacon")) d = experiments.to_dict() e2 = ExperimentListDict(d).decode() assert experiments[0].identifier == e2[0].identifier assert experiments[1].identifier == e2[1].identifier assert tuple(experiments.identifiers()) == ("bacon", "sausage") experiments[0].identifier = "spam" assert tuple(experiments.identifiers()) == ("spam", "sausage") experiments.append(Experiment(identifier="bacon")) experiments.select_on_experiment_identifiers(["spam", "bacon"]) assert list(experiments.identifiers()) == ["spam", "bacon"] experiments.append(Experiment(identifier="ham")) experiments.append(Experiment(identifier="jam")) experiments.remove_on_experiment_identifiers(["spam", "jam"]) assert list(experiments.identifiers()) == ["bacon", "ham"]
def refine(self, exps, ref, refining_predictions=False, best=None): exps_out = exps if not self.params.skip_hopper: if self.params.dispatch.refine: print("WARNING: hopper_process will always run its own refinement, ignoring dials.refine phil scope") self.params.dispatch.refine = False assert len(exps) == 1 if self.params.reidx_obs: exps, ref = self._reindex_obs(exps, self.observed) exp, ref, self.stage1_modeler, x = hopper_utils.refine(exps[0], ref, self.params.diffBragg, spec=self.params.refspec, gpu_device=self.device_id, return_modeler=True, best=best) orig_exp_name = os.path.abspath(self.params.output.refined_experiments_filename) refls_name = os.path.abspath(self.params.output.indexed_filename) self.params.diffBragg.outdir = self.params.output.output_dir # TODO: what about composite mode ? self.stage1_df = save_to_pandas(x, self.stage1_modeler.SIM, orig_exp_name, self.params.diffBragg, self.stage1_modeler.E, 0, refls_name, None) exps_out = ExperimentList() exps_out.append(exp) basename = os.path.splitext(os.path.basename(refls_name))[0] self._save_modeler_info(basename) return super(Hopper_Processor, self).refine(exps_out, ref)
def experiments(): """Make a list of three empty experiments""" experiments = ExperimentList() experiments.append(Experiment()) experiments.append(Experiment()) experiments.append(Experiment()) return experiments
def index( experiments: ExperimentList, observed: flex.reflection_table, params: phil.scope_extract, ) -> Tuple[ExperimentList, flex.reflection_table, dict]: reflection_tables, params, method_list = preprocess( experiments, observed, params) # Do the indexing and generate a summary of results indexed_experiments, indexed_reflections, results_summary = index_all_concurrent( experiments, reflection_tables, params, method_list, ) # combine beam and detector models if not already if (len(indexed_experiments.detectors())) > 1 or (len( indexed_experiments.beams())) > 1: combine = CombineWithReference( detector=indexed_experiments[0].detector, beam=indexed_experiments[0].beam) elist = ExperimentList() for expt in indexed_experiments: elist.append(combine(expt)) indexed_experiments = elist return indexed_experiments, indexed_reflections, results_summary
def test_change_of_basis_ops_to_minimum_cell_mpro(): input_ucs = [ (46.023, 55.001, 64.452, 64.744, 78.659, 89.824), (44.747, 53.916, 62.554, 114.985, 99.610, 90.736), ] # Setup the input experiments and reflection tables expts = ExperimentList() for uc in input_ucs: uc = uctbx.unit_cell(uc) sg = sgtbx.space_group_info("P1").group() B = scitbx.matrix.sqr(uc.fractionalization_matrix()).transpose() expts.append( Experiment(crystal=Crystal(B, space_group=sg, reciprocal=True))) # Actually run the method we are testing cb_ops = change_of_basis_ops_to_minimum_cell( expts, max_delta=5, relative_length_tolerance=0.05, absolute_angle_tolerance=2) expts.change_basis(cb_ops, in_place=True) assert symmetry.unit_cells_are_similar_to( expts, median_unit_cell(expts), relative_length_tolerance=0.05, absolute_angle_tolerance=2, )
def index(experiments, observed, params): params.refinement.parameterisation.scan_varying = False params.indexing.stills.indexer = "stills" reflections = observed.split_by_experiment_id() # Calculate necessary quantities for refl, experiment in zip(reflections, experiments): elist = ExperimentList([experiment]) refl["imageset_id"] = flex.int(refl.size(), 0) # needed for centroid_px_to_mm refl.centroid_px_to_mm(elist) refl.map_centroids_to_reciprocal_space(elist) if (params.indexing.max_cell is Auto) and (not params.indexing.known_symmetry.unit_cell): max_cells = [] for refl in reflections: try: max_cells.append(find_max_cell(refl).max_cell) except (DialsIndexError, AssertionError): pass logger.info(f"Setting max cell to {max(max_cells):.1f} " + "\u212B") params.indexing.max_cell = max(max_cells) method_list = params.method if "real_space_grid_search" in method_list: if not params.indexing.known_symmetry.unit_cell: logger.info( "No unit cell given, real_space_grid_search will not be used") method_list.remove("real_space_grid_search") methods = ", ".join(method_list) pl = "s" if (len(method_list) > 1) else "" logger.info(f"Attempting indexing with {methods} method{pl}") indexed_experiments, indexed_reflections, results_summary = index_all_concurrent( experiments, reflections, params, method_list, ) summary_table = make_summary_table(results_summary) logger.info("\nSummary of images sucessfully indexed\n" + summary_table) n_images = len(set(e.imageset.get_path(0) for e in indexed_experiments)) logger.info( f"{indexed_reflections.size()} spots indexed on {n_images} images\n") # combine beam and detector models if not already if (len(indexed_experiments.detectors())) > 1 or (len( indexed_experiments.beams())) > 1: combine = CombineWithReference( detector=indexed_experiments[0].detector, beam=indexed_experiments[0].beam) elist = ExperimentList() for expt in indexed_experiments: elist.append(combine(expt)) indexed_experiments = elist return indexed_experiments, indexed_reflections, results_summary
def predict_to_miller_set_with_shadow(self, expt, resolution): predicted = flex.reflection_table.from_predictions(expt, dmin=resolution) # transmogrify this to an ExperimentList from an Experiment experiments = ExperimentList() experiments.append(expt) predicted["id"] = flex.int(predicted.size(), 0) shadowed = filter_shadowed_reflections( experiments, predicted, experiment_goniometer=True ) predicted = predicted.select(~shadowed) hkl = predicted["miller_index"] # now get a full set of all unique miller indices obs = miller.set( crystal_symmetry=crystal.symmetry( space_group=expt.crystal.get_space_group(), unit_cell=expt.crystal.get_unit_cell(), ), anomalous_flag=True, indices=hkl, ).unique_under_symmetry() return obs, shadowed
def test_sort_tables_to_experiments_order_single_dataset_files(): """Test reflection table sorting when tables contain a single dataset.""" # Reflection tables in the wrong order reflection_tables = [ mock_reflection_file_object(id_=1).data, mock_reflection_file_object(id_=0).data, ] experiments = ExperimentList() experiments.append(Experiment(identifier=str(0))) experiments.append(Experiment(identifier=str(1))) refls = sort_tables_to_experiments_order(reflection_tables, experiments) # Check that reflection tables are rearranged assert refls[0] is reflection_tables[1] assert refls[1] is reflection_tables[0] assert list(refls[0].experiment_identifiers().values()) == ["0"] assert list(refls[1].experiment_identifiers().values()) == ["1"] # Reflection tables in correct order reflection_tables = [ mock_reflection_file_object(id_=0).data, mock_reflection_file_object(id_=1).data, ] experiments = ExperimentList() experiments.append(Experiment(identifier=str(0))) experiments.append(Experiment(identifier=str(1))) refls = sort_tables_to_experiments_order(reflection_tables, experiments) # Check that nothing has been changed assert refls[0] is reflection_tables[0] assert refls[1] is reflection_tables[1] assert list(refls[0].experiment_identifiers().values()) == ["0"] assert list(refls[1].experiment_identifiers().values()) == ["1"]
def predict_to_miller_set_with_shadow(self, expt, resolution): from dials.array_family import flex from dials.algorithms.shadowing.filter import filter_shadowed_reflections predicted = flex.reflection_table.from_predictions(expt, dmin=resolution) # transmogrify this to an ExperimentList from an Experiment from dxtbx.model import ExperimentList experiments = ExperimentList() experiments.append(expt) predicted['id'] = flex.int(predicted.size(), 0) shadowed = filter_shadowed_reflections(experiments, predicted, experiment_goniometer=True) predicted = predicted.select(~shadowed) hkl = predicted['miller_index'] # now get a full set of all unique miller indices from cctbx import miller from cctbx import crystal obs = miller.set(crystal_symmetry=crystal.symmetry( space_group=expt.crystal.get_space_group(), unit_cell=expt.crystal.get_unit_cell()), anomalous_flag=True, indices=hkl).unique_under_symmetry() return obs, shadowed
def save_opt_det(phil_params, x, ref_params, SIM): opt_det = get_optimized_detector(x, ref_params, SIM) El = ExperimentList() E = Experiment() E.detector = opt_det El.append(E) El.as_file(phil_params.geometry.optimized_detector_name) print("Saved detector model to %s" % phil_params.geometry.optimized_detector_name)
def test_select_remove_on_experiment_identifiers(): table = flex.reflection_table() table["id"] = flex.int([0, 1, 2, 3]) experiments = ExperimentList() experiments.append(Experiment(identifier="abcd")) experiments.append(Experiment(identifier="efgh")) experiments.append(Experiment(identifier="ijkl")) experiments.append(Experiment(identifier="mnop")) table.experiment_identifiers()[0] = "abcd" table.experiment_identifiers()[1] = "efgh" table.experiment_identifiers()[2] = "ijkl" table.experiment_identifiers()[3] = "mnop" table.assert_experiment_identifiers_are_consistent(experiments) table = table.remove_on_experiment_identifiers(["efgh"]) del experiments[1] table.assert_experiment_identifiers_are_consistent(experiments) assert list(table.experiment_identifiers().keys()) == [0, 2, 3] assert list( table.experiment_identifiers().values()) == ["abcd", "ijkl", "mnop"] table = table.select_on_experiment_identifiers(["abcd", "mnop"]) del experiments[1] # now ijkl table.assert_experiment_identifiers_are_consistent(experiments) assert list(table.experiment_identifiers().keys()) == [0, 3] assert list(table.experiment_identifiers().values()) == ["abcd", "mnop"] # reset 'id' column such that they are numbered 0 .. n-1 table.reset_ids() table.assert_experiment_identifiers_are_consistent(experiments) assert list(table.experiment_identifiers().keys()) == [0, 1] assert list(table.experiment_identifiers().values()) == ["abcd", "mnop"] # test that the function doesn't fail if no identifiers set table1 = copy.deepcopy(table) for k in table1.experiment_identifiers().keys(): del table1.experiment_identifiers()[k] table1.reset_ids() assert list(table1.experiment_identifiers().keys()) == [] # Test exception is raised if bad choice with pytest.raises(KeyError): table.remove_on_experiment_identifiers(["efgh"]) with pytest.raises(KeyError): table.select_on_experiment_identifiers(["efgh"]) table = flex.reflection_table() table["id"] = flex.int([0, 1, 2, 3]) # Test exception is raised if identifiers map not set with pytest.raises(KeyError): table.remove_on_experiment_identifiers(["efgh"]) with pytest.raises(KeyError): table.select_on_experiment_identifiers(["abcd", "mnop"])
def test_experimentlist_imagesequence_decode(mocker): # These models are shared between experiments beam = Beam(s0=(0, 0, -1)) detector = Detector() gonio = Goniometer() # Construct the experiment list experiments = ExperimentList() for i in range(3): experiments.append( Experiment( beam=beam, detector=detector, scan=ScanFactory.make_scan( image_range=(i + 1, i + 1), exposure_times=[1], oscillation=(0, 0), epochs=[0], ), goniometer=gonio, )) # Convert experiment list to dict and manually insert a shared imageset d = experiments.to_dict() d["imageset"].append({ "__id__": "ImageSequence", "template": "Puck3_10_1_####.cbf.gz" }) for e in d["experiment"]: e["imageset"] = 0 # Monkeypatch this function as we don't actually have an imageset make_sequence = mocker.patch.object(ExperimentListDict, "_make_sequence") # Ensure that if make_sequence is called more than once it returns a different # value each time make_sequence.side_effect = lambda *args, **kwargs: mocker.MagicMock() # Decode the dict to get a new experiment list experiments2 = ExperimentListDict(d).decode() # This function should only be called once per imageset make_sequence.assert_called_once() # Verify that this experiment is as we expect assert len(experiments2) == 3 assert len(experiments2.imagesets()) == 1 assert len(experiments2.goniometers()) == 1 assert len(experiments2.detectors()) == 1 assert len(experiments2.beams()) == 1 assert len(experiments2.scans()) == 3 for expt in experiments2: assert expt.imageset is experiments2.imagesets()[0]
def test_exp(idval=0): """Test experiments object.""" experiments = ExperimentList() exp_dict = { "__id__": "crystal", "real_space_a": [1.0, 0.0, 0.0], "real_space_b": [0.0, 1.0, 0.0], "real_space_c": [0.0, 0.0, 2.0], "space_group_hall_symbol": " C 2y", } crystal = Crystal.from_dict(exp_dict) experiments.append(Experiment(crystal=crystal)) experiments[0].identifier = str(idval) return experiments
def generate_experiments_reflections( space_group, lattice_group=None, unit_cell=None, unit_cell_volume=1000, seed=0, d_min=1, sigma=0.1, sample_size=100, map_to_p1=False, twin_fractions=None, map_to_minimum=True, ): datasets, reindexing_ops = generate_test_data( space_group, lattice_group=lattice_group, unit_cell=unit_cell, unit_cell_volume=unit_cell_volume, seed=seed, d_min=d_min, sigma=sigma, sample_size=sample_size, map_to_p1=map_to_p1, twin_fractions=twin_fractions, map_to_minimum=map_to_minimum, ) expts = ExperimentList() refl_tables = [] for i, dataset in enumerate(datasets): B = scitbx.matrix.sqr( dataset.unit_cell().fractionalization_matrix()).transpose() expts.append( Experiment( crystal=Crystal(B, space_group=dataset.space_group(), reciprocal=True), scan=Scan(image_range=(0, 180), oscillation=(0.0, 1.0)), )) refl = flex.reflection_table() refl["miller_index"] = dataset.indices() refl["id"] = flex.int(refl.size(), i) refl["d"] = dataset.d_spacings().data() refl["intensity.sum.value"] = dataset.data() refl["intensity.sum.variance"] = flex.pow2(dataset.sigmas()) refl.set_flags(flex.bool(len(refl), True), refl.flags.integrated_sum) refl_tables.append(refl) return expts, refl_tables, reindexing_ops
def make_MAD_merged_mtz_file(params, experiments, reflections, wavelengths): """Make a multi wavelength merged mtz file from experiments and reflections.""" # need to add a crystal to the mtz object # now go through data selecting on wavelength - loop over each to get mtz_object # Create the mtz file mtz_writer = MADMergedMTZWriter(experiments[0].crystal.get_space_group(), experiments[0].crystal.get_unit_cell()) # now add each wavelength. if len(params.output.dataset_names) != len(wavelengths.keys()): logger.info( "Unequal number of dataset names and wavelengths, using default naming." ) dnames = [None] * len(wavelengths.keys()) else: dnames = params.output.dataset_names if len(params.output.crystal_names) != len(wavelengths.keys()): logger.info( "Unequal number of crystal names and wavelengths, using default naming." ) cnames = [None] * len(wavelengths.keys()) else: cnames = params.output.crystal_names for dname, cname, (wavelength, exp_nos) in zip(dnames, cnames, wavelengths.items()): expids = [] new_exps = ExperimentList() for i in exp_nos: expids.append(experiments[i].identifier) # string new_exps.append(experiments[i]) refls = reflections[0].select_on_experiment_identifiers(expids) logger.info("Running merge for wavelength: %s", wavelength) merged, anom, amplitudes, anom_amp = merge_and_truncate( params, new_exps, [refls]) #### Add each wavelength as a new crystal. mtz_writer.add_crystal(crystal_name=cname, project_name=params.output.project_name) mtz_writer.add_dataset(wavelength, merged, anom, amplitudes, anom_amp, name=dname) return mtz_writer.mtz_file
def test_change_of_basis_ops_to_minimum_cell_with_outlier(): symmetries = [ crystal.symmetry(unit_cell=uc, space_group="P1") for uc in ( (52.8868, 52.8868, 333.522, 90, 90, 120), (52.6503, 53.0292, 333.783, 89.9872, 89.2247, 60.8078), (52.9571, 53.0005, 334.255, 90.0493, 90.0042, 119.893), ( 54.4465, 56.5677, 355.775, 93.4376, 90.0999, 118.256, ), # This is an outlier (52.9235, 52.9235, 335.296, 90, 90, 120), (53.4531, 53.4531, 322.909, 90, 90, 120), ) ] # Setup the input experiments and reflection tables expts = ExperimentList() for cs in symmetries: B = scitbx.matrix.sqr( cs.unit_cell().fractionalization_matrix()).transpose() expts.append( Experiment(crystal=Crystal( B, space_group=cs.space_group(), reciprocal=True))) # Actually run the method we are testing cb_ops = change_of_basis_ops_to_minimum_cell( expts, max_delta=5, relative_length_tolerance=0.05, absolute_angle_tolerance=2) assert cb_ops.count(None) == 1 assert cb_ops[3] is None expts = ExperimentList( [expt for expt, cb_op in zip(expts, cb_ops) if cb_op]) cb_ops = [cb_op for cb_op in cb_ops if cb_op] expts.change_basis(cb_ops, in_place=True) assert symmetry.unit_cells_are_similar_to( expts, median_unit_cell(expts), relative_length_tolerance=0.05, absolute_angle_tolerance=2, )
def test_median_cell(): unit_cells = [ uctbx.unit_cell(uc) for uc in [ (10, 11, 11.9, 90, 85, 90), (10.1, 11.2, 12, 90, 85.5, 90), (10.2, 11.1, 12, 90, 84.7, 90), ] ] expts = ExperimentList() for uc in unit_cells: sg = sgtbx.space_group_info("P1").group() B = scitbx.matrix.sqr(uc.fractionalization_matrix()).transpose() expts.append( Experiment(crystal=Crystal(B, space_group=sg, reciprocal=True))) median = median_unit_cell(expts) assert median.parameters() == pytest.approx((10.1, 11.1, 12, 90, 85, 90))
def test_experiments_multiaxisgonio(): """Create a mock experiments object.""" # beam along +z gonio_1 = GoniometerFactory.from_dict( { "axes": [ [ 1.0 / sqrt(2.0), 0.0, -1.0 / sqrt(2.0), ], [1.0, 0.0, 0.0], ], "angles": [0.0, 0.0], "names": ["GON_PHI", "GON_OMEGA"], "scan_axis": 1, } ) gonio_2 = GoniometerFactory.from_dict( { "axes": [ [ 1.0 / sqrt(2.0), 0.0, -1.0 / sqrt(2.0), ], [1.0, 0.0, 0.0], ], "angles": [0.0, 0.0], "names": ["GON_PHI", "GON_OMEGA"], "scan_axis": 0, } ) experiments = ExperimentList() for g in [gonio_1, gonio_2]: experiments.append( Experiment( beam=Beam(s0=(0.0, 0.0, 2.0)), goniometer=g, scan=Scan(image_range=[1, 90], oscillation=[0.0, 1.0]), ) ) return experiments
def generated_exp(n=1): """Generate an experiment list with two experiments.""" experiments = ExperimentList() exp_dict = { "__id__": "crystal", "real_space_a": [1.0, 0.0, 0.0], "real_space_b": [0.0, 1.0, 0.0], "real_space_c": [0.0, 0.0, 2.0], "space_group_hall_symbol": " C 2y", } for i in range(n): experiments.append( Experiment( scan=Scan(image_range=[1, 25], oscillation=[0.0, 1.0]), crystal=Crystal.from_dict(exp_dict), identifier=str(i), )) return experiments
def test_interpret_images_to_doses_options(): """Test handling of command line options for experiments input.""" experiments = ExperimentList() experiments.append(Experiment(scan=Scan(image_range=(1, 10), oscillation=(0, 1.0)))) experiments.append(Experiment(scan=Scan(image_range=(1, 20), oscillation=(0, 1.0)))) experiments.append(Experiment(scan=Scan(image_range=(1, 10), oscillation=(0, 1.0)))) # Default starting_doses, dpi = dials.pychef.interpret_images_to_doses_options( experiments, dose_per_image=[1] ) assert starting_doses == [0, 0, 0] assert dpi == [1.0, 1.0, 1.0] # Multi-sweep measurements on same crystal starting_doses, dpi = dials.pychef.interpret_images_to_doses_options( experiments, dose_per_image=[1], shared_crystal=True ) assert starting_doses == [0, 10, 30] assert dpi == [1.0, 1.0, 1.0] # Specify starting doses starting_doses, dpi = dials.pychef.interpret_images_to_doses_options( experiments, dose_per_image=[1], starting_doses=[0, 20, 0], shared_crystal=False ) assert starting_doses == [0, 20, 0] assert dpi == [1.0, 1.0, 1.0] # Specify doses per image and shared crystal starting_doses, dpi = dials.pychef.interpret_images_to_doses_options( experiments, dose_per_image=[1.0, 2.0, 1.0], shared_crystal=True ) assert starting_doses == [0, 10, 50] assert dpi == [1.0, 2.0, 1.0] # Test error is raised if bad input values for starting doses or dose per image. with pytest.raises(ValueError): _, __ = dials.pychef.interpret_images_to_doses_options( experiments, dose_per_image=[1.0], starting_doses=[0, 1] ) with pytest.raises(ValueError): _, __ = dials.pychef.interpret_images_to_doses_options( experiments, dose_per_image=[1.0, 2.0] )
def experiment_list(): 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] ident = ["sausage", "eggs", "bacon", "toast", "beans"] # Populate with various experiments for i in range(5): experiments.append(Experiment( beam=b[i], detector=d[i], goniometer=g[i], scan=s[i], identifier=ident[i])) # Return the list of experiments return experiments
def from_stills_and_crystal(imageset, crystal, load_models=True): """Create an experiment list from stills and crystal.""" experiments = ExperimentList() if load_models: for i in range(len(imageset)): experiments.append( Experiment( imageset=imageset[i:i + 1], beam=imageset.get_beam(i), detector=imageset.get_detector(i), goniometer=imageset.get_goniometer(i), scan=imageset.get_scan(i), crystal=crystal, )) else: for i in range(len(imageset)): experiments.append( Experiment(imageset=imageset[i:i + 1], crystal=crystal)) return experiments
def test_sort_tables_to_experiments_order_multi_dataset_files(): """Test reflection table sorting when a table contains multiple datasets.""" # Reflection tables in the wrong order reflection_tables = [ mock_two_reflection_file_object(ids=[1, 2]).data, mock_reflection_file_object(id_=0).data, ] experiments = ExperimentList() experiments.append(Experiment(identifier=str(0))) experiments.append(Experiment(identifier=str(1))) experiments.append(Experiment(identifier=str(2))) refls = sort_tables_to_experiments_order(reflection_tables, experiments) # Check that reflection tables are rearranged assert refls[0] is reflection_tables[1] assert refls[1] is reflection_tables[0] assert list(refls[0].experiment_identifiers().values()) == ["0"] assert list(refls[1].experiment_identifiers().values()) == ["1", "2"]
def test_split_chunk_sizes(tmpdir, option, with_identifiers): ids = list(range(0, 5)) experiments = ExperimentList() reflections = flex.reflection_table() reflections["id"] = flex.int(ids) reflections["intensity"] = flex.double([(i + 1) * 100.0 for i in ids]) for i in ids: exp = generate_exp() if with_identifiers: exp.identifier = str(i) reflections.experiment_identifiers()[i] = str(i) experiments.append(exp) experiments.as_json(tmpdir.join("tmp.expt").strpath) reflections.as_file(tmpdir.join("tmp.refl").strpath) result = procrunner.run( [ "dials.split_experiments", tmpdir.join("tmp.expt").strpath, tmpdir.join("tmp.refl").strpath, option, ], working_directory=tmpdir, ) assert not result.returncode and not result.stderr for j, n, intensities in zip( [0, 1, 2], [2, 2, 1], [[100.0, 200.0], [300.0, 400.0], [500.0]] ): assert tmpdir.join("split_%s.refl" % j).check() assert tmpdir.join("split_%s.expt" % j).check() expts = load.experiment_list( tmpdir.join("split_%s.expt" % j), check_format=False ) assert len(expts) == n refls = flex.reflection_table.from_file(tmpdir.join("split_%s.refl" % j)) assert list(set(refls["id"])) == list(range(0, n)) assert list(refls["intensity"]) == intensities refls.assert_experiment_identifiers_are_consistent(expts)
def prepare_dxtbx_models(self, setting_specific_ai, sg, isoform=None): from dxtbx.model import BeamFactory beam = BeamFactory.simple(wavelength=self.inputai.wavelength) from dxtbx.model import DetectorFactory detector = DetectorFactory.simple( sensor=DetectorFactory.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 import Crystal crystal = Crystal( 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, ) crystal.set_mosaicity(setting_specific_ai.getMosaicity()) if isoform is not None: newB = matrix.sqr(isoform.fractionalization_matrix()).transpose() crystal.set_B(newB) from dxtbx.model import Experiment, ExperimentList experiments = ExperimentList() experiments.append( Experiment(beam=beam, detector=detector, crystal=crystal)) print beam print detector print crystal return experiments
def _export_unmerged_mtz(params, experiments, reflection_table): """Export data to unmerged_mtz format (as single file or split by wavelength).""" from dials.command_line.export import MTZExporter from dials.command_line.export import phil_scope as export_phil_scope export_params = export_phil_scope.extract() export_params.intensity = ["scale"] export_params.mtz.partiality_threshold = params.cut_data.partiality_cutoff export_params.mtz.crystal_name = params.output.crystal_name if params.cut_data.d_min: export_params.mtz.d_min = params.cut_data.d_min if len(params.output.unmerged_mtz) > 1: from dxtbx.model import ExperimentList wavelengths = match_wavelengths(experiments) assert len(params.output.unmerged_mtz) == len(wavelengths.keys()) for filename, wavelength in zip(params.output.unmerged_mtz, wavelengths.keys()): export_params.mtz.hklout = filename logger.info("\nSaving output to an unmerged mtz file to %s.", filename) exps = ExperimentList() ids = [] for i, exp in enumerate(experiments): if i in wavelengths[wavelength]: exps.append(exp) ids.append(exp.identifier) exporter = MTZExporter( export_params, exps, [reflection_table.select_on_experiment_identifiers(ids)], ) exporter.export() else: logger.info( "\nSaving output to an unmerged mtz file to %s.", params.output.unmerged_mtz[0], ) export_params.mtz.hklout = params.output.unmerged_mtz[0] exporter = MTZExporter(export_params, experiments, [reflection_table]) exporter.export()
def test_UnitCellAnalysisObserver(): # generate some random unit cells sgi = sgtbx.space_group_info("P1") unit_cells = [ sgi.any_compatible_unit_cell(volume=random.uniform(990, 1010)) for i in range(10) ] # generate experiment list experiments = ExperimentList() U = matrix.identity(3) for uc in unit_cells: B = matrix.sqr(uc.fractionalization_matrix()).transpose() direct_matrix = (U * B).inverse() experiments.append( Experiment(crystal=Crystal( direct_matrix[:3], direct_matrix[3:6], direct_matrix[6:9], space_group=sgi.group(), ))) # generate dendrogram crystal_symmetries = [ expt.crystal.get_crystal_symmetry() for expt in experiments ] lattice_ids = experiments.identifiers() ucs = UnitCellCluster.from_crystal_symmetries(crystal_symmetries, lattice_ids=lattice_ids) _, dendrogram, _ = ucs.ab_cluster(write_file_lists=False, doplot=False) # setup script script = mock.Mock() script._experiments = experiments script.unit_cell_dendrogram = dendrogram # test the observer observer = observers.UnitCellAnalysisObserver() observer.update(script) assert set(observer.data) == {"experiments", "dendrogram"} d = observer.make_plots() assert "unit_cell_graphs" in d
def from_sequence_and_crystal(imageset, crystal, load_models=True): """Create an experiment list from sequence and crystal.""" assert isinstance(imageset, ImageSequence) experiments = ExperimentList() if load_models: # if imagesequence is still images, make one experiment for each # all referencing into the same image set if imageset.get_scan().is_still(): start, end = imageset.get_scan().get_array_range() for j in range(start, end): subset = imageset[j : j + 1] experiments.append( Experiment( imageset=imageset, beam=imageset.get_beam(), detector=imageset.get_detector(), goniometer=imageset.get_goniometer(), scan=subset.get_scan(), crystal=crystal, ) ) else: 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 else: return ExperimentList([Experiment(imageset=imageset, crystal=crystal)])
def test_experimentlist_with_identifiers(): from dxtbx.model import Beam, Detector, Goniometer, Scan # Initialise a list of experiments experiments = ExperimentList() experiments.append( Experiment(beam=Beam(s0=(0, 0, -1)), detector=Detector(), identifier="bacon")) experiments.append( Experiment(beam=Beam(s0=(0, 0, -1)), detector=Detector(), identifier="sausage")) with pytest.raises(Exception): experiments.append( Experiment(beam=Beam(), detector=Detector(), identifier="bacon")) d = experiments.to_dict() e2 = ExperimentListDict(d).decode() assert experiments[0].identifier == e2[0].identifier assert experiments[1].identifier == e2[1].identifier assert tuple(experiments.identifiers()) == ("bacon", "sausage") experiments[0].identifier = "spam" assert tuple(experiments.identifiers()) == ("spam", "sausage")
def _export_multi_merged_mtz(params, experiments, reflection_table): from dxtbx.model import ExperimentList wavelengths = match_wavelengths(experiments) assert len(params.output.merged_mtz) == len(wavelengths.keys()) for filename, wavelength in zip(params.output.merged_mtz, wavelengths.keys()): exps = ExperimentList() ids = [] for i, exp in enumerate(experiments): if i in wavelengths[wavelength]: exps.append(exp) ids.append(exp.identifier) refls = reflection_table.select_on_experiment_identifiers(ids) scaled_array = scaled_data_as_miller_array([refls], exps) merged = scaled_array.merge_equivalents( use_internal_variance=params.output.use_internal_variance).array() merged_anom = (scaled_array.as_anomalous_array().merge_equivalents( use_internal_variance=params.output.use_internal_variance).array()) mtz_file = make_merged_mtz_file(merged, merged_anom) logger.info("\nSaving output to a merged mtz file to %s.\n", filename) mtz_file.write(filename)