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):
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 :-(
filenames = [""] * len(scan)
reader = Reader(filenames)
masker = Masker(filenames)
data = ImageSetData(reader, masker)
imageset = ImageSweep(data, beam, detector, goniometer, 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 find_lattices(self):
self.find_candidate_basis_vectors()
if self.params.optimise_initial_basis_vectors:
self.optimise_basis_vectors()
self.candidate_crystal_models = self.find_candidate_orientation_matrices(
self.candidate_basis_vectors)
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 expt in self.experiments:
experiments.append(
Experiment(
imageset=expt.imageset,
beam=expt.beam,
detector=expt.detector,
goniometer=expt.goniometer,
scan=expt.scan,
crystal=cm,
))
return experiments
def run(self):
"""Execute the script."""
# Parse the command line
self.params, options = self.parser.parse_args(show_diff_phil=True)
if not self.params.input.experiments:
self.parser.print_help()
sys.exit()
# Try to load the models
experiments = flatten_experiments(self.params.input.experiments)
nexp = len(experiments)
if nexp == 0:
print("No Experiments found in the input")
self.parser.print_help()
return
ref_beam = experiments[0].beam
ref_goniometer = experiments[0].goniometer
ref_detector = experiments[0].detector
scan = self.extended_scan(experiments)
crystal = self.combine_crystals(experiments, scan)
experiment = Experiment(
beam=ref_beam,
detector=ref_detector,
scan=scan,
goniometer=ref_goniometer,
crystal=crystal,
)
experiments = ExperimentList([experiment])
# Reset experiment IDs in the reflections
reflections = flatten_reflections(self.params.input.reflections)
assert len(reflections) == 1
reflections = reflections[0]
reflections["id"] *= 0
# Save the experiments to file
print(
"Saving the combined experiment to {0}".format(
self.params.output.experiments
)
)
from dxtbx.model.experiment_list import ExperimentListDumper
dump = ExperimentListDumper(experiments)
dump.as_json(self.params.output.experiments)
# Save the reflections to file
print(
"Saving the combined reflections to {0}".format(
self.params.output.reflections
)
)
reflections.as_pickle(self.params.output.reflections)
def generate_reflections(self):
# Build a mock scan for a 3 degree sweep
from dxtbx.model import ScanFactory
sf = ScanFactory()
self.scan = sf.make_scan(image_range=(1, 1),
exposure_times=0.1,
oscillation=(0, 3.0),
epochs=range(1),
deg=True)
sweep_range = self.scan.get_oscillation_range(deg=False)
# Create a scans ExperimentList, only for generating reflections
experiments = ExperimentList()
experiments.append(
Experiment(beam=self.beam,
detector=self.detector,
goniometer=self.gonio,
scan=self.scan,
crystal=self.crystal,
imageset=None))
# Create a ScansRayPredictor
ray_predictor = ScansRayPredictor(experiments, sweep_range)
# Generate rays - only to work out which hkls are predicted
resolution = 2.0
index_generator = IndexGenerator(
self.crystal.get_unit_cell(),
space_group(space_group_symbols(1).hall()).type(), resolution)
indices = index_generator.to_array()
rays = ray_predictor(indices)
# Make a standard reflection_table and copy in the ray data
self.reflections = flex.reflection_table.empty_standard(len(rays))
self.reflections.update(rays)
def 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(self):
assert self.crystal is not None
from dxtbx.model.experiment_list import Experiment, ExperimentList
imageset = self.imageset
scan = copy.deepcopy(imageset.get_scan())
gonio = imageset.get_goniometer()
prediction_width = self.settings.prediction_width
if prediction_width is None:
prediction_width = scan.get_oscillation()[1]
if isinstance(gonio, MultiAxisGoniometer):
scan_angle = gonio.get_angles()[gonio.get_scan_axis()]
else:
return
scan.set_oscillation(
(scan_angle, prediction_width))
expt = Experiment(
imageset=imageset,
crystal=self.crystal,
detector=imageset.get_detector(),
beam=imageset.get_beam(),
scan=scan[:1],
goniometer=imageset.get_goniometer())
# Populate the reflection table with predictions
from dials.array_family import flex
predicted = flex.reflection_table.from_predictions(
expt,
force_static=True,
)
predicted['id'] = flex.int(len(predicted), 0)
return predicted
def predict_reflections(self):
from dials.algorithms import shoebox
from dials.array_family import flex
from dxtbx.model.experiment_list import ExperimentList
from dxtbx.model.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 find_lattices(self):
if self.params.multiple_lattice_search.cluster_analysis_search:
self.find_basis_vector_combinations_cluster_analysis()
self.debug_show_candidate_basis_vectors()
if self.params.debug_plots:
self.debug_plot_candidate_basis_vectors()
crystal_models = self.candidate_crystal_models
if self.params.multiple_lattice_search.max_lattices is not None:
crystal_models = \
crystal_models[:self.params.multiple_lattice_search.max_lattices]
else:
self.find_candidate_basis_vectors()
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)
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 experiment():
beam = BeamFactory.make_beam(wavelength=0.97625, sample_to_source=(0, 0, 1))
detector = DetectorFactory.simple(
sensor="PAD",
distance=265.27,
beam_centre=(210.7602, 205.27684),
fast_direction="+x",
slow_direction="-y",
pixel_size=(0.172, 0.172),
image_size=(2463, 2527),
trusted_range=(-1, 1e8),
)
goniometer = GoniometerFactory.single_axis()
scan = ScanFactory.make_scan(
image_range=(1, 20),
exposure_times=0.067,
oscillation=(82, 0.15),
epochs=[0] * 20,
)
isetdata = ImageSetData(
reader=Format.Reader(None, ["path"] * len(scan)), masker=None
)
iset = ImageSequence(
isetdata, beam=beam, detector=detector, goniometer=goniometer, scan=scan
)
return Experiment(
imageset=iset, beam=beam, detector=detector, goniometer=goniometer, scan=scan
)
def __init__(self, test_nave_model=False):
# Set up experimental models with regular geometry
from dxtbx.model import BeamFactory, DetectorFactory, GoniometerFactory
# Beam along the Z axis
self.beam = BeamFactory.make_beam(unit_s0=matrix.col((0, 0, 1)), wavelength=1.0)
# Goniometer (used only for index generation) along X axis
self.goniometer = GoniometerFactory.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))
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 = DetectorFactory.make_detector(
"PAD",
dir1,
dir2,
origin,
(pix_size, pix_size),
(npx_fast, npx_slow),
(0, 1.0e6),
)
# Cubic 100 A^3 crystal
a = matrix.col((100, 0, 0))
b = matrix.col((0, 100, 0))
c = matrix.col((0, 0, 100))
if test_nave_model:
from dxtbx.model import MosaicCrystalSauter2014
self.crystal = MosaicCrystalSauter2014(a, b, c, space_group_symbol="P 1")
self.crystal.set_half_mosaicity_deg(500)
self.crystal.set_domain_size_ang(0.2)
else:
from dxtbx.model import Crystal
self.crystal = Crystal(a, b, c, space_group_symbol="P 1")
# Collect these models in an Experiment (ignoring the goniometer)
from dxtbx.model.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()
def create_models(self, cmdline_overrides=None):
from dxtbx.model import ScanFactory
from libtbx.phil import parse
from dials.test.algorithms.refinement.setup_geometry import Extract
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-20 * 0.5 deg images
sf = ScanFactory()
self.scan = sf.make_scan((1, 20), 0.5, (0, 0.5), list(range(20)))
# 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 = ScansExperimentsPredictor(self.experiments)
# Create scan-varying parameterisations of these models, with 3 samples
self.det_param = ScanVaryingDetectorParameterisationSinglePanel(
self.detector, self.scan.get_array_range(), 3)
self.s0_param = ScanVaryingBeamParameterisation(
self.beam, self.scan.get_array_range(), 3, self.goniometer)
self.xlo_param = ScanVaryingCrystalOrientationParameterisation(
self.crystal, self.scan.get_array_range(), 3)
self.xluc_param = ScanVaryingCrystalUnitCellParameterisation(
self.crystal, self.scan.get_array_range(), 3)
self.gon_param = ScanVaryingGoniometerParameterisation(
self.goniometer, self.scan.get_array_range(), 3, self.beam)
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 __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 __init__(self):
import os
import libtbx.load_env
from dxtbx.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_list import Experiment, ExperimentList
try:
dials_regression = libtbx.env.dist_path('dials_regression')
except KeyError:
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.imageset(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)
try:
mosaicity = self.crystal.get_mosaicity(deg=False)
except AttributeError:
mosaicity = 0
self.delta_m = 3 * mosaicity
self.nsigma = 3
self.profile_model = Model(None, self.nsigma,
self.beam.get_sigma_divergence(deg=False),
mosaicity)
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 test_extract_experiment_data():
"""Test basic operation of the extract_experiment_data function. Does not
test extraction of data from scan-varying models"""
# Set up an Experiment with idealised geometry
from dxtbx.model import BeamFactory
from dxtbx.model import GoniometerFactory
from dxtbx.model import Crystal
from dxtbx.model import ScanFactory
from dxtbx.model.experiment_list import Experiment
beam = BeamFactory.make_beam(unit_s0=(0, 0, -1), wavelength=1.0)
goniometer = GoniometerFactory.known_axis((1, 0, 0))
a = (100, 0, 0)
b = (0, 90, 0)
c = (0, 0, 80)
crystal = Crystal(a, b, c, space_group_symbol="P1")
scan = ScanFactory.make_scan(
image_range=(1, 91),
exposure_times=0.1,
oscillation=(0, 1.0),
epochs=list(range(91)),
deg=True,
)
exp = Experiment(beam=beam,
goniometer=goniometer,
scan=scan,
crystal=crystal)
# Extract experiment data
dat = extract_experiment_data(exp, scale=100)
# Check results are as expected
za = dat["zone_axes"]
# At the first image the c axis is aligned antiparallel with the beam vector,
# while the a and b axes are orthogonal. The zone axis calculation is scaled
# by 100 (i.e. the max cell dimension, which is the default), therefore we
# expect the zone axis [uvw] = [0 0 -100/80]
assert za[0].elems == pytest.approx((0, 0, -100 / 80))
# At the start of the 91st image the crystal has rotated by 90 degrees, so
# now c is orthogonal to the beam while b is anti-parallel to it. The zone
# axis is now expected to be [uvw] = [0 -100/90 0]
assert za[-1].elems == pytest.approx((0, -100 / 90, 0))
rsa = dat["real_space_axes"]
a, b, c = rsa[0]
assert a.elems == pytest.approx(crystal.get_real_space_vectors()[0])
assert b.elems == pytest.approx(crystal.get_real_space_vectors()[1])
assert c.elems == pytest.approx(crystal.get_real_space_vectors()[2])
def create_experiments(image_start=1):
# Create models
from libtbx.phil import parse
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,
)
from dials.test.algorithms.refinement.setup_geometry import Extract
models = Extract(master_phil, overrides)
detector = models.detector
goniometer = models.goniometer
crystal = models.crystal
beam = models.beam
# Build a mock scan for a 72 degree sequence
from dxtbx.model import ScanFactory
sf = ScanFactory()
scan = sf.make_scan(
image_range=(image_start, image_start + 720 - 1),
exposure_times=0.1,
oscillation=(0, 0.1),
epochs=list(range(720)),
deg=True,
)
# No matter what image_start is, scan should start at 0.0 and end at 72.0 deg
assert scan.get_oscillation_range(deg=True) == (0.0, 72.0)
# Create an ExperimentList
experiments = ExperimentList()
experiments.append(
Experiment(
beam=beam,
detector=detector,
goniometer=goniometer,
scan=scan,
crystal=crystal,
imageset=None,
)
)
return experiments
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_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):
#self.real_space_grid_search()
self.real_space_grid_smart_search()
crystal_models = self.candidate_crystal_models
experiments = ExperimentList()
for cm in crystal_models:
for expt in self.experiments:
experiments.append(
Experiment(imageset=expt.imageset,
beam=expt.beam,
detector=expt.detector,
goniometer=expt.goniometer,
scan=expt.scan,
crystal=cm))
return experiments
def predict_reflections(
self,
imageset,
crystal,
beam,
detector,
goniometer=None,
scan=None,
dmin=None,
dmax=None,
margin=1,
force_static=False,
padding=0,
**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_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,
padding=padding,
)
return predict()
def combine_crystals(experiments):
"""Replace all crystals in the experiments list with the first crystal"""
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,
identifier=exp.identifier,
))
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 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 sequence
sf = ScanFactory()
scan = sf.make_scan(
image_range=(1, 180),
exposure_times=0.1,
oscillation=(0, 1.0),
epochs=list(range(180)),
deg=True,
)
sequence_range = scan.get_oscillation_range(deg=False)
im_width = scan.get_oscillation(deg=False)[1]
assert sequence_range == (0.0, math.pi)
assert approx_equal(im_width, 1.0 * math.pi / 180.0)
experiments = ExperimentList()
experiments.append(
Experiment(
beam=beam,
detector=detector,
goniometer=goniometer,
scan=scan,
crystal=crystal,
imageset=None,
)
)
return experiments
def as_explist(self):
"""
return experiment list for simulated image
"""
exp = Experiment()
exp.crystal = self.crystal
exp.beam = self.beam
exp.detector = self.detector
exp.imageset = self.imageset
explist = ExperimentList()
explist.append(exp)
return explist
def generate_reflections(self):
# Build a mock scan for a 3 degree sequence
sf = ScanFactory()
self.scan = sf.make_scan(
image_range=(1, 1),
exposure_times=0.1,
oscillation=(0, 3.0),
epochs=list(range(1)),
deg=True,
)
sequence_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, sequence_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)
# Set dummy observed variances to allow statistical weights to be set
self.reflections["xyzobs.mm.variance"] += (1e-3, 1e-3, 1e-6)
def find_lattices(self):
experiments = ExperimentList()
for cm, expt in zip(self.known_orientations, self.experiments):
# 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)
experiments.append(
Experiment(
imageset=expt.imageset,
beam=expt.beam,
detector=expt.detector,
goniometer=expt.goniometer,
scan=expt.scan,
crystal=cm,
identifier=expt.identifier,
))
return experiments
def find_lattices(self):
self.find_candidate_basis_vectors()
self.candidate_crystal_models = self.find_candidate_orientation_matrices(
self.candidate_basis_vectors)
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 find_lattices(self):
try:
assert self._symmetry_handler.target_symmetry_primitive is not None
assert (
self._symmetry_handler.target_symmetry_primitive.unit_cell() is not None
)
except AssertionError:
raise Sorry("indigo requires a known unit_cell=a,b,c,aa,bb,cc")
# Set reciprocal space orthogonalisation matrix
uc = self._symmetry_handler.target_symmetry_primitive.unit_cell()
self.Bmat = matrix.sqr(uc.fractionalization_matrix()).transpose()
self._low_res_spot_match()
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 expt in self.experiments:
experiments.append(
Experiment(
imageset=expt.imageset,
beam=expt.beam,
detector=expt.detector,
goniometer=expt.goniometer,
scan=expt.scan,
crystal=cm,
)
)
return experiments
def as_explist(self, fname=None, toggle_conventions=False):
"""
return experiment list for simulated image
"""
C = self.crystal
if toggle_conventions:
# switch to DIALS convention before writing CBF
# also change basis of crystal
CURRENT_CONV = self.beamcenter_convention
FSO = sqr(self.fdet_vector + self.sdet_vector +
self.pix0_vector_mm)
self.beamcenter_convention = DIALS
FSO2 = sqr(self.fdet_vector + self.sdet_vector +
self.dials_origin_mm)
xtal_transform = FSO.inverse() * FSO2
# transform the crystal vectors
a, b, c = map(lambda x: xtal_transform * col(x),
C.get_real_space_vectors())
Cdict = C.to_dict()
Cdict['real_space_a'] = a
Cdict['real_space_b'] = b
Cdict['real_space_b'] = c
C = CrystalFactory.from_dict(Cdict)
exp = Experiment()
exp.crystal = C
exp.beam = self.beam
exp.detector = self.detector
exp.imageset = self.imageset
explist = ExperimentList()
explist.append(exp)
if fname is not None:
explist.as_file(fname)
if toggle_conventions:
self.beamcenter_convention = CURRENT_CONV
return explist
