def __call__(self, imageset):
"""
Override the parameters
"""
from dxtbx.imageset import ImageSequence, ImageSetFactory
from dxtbx.model import BeamFactory
from dxtbx.model import DetectorFactory
from dxtbx.model import GoniometerFactory
from dxtbx.model import ScanFactory
from copy import deepcopy
if self.params.geometry.convert_sequences_to_stills:
imageset = ImageSetFactory.imageset_from_anyset(imageset)
for j in imageset.indices():
imageset.set_scan(None, j)
imageset.set_goniometer(None, j)
if not isinstance(imageset, ImageSequence):
if self.params.geometry.convert_stills_to_sequences:
imageset = self.convert_stills_to_sequence(imageset)
if isinstance(imageset, ImageSequence):
beam = BeamFactory.from_phil(self.params.geometry, imageset.get_beam())
detector = DetectorFactory.from_phil(
self.params.geometry, imageset.get_detector(), beam
)
goniometer = GoniometerFactory.from_phil(
self.params.geometry, imageset.get_goniometer()
)
scan = ScanFactory.from_phil(
self.params.geometry, deepcopy(imageset.get_scan())
)
i0, i1 = scan.get_array_range()
j0, j1 = imageset.get_scan().get_array_range()
if i0 < j0 or i1 > j1:
imageset = self.extrapolate_imageset(
imageset=imageset,
beam=beam,
detector=detector,
goniometer=goniometer,
scan=scan,
)
else:
imageset.set_beam(beam)
imageset.set_detector(detector)
imageset.set_goniometer(goniometer)
imageset.set_scan(scan)
else:
for i in range(len(imageset)):
beam = BeamFactory.from_phil(self.params.geometry, imageset.get_beam(i))
detector = DetectorFactory.from_phil(
self.params.geometry, imageset.get_detector(i), beam
)
goniometer = GoniometerFactory.from_phil(
self.params.geometry, imageset.get_goniometer(i)
)
scan = ScanFactory.from_phil(self.params.geometry, imageset.get_scan(i))
imageset.set_beam(beam, i)
imageset.set_detector(detector, i)
imageset.set_goniometer(goniometer, i)
imageset.set_scan(scan, i)
return imageset
def __call__(self, imageset):
'''
Override the parameters
'''
from dxtbx.imageset import ImageSet
from dxtbx.imageset import ImageSweep
from dxtbx.model import BeamFactory
from dxtbx.model import DetectorFactory
from dxtbx.model import GoniometerFactory
from dxtbx.model import ScanFactory
from copy import deepcopy
if self.params.geometry.convert_sweeps_to_stills:
imageset = ImageSet(reader=imageset.reader())
if not isinstance(imageset, ImageSweep):
if self.params.geometry.convert_stills_to_sweeps:
imageset = self.convert_stills_to_sweep(imageset)
if isinstance(imageset, ImageSweep):
beam = BeamFactory.from_phil(
self.params.geometry,
imageset.get_beam())
detector = DetectorFactory.from_phil(
self.params.geometry,
imageset.get_detector(),
beam)
goniometer = GoniometerFactory.from_phil(
self.params.geometry,
imageset.get_goniometer())
scan = ScanFactory.from_phil(
self.params.geometry,
deepcopy(imageset.get_scan()))
i0, i1 = scan.get_array_range()
j0, j1 = imageset.get_scan().get_array_range()
imageset.set_beam(beam)
imageset.set_detector(detector)
imageset.set_goniometer(goniometer)
imageset.set_scan(scan)
else:
for i in range(len(imageset)):
beam = BeamFactory.from_phil(
self.params.geometry,
imageset.get_beam(i))
detector = DetectorFactory.from_phil(
self.params.geometry,
imageset.get_detector(i),
beam)
goniometer = GoniometerFactory.from_phil(
self.params.geometry,
imageset.get_goniometer(i))
scan = ScanFactory.from_phil(
self.params.geometry,
imageset.get_scan(i))
imageset.set_beam(beam, i)
imageset.set_detector(detector, i)
imageset.set_goniometer(goniometer, i)
imageset.set_scan(scan, i)
return imageset
def tst_goniometer(self):
from dxtbx.model import Goniometer, GoniometerFactory
g1 = Goniometer((1, 0, 0), (1, 0, 0, 0, 1, 0, 0, 0, 1))
d = g1.to_dict()
g2 = GoniometerFactory.from_dict(d)
assert (d['rotation_axis'] == (1, 0, 0))
assert (d['fixed_rotation'] == (1, 0, 0, 0, 1, 0, 0, 0, 1))
assert (g1 == g2)
# Test with a template and partial dictionary
d2 = {'rotation_axis': (0, 1, 0)}
g3 = GoniometerFactory.from_dict(d2, d)
assert (g3.get_rotation_axis() == (0, 1, 0))
assert (g3.get_fixed_rotation() == (1, 0, 0, 0, 1, 0, 0, 0, 1))
assert (g2 != g3)
def test_goniometer():
g1 = Goniometer((1, 0, 0), (1, 0, 0, 0, 1, 0, 0, 0, 1))
d = g1.to_dict()
g2 = GoniometerFactory.from_dict(d)
assert d["rotation_axis"] == (1, 0, 0)
assert d["fixed_rotation"] == (1, 0, 0, 0, 1, 0, 0, 0, 1)
assert g1 == g2
assert "setting_rotation_at_scan_points" not in d
# Test with a template and partial dictionary
d2 = {"rotation_axis": (0, 1, 0)}
g3 = GoniometerFactory.from_dict(d2, d)
assert g3.get_rotation_axis() == (0, 1, 0)
assert g3.get_fixed_rotation() == (1, 0, 0, 0, 1, 0, 0, 0, 1)
assert g2 != g3
def imagesweep_from_dict(d, check_format=True, directory=None):
"""Construct and image sweep from the dictionary."""
# Get the template (required)
template = load_path(str(d["template"]), directory=directory)
# If the scan isn't set, find all available files
scan_dict = d.get("scan")
if scan_dict is None:
image_range = None
else:
image_range = scan_dict.get("image_range")
# Set the models with the exisiting models as templates
beam = BeamFactory.from_dict(d.get("beam"))
goniometer = GoniometerFactory.from_dict(d.get("goniometer"))
detector = DetectorFactory.from_dict(d.get("detector"))
scan = ScanFactory.from_dict(d.get("scan"))
# Construct the sweep
try:
sweep = ImageSetFactory.from_template(
template,
image_range,
beam=beam,
detector=detector,
goniometer=goniometer,
scan=scan,
check_format=check_format,
)[0]
except Exception:
indices = range(image_range[0], image_range[1] + 1)
sweep = ImageSetFactory.make_sweep(
template,
indices,
beam=beam,
detector=detector,
goniometer=goniometer,
scan=scan,
check_format=check_format,
)
# Set some external lookups
if "mask" in d and d["mask"] is not None and d["mask"] is not "":
path = load_path(d["mask"], directory=directory)
with open(path) as infile:
sweep.external_lookup.mask.filename = path
sweep.external_lookup.mask.data = ImageBool(pickle.load(infile))
if "gain" in d and d["gain"] is not None and d["gain"] is not "":
path = load_path(d["gain"], directory=directory)
with open(path) as infile:
sweep.external_lookup.gain.filename = path
sweep.external_lookup.gain.data = ImageDouble(pickle.load(infile))
if "pedestal" in d and d["pedestal"] is not None and d["pedestal"] is not "":
path = load_path(d["pedestal"], directory=directory)
with open(path) as infile:
sweep.external_lookup.pedestal.filename = path
sweep.external_lookup.pedestal.data = ImageDouble(pickle.load(infile))
# Return the sweep
return sweep
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 test_goniometer():
from dxtbx.model import Goniometer, GoniometerFactory
g1 = Goniometer((1, 0, 0), (1, 0, 0, 0, 1, 0, 0, 0, 1))
d = g1.to_dict()
g2 = GoniometerFactory.from_dict(d)
assert d['rotation_axis'] == (1, 0, 0)
assert d['fixed_rotation'] == (1, 0, 0, 0, 1, 0, 0, 0, 1)
assert g1 == g2
assert 'setting_rotation_at_scan_points' not in d
# Test with a template and partial dictionary
d2 = {'rotation_axis': (0, 1, 0)}
g3 = GoniometerFactory.from_dict(d2, d)
assert g3.get_rotation_axis() == (0, 1, 0)
assert g3.get_fixed_rotation() == (1, 0, 0, 0, 1, 0, 0, 0, 1)
assert g2 != g3
def imagesweep_from_dict(d, check_format=True):
'''Construct and image sweep from the dictionary.'''
from dxtbx.imageset import ImageSetFactory
from dxtbx.model import BeamFactory, DetectorFactory, GoniometerFactory, ScanFactory
from dxtbx.serialize.filename import load_path
# Get the template (required)
template = load_path(str(d['template']))
# If the scan isn't set, find all available files
scan_dict = d.get('scan')
if scan_dict is None:
image_range = None
else:
image_range = scan_dict.get('image_range')
# Set the models with the exisiting models as templates
beam = BeamFactory.from_dict(d.get('beam'))
goniometer = GoniometerFactory.from_dict(d.get('goniometer'))
detector = DetectorFactory.from_dict(d.get('detector'))
scan = ScanFactory.from_dict(d.get('scan'))
# Construct the sweep
try:
sweep = ImageSetFactory.from_template(template,
image_range,
beam=beam,
detector=detector,
goniometer=goniometer,
scan=scan,
check_format=check_format)[0]
except Exception:
indices = range(image_range[0], image_range[1] + 1)
sweep = ImageSetFactory.make_sweep(template,
indices,
beam=beam,
detector=detector,
goniometer=goniometer,
scan=scan,
check_format=check_format)
# Set some external lookups
if 'mask' in d and d['mask'] is not None and d['mask'] is not "":
with open(d['mask']) as infile:
sweep.external_lookup.mask.filename = d['mask']
sweep.external_lookup.mask.data = ImageBool(pickle.load(infile))
if 'gain' in d and d['gain'] is not None and d['gain'] is not "":
with open(d['gain']) as infile:
sweep.external_lookup.gain.filename = d['gain']
sweep.external_lookup.gain.data = ImageDouble(pickle.load(infile))
if 'pedestal' in d and d['pedestal'] is not None and d[
'pedestal'] is not "":
with open(d['pedestal']) as infile:
sweep.external_lookup.pedestal.filename = d['pedestal']
sweep.external_lookup.pedestal.data = ImageDouble(
pickle.load(infile))
# Return the sweep
return sweep
def __init__(self, override_fdp=None):
# Set up detector
distance = 100
pixel_size = 0.1
image_size = (1000, 1000)
beam_centre_mm = (
pixel_size * image_size[0] / 2,
pixel_size * image_size[1] / 2,
)
self.detector = DetectorFactory().simple(
"CCD",
distance,
beam_centre_mm,
"+x",
"-y",
(pixel_size, pixel_size),
image_size,
)
# Set up beam
self.beam = BeamFactory().simple(wavelength=1)
# Set up scan
sequence_width = 90.0
osc_start = 0.0
image_width = 0.2
oscillation = (osc_start, image_width)
nframes = int(math.ceil(sequence_width / image_width))
image_range = (1, nframes)
exposure_times = 0.0
epochs = [0] * nframes
self.scan = ScanFactory().make_scan(image_range,
exposure_times,
oscillation,
epochs,
deg=True)
# Set up goniometer
self.goniometer = GoniometerFactory.known_axis(
self.detector[0].get_fast_axis())
# Set up simulated structure factors
self.sfall = self.fcalc_from_pdb(resolution=1.6,
algorithm="direct",
override_fdp=override_fdp)
# Set up crystal
self.crystal = Crystal(
real_space_a=(50, 0, 0),
real_space_b=(0, 60, 0),
real_space_c=(0, 0, 70),
space_group_symbol="P1",
)
axis = matrix.col(elems=(-0.14480368275412925, -0.6202131724405818,
-0.7709523423610766))
self.crystal.set_U(
axis.axis_and_angle_as_r3_rotation_matrix(angle=0.625126343998969))
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 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 test_multi_axis_goniometer():
g1 = GoniometerFactory.multi_axis(flex.vec3_double(((1, 0, 0), )),
flex.double((0, )),
flex.std_string(("PHI", )), 0)
d = g1.to_dict()
g2 = GoniometerFactory.from_dict(d)
assert d["axes"] == [(1, 0, 0)]
assert d["angles"] == [0.0]
assert d["names"] == ["PHI"]
assert d["scan_axis"] == 0
assert g1 == g2
assert "setting_rotation_at_scan_points" not in d
# Test with a template and partial dictionary
d2 = {"axes": [(0, 1, 0)]}
g3 = GoniometerFactory.from_dict(d2, d)
assert g3.get_rotation_axis() == (0, 1, 0)
assert g3.get_fixed_rotation() == (1, 0, 0, 0, 1, 0, 0, 0, 1)
assert g2 != g3
def test_goniometer_with_scan_points():
simple_g = Goniometer((1, 0, 0), (1, 0, 0, 0, 1, 0, 0, 0, 1))
multi_ax_g = GoniometerFactory.multi_axis(flex.vec3_double(((1, 0, 0), )),
flex.double((0, )),
flex.std_string(("PHI", )), 0)
for g1 in [simple_g, multi_ax_g]:
S_static = matrix.sqr(g1.get_setting_rotation())
g1.set_setting_rotation_at_scan_points([S_static] * 5)
d = g1.to_dict()
g2 = GoniometerFactory.from_dict(d)
for Scomp in d["setting_rotation_at_scan_points"]:
assert matrix.sqr(Scomp) == S_static
for Scomp in g2.get_setting_rotation_at_scan_points():
assert matrix.sqr(Scomp) == S_static
assert g1 == g2
def test_multi_axis_goniometer():
from dxtbx.model import GoniometerFactory
from scitbx.array_family import flex
g1 = GoniometerFactory.multi_axis(flex.vec3_double(((1, 0, 0), )),
flex.double((0, )),
flex.std_string(('PHI', )), 0)
d = g1.to_dict()
g2 = GoniometerFactory.from_dict(d)
assert d['axes'] == [(1, 0, 0)]
assert d['angles'] == [0.0]
assert d['names'] == ['PHI']
assert d['scan_axis'] == 0
assert g1 == g2
assert 'setting_rotation_at_scan_points' not in d
# Test with a template and partial dictionary
d2 = {'axes': [(0, 1, 0)]}
g3 = GoniometerFactory.from_dict(d2, d)
assert g3.get_rotation_axis() == (0, 1, 0)
assert g3.get_fixed_rotation() == (1, 0, 0, 0, 1, 0, 0, 0, 1)
assert g2 != g3
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 import_geometry(xds_inp=None, dials_json=None):
assert (xds_inp, dials_json).count(None) == 1
geom_kwds = set([
"DIRECTION_OF_DETECTOR_X-AXIS",
"DIRECTION_OF_DETECTOR_Y-AXIS",
"DETECTOR_DISTANCE",
"ORGX",
"ORGY",
"ROTATION_AXIS", # "X-RAY_WAVELENGTH",
"INCIDENT_BEAM_DIRECTION",
"SEGMENT",
"DIRECTION_OF_SEGMENT_X-AXIS",
"DIRECTION_OF_SEGMENT_Y-AXIS",
"SEGMENT_DISTANCE",
"SEGMENT_ORGX",
"SEGMENT_ORGY"
])
# FIXME in case of multi-segment detector..
if xds_inp:
inp = get_xdsinp_keyword(xds_inp)
inp = filter(lambda x: x[0] in geom_kwds, inp)
return map(lambda x: "%s= %s" % x, inp)
elif dials_json:
import dxtbx.imageset
from dxtbx.serialize.load import _decode_dict
from dxtbx.model import BeamFactory
from dxtbx.model import DetectorFactory
from dxtbx.model import GoniometerFactory
from dxtbx.model import ScanFactory
from dxtbx.serialize.xds import to_xds
j = json.loads(open(dials_json).read(), object_hook=_decode_dict)
# dummy
sweep = dxtbx.imageset.ImageSetFactory.from_template(
"####", image_range=[1, 1], check_format=False)[0]
sweep.set_detector(DetectorFactory.from_dict(j["detector"][0]))
sweep.set_beam(BeamFactory.from_dict(j["beam"][0]))
sweep.set_goniometer(GoniometerFactory.from_dict(j["goniometer"][0]))
sweep.set_scan(
ScanFactory.make_scan(image_range=[1, 1],
exposure_times=[1],
oscillation=[1, 2],
epochs=[0])) # dummy
sio = cStringIO.StringIO()
to_xds(sweep).XDS_INP(sio)
inp = get_xdsinp_keyword(inp_str=sio.getvalue())
inp = filter(lambda x: x[0] in geom_kwds, inp)
return map(lambda x: "%s= %s" % x, inp)
return []
def test_goniometer_with_scan_points():
from dxtbx.model import Goniometer, GoniometerFactory
from scitbx.array_family import flex
simple_g = Goniometer((1, 0, 0), (1, 0, 0, 0, 1, 0, 0, 0, 1))
multi_ax_g = GoniometerFactory.multi_axis(flex.vec3_double(((1, 0, 0), )),
flex.double((0, )),
flex.std_string(('PHI', )), 0)
from scitbx import matrix
for g1 in [simple_g, multi_ax_g]:
S_static = matrix.sqr(g1.get_setting_rotation())
g1.set_setting_rotation_at_scan_points([S_static] * 5)
d = g1.to_dict()
g2 = GoniometerFactory.from_dict(d)
for Scomp in d['setting_rotation_at_scan_points']:
assert matrix.sqr(Scomp) == S_static
for Scomp in g2.get_setting_rotation_at_scan_points():
assert matrix.sqr(Scomp) == S_static
assert g1 == g2
def test_experiment_singleaxisgonio():
gonio = GoniometerFactory.from_dict({
"axes": [
[1.0, 0.0, 0.0],
],
"angles": [0.0],
"names": ["GON_PHI"],
"scan_axis": 0,
})
return Experiment(
beam=Beam(s0=(0.0, 0.0, 2.0)),
goniometer=gonio,
scan=Scan(image_range=[1, 90], oscillation=[0.0, 1.0]),
)
def load_models(obj):
try:
beam = BeamFactory.from_dict(blist[obj['beam']])
except Exception:
beam = None
try:
dobj = dlist[obj['detector']]
detector = DetectorFactory.from_dict(dobj)
except Exception:
detector = None
try:
gonio = GoniometerFactory.from_dict(glist[obj['goniometer']])
except Exception:
gonio = None
try:
scan = ScanFactory.from_dict(slist[obj['scan']])
except Exception:
scan = None
return beam, detector, gonio, scan
def _goniometer_from_dict(obj):
''' Get the goniometer from a dictionary. '''
from dxtbx.model import GoniometerFactory
return GoniometerFactory.from_dict(obj)
def imagesweep_from_dict(d, check_format=True):
'''Construct and image sweep from the dictionary.'''
from dxtbx.imageset import ImageSetFactory
from dxtbx.model import BeamFactory, DetectorFactory, GoniometerFactory, ScanFactory
from dxtbx.serialize.filename import load_path
# Get the template (required)
template = load_path(str(d['template']))
# If the scan isn't set, find all available files
scan_dict = d.get('scan')
if scan_dict is None:
image_range = None
else:
image_range = scan_dict.get('image_range')
# Construct the sweep
try:
sweep = ImageSetFactory.from_template(template,
image_range,
check_format=check_format)[0]
# Get the existing models as dictionaries
beam_dict = sweep.get_beam().to_dict()
gonio_dict = sweep.get_goniometer().to_dict()
detector_dict = sweep.get_detector().to_dict()
scan_dict = sweep.get_scan().to_dict()
except Exception:
indices = range(image_range[0], image_range[1] + 1)
sweep = ImageSetFactory.make_sweep(template,
indices,
check_format=False)
beam_dict = None
gonio_dict = None
detector_dict = None
scan_dict = None
# Set some external lookups
if 'mask' in d and d['mask'] is not None:
with open(d['mask']) as infile:
sweep.external_lookup.mask.filename = d['mask']
sweep.external_lookup.mask.data = pickle.load(infile)
if 'gain' in d and d['gain'] is not None:
with open(d['gain']) as infile:
sweep.external_lookup.gain.filename = d['gain']
sweep.external_lookup.gain.data = pickle.load(infile)
if 'pedestal' in d and d['pedestal'] is not None:
with open(d['pedestal']) as infile:
sweep.external_lookup.pedestal.filename = d['pedestal']
sweep.external_lookup.pedestal.data = pickle.load(infile)
# Set the models with the exisiting models as templates
sweep.set_beam(BeamFactory.from_dict(d.get('beam'), beam_dict))
sweep.set_goniometer(
GoniometerFactory.from_dict(d.get('goniometer'), gonio_dict))
sweep.set_detector(
DetectorFactory.from_dict(d.get('detector'), detector_dict))
sweep.set_scan(ScanFactory.from_dict(d.get('scan'), scan_dict))
# Return the sweep
return sweep
def build_goniometer(self):
self.goniometer = GoniometerFactory.known_axis(
self._params.goniometer.axis)
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 import Crystal
crystal = Crystal((40., 0., 0.), (0., 40., 0.), (0., 0., 40.),
space_group_symbol="P1")
from dxtbx.model import GoniometerFactory
goniometer = GoniometerFactory.known_axis((1., 0., 0.))
# Build a mock scan for a 180 degree sweep
from dxtbx.model import ScanFactory
sf = ScanFactory()
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_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,
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
def test_refinement(dials_regression):
"""Test a refinement run"""
# Get a beam and detector from a experiments. This one has a CS-PAD, but that
# is irrelevant
data_dir = os.path.join(dials_regression, "refinement_test_data",
"hierarchy_test")
experiments_path = os.path.join(data_dir, "datablock.json")
assert os.path.exists(experiments_path)
# load models
from dxtbx.model.experiment_list import ExperimentListFactory
experiments = ExperimentListFactory.from_serialized_format(
experiments_path, check_format=False)
im_set = experiments.imagesets()[0]
detector = deepcopy(im_set.get_detector())
beam = im_set.get_beam()
# Invent a crystal, goniometer and scan for this test
from dxtbx.model import Crystal
crystal = Crystal((40.0, 0.0, 0.0), (0.0, 40.0, 0.0), (0.0, 0.0, 40.0),
space_group_symbol="P1")
orig_xl = deepcopy(crystal)
from dxtbx.model import GoniometerFactory
goniometer = GoniometerFactory.known_axis((1.0, 0.0, 0.0))
# Build a mock scan for a 180 degree sequence
from dxtbx.model import ScanFactory
sf = ScanFactory()
scan = sf.make_scan(
image_range=(1, 1800),
exposure_times=0.1,
oscillation=(0, 0.1),
epochs=list(range(1800)),
deg=True,
)
sequence_range = scan.get_oscillation_range(deg=False)
im_width = scan.get_oscillation(deg=False)[1]
assert sequence_range == (0.0, pi)
assert approx_equal(im_width, 0.1 * pi / 180.0)
# 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, _ = generate_reflections(experiments)
# change unit cell a bit (=0.1 Angstrom length upsets, 0.1 degree of
# alpha and beta angles)
from dials.algorithms.refinement.parameterisation.crystal_parameters import (
CrystalUnitCellParameterisation, )
xluc_param = CrystalUnitCellParameterisation(crystal)
cell_params = crystal.get_unit_cell().parameters()
cell_params = [
a + b for a, b in zip(cell_params, [0.1, -0.1, 0.1, 0.1, -0.1, 0.0])
]
from cctbx.uctbx import unit_cell
from rstbx.symmetry.constraints.parameter_reduction import symmetrize_reduce_enlarge
from scitbx import matrix
new_uc = unit_cell(cell_params)
newB = matrix.sqr(new_uc.fractionalization_matrix()).transpose()
S = symmetrize_reduce_enlarge(crystal.get_space_group())
S.set_orientation(orientation=newB)
X = tuple([e * 1.0e5 for e in S.forward_independent_parameters()])
xluc_param.set_param_vals(X)
# reparameterise the crystal at the perturbed geometry
xluc_param = CrystalUnitCellParameterisation(crystal)
# Dummy parameterisations for other models
beam_param = None
xlo_param = None
det_param = None
# parameterisation of the prediction equation
from dials.algorithms.refinement.parameterisation.parameter_report import (
ParameterReporter, )
pred_param = TwoThetaPredictionParameterisation(experiments, det_param,
beam_param, xlo_param,
[xluc_param])
param_reporter = ParameterReporter(det_param, beam_param, xlo_param,
[xluc_param])
# reflection manager
refman = TwoThetaReflectionManager(refs, experiments, nref_per_degree=20)
# reflection predictor
ref_predictor = TwoThetaExperimentsPredictor(experiments)
# target function
target = TwoThetaTarget(experiments, ref_predictor, refman, pred_param)
# minimisation engine
from dials.algorithms.refinement.engine import (
LevenbergMarquardtIterations as Refinery, )
refinery = Refinery(
target=target,
prediction_parameterisation=pred_param,
log=None,
max_iterations=20,
)
# Refiner
from dials.algorithms.refinement.refiner import Refiner
refiner = Refiner(
experiments=experiments,
pred_param=pred_param,
param_reporter=param_reporter,
refman=refman,
target=target,
refinery=refinery,
)
refiner.run()
# compare crystal with original crystal
refined_xl = refiner.get_experiments()[0].crystal
# print refined_xl
assert refined_xl.is_similar_to(orig_xl,
uc_rel_length_tolerance=0.001,
uc_abs_angle_tolerance=0.01)
def _goniometer_from_dict(obj):
""" Get the goniometer from a dictionary. """
return GoniometerFactory.from_dict(obj)
