def __init__(self, phi0, misset0, phi1, misset1):
"""Initialise the rotation axis and what have you from some
experimental results. N.B. all input values in DEGREES."""
# canonical: X = X-ray beam
# Z = rotation axis
# Y = Z ^ X
z = matrix.col([0, 0, 1])
# then calculate the rotation axis
R = (
(
z.axis_and_angle_as_r3_rotation_matrix(phi1, deg=True)
* matrix.sqr(xyz_matrix(misset1[0], misset1[1], misset1[2]))
)
* (
z.axis_and_angle_as_r3_rotation_matrix(phi0, deg=True)
* matrix.sqr(xyz_matrix(misset0[0], misset0[1], misset0[2]))
).inverse()
)
self._z = z
self._r = matrix.col(r3_rotation_axis_and_angle_from_matrix(R).axis)
self._M0 = matrix.sqr(xyz_matrix(misset0[0], misset0[1], misset0[2]))
return
def __init__(self, phi0, misset0, phi1, misset1):
"""Initialise the rotation axis and what have you from some
experimental results. N.B. all input values in DEGREES."""
# canonical: X = X-ray beam
# Z = rotation axis
# Y = Z ^ X
z = matrix.col([0, 0, 1])
# then calculate the rotation axis
R = (
(
z.axis_and_angle_as_r3_rotation_matrix(phi1, deg=True)
* matrix.sqr(xyz_matrix(misset1[0], misset1[1], misset1[2]))
)
* (
z.axis_and_angle_as_r3_rotation_matrix(phi0, deg=True)
* matrix.sqr(xyz_matrix(misset0[0], misset0[1], misset0[2]))
).inverse()
)
self._z = z
self._r = matrix.col(r3_rotation_axis_and_angle_from_matrix(R).axis)
self._M0 = matrix.sqr(xyz_matrix(misset0[0], misset0[1], misset0[2]))
return
def compute(work_params,
use_wavelength_2=False,
store_miller_index_i_seqs=False,
store_spots=False,
store_signals=False,
set_pixels=False):
i_calc = build_i_calc(work_params)
from scitbx.math.euler_angles import xyz_matrix
crystal_rotation_matrix = xyz_matrix(*work_params.euler_angles_xyz)
work_params.crystal_rotation_matrix = crystal_rotation_matrix
if (not use_wavelength_2):
wavelength = work_params.wavelength
else:
wavelength = work_params.wavelength_2
from rstbx.simage import image_simple
return i_calc, image_simple(
store_miller_index_i_seqs=store_miller_index_i_seqs,
store_spots=store_spots,
store_signals=store_signals,
set_pixels=set_pixels).compute(
unit_cell=i_calc.p1_anom.unit_cell(),
miller_indices=i_calc.p1_anom.indices(),
spot_intensity_factors=i_calc.p1_anom.data(),
crystal_rotation_matrix=crystal_rotation_matrix,
ewald_radius=1 / wavelength,
ewald_proximity=work_params.ewald_proximity,
signal_max=work_params.signal_max,
detector_distance=work_params.detector.distance,
detector_size=work_params.detector.size,
detector_pixels=work_params.detector.pixels,
point_spread=work_params.point_spread,
gaussian_falloff_scale=work_params.gaussian_falloff_scale)
def compute(
work_params,
use_wavelength_2=False,
store_miller_index_i_seqs=False,
store_spots=False,
store_signals=False,
set_pixels=False):
i_calc = build_i_calc(work_params)
from scitbx.math.euler_angles import xyz_matrix
crystal_rotation_matrix = xyz_matrix(*work_params.euler_angles_xyz)
work_params.crystal_rotation_matrix = crystal_rotation_matrix
if (not use_wavelength_2):
wavelength = work_params.wavelength
else:
wavelength = work_params.wavelength_2
from rstbx.simage import image_simple
return i_calc, image_simple(
store_miller_index_i_seqs=store_miller_index_i_seqs,
store_spots=store_spots,
store_signals=store_signals,
set_pixels=set_pixels).compute(
unit_cell=i_calc.p1_anom.unit_cell(),
miller_indices=i_calc.p1_anom.indices(),
spot_intensity_factors=i_calc.p1_anom.data(),
crystal_rotation_matrix=crystal_rotation_matrix,
ewald_radius=1/wavelength,
ewald_proximity=work_params.ewald_proximity,
signal_max=work_params.signal_max,
detector_distance=work_params.detector.distance,
detector_size=work_params.detector.size,
detector_pixels=work_params.detector.pixels,
point_spread=work_params.point_spread,
gaussian_falloff_scale=work_params.gaussian_falloff_scale)
def exercise():
from dials.algorithms.indexing import compare_orientation_matrices
from dxtbx.model import Crystal
from cctbx import sgtbx
from scitbx import matrix
from scitbx.math import euler_angles as euler
# try and see if we can get back the original rotation matrix and euler angles
real_space_a = matrix.col((10, 0, 0))
real_space_b = matrix.col((0, 10, 10))
real_space_c = matrix.col((0, 0, 10))
euler_angles = (1.3, 5.6, 7.8)
R = matrix.sqr(
euler.xyz_matrix(euler_angles[0], euler_angles[1], euler_angles[2]))
crystal_a = Crystal(real_space_a,
real_space_b,
real_space_c,
space_group=sgtbx.space_group('P 1'))
crystal_b = Crystal(R * real_space_a,
R * real_space_b,
R * real_space_c,
space_group=sgtbx.space_group('P 1'))
assert approx_equal(
matrix.sqr(crystal_b.get_U()) *
matrix.sqr(crystal_a.get_U()).transpose(), R)
best_R_ab, best_axis, best_angle, best_cb_op = \
compare_orientation_matrices.difference_rotation_matrix_axis_angle(
crystal_a,
crystal_b)
best_euler_angles = euler.xyz_angles(best_R_ab)
assert approx_equal(best_euler_angles, euler_angles)
assert best_cb_op.is_identity_op()
assert approx_equal(best_R_ab, R)
# now see if we can deconvolute the original euler angles after applying
# a change of basis to one of the crystals
crystal_a = Crystal(real_space_a,
real_space_b,
real_space_c,
space_group=sgtbx.space_group('I 2 3'))
crystal_b = Crystal(R * real_space_a,
R * real_space_b,
R * real_space_c,
space_group=sgtbx.space_group('I 2 3'))
cb_op = sgtbx.change_of_basis_op('z,x,y')
crystal_b = crystal_b.change_basis(cb_op)
best_R_ab, best_axis, best_angle, best_cb_op = \
compare_orientation_matrices.difference_rotation_matrix_axis_angle(
crystal_a,
crystal_b)
best_euler_angles = euler.xyz_angles(best_R_ab)
assert approx_equal(best_euler_angles, euler_angles)
assert best_cb_op.c() == cb_op.inverse().c()
assert approx_equal(best_R_ab, R)
def exercise():
from dials.algorithms.indexing import compare_orientation_matrices
from dxtbx.model.crystal import crystal_model
from cctbx import sgtbx
from scitbx import matrix
from scitbx.math import euler_angles as euler
# try and see if we can get back the original rotation matrix and euler angles
real_space_a = matrix.col((10,0,0))
real_space_b = matrix.col((0,10,10))
real_space_c = matrix.col((0,0,10))
euler_angles = (1.3, 5.6, 7.8)
R = matrix.sqr(
euler.xyz_matrix(euler_angles[0], euler_angles[1], euler_angles[2]))
crystal_a = crystal_model(real_space_a,
real_space_b,
real_space_c,
space_group=sgtbx.space_group('P 1'))
crystal_b = crystal_model(R * real_space_a,
R * real_space_b,
R * real_space_c,
space_group=sgtbx.space_group('P 1'))
assert approx_equal(crystal_b.get_U() * crystal_a.get_U().transpose(), R)
best_R_ab, best_axis, best_angle, best_cb_op = \
compare_orientation_matrices.difference_rotation_matrix_axis_angle(
crystal_a,
crystal_b)
best_euler_angles = euler.xyz_angles(best_R_ab)
assert approx_equal(best_euler_angles, euler_angles)
assert best_cb_op.is_identity_op()
assert approx_equal(best_R_ab, R)
# now see if we can deconvolute the original euler angles after applying
# a change of basis to one of the crystals
crystal_a = crystal_model(real_space_a,
real_space_b,
real_space_c,
space_group=sgtbx.space_group('I 2 3'))
crystal_b = crystal_model(R * real_space_a,
R * real_space_b,
R * real_space_c,
space_group=sgtbx.space_group('I 2 3'))
cb_op = sgtbx.change_of_basis_op('z,x,y')
crystal_b = crystal_b.change_basis(cb_op)
best_R_ab, best_axis, best_angle, best_cb_op = \
compare_orientation_matrices.difference_rotation_matrix_axis_angle(
crystal_a,
crystal_b)
best_euler_angles = euler.xyz_angles(best_R_ab)
assert approx_equal(best_euler_angles, euler_angles)
assert best_cb_op.c() == cb_op.inverse().c()
assert approx_equal(best_R_ab, R)
def test_compare_orientation_matrices():
# try and see if we can get back the original rotation matrix and euler angles
real_space_a = matrix.col((10, 0, 0))
real_space_b = matrix.col((0, 10, 10))
real_space_c = matrix.col((0, 0, 10))
euler_angles = (1.3, 5.6, 7.8)
R = matrix.sqr(
euler.xyz_matrix(euler_angles[0], euler_angles[1], euler_angles[2]))
crystal_a = Crystal(real_space_a,
real_space_b,
real_space_c,
space_group=sgtbx.space_group('P 1'))
crystal_b = Crystal(R * real_space_a,
R * real_space_b,
R * real_space_c,
space_group=sgtbx.space_group('P 1'))
assert (matrix.sqr(crystal_b.get_U()) *
matrix.sqr(crystal_a.get_U()).transpose()).elems == pytest.approx(
R.elems)
best_R_ab, best_axis, best_angle, best_cb_op = \
compare_orientation_matrices.difference_rotation_matrix_axis_angle(
crystal_a,
crystal_b)
best_euler_angles = euler.xyz_angles(best_R_ab)
assert best_euler_angles == pytest.approx(euler_angles)
assert best_cb_op.is_identity_op()
assert best_R_ab.elems == pytest.approx(R.elems)
# now see if we can deconvolute the original euler angles after applying
# a change of basis to one of the crystals
crystal_a = Crystal(real_space_a,
real_space_b,
real_space_c,
space_group=sgtbx.space_group('I 2 3'))
crystal_b = Crystal(R * real_space_a,
R * real_space_b,
R * real_space_c,
space_group=sgtbx.space_group('I 2 3'))
cb_op = sgtbx.change_of_basis_op('z,x,y')
crystal_b = crystal_b.change_basis(cb_op)
best_R_ab, best_axis, best_angle, best_cb_op = \
compare_orientation_matrices.difference_rotation_matrix_axis_angle(
crystal_a,
crystal_b)
best_euler_angles = euler.xyz_angles(best_R_ab)
assert best_euler_angles == pytest.approx(euler_angles)
assert best_cb_op.c() == cb_op.inverse().c()
assert best_R_ab.elems == pytest.approx(R.elems)
def test_crystal_model():
real_space_a = matrix.col((10, 0, 0))
real_space_b = matrix.col((0, 11, 0))
real_space_c = matrix.col((0, 0, 12))
model = Crystal(
real_space_a=(10, 0, 0),
real_space_b=(0, 11, 0),
real_space_c=(0, 0, 12),
space_group_symbol="P 1",
)
# This doesn't work as python class uctbx.unit_cell(uctbx_ext.unit_cell)
# so C++ and python classes are different types
# assert isinstance(model.get_unit_cell(), uctbx.unit_cell)
assert model.get_unit_cell().parameters() == (10.0, 11.0, 12.0, 90.0, 90.0,
90.0)
assert approx_equal(model.get_A(),
(1 / 10, 0, 0, 0, 1 / 11, 0, 0, 0, 1 / 12))
assert approx_equal(
matrix.sqr(model.get_A()).inverse(), (10, 0, 0, 0, 11, 0, 0, 0, 12))
assert approx_equal(model.get_B(), model.get_A())
assert approx_equal(model.get_U(), (1, 0, 0, 0, 1, 0, 0, 0, 1))
assert approx_equal(model.get_real_space_vectors(),
(real_space_a, real_space_b, real_space_c))
assert (model.get_crystal_symmetry().unit_cell().parameters() ==
model.get_unit_cell().parameters())
assert model.get_crystal_symmetry().space_group() == model.get_space_group(
)
model2 = Crystal(
real_space_a=(10, 0, 0),
real_space_b=(0, 11, 0),
real_space_c=(0, 0, 12),
space_group_symbol="P 1",
)
assert model == model2
model2a = Crystal(model.get_A(), model.get_space_group())
assert model == model2a
model2b = Crystal(
matrix.sqr(model.get_A()).inverse().elems,
model.get_space_group().type().lookup_symbol(),
reciprocal=False,
)
assert model == model2b
# rotate 45 degrees about x-axis
R1 = matrix.sqr((
1,
0,
0,
0,
math.cos(math.pi / 4),
-math.sin(math.pi / 4),
0,
math.sin(math.pi / 4),
math.cos(math.pi / 4),
))
# rotate 30 degrees about y-axis
R2 = matrix.sqr((
math.cos(math.pi / 6),
0,
math.sin(math.pi / 6),
0,
1,
0,
-math.sin(math.pi / 6),
0,
math.cos(math.pi / 6),
))
# rotate 60 degrees about z-axis
R3 = matrix.sqr((
math.cos(math.pi / 3),
-math.sin(math.pi / 3),
0,
math.sin(math.pi / 3),
math.cos(math.pi / 3),
0,
0,
0,
1,
))
R = R1 * R2 * R3
model.set_U(R)
# B is unchanged
assert approx_equal(model.get_B(),
(1 / 10, 0, 0, 0, 1 / 11, 0, 0, 0, 1 / 12))
assert approx_equal(model.get_U(), R)
assert approx_equal(model.get_A(),
matrix.sqr(model.get_U()) * matrix.sqr(model.get_B()))
a_, b_, c_ = model.get_real_space_vectors()
assert approx_equal(a_, R * real_space_a)
assert approx_equal(b_, R * real_space_b)
assert approx_equal(c_, R * real_space_c)
assert (str(model).replace("-0.0000", " 0.0000") == """\
Crystal:
Unit cell: (10.000, 11.000, 12.000, 90.000, 90.000, 90.000)
Space group: P 1
U matrix: {{ 0.4330, -0.7500, 0.5000},
{ 0.7891, 0.0474, -0.6124},
{ 0.4356, 0.6597, 0.6124}}
B matrix: {{ 0.1000, 0.0000, 0.0000},
{ 0.0000, 0.0909, 0.0000},
{ 0.0000, 0.0000, 0.0833}}
A = UB: {{ 0.0433, -0.0682, 0.0417},
{ 0.0789, 0.0043, -0.0510},
{ 0.0436, 0.0600, 0.0510}}
""")
model.set_B((1 / 12, 0, 0, 0, 1 / 12, 0, 0, 0, 1 / 12))
assert approx_equal(model.get_unit_cell().parameters(),
(12, 12, 12, 90, 90, 90))
U = matrix.sqr((0.3455, -0.2589, -0.9020, 0.8914, 0.3909, 0.2293, 0.2933,
-0.8833, 0.3658))
B = matrix.sqr((1 / 13, 0, 0, 0, 1 / 13, 0, 0, 0, 1 / 13))
model.set_A(U * B)
assert approx_equal(model.get_A(), U * B)
assert approx_equal(model.get_U(), U, 1e-4)
assert approx_equal(model.get_B(), B, 1e-5)
model3 = Crystal(
real_space_a=(10, 0, 0),
real_space_b=(0, 11, 0),
real_space_c=(0, 0, 12),
space_group=sgtbx.space_group_info("P 222").group(),
)
assert model3.get_space_group().type().hall_symbol() == " P 2 2"
assert model != model3
#
sgi_ref = sgtbx.space_group_info(number=230)
model_ref = Crystal(
real_space_a=(44, 0, 0),
real_space_b=(0, 44, 0),
real_space_c=(0, 0, 44),
space_group=sgi_ref.group(),
)
assert approx_equal(model_ref.get_U(), (1, 0, 0, 0, 1, 0, 0, 0, 1))
assert approx_equal(model_ref.get_B(),
(1 / 44, 0, 0, 0, 1 / 44, 0, 0, 0, 1 / 44))
assert approx_equal(model_ref.get_A(), model_ref.get_B())
assert approx_equal(model_ref.get_unit_cell().parameters(),
(44, 44, 44, 90, 90, 90))
a_ref, b_ref, c_ref = map(matrix.col, model_ref.get_real_space_vectors())
cb_op_to_primitive = sgi_ref.change_of_basis_op_to_primitive_setting()
model_primitive = model_ref.change_basis(cb_op_to_primitive)
cb_op_to_reference = (model_primitive.get_space_group().info().
change_of_basis_op_to_reference_setting())
a_prim, b_prim, c_prim = map(matrix.col,
model_primitive.get_real_space_vectors())
assert (cb_op_to_primitive.as_abc() ==
"-1/2*a+1/2*b+1/2*c,1/2*a-1/2*b+1/2*c,1/2*a+1/2*b-1/2*c")
assert approx_equal(a_prim, -1 / 2 * a_ref + 1 / 2 * b_ref + 1 / 2 * c_ref)
assert approx_equal(b_prim, 1 / 2 * a_ref - 1 / 2 * b_ref + 1 / 2 * c_ref)
assert approx_equal(c_prim, 1 / 2 * a_ref + 1 / 2 * b_ref - 1 / 2 * c_ref)
assert cb_op_to_reference.as_abc() == "b+c,a+c,a+b"
assert approx_equal(a_ref, b_prim + c_prim)
assert approx_equal(b_ref, a_prim + c_prim)
assert approx_equal(c_ref, a_prim + b_prim)
assert approx_equal(
model_primitive.get_U(),
[
-0.5773502691896258,
0.40824829046386285,
0.7071067811865476,
0.5773502691896257,
-0.4082482904638631,
0.7071067811865476,
0.5773502691896257,
0.8164965809277259,
0.0,
],
)
assert approx_equal(
model_primitive.get_B(),
[
0.0262431940540739,
0.0,
0.0,
0.00927837023781507,
0.02783511071344521,
0.0,
0.01607060866333063,
0.01607060866333063,
0.03214121732666125,
],
)
assert approx_equal(
model_primitive.get_A(),
(0, 1 / 44, 1 / 44, 1 / 44, 0, 1 / 44, 1 / 44, 1 / 44, 0),
)
assert approx_equal(
model_primitive.get_unit_cell().parameters(),
[
38.1051177665153,
38.1051177665153,
38.1051177665153,
109.47122063449069,
109.47122063449069,
109.47122063449069,
],
)
assert model_ref != model_primitive
model_ref_recycled = model_primitive.change_basis(cb_op_to_reference)
assert approx_equal(model_ref.get_U(), model_ref_recycled.get_U())
assert approx_equal(model_ref.get_B(), model_ref_recycled.get_B())
assert approx_equal(model_ref.get_A(), model_ref_recycled.get_A())
assert approx_equal(
model_ref.get_unit_cell().parameters(),
model_ref_recycled.get_unit_cell().parameters(),
)
assert model_ref == model_ref_recycled
uc = uctbx.unit_cell(
(58.2567, 58.1264, 39.7093, 46.9077, 46.8612, 62.1055))
sg = sgtbx.space_group_info(symbol="P1").group()
cs = crystal.symmetry(unit_cell=uc, space_group=sg)
cb_op_to_minimum = cs.change_of_basis_op_to_minimum_cell()
# the reciprocal matrix
B = matrix.sqr(uc.fractionalization_matrix()).transpose()
U = random_rotation()
direct_matrix = (U * B).inverse()
model = Crystal(direct_matrix[:3],
direct_matrix[3:6],
direct_matrix[6:9],
space_group=sg)
assert uc.is_similar_to(model.get_unit_cell())
uc_minimum = uc.change_basis(cb_op_to_minimum)
model_minimum = model.change_basis(cb_op_to_minimum)
assert uc_minimum.is_similar_to(model_minimum.get_unit_cell())
assert model_minimum != model
model_minimum.update(model)
assert model_minimum == model # lgtm
A_static = matrix.sqr(model.get_A())
A_as_scan_points = [A_static]
num_scan_points = 11
for i in range(num_scan_points - 1):
A_as_scan_points.append(
A_as_scan_points[-1] *
matrix.sqr(euler_angles.xyz_matrix(0.1, 0.2, 0.3)))
model.set_A_at_scan_points(A_as_scan_points)
model_minimum = model.change_basis(cb_op_to_minimum)
assert model.num_scan_points == model_minimum.num_scan_points == num_scan_points
M = matrix.sqr(cb_op_to_minimum.c_inv().r().transpose().as_double())
M_inv = M.inverse()
for i in range(num_scan_points):
A_orig = matrix.sqr(model.get_A_at_scan_point(i))
A_min = matrix.sqr(model_minimum.get_A_at_scan_point(i))
assert approx_equal(A_min, A_orig * M_inv)
assert model.get_unit_cell().parameters() == pytest.approx(
(58.2567, 58.1264, 39.7093, 46.9077, 46.8612, 62.1055))
uc = uctbx.unit_cell((10, 11, 12, 91, 92, 93))
model.set_unit_cell(uc)
assert model.get_unit_cell().parameters() == pytest.approx(uc.parameters())
def exercise_crystal_model():
real_space_a = matrix.col((10,0,0))
real_space_b = matrix.col((0,11,0))
real_space_c = matrix.col((0,0,12))
model = crystal_model(real_space_a=(10,0,0),
real_space_b=(0,11,0),
real_space_c=(0,0,12),
space_group_symbol="P 1")
assert isinstance(model.get_unit_cell(), uctbx.unit_cell)
assert model.get_unit_cell().parameters() == (
10.0, 11.0, 12.0, 90.0, 90.0, 90.0)
assert approx_equal(model.get_A(), (1/10, 0, 0, 0, 1/11, 0, 0, 0, 1/12))
assert approx_equal(model.get_A().inverse(), (10, 0, 0, 0, 11, 0, 0, 0, 12))
assert approx_equal(model.get_B(), model.get_A())
assert approx_equal(model.get_U(), (1, 0, 0, 0, 1, 0, 0, 0, 1))
assert approx_equal(model.get_real_space_vectors(),
(real_space_a, real_space_b, real_space_c))
assert approx_equal(model.get_mosaicity(), 0)
model2 = crystal_model(real_space_a=(10,0,0),
real_space_b=(0,11,0),
real_space_c=(0,0,12),
space_group_symbol="P 1")
assert model == model2
model2.set_mosaicity(0.01)
assert model != model2
# rotate 45 degrees about x-axis
R1 = matrix.sqr((1, 0, 0,
0, math.cos(math.pi/4), -math.sin(math.pi/4),
0, math.sin(math.pi/4), math.cos(math.pi/4)))
# rotate 30 degrees about y-axis
R2 = matrix.sqr((math.cos(math.pi/6), 0, math.sin(math.pi/6),
0, 1, 0,
-math.sin(math.pi/6), 0, math.cos(math.pi/6)))
# rotate 60 degrees about z-axis
R3 = matrix.sqr((math.cos(math.pi/3), -math.sin(math.pi/3), 0,
math.sin(math.pi/3), math.cos(math.pi/3), 0,
0, 0, 1))
R = R1 * R2 * R3
model.set_U(R)
# B is unchanged
assert approx_equal(model.get_B(), (1/10, 0, 0, 0, 1/11, 0, 0, 0, 1/12))
assert approx_equal(model.get_U(), R)
assert approx_equal(model.get_A(), model.get_U() * model.get_B())
a_, b_, c_ = model.get_real_space_vectors()
assert approx_equal(a_, R * real_space_a)
assert approx_equal(b_, R * real_space_b)
assert approx_equal(c_, R * real_space_c)
s = StringIO()
print >> s, model
assert not show_diff(s.getvalue().replace("-0.0000", " 0.0000"), """\
Crystal:
Unit cell: (10.000, 11.000, 12.000, 90.000, 90.000, 90.000)
Space group: P 1
U matrix: {{ 0.4330, -0.7500, 0.5000},
{ 0.7891, 0.0474, -0.6124},
{ 0.4356, 0.6597, 0.6124}}
B matrix: {{ 0.1000, 0.0000, 0.0000},
{ 0.0000, 0.0909, 0.0000},
{ 0.0000, 0.0000, 0.0833}}
A = UB: {{ 0.0433, -0.0682, 0.0417},
{ 0.0789, 0.0043, -0.0510},
{ 0.0436, 0.0600, 0.0510}}
""")
model.set_B((1/12, 0, 0, 0, 1/12, 0, 0, 0, 1/12))
assert approx_equal(model.get_unit_cell().parameters(),
(12, 12, 12, 90, 90, 90))
U = matrix.sqr((
0.3455, -0.2589, -0.9020, 0.8914, 0.3909, 0.2293, 0.2933, -0.8833, 0.3658))
B = matrix.sqr((1/13, 0, 0, 0, 1/13, 0, 0, 0, 1/13))
model.set_A(U * B)
assert approx_equal(model.get_A(), U * B)
assert approx_equal(model.get_U(), U, 1e-4)
assert approx_equal(model.get_B(), B, 1e-5)
model3 = crystal_model(
real_space_a=(10,0,0),
real_space_b=(0,11,0),
real_space_c=(0,0,12),
space_group=sgtbx.space_group_info("P 222").group(),
mosaicity=0.01)
assert model3.get_space_group().type().hall_symbol() == " P 2 2"
assert model != model3
#
sgi_ref = sgtbx.space_group_info(number=230)
model_ref = crystal_model(
real_space_a=(44,0,0),
real_space_b=(0,44,0),
real_space_c=(0,0,44),
space_group=sgi_ref.group())
assert approx_equal(model_ref.get_U(), (1,0,0,0,1,0,0,0,1))
assert approx_equal(model_ref.get_B(), (1/44,0,0,0,1/44,0,0,0,1/44))
assert approx_equal(model_ref.get_A(), model_ref.get_B())
assert approx_equal(model_ref.get_unit_cell().parameters(),
(44,44,44,90,90,90))
a_ref, b_ref, c_ref = model_ref.get_real_space_vectors()
cb_op_to_primitive = sgi_ref.change_of_basis_op_to_primitive_setting()
model_primitive = model_ref.change_basis(cb_op_to_primitive)
cb_op_to_reference = model_primitive.get_space_group().info()\
.change_of_basis_op_to_reference_setting()
a_prim, b_prim, c_prim = model_primitive.get_real_space_vectors()
#print cb_op_to_primitive.as_abc()
##'-1/2*a+1/2*b+1/2*c,1/2*a-1/2*b+1/2*c,1/2*a+1/2*b-1/2*c'
assert approx_equal(a_prim, -1/2 * a_ref + 1/2 * b_ref + 1/2 * c_ref)
assert approx_equal(b_prim, 1/2 * a_ref - 1/2 * b_ref + 1/2 * c_ref)
assert approx_equal(c_prim, 1/2 * a_ref + 1/2 * b_ref - 1/2 * c_ref)
#print cb_op_to_reference.as_abc()
##b+c,a+c,a+b
assert approx_equal(a_ref, b_prim + c_prim)
assert approx_equal(b_ref, a_prim + c_prim)
assert approx_equal(c_ref, a_prim + b_prim)
assert approx_equal(
model_primitive.get_U(),
[-0.5773502691896258, 0.40824829046386285, 0.7071067811865476,
0.5773502691896257, -0.4082482904638631, 0.7071067811865476,
0.5773502691896257, 0.8164965809277259, 0.0])
assert approx_equal(
model_primitive.get_B(),
[0.0262431940540739, 0.0, 0.0, 0.00927837023781507, 0.02783511071344521,
0.0, 0.01607060866333063, 0.01607060866333063, 0.03214121732666125])
assert approx_equal(
model_primitive.get_A(), (0, 1/44, 1/44, 1/44, 0, 1/44, 1/44, 1/44, 0))
assert approx_equal(
model_primitive.get_unit_cell().parameters(),
[38.1051177665153, 38.1051177665153, 38.1051177665153,
109.47122063449069, 109.47122063449069, 109.47122063449069])
assert model_ref != model_primitive
model_ref_recycled = model_primitive.change_basis(cb_op_to_reference)
assert approx_equal(model_ref.get_U(), model_ref_recycled.get_U())
assert approx_equal(model_ref.get_B(), model_ref_recycled.get_B())
assert approx_equal(model_ref.get_A(), model_ref_recycled.get_A())
assert approx_equal(model_ref.get_unit_cell().parameters(),
model_ref_recycled.get_unit_cell().parameters())
assert model_ref == model_ref_recycled
#
uc = uctbx.unit_cell((58.2567, 58.1264, 39.7093, 46.9077, 46.8612, 62.1055))
sg = sgtbx.space_group_info(symbol="P1").group()
cs = crystal.symmetry(unit_cell=uc, space_group=sg)
cb_op_to_minimum = cs.change_of_basis_op_to_minimum_cell()
# the reciprocal matrix
B = matrix.sqr(uc.fractionalization_matrix()).transpose()
U = random_rotation()
direct_matrix = (U * B).inverse()
model = crystal_model(direct_matrix[:3],
direct_matrix[3:6],
direct_matrix[6:9],
space_group=sg)
assert uc.is_similar_to(model.get_unit_cell())
uc_minimum = uc.change_basis(cb_op_to_minimum)
model_minimum = model.change_basis(cb_op_to_minimum)
assert uc_minimum.is_similar_to(model_minimum.get_unit_cell())
assert model_minimum != model
model_minimum.update(model)
assert model_minimum == model
#
from scitbx.math import euler_angles
A_static = model.get_A()
A_as_scan_points = [A_static]
num_scan_points = 11
for i in range(num_scan_points-1):
A_as_scan_points.append(
A_as_scan_points[-1] * matrix.sqr(euler_angles.xyz_matrix(0.1,0.2,0.3)))
model.set_A_at_scan_points(A_as_scan_points)
model_minimum = model.change_basis(cb_op_to_minimum)
assert model.num_scan_points == model_minimum.num_scan_points == num_scan_points
M = matrix.sqr(cb_op_to_minimum.c_inv().r().transpose().as_double())
M_inv = M.inverse()
for i in range(num_scan_points):
A_orig = model.get_A_at_scan_point(i)
A_min = model_minimum.get_A_at_scan_point(i)
assert A_min == A_orig * M_inv
def exercise_image_simple():
expected_sum_image_pixels_iter = iter((200, 156) + (400, 308) * 2 +
(450, 351) + (900, 693) * 2 +
(91, 69) + (181, 139) * 2 +
(160, 124) + (320, 248) * 2 +
(246, 188) + (490, 377) * 2)
from cctbx import uctbx
unit_cell = uctbx.unit_cell((11, 12, 13, 85, 95, 105))
from cctbx.array_family import flex
miller_indices = flex.miller_index([(-1, 2, 1)])
from scitbx.math import euler_angles
crystal_rotation_matrix = euler_angles.xyz_matrix(80, 20, 30)
import rstbx.simage
from libtbx.test_utils import approx_equal, show_diff
dpx, dpy = 4, 5
for ewald_proximity, star in [(0.1, " "), (0.5, "*")]:
image_lines = []
for point_spread in range(1, 5 + 1):
for spot_intensity_factor in [0.5, 1, None]:
if (spot_intensity_factor is None):
spot_intensity_factors = None
else:
spot_intensity_factors = flex.double(
[spot_intensity_factor])
for apply_proximity_factor in [False, True]:
if (star == "*"):
expected_sum_image_pixels = next(
expected_sum_image_pixels_iter)
for code in range(16):
store_miller_index_i_seqs = bool(code & 0x1)
store_spots = bool(code & 0x2)
store_signals = bool(code & 0x4)
set_pixels = bool(code & 0x8)
image = rstbx.simage.image_simple(
apply_proximity_factor=apply_proximity_factor,
store_miller_index_i_seqs=store_miller_index_i_seqs,
store_spots=store_spots,
store_signals=store_signals,
set_pixels=set_pixels
).compute(
unit_cell=unit_cell,
miller_indices=miller_indices,
spot_intensity_factors=spot_intensity_factors,
crystal_rotation_matrix=crystal_rotation_matrix,
ewald_radius=0.5,
ewald_proximity=ewald_proximity,
signal_max=100,
detector_distance=5,
detector_size=(10, 12),
detector_pixels=(dpx, dpy),
point_spread=point_spread,
gaussian_falloff_scale=4)
if (store_signals and image.signals.size() == 1):
partialities = rstbx.simage.image_simple(
apply_proximity_filter=False,
apply_proximity_factor=apply_proximity_factor,
store_signals=True
).compute(
unit_cell=unit_cell,
miller_indices=miller_indices,
spot_intensity_factors=None,
crystal_rotation_matrix=crystal_rotation_matrix,
ewald_radius=0.5,
ewald_proximity=ewald_proximity,
signal_max=1,
detector_distance=5,
detector_size=(10, 12),
detector_pixels=(dpx, dpy),
point_spread=point_spread,
gaussian_falloff_scale=4).signals
f = 100
if (spot_intensity_factor is not None):
f *= spot_intensity_factor
assert approx_equal(partialities * f,
image.signals)
if (store_miller_index_i_seqs and star == "*"):
assert image.miller_index_i_seqs.size() == 1
else:
assert image.miller_index_i_seqs.size() == 0
if (store_spots and star == "*"):
assert image.spots.size() == 1
else:
assert image.spots.size() == 0
if (store_signals and star == "*"):
assert image.signals.size() == 1
else:
assert image.signals.size() == 0
if (not set_pixels):
assert image.pixels.size() == 0
else:
assert image.pixels.size() == 20
sum_image_pixels = flex.sum(image.pixels)
if (star == "*"):
assert sum_image_pixels == expected_sum_image_pixels
else:
assert sum_image_pixels == 0
assert image.pixels.all() == (dpx, dpy)
for i in range(dpx):
line = []
for j in range(dpy):
if (image.pixels[(i, j)]): c = star
else: c = " "
line.append(c)
image_lines.append("|" + "".join(line) + "|")
image_lines.append("")
assert not show_diff(
"\n".join(image_lines), """\
| |
| |
| ** |
| ** |
| |
| ***|
| ***|
| ***|
| |
| ** |
| *** |
| ** |
| * |
| ****|
| ****|
| ****|
| *** |
|*****|
|*****|
|*****|
""".replace("*", star))
def test_compare_orientation_matrices():
# try and see if we can get back the original rotation matrix and euler angles
real_space_a = matrix.col((10, 0, 0))
real_space_b = matrix.col((0, 10, 10))
real_space_c = matrix.col((0, 0, 10))
euler_angles = (1.3, 5.6, 7.8)
R = matrix.sqr(
euler.xyz_matrix(euler_angles[0], euler_angles[1], euler_angles[2]))
crystal_a = Crystal(real_space_a,
real_space_b,
real_space_c,
space_group=sgtbx.space_group("P 1"))
crystal_b = Crystal(
R * real_space_a,
R * real_space_b,
R * real_space_c,
space_group=sgtbx.space_group("P 1"),
)
assert (matrix.sqr(crystal_b.get_U()) *
matrix.sqr(crystal_a.get_U()).transpose()).elems == pytest.approx(
R.elems)
(
best_R_ab,
best_axis,
best_angle,
best_cb_op,
) = compare_orientation_matrices.difference_rotation_matrix_axis_angle(
crystal_a, crystal_b)
best_euler_angles = euler.xyz_angles(best_R_ab)
assert best_euler_angles == pytest.approx(euler_angles)
assert best_cb_op.is_identity_op()
assert best_R_ab.elems == pytest.approx(R.elems)
# now see if we can deconvolute the original euler angles after applying
# a change of basis to one of the crystals
crystal_a = Crystal(real_space_a,
real_space_b,
real_space_c,
space_group=sgtbx.space_group("I 2 3"))
cb_op = sgtbx.change_of_basis_op("z,x,y")
crystal_b = Crystal(
R * real_space_a,
R * real_space_b,
R * real_space_c,
space_group=sgtbx.space_group("I 2 3"),
).change_basis(cb_op)
(
best_R_ab,
best_axis,
best_angle,
best_cb_op,
) = compare_orientation_matrices.difference_rotation_matrix_axis_angle(
crystal_a, crystal_b)
best_euler_angles = euler.xyz_angles(best_R_ab)
assert best_euler_angles == pytest.approx(euler_angles)
assert best_cb_op.c() == cb_op.inverse().c()
assert best_R_ab.elems == pytest.approx(R.elems)
crystal_c = crystal_b.change_basis(sgtbx.change_of_basis_op("-y,-z,x"))
assert crystal_c != crystal_b
s = compare_orientation_matrices.rotation_matrix_differences(
[crystal_a, crystal_b, crystal_c], comparison="pairwise")
s = "\n".join(s.splitlines()[:-1]).replace("-0.000", "0.000")
print(s)
assert (s == """\
Change of basis op: b,c,a
Rotation matrix to transform crystal 1 to crystal 2:
{{0.986, -0.135, 0.098},
{0.138, 0.990, -0.023},
{-0.094, 0.036, 0.995}}
Rotation of 9.738 degrees about axis (0.172, 0.565, 0.807)
Change of basis op: -a,-b,c
Rotation matrix to transform crystal 1 to crystal 3:
{{0.986, -0.135, 0.098},
{0.138, 0.990, -0.023},
{-0.094, 0.036, 0.995}}
Rotation of 9.738 degrees about axis (0.172, 0.565, 0.807)
Change of basis op: c,-a,-b
Rotation matrix to transform crystal 2 to crystal 3:
{{1.000, 0.000, 0.000},
{0.000, 1.000, 0.000},
{0.000, 0.000, 1.000}}""")
s = compare_orientation_matrices.rotation_matrix_differences(
[crystal_a, crystal_b, crystal_c], comparison="sequential")
s = "\n".join(s.splitlines()[:-1]).replace("-0.000", "0.000")
print(s)
assert (s == """\
Change of basis op: b,c,a
Rotation matrix to transform crystal 1 to crystal 2:
{{0.986, -0.135, 0.098},
{0.138, 0.990, -0.023},
{-0.094, 0.036, 0.995}}
Rotation of 9.738 degrees about axis (0.172, 0.565, 0.807)
Change of basis op: c,-a,-b
Rotation matrix to transform crystal 2 to crystal 3:
{{1.000, 0.000, 0.000},
{0.000, 1.000, 0.000},
{0.000, 0.000, 1.000}}""")
s = compare_orientation_matrices.rotation_matrix_differences(
(crystal_a, crystal_b), miller_indices=((1, 0, 0), (1, 1, 0)))
assert (s == """\
Change of basis op: b,c,a
Rotation matrix to transform crystal 1 to crystal 2:
{{0.986, -0.135, 0.098},
{0.138, 0.990, -0.023},
{-0.094, 0.036, 0.995}}
Rotation of 9.738 degrees about axis (0.172, 0.565, 0.807)
(1,0,0): 15.26 deg
(1,1,0): 9.12 deg
""")
def exercise_image_simple():
expected_sum_image_pixels_iter = iter(
(200, 156) + (400, 308)*2
+ (450, 351) + (900, 693)*2
+ ( 91, 69) + (181, 139)*2
+ (160, 124) + (320, 248)*2
+ (246, 188) + (490, 377)*2)
from cctbx import uctbx
unit_cell = uctbx.unit_cell((11,12,13,85,95,105))
from cctbx.array_family import flex
miller_indices = flex.miller_index([(-1,2,1)])
from scitbx.math import euler_angles
crystal_rotation_matrix = euler_angles.xyz_matrix(80,20,30)
import rstbx.simage
from libtbx.test_utils import approx_equal, show_diff
dpx, dpy = 4, 5
for ewald_proximity,star in [(0.1, " "), (0.5, "*")]:
image_lines = []
for point_spread in xrange(1,5+1):
for spot_intensity_factor in [0.5, 1, None]:
if (spot_intensity_factor is None):
spot_intensity_factors = None
else:
spot_intensity_factors = flex.double([spot_intensity_factor])
for apply_proximity_factor in [False, True]:
if (star == "*"):
expected_sum_image_pixels = expected_sum_image_pixels_iter.next()
for code in xrange(16):
store_miller_index_i_seqs = bool(code & 0x1)
store_spots = bool(code & 0x2)
store_signals = bool(code & 0x4)
set_pixels = bool(code & 0x8)
image = rstbx.simage.image_simple(
apply_proximity_factor=apply_proximity_factor,
store_miller_index_i_seqs=store_miller_index_i_seqs,
store_spots=store_spots,
store_signals=store_signals,
set_pixels=set_pixels).compute(
unit_cell=unit_cell,
miller_indices=miller_indices,
spot_intensity_factors=spot_intensity_factors,
crystal_rotation_matrix=crystal_rotation_matrix,
ewald_radius=0.5,
ewald_proximity=ewald_proximity,
signal_max=100,
detector_distance=5,
detector_size=(10,12),
detector_pixels=(dpx,dpy),
point_spread=point_spread,
gaussian_falloff_scale=4)
if (store_signals and image.signals.size() == 1):
partialities = rstbx.simage.image_simple(
apply_proximity_filter=False,
apply_proximity_factor=apply_proximity_factor,
store_signals=True).compute(
unit_cell=unit_cell,
miller_indices=miller_indices,
spot_intensity_factors=None,
crystal_rotation_matrix=crystal_rotation_matrix,
ewald_radius=0.5,
ewald_proximity=ewald_proximity,
signal_max=1,
detector_distance=5,
detector_size=(10,12),
detector_pixels=(dpx,dpy),
point_spread=point_spread,
gaussian_falloff_scale=4).signals
f = 100
if (spot_intensity_factor is not None):
f *= spot_intensity_factor
assert approx_equal(partialities*f, image.signals)
if (store_miller_index_i_seqs and star == "*"):
assert image.miller_index_i_seqs.size() == 1
else:
assert image.miller_index_i_seqs.size() == 0
if (store_spots and star == "*"):
assert image.spots.size() == 1
else:
assert image.spots.size() == 0
if (store_signals and star == "*"):
assert image.signals.size() == 1
else:
assert image.signals.size() == 0
if (not set_pixels):
assert image.pixels.size() == 0
else:
assert image.pixels.size() == 20
sum_image_pixels = flex.sum(image.pixels)
if (star == "*"):
assert sum_image_pixels == expected_sum_image_pixels
else:
assert sum_image_pixels == 0
assert image.pixels.all() == (dpx,dpy)
for i in xrange(dpx):
line = []
for j in xrange(dpy):
if (image.pixels[(i,j)]): c = star
else: c = " "
line.append(c)
image_lines.append("|"+"".join(line)+"|")
image_lines.append("")
assert not show_diff("\n".join(image_lines), """\
| |
| |
| ** |
| ** |
| |
| ***|
| ***|
| ***|
| |
| ** |
| *** |
| ** |
| * |
| ****|
| ****|
| ****|
| *** |
|*****|
|*****|
|*****|
""".replace("*", star))
