def difference_rotation_matrix_and_euler_angles(crystal_a, crystal_b):
  from cctbx import sgtbx
  #assert crystal_a.get_space_group() == crystal_b.get_space_group()
  space_group = crystal_b.get_space_group()
  min_sum_euler_angles = 1e8
  best_R_ab = None
  best_cb_op = None
  # iterate over space group ops to find smallest differences
  for i_op, op in enumerate(space_group.build_derived_laue_group().all_ops()):
    if op.r().determinant() < 0:
      continue
    elif not op.t().is_zero():
      continue
    cb_op = sgtbx.change_of_basis_op(op.inverse())
    crystal_b_sym = crystal_b.change_basis(cb_op)
    U_a = crystal_a.get_U()
    U_b = crystal_b_sym.get_U()
    assert U_a.is_r3_rotation_matrix()
    assert U_b.is_r3_rotation_matrix()
    # the rotation matrix to transform from U_a to U_b
    R_ab = U_b * U_a.transpose()
    euler_angles = euler.xyz_angles(R_ab)
    sum_euler_angles = sum(abs(ea) for ea in euler_angles)
    if sum_euler_angles < min_sum_euler_angles:
      min_sum_euler_angles = sum_euler_angles
      best_R_ab = R_ab
      best_cb_op = cb_op

  best_euler_angles = euler.xyz_angles(best_R_ab)
  return best_R_ab, best_euler_angles, best_cb_op
예제 #2
0
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)
예제 #4
0
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)
예제 #5
0
def ersatz_misset(integrate_lp):
    a_s = []
    b_s = []
    c_s = []

    for record in open(integrate_lp):
        if 'COORDINATES OF UNIT CELL A-AXIS' in record:
            a = map(float, record.split()[-3:])
            a_s.append(matrix.col(a))
        elif 'COORDINATES OF UNIT CELL B-AXIS' in record:
            b = map(float, record.split()[-3:])
            b_s.append(matrix.col(b))
        elif 'COORDINATES OF UNIT CELL C-AXIS' in record:
            c = map(float, record.split()[-3:])
            c_s.append(matrix.col(c))

    assert(len(a_s) == len(b_s) == len(c_s))

    ub0 = matrix.sqr(a_s[0].elems + b_s[0].elems + c_s[0].elems).inverse()

    for j in range(len(a_s)):
        ub = matrix.sqr(a_s[j].elems + b_s[j].elems + c_s[j].elems).inverse()
        print '%7.3f %7.3f %7.3f' % tuple(xyz_angles(ub.inverse() * ub0))

    return
예제 #6
0
def ersatz_misset(integrate_lp):
    a_s = []
    b_s = []
    c_s = []

    for record in open(integrate_lp):
        if 'COORDINATES OF UNIT CELL A-AXIS' in record:
            a = map(float, record.split()[-3:])
            a_s.append(matrix.col(a))
        elif 'COORDINATES OF UNIT CELL B-AXIS' in record:
            b = map(float, record.split()[-3:])
            b_s.append(matrix.col(b))
        elif 'COORDINATES OF UNIT CELL C-AXIS' in record:
            c = map(float, record.split()[-3:])
            c_s.append(matrix.col(c))

    assert (len(a_s) == len(b_s) == len(c_s))

    ub0 = matrix.sqr(a_s[0].elems + b_s[0].elems + c_s[0].elems).inverse()

    for j in range(len(a_s)):
        ub = matrix.sqr(a_s[j].elems + b_s[j].elems + c_s[j].elems).inverse()
        print '%7.3f %7.3f %7.3f' % tuple(xyz_angles(ub.inverse() * ub0))

    return
예제 #7
0
파일: MissetExpert.py 프로젝트: xia2/xia2
    def missets(self, phi):
        """Calculate the missetting angles for the given rotation angle."""

        P = self._z.axis_and_angle_as_r3_rotation_matrix(phi, deg=True)
        R = self._r.axis_and_angle_as_r3_rotation_matrix(phi, deg=True)
        M = P.inverse() * R * self._M0

        return xyz_angles(M)
예제 #8
0
  def missets(self, phi):
    '''Calculate the missetting angles for the given rotation angle.'''

    P = self._z.axis_and_angle_as_r3_rotation_matrix(phi, deg = True)
    R = self._r.axis_and_angle_as_r3_rotation_matrix(phi, deg = True)
    M = P.inverse() * R * self._M0

    return xyz_angles(M)
예제 #9
0
def dump_mtz_orientation(mtz_file):
    from iotbx import mtz
    from scitbx import matrix
    from scitbx.math.euler_angles import xyz_angles

    m = mtz.object(mtz_file)
    for b in m.batches():
        rxyz = tuple(xyz_angles(matrix.sqr(b.umat())))
        print(b.num(), '%7.4f %7.4f %7.4f' % rxyz)
예제 #10
0
def dump_mtz_orientation(mtz_file):
  from iotbx import mtz
  from scitbx import matrix
  from scitbx.math.euler_angles import xyz_angles
  import os.path

  m = mtz.object(mtz_file)
  for b in m.batches():
    rxyz = tuple(xyz_angles(matrix.sqr(b.umat())))
    print b.num(), '%7.4f %7.4f %7.4f' % rxyz

  return
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
""")
예제 #12
0
def ersatz_misset_predict(xparm_xds, spot_xds):
    '''As well as possible, try to predict the misorientation angles as a
    function of frame # from the indexed spots from the XDS IDXREF step.
    Calculation will be performed in CBF coordinae frame.'''

    cfc = coordinate_frame_converter(xparm_xds)
    axis = cfc.get_c('rotation_axis')
    wavelength = cfc.get('wavelength')
    beam = (1.0 / wavelength) * cfc.get_c('sample_to_source').normalize()
    U, B = cfc.get_u_b()
    UB = U * B

    detector_origin = cfc.get_c('detector_origin')
    detector_fast = cfc.get_c('detector_fast')
    detector_slow = cfc.get_c('detector_slow')
    pixel_size_fast, pixel_size_slow = cfc.get('detector_pixel_size_fast_slow')
    size_fast, size_slow = cfc.get('detector_size_fast_slow')

    img_start, osc_start, osc_range = parse_xds_xparm_scan_info(xparm_xds)

    rx_s = {}
    ry_s = {}
    rz_s = {}

    for record in open(spot_xds):
        values = map(float, record.split())
        if len(values) != 7:
            continue
        hkl = tuple(map(nint, values[-3:]))
        if hkl == (0, 0, 0):
            continue

        x, y, f = values[:3]

        phi = ((f - img_start + 1) * osc_range + osc_start) * math.pi / 180.0

        lab_xyz = detector_origin + \
                  detector_fast * x * pixel_size_fast + \
                  detector_slow * y * pixel_size_slow

        rec_xyz = ((1.0 / wavelength) * lab_xyz.normalize() + beam).rotate(
            axis, - phi)

        calc_xyz = UB * hkl

        # now compute vector and angle to overlay calculated position on
        # observed position, then convert this to a matrix

        shift_axis = calc_xyz.cross(rec_xyz)
        shift_angle = calc_xyz.angle(rec_xyz)

        M = matrix.sqr(r3_rotation_axis_and_angle_as_matrix(
            shift_axis, shift_angle))

        rx, ry, rz = xyz_angles(M)

        j = int(f)

        if not j in rx_s:
            rx_s[j] = []
        if not j in ry_s:
            ry_s[j] = []
        if not j in rz_s:
            rz_s[j] = []

        rx_s[j].append(rx)
        ry_s[j].append(ry)
        rz_s[j].append(rz)

    j = min(rx_s)
    ms_x0 = meansd(rx_s[j])[0]
    ms_y0 = meansd(ry_s[j])[0]
    ms_z0 = meansd(rz_s[j])[0]

    for j in sorted(rx_s)[1:]:
        ms_x = meansd(rx_s[j])
        ms_y = meansd(ry_s[j])
        ms_z = meansd(rz_s[j])

        print '%4d %6.3f %6.3f %6.3f' % \
            (j, ms_x[0] - ms_x0, ms_y[0] - ms_y0, ms_z[0] - ms_z0)
예제 #13
0
def ersatz_misset_predict(xparm_xds, spot_xds):
    '''As well as possible, try to predict the misorientation angles as a
    function of frame # from the indexed spots from the XDS IDXREF step.
    Calculation will be performed in CBF coordinae frame.'''

    cfc = coordinate_frame_converter(xparm_xds)
    axis = cfc.get_c('rotation_axis')
    wavelength = cfc.get('wavelength')
    beam = (1.0 / wavelength) * cfc.get_c('sample_to_source').normalize()
    U, B = cfc.get_u_b()
    UB = U * B

    detector_origin = cfc.get_c('detector_origin')
    detector_fast = cfc.get_c('detector_fast')
    detector_slow = cfc.get_c('detector_slow')
    pixel_size_fast, pixel_size_slow = cfc.get('detector_pixel_size_fast_slow')
    size_fast, size_slow = cfc.get('detector_size_fast_slow')

    img_start, osc_start, osc_range = parse_xds_xparm_scan_info(xparm_xds)

    rx_s = {}
    ry_s = {}
    rz_s = {}

    for record in open(spot_xds):
        values = map(float, record.split())
        if len(values) != 7:
            continue
        hkl = tuple(map(nint, values[-3:]))
        if hkl == (0, 0, 0):
            continue

        x, y, f = values[:3]

        phi = ((f - img_start + 1) * osc_range + osc_start) * math.pi / 180.0

        lab_xyz = detector_origin + \
                  detector_fast * x * pixel_size_fast + \
                  detector_slow * y * pixel_size_slow

        rec_xyz = ((1.0 / wavelength) * lab_xyz.normalize() + beam).rotate(
            axis, -phi)

        calc_xyz = UB * hkl

        # now compute vector and angle to overlay calculated position on
        # observed position, then convert this to a matrix

        shift_axis = calc_xyz.cross(rec_xyz)
        shift_angle = calc_xyz.angle(rec_xyz)

        M = matrix.sqr(
            r3_rotation_axis_and_angle_as_matrix(shift_axis, shift_angle))

        rx, ry, rz = xyz_angles(M)

        j = int(f)

        if not j in rx_s:
            rx_s[j] = []
        if not j in ry_s:
            ry_s[j] = []
        if not j in rz_s:
            rz_s[j] = []

        rx_s[j].append(rx)
        ry_s[j].append(ry)
        rz_s[j].append(rz)

    j = min(rx_s)
    ms_x0 = meansd(rx_s[j])[0]
    ms_y0 = meansd(ry_s[j])[0]
    ms_z0 = meansd(rz_s[j])[0]

    for j in sorted(rx_s)[1:]:
        ms_x = meansd(rx_s[j])
        ms_y = meansd(ry_s[j])
        ms_z = meansd(rz_s[j])

        print '%4d %6.3f %6.3f %6.3f' % \
            (j, ms_x[0] - ms_x0, ms_y[0] - ms_y0, ms_z[0] - ms_z0)
예제 #14
0
def run():
    random_seed = 35
    flex.set_random_seed(random_seed)
    random.seed(random_seed)
    data = merge_close_spots.merge_close_spots()
    # unit cell and space group for lysozyme
    known_symmetry = crystal.symmetry("78,78,37,90,90,90", "P43212")

    sim = data.two_color_sim
    merged_spot_info = data.spot_proximity(sim)
    merged_refl = merged_spot_info[0]

    detector = data.detector
    beams = data.beams

    # to make sure input crystal and indexed crystal model are the same
    # orientation before using the refiner
    A = sim['input_orientation']
    A_inv = A.inverse()
    a = A_inv[:3]
    b = A_inv[3:6]
    c = A_inv[6:]
    crystinp = Crystal(a, b, c, space_group=known_symmetry.space_group())
    result = index(merged_refl, detector, known_symmetry, beams)
    print("RESULTS ARE IN")
    cm = result.refined_experiments.crystals()[0]
    R, best_axis, best_angle, change_of_basis = difference_rotation_matrix_axis_angle(
        crystal_a=cm, crystal_b=crystinp)
    euler_angles = euler.xyz_angles(R)

    print "input crystal: %s" % crystinp
    print "Indexed crystal: %s" % cm
    print "rotation of: %s" % R
    print "euler angles:", euler_angles
    print "change of basis:", change_of_basis.as_hkl()

    # cmd_line = command_line.argument_interpreter(master_params=master_phil_scope)
    # working_phil = cmd_line.process_and_fetch(args=[])
    params = master_phil_scope.extract()
    params.refinement.parameterisation.beam.fix = "all"
    params.refinement.parameterisation.detector.fix = "all"
    params.indexing.known_symmetry.space_group = known_symmetry.space_group_info(
    )
    params.refinement.verbosity = 3
    params.indexing.refinement_protocol.d_min_start = 3
    params.indexing.refinement_protocol.n_macro_cycles = 1
    params.indexing.known_symmetry.unit_cell = known_symmetry.unit_cell()
    params.indexing.multiple_lattice_search.max_lattices = 1
    params.indexing.debug = True
    params.indexing.known_symmetry.absolute_angle_tolerance = 5.0
    params.indexing.known_symmetry.relative_length_tolerance = 0.3

    expts = copy.deepcopy(result.refined_experiments)
    expts.crystals()[0].change_basis(change_of_basis)
    print(expts.crystals()[0])

    refined = refine(params, result.reflections, expts, verbosity=1)
    print(refined[0].get_experiments().crystals()[0])

    # from annlib_ext import AnnAdaptor
    # ann = AnnAdaptor(merged_refl['xyzobs.px.value'].as_double(), dim=3, k=1)
    # ann.query(result.reflections['xyzobs.px.value'].as_double()+1e-6)
    indices_sim = change_of_basis.apply(merged_refl['set_miller_index'])
    id_sim = merged_refl['set_id']
    # only get those that refined:
    idx = align_merged_and_refined_refl(merged_refl,
                                        result.refined_reflections)
    indices_sim = flex.miller_index([indices_sim[i] for i in idx])
    id_sim = flex.int([id_sim[i] for i in idx])
    indices_result = result.refined_reflections['miller_index']
    id_result = result.refined_reflections['id']

    correct_ind = (indices_sim == indices_result)
    wrong_wavelength = (id_sim != id_result) & (id_sim != 2)
    wrong_index = (indices_sim != indices_result)
    correct_wavelength = (id_sim == id_result) | (id_sim == 2)
    correct = correct_ind & correct_wavelength
    print "Correct index and wavelength: %i/%i" % (correct.count(True),
                                                   len(correct))
    print "Correct index but wrong wavelength: %i/%i" % (
        wrong_wavelength.count(True), len(wrong_wavelength))
    print "Wrong index but correct wavelength: %i/%i" % (
        wrong_index.count(True), len(correct_wavelength))