예제 #1
0
파일: tst_miller.py 프로젝트: dials/cctbx
def exercise_match_multi_indices():
  h0 = flex.miller_index(((1,2,3), (-1,-2,-3), (2,3,4), (-2,-3,-4), (3,4,5)))
  d0 = flex.double((1,2,3,4,5))
  h1 = flex.miller_index(((1,2,3), (-2,-3,-4), (1,2,3), (2,3,4)))
  d1 = flex.double((10,20,30,40))
  mi = miller.match_multi_indices(h0, h0)
  assert mi.have_singles() == 0
  assert list(mi.pairs()) == list(zip(range(5), range(5)))
  mi = miller.match_multi_indices(h0, h1)
  assert tuple(mi.singles(0)) == (1,4,)
  assert tuple(mi.singles(1)) == ()
  assert len(set(mi.pairs()) - set([(0,0), (0,2), (2,3), (3, 1)])) == 0
  assert tuple(mi.number_of_matches(0)) == (2, 0, 1, 1, 0)
  assert tuple(mi.pair_selection(0)) == (1, 0, 1, 1, 0)
  assert tuple(mi.single_selection(0)) == (0, 1, 0, 0, 1)
  assert tuple(mi.number_of_matches(1)) == (1, 1, 1, 1)
  assert tuple(mi.pair_selection(1)) == (1, 1, 1, 1)
  assert tuple(mi.single_selection(1)) == (0, 0, 0, 0)
  assert tuple(mi.paired_miller_indices(0)) \
      == tuple(h0.select(mi.pair_selection(0)))
  l1 = list(mi.paired_miller_indices(1))
  l2 = list(h1.select(mi.pair_selection(1)))
  l1.sort()
  l2.sort()
  assert l1 == l2
  try:
    miller.match_multi_indices(h1, h0)
  except RuntimeError as e:
    pass
  else:
    raise Exception_expected
예제 #2
0
    def reindex(self, reindex_operation):
        """Reindex the reflections by the given reindexing operation."""

        R = rt_mx(reindex_operation).inverse()

        # first construct mapping table - native, anomalous

        map_native = {}

        hkls = flex.miller_index()

        for hkl in self._merged_reflections:
            Fhkl = R * hkl
            Rhkl = nint(Fhkl[0]), nint(Fhkl[1]), nint(Fhkl[2])
            hkls.append(Rhkl)

        map_to_asu(self._mf.get_space_group().type(), False, hkls)

        for j, hkl in enumerate(self._merged_reflections):
            map_native[hkl] = hkls[j]

        map_anomalous = {}

        hkls = flex.miller_index()

        for hkl in self._merged_reflections_anomalous:
            Fhkl = R * hkl
            Rhkl = nint(Fhkl[0]), nint(Fhkl[1]), nint(Fhkl[2])
            hkls.append(Rhkl)

        map_to_asu(self._mf.get_space_group().type(), True, hkls)

        for j, hkl in enumerate(self._merged_reflections_anomalous):
            map_anomalous[hkl] = hkls[j]

        # then remap the actual measurements

        merged_reflections = {}

        for hkl in self._merged_reflections:
            Rhkl = map_native[hkl]
            merged_reflections[Rhkl] = self._merged_reflections[hkl]

        self._merged_reflections = merged_reflections

        merged_reflections = {}

        for hkl in self._merged_reflections_anomalous:
            Rhkl = map_anomalous[hkl]
            merged_reflections[Rhkl] = self._merged_reflections_anomalous[hkl]

        self._merged_reflections_anomalous = merged_reflections

        unmerged_reflections = {}

        for hkl in self._unmerged_reflections:
            Rhkl = map_native[hkl]
            unmerged_reflections[Rhkl] = self._unmerged_reflections[hkl]

        self._unmerged_reflections = unmerged_reflections
예제 #3
0
def exercise_match_multi_indices():
  h0 = flex.miller_index(((1,2,3), (-1,-2,-3), (2,3,4), (-2,-3,-4), (3,4,5)))
  d0 = flex.double((1,2,3,4,5))
  h1 = flex.miller_index(((1,2,3), (-2,-3,-4), (1,2,3), (2,3,4)))
  d1 = flex.double((10,20,30,40))
  mi = miller.match_multi_indices(h0, h0)
  assert mi.have_singles() == 0
  assert list(mi.pairs()) == zip(range(5), range(5))
  mi = miller.match_multi_indices(h0, h1)
  assert tuple(mi.singles(0)) == (1,4,)
  assert tuple(mi.singles(1)) == ()
  assert len(set(mi.pairs()) - set([(0,0), (0,2), (2,3), (3, 1)])) == 0
  assert tuple(mi.number_of_matches(0)) == (2, 0, 1, 1, 0)
  assert tuple(mi.pair_selection(0)) == (1, 0, 1, 1, 0)
  assert tuple(mi.single_selection(0)) == (0, 1, 0, 0, 1)
  assert tuple(mi.number_of_matches(1)) == (1, 1, 1, 1)
  assert tuple(mi.pair_selection(1)) == (1, 1, 1, 1)
  assert tuple(mi.single_selection(1)) == (0, 0, 0, 0)
  assert tuple(mi.paired_miller_indices(0)) \
      == tuple(h0.select(mi.pair_selection(0)))
  l1 = list(mi.paired_miller_indices(1))
  l2 = list(h1.select(mi.pair_selection(1)))
  l1.sort()
  l2.sort()
  assert l1 == l2
  try:
    miller.match_multi_indices(h1, h0)
  except RuntimeError, e:
    pass
예제 #4
0
def exercise_triplet_generator():
  sg = sgtbx.space_group_info("P 41").group()
  i = flex.miller_index(((1,2,3),(2,3,4)))
  a = flex.double((1,2))
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, False)
  assert t.t_den() == sg.t_den()
  assert t.max_relations_per_reflection() == 0
  assert t.sigma_2_only() == False
  assert t.discard_weights() == False
  t = dmtbx.ext.triplet_generator(sg, i, a, 3, True, False)
  assert t.max_relations_per_reflection() == 3
  assert t.sigma_2_only() == True
  assert t.discard_weights() == False
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, True)
  assert t.sigma_2_only() == False
  assert t.discard_weights() == True
  assert tuple(t.n_relations()) == (0,0)
  assert t.relations_for(0) == ()
  assert approx_equal(tuple(t.sums_of_amplitude_products(a)), (0,0))
  s = flex.bool()
  r = t.raw_apply_tangent_formula(a, a, s, False, False, 1.e-15)
  assert approx_equal(tuple(r), (1,2))
  i = flex.miller_index(((4,6,0),(5,2,5),(6,1,5)))
  a = flex.double((1,2,3))
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, False)
  assert tuple(t.n_relations()) == (4,2,2)
  assert [r.format(i, 0) for r in t.relations_for(0)] \
      == ["(4,6,0) (5,2,5) %s (6,1,5) %s 3 2" % (True, False),
          "(4,6,0) (5,2,5) %s (6,1,5) %s 9 2" % (False, True)]
  assert [r.format(i, 1) for r in t.relations_for(1)] \
      == ["(5,2,5) (4,6,0) %s (6,1,5) %s 3 2" % (False, False)]
  assert [r.format(i, 2) for r in t.relations_for(2)] \
      == ["(6,1,5) (4,6,0) %s (5,2,5) %s 9 2" % (False, False)]
  assert approx_equal(tuple(t.sums_of_amplitude_products(a)), (24,6,4))
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, True)
  assert tuple(t.n_relations()) == (1,1,1)
  assert [r.format(i, 0) for r in t.relations_for(0)] \
      == ["(4,6,0) (5,2,5) %s (6,1,5) %s 3 1" % (True, False)]
  assert approx_equal(tuple(t.sums_of_amplitude_products(a)), (6,3,2))
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, False)
  r0 = t.relations_for(0)
  r1 = t.relations_for(1)
  assert r0[0].is_sigma_2(0)
  assert r0[0].is_similar_to(r0[1])
  assert not r0[0].is_similar_to(r1[0])
  i = flex.miller_index(((4,6,0),(5,1,2)))
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, False)
  assert [r.format(i, 0) for r in t.relations_for(0)] \
      == ["(4,6,0) (5,1,2) %s (5,1,2) %s 6 4" % (False, True)]
  assert [r.format(i, 1) for r in t.relations_for(1)] \
      == ["(5,1,2) (4,6,0) %s (5,1,2) %s 6 4" % (False, False)]
  assert not t.relations_for(0)[0].is_sigma_2(0)
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, True)
  assert [r.format(i, 0) for r in t.relations_for(0)] \
      == ["(4,6,0) (5,1,2) %s (5,1,2) %s 6 1" % (False, True)]
  assert [r.format(i, 1) for r in t.relations_for(1)] \
      == ["(5,1,2) (4,6,0) %s (5,1,2) %s 6 1" % (False, False)]
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, True, False)
  assert tuple(t.n_relations()) == (0,0)
예제 #5
0
def exercise_triplet_generator():
  sg = sgtbx.space_group_info("P 41").group()
  i = flex.miller_index(((1,2,3),(2,3,4)))
  a = flex.double((1,2))
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, False)
  assert t.t_den() == sg.t_den()
  assert t.max_relations_per_reflection() == 0
  assert t.sigma_2_only() == False
  assert t.discard_weights() == False
  t = dmtbx.ext.triplet_generator(sg, i, a, 3, True, False)
  assert t.max_relations_per_reflection() == 3
  assert t.sigma_2_only() == True
  assert t.discard_weights() == False
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, True)
  assert t.sigma_2_only() == False
  assert t.discard_weights() == True
  assert tuple(t.n_relations()) == (0,0)
  assert t.relations_for(0) == ()
  assert approx_equal(tuple(t.sums_of_amplitude_products(a)), (0,0))
  s = flex.bool()
  r = t.raw_apply_tangent_formula(a, a, s, False, False, 1.e-15)
  assert approx_equal(tuple(r), (1,2))
  i = flex.miller_index(((4,6,0),(5,2,5),(6,1,5)))
  a = flex.double((1,2,3))
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, False)
  assert tuple(t.n_relations()) == (4,2,2)
  assert [r.format(i, 0) for r in t.relations_for(0)] \
      == ["(4,6,0) (5,2,5) %s (6,1,5) %s 3 2" % (True, False),
          "(4,6,0) (5,2,5) %s (6,1,5) %s 9 2" % (False, True)]
  assert [r.format(i, 1) for r in t.relations_for(1)] \
      == ["(5,2,5) (4,6,0) %s (6,1,5) %s 3 2" % (False, False)]
  assert [r.format(i, 2) for r in t.relations_for(2)] \
      == ["(6,1,5) (4,6,0) %s (5,2,5) %s 9 2" % (False, False)]
  assert approx_equal(tuple(t.sums_of_amplitude_products(a)), (24,6,4))
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, True)
  assert tuple(t.n_relations()) == (1,1,1)
  assert [r.format(i, 0) for r in t.relations_for(0)] \
      == ["(4,6,0) (5,2,5) %s (6,1,5) %s 3 1" % (True, False)]
  assert approx_equal(tuple(t.sums_of_amplitude_products(a)), (6,3,2))
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, False)
  r0 = t.relations_for(0)
  r1 = t.relations_for(1)
  assert r0[0].is_sigma_2(0)
  assert r0[0].is_similar_to(r0[1])
  assert not r0[0].is_similar_to(r1[0])
  i = flex.miller_index(((4,6,0),(5,1,2)))
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, False)
  assert [r.format(i, 0) for r in t.relations_for(0)] \
      == ["(4,6,0) (5,1,2) %s (5,1,2) %s 6 4" % (False, True)]
  assert [r.format(i, 1) for r in t.relations_for(1)] \
      == ["(5,1,2) (4,6,0) %s (5,1,2) %s 6 4" % (False, False)]
  assert not t.relations_for(0)[0].is_sigma_2(0)
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, False, True)
  assert [r.format(i, 0) for r in t.relations_for(0)] \
      == ["(4,6,0) (5,1,2) %s (5,1,2) %s 6 1" % (False, True)]
  assert [r.format(i, 1) for r in t.relations_for(1)] \
      == ["(5,1,2) (4,6,0) %s (5,1,2) %s 6 1" % (False, False)]
  t = dmtbx.ext.triplet_generator(sg, i, None, 0, True, False)
  assert tuple(t.n_relations()) == (0,0)
예제 #6
0
파일: tst_miller.py 프로젝트: dials/cctbx
def exercise_union_of_indices():
  u = miller.union_of_indices_registry()
  assert u.as_array().size() == 0
  u.update(indices=flex.miller_index([(1,2,0)]))
  assert list(u.as_array()) == [(1,2,0)]
  u.update(indices=flex.miller_index([(1,2,0)]))
  assert list(u.as_array()) == [(1,2,0)]
  u.update(indices=flex.miller_index([(3,2,0)]))
  assert sorted(u.as_array()) == [(1,2,0), (3,2,0)]
예제 #7
0
def exercise_union_of_indices():
  u = miller.union_of_indices_registry()
  assert u.as_array().size() == 0
  u.update(indices=flex.miller_index([(1,2,0)]))
  assert list(u.as_array()) == [(1,2,0)]
  u.update(indices=flex.miller_index([(1,2,0)]))
  assert list(u.as_array()) == [(1,2,0)]
  u.update(indices=flex.miller_index([(3,2,0)]))
  assert sorted(u.as_array()) == [(1,2,0), (3,2,0)]
예제 #8
0
    def _get_unique_Hi(self):
        COMM.barrier()
        if COMM.rank == 0:
            from cctbx.crystal import symmetry
            from cctbx import miller
            from cctbx.array_family import flex as cctbx_flex

            ii = list(self.Modelers.keys())[0]
            uc = self.Modelers[ii].ucell_man
            params = uc.a, uc.b, uc.c, uc.al * 180 / np.pi, uc.be * 180 / np.pi, uc.ga * 180 / np.pi
            if self.params.refiner.force_unit_cell is not None:
                params = self.params.refiner.force_unit_cell
            symm = symmetry(unit_cell=params, space_group_symbol=self.symbol)
            hi_asu_flex = cctbx_flex.miller_index(self.Hi_asu_all_ranks)
            mset = miller.set(symm, hi_asu_flex, anomalous_flag=True)
            marr = miller.array(mset)
            binner = marr.setup_binner(
                d_max=self.params.refiner.stage_two.d_max,
                d_min=self.params.refiner.stage_two.d_min,
                n_bins=self.params.refiner.stage_two.n_bin)
            from collections import Counter
            print("Average multiplicities:")
            print("<><><><><><><><><><><><>")
            for i_bin in range(self.params.refiner.stage_two.n_bin - 1):
                dmax, dmin = binner.bin_d_range(i_bin + 1)
                F_in_bin = marr.resolution_filter(d_max=dmax, d_min=dmin)
                multi_in_bin = np.array(
                    list(Counter(F_in_bin.indices()).values()))
                print("%2.5g-%2.5g : Multiplicity=%.4f" %
                      (dmax, dmin, multi_in_bin.mean()))
                for ii in range(1, 100, 8):
                    print("\t %d refls with multi %d" %
                          (sum(multi_in_bin == ii), ii))

            print("Overall completeness\n<><><><><><><><>")
            symm = symmetry(unit_cell=params, space_group_symbol=self.symbol)
            hi_flex_unique = cctbx_flex.miller_index(
                list(set(self.Hi_asu_all_ranks)))
            mset = miller.set(symm, hi_flex_unique, anomalous_flag=True)
            self.binner = mset.setup_binner(
                d_min=self.params.refiner.stage_two.d_min,
                d_max=self.params.refiner.stage_two.d_max,
                n_bins=self.params.refiner.stage_two.n_bin)
            mset.completeness(use_binning=True).show()
            marr_unique_h = miller.array(mset)
            print("Rank %d: total miller vars=%d" %
                  (COMM.rank, len(set(self.Hi_asu_all_ranks))))
        else:
            marr_unique_h = None

        marr_unique_h = COMM.bcast(marr_unique_h)
        return marr_unique_h
예제 #9
0
def exercise_match_indices():
    h0 = flex.miller_index(
        ((1, 2, 3), (-1, -2, -3), (2, 3, 4), (-2, -3, -4), (3, 4, 5)))
    d0 = flex.double((1, 2, 3, 4, 5))
    h1 = flex.miller_index(((-1, -2, -3), (-2, -3, -4), (1, 2, 3), (2, 3, 4)))
    d1 = flex.double((10, 20, 30, 40))
    mi = miller.match_indices(h0, h0)
    assert mi.have_singles() == 0
    assert list(mi.pairs()) == zip(range(5), range(5))
    mi = miller.match_indices(h0, h1)
    assert tuple(mi.singles(0)) == (4, )
    assert tuple(mi.singles(1)) == ()
    assert tuple(mi.pairs()) == ((0, 2), (1, 0), (2, 3), (3, 1))
    assert tuple(mi.pair_selection(0)) == (1, 1, 1, 1, 0)
    assert tuple(mi.single_selection(0)) == (0, 0, 0, 0, 1)
    assert tuple(mi.pair_selection(1)) == (1, 1, 1, 1)
    assert tuple(mi.single_selection(1)) == (0, 0, 0, 0)
    assert tuple(mi.paired_miller_indices(0)) \
        == tuple(h0.select(mi.pair_selection(0)))
    l1 = list(mi.paired_miller_indices(1))
    l2 = list(h1.select(mi.pair_selection(1)))
    l1.sort()
    l2.sort()
    assert l1 == l2
    assert approx_equal(tuple(mi.plus(d0, d1)), (31, 12, 43, 24))
    assert approx_equal(tuple(mi.minus(d0, d1)), (-29, -8, -37, -16))
    assert approx_equal(tuple(mi.multiplies(d0, d1)), (30, 20, 120, 80))
    assert approx_equal(tuple(mi.divides(d0, d1)),
                        (1 / 30., 2 / 10., 3 / 40., 4 / 20.))
    assert approx_equal(tuple(mi.additive_sigmas(d0, d1)), [
        math.sqrt(x * x + y * y)
        for x, y in ((1, 30), (2, 10), (3, 40), (4, 20))
    ])
    q = flex.size_t((3, 2, 0, 4, 1))
    h1 = h0.select(q)
    assert tuple(miller.match_indices(h1, h0).permutation()) == tuple(q)
    p = miller.match_indices(h0, h1).permutation()
    assert tuple(p) == (2, 4, 1, 0, 3)
    assert tuple(h1.select(p)) == tuple(h0)
    cd0 = [
        complex(a, b)
        for (a, b) in (1, 1), (2, 0), (3.5, -1.5), (5, -3), (-8, 5.4)
    ]
    cd1 = [
        complex(a, b)
        for (a, b) in (1, -1), (2, 1), (0.5, 1.5), (-1, -8), (10, 0)
    ]
    cd2 = flex.complex_double(cd0)
    cd3 = flex.complex_double(cd1)
    mi = miller.match_indices(h0, h0)
    assert approx_equal(tuple(mi.plus(cd2, cd3)),
                        ((2 + 0j), (4 + 1j), (4 + 0j), (4 - 11j), (2 + 5.4j)))
def exercise_fast_nv1995():
    space_group = sgtbx.space_group_info("P 21 21 21").group()
    miller_indices_f_obs = flex.miller_index(((3, 4, 5), (4, 5, 6)))
    f = translation_search.fast_nv1995(
        gridding=(20, 20, 36),
        space_group=space_group,
        anomalous_flag=False,
        miller_indices_f_obs=miller_indices_f_obs,
        f_obs=flex.double((1, 2)),
        f_part=flex.complex_double(),
        miller_indices_p1_f_calc=flex.miller_index(((1, 2, 3), )),
        p1_f_calc=flex.complex_double((12, )))
    assert f.target_map().all() == (20, 20, 36)
def exercise_fast_nv1995():
  space_group = sgtbx.space_group_info("P 21 21 21").group()
  miller_indices_f_obs = flex.miller_index(((3,4,5),(4,5,6)))
  f = translation_search.fast_nv1995(
    gridding=(20,20,36),
    space_group=space_group,
    anomalous_flag=False,
    miller_indices_f_obs=miller_indices_f_obs,
    f_obs=flex.double((1,2)),
    f_part=flex.complex_double(),
    miller_indices_p1_f_calc=flex.miller_index(((1,2,3),)),
    p1_f_calc=flex.complex_double((12,)))
  assert f.target_map().all() == (20,20,36)
def exercise_fast_terms():
  space_group = sgtbx.space_group_info("P 21 21 21").group()
  miller_indices_f_obs = flex.miller_index(((3,4,5),(4,5,6)))
  f = translation_search.fast_terms(
    gridding=(20,20,36),
    anomalous_flag=False,
    miller_indices_p1_f_calc=flex.miller_index(((1,2,3),)),
    p1_f_calc=flex.complex_double((12,)))
  assert f.summation(
    space_group=space_group,
    miller_indices_f_obs=miller_indices_f_obs,
    m=flex.double((1,2)),
    f_part=None,
    squared_flag=False).fft().accu_real_copy().all() == (20,20,36)
예제 #13
0
def exercise_asu():
    sg_type = sgtbx.space_group_type("P 41")
    asu = sgtbx.reciprocal_space_asu(sg_type)
    miller_indices = flex.miller_index(((1, 2, 3), (3, 5, 0)))
    for h in miller_indices:
        h_eq = miller.sym_equiv_indices(sg_type.group(), h)
        for i_eq in xrange(h_eq.multiplicity(False)):
            h_i = h_eq(i_eq)
            for anomalous_flag in (False, True):
                a = miller.asym_index(sg_type.group(), asu, h_i.h())
                assert a.h() == h
                o = a.one_column(anomalous_flag)
                assert o.i_column() == 0
                t = a.two_column(anomalous_flag)
                assert t.h() == h
                assert (o.h() != h) == (t.i_column() == 1)
                assert not anomalous_flag or (t.i_column() !=
                                              0) == h_i.friedel_flag()
                assert anomalous_flag or t.i_column() == 0
    miller.map_to_asu(sg_type, False, miller_indices)
    data = flex.double((0, 0))
    miller.map_to_asu(sg_type, False, miller_indices, data)
    miller.map_to_asu(sg_type, False, miller_indices, data, False)
    miller.map_to_asu(sg_type, False, miller_indices, data, True)
    data = flex.complex_double((0, 0))
    miller.map_to_asu(sg_type, False, miller_indices, data)
    data = flex.hendrickson_lattman(((1, 2, 3, 4), (2, 3, 4, 5)))
    miller.map_to_asu(sg_type, False, miller_indices, data)
    for sg_symbol in ("P 41", "P 31 1 2"):
        exercise_map_to_asu(sg_symbol)
    #
    sg_type = sgtbx.space_group_type("P 2")
    miller_indices = flex.miller_index(((1, 2, 3), (-1, -2, -3)))
    assert not miller.is_unique_set_under_symmetry(
        space_group_type=sg_type,
        anomalous_flag=False,
        miller_indices=miller_indices)
    assert miller.is_unique_set_under_symmetry(space_group_type=sg_type,
                                               anomalous_flag=True,
                                               miller_indices=miller_indices)
    assert list(
        miller.unique_under_symmetry_selection(
            space_group_type=sg_type,
            anomalous_flag=False,
            miller_indices=miller_indices)) == [0]
    assert list(
        miller.unique_under_symmetry_selection(
            space_group_type=sg_type,
            anomalous_flag=True,
            miller_indices=miller_indices)) == [0, 1]
def exercise_fast_terms():
    space_group = sgtbx.space_group_info("P 21 21 21").group()
    miller_indices_f_obs = flex.miller_index(((3, 4, 5), (4, 5, 6)))
    f = translation_search.fast_terms(
        gridding=(20, 20, 36),
        anomalous_flag=False,
        miller_indices_p1_f_calc=flex.miller_index(((1, 2, 3), )),
        p1_f_calc=flex.complex_double((12, )))
    assert f.summation(space_group=space_group,
                       miller_indices_f_obs=miller_indices_f_obs,
                       m=flex.double((1, 2)),
                       f_part=None,
                       squared_flag=False).fft().accu_real_copy().all() == (20,
                                                                            20,
                                                                            36)
예제 #15
0
def exercise_asu():
  sg_type = sgtbx.space_group_type("P 41")
  asu = sgtbx.reciprocal_space_asu(sg_type)
  miller_indices = flex.miller_index(((1,2,3), (3,5,0)))
  for h in miller_indices:
    h_eq = miller.sym_equiv_indices(sg_type.group(), h)
    for i_eq in xrange(h_eq.multiplicity(False)):
      h_i = h_eq(i_eq)
      for anomalous_flag in (False,True):
        a = miller.asym_index(sg_type.group(), asu, h_i.h())
        assert a.h() == h
        o = a.one_column(anomalous_flag)
        assert o.i_column() == 0
        t = a.two_column(anomalous_flag)
        assert t.h() == h
        assert (o.h() != h) == (t.i_column() == 1)
        assert not anomalous_flag or (t.i_column() != 0) == h_i.friedel_flag()
        assert anomalous_flag or t.i_column() == 0
  miller.map_to_asu(sg_type, False, miller_indices)
  data = flex.double((0,0))
  miller.map_to_asu(sg_type, False, miller_indices, data)
  miller.map_to_asu(sg_type, False, miller_indices, data, False)
  miller.map_to_asu(sg_type, False, miller_indices, data, True)
  data = flex.complex_double((0,0))
  miller.map_to_asu(sg_type, False, miller_indices, data)
  data = flex.hendrickson_lattman(((1,2,3,4),(2,3,4,5)))
  miller.map_to_asu(sg_type, False, miller_indices, data)
  for sg_symbol in ("P 41", "P 31 1 2"):
    exercise_map_to_asu(sg_symbol)
  #
  sg_type = sgtbx.space_group_type("P 2")
  miller_indices = flex.miller_index(((1,2,3), (-1,-2,-3)))
  assert not miller.is_unique_set_under_symmetry(
    space_group_type=sg_type,
    anomalous_flag=False,
    miller_indices=miller_indices)
  assert miller.is_unique_set_under_symmetry(
    space_group_type=sg_type,
    anomalous_flag=True,
    miller_indices=miller_indices)
  assert list(miller.unique_under_symmetry_selection(
    space_group_type=sg_type,
    anomalous_flag=False,
    miller_indices=miller_indices)) == [0]
  assert list(miller.unique_under_symmetry_selection(
    space_group_type=sg_type,
    anomalous_flag=True,
    miller_indices=miller_indices)) == [0,1]
예제 #16
0
    def as_mtz(self, scale_factor, prefix):
        #This reads in an hkl map and returns a .mtz map
        #Read in hkl file and populate miller array
        inf = open(self.diffuse_file, 'r')
        indices = flex.miller_index()
        i_obs = flex.double()
        sig_i = flex.double()
        for line in inf.readlines():
            assert len(line.split()) == 4
            line = line.strip().split()
            #####ATTENTION:SCALE FACTOR##############
            i_obs_ = float(
                line[3]
            ) / scale_factor  #is a uniform scale factor meant to re-size all diffuse intensities (normally too large for scalepack)
            sig_i_ = math.sqrt(i_obs_)
            #if(abs(i_obs_)>1.e-6): # perhaps you don't want zeros
            indices.append([int(line[0]), int(line[1]), int(line[2])])
            i_obs.append(i_obs_)
            sig_i.append(sig_i_)
        inf.close()

        # get miller array object
        cs = self.symmetry
        ma = miller.array(miller_set=miller.set(cs, indices),
                          data=i_obs,
                          sigmas=sig_i)
        ma.set_observation_type_xray_intensity()
        mtz_dataset = ma.as_mtz_dataset(column_root_label="I")
        mtz_dataset.mtz_object().write(prefix + '.mtz')
def run(args):

  from dials.util.options import OptionParser
  from dials.util.options import flatten_experiments
  from libtbx.utils import Sorry
  import libtbx.load_env

  usage = "%s [options] experiments.json" %libtbx.env.dispatcher_name

  parser = OptionParser(
    usage=usage,
    phil=phil_scope,
    read_experiments=True,
    check_format=False,
    epilog=help_message)

  params, options = parser.parse_args(show_diff_phil=True)
  experiments = flatten_experiments(params.input.experiments)
  if len(experiments) <= 1:
    parser.print_help()
    return

  hkl = flex.miller_index(params.hkl)

  from dials.algorithms.indexing.compare_orientation_matrices import \
       show_rotation_matrix_differences
  show_rotation_matrix_differences(experiments.crystals(),
                                   miller_indices=hkl)
예제 #18
0
  def __init__(self, data, lattice_id, resort=False, verbose=True):
    self.verbose = verbose
    ######  INPUTS #######
    #       data = miller array: ASU miller index & intensity
    #       lattice_id = flex double: assignment of each miller index to a lattice number
    ######################

    if resort:
      order = flex.sort_permutation(lattice_id.data())
      sorted_lattice_id = flex.select(lattice_id.data(), order)
      sorted_data = data.data().select( order)
      sorted_indices = data.indices().select( order)
      self.lattice_id = sorted_lattice_id
      self.data = data.customized_copy(indices = sorted_indices, data = sorted_data)
    else:
      self.lattice_id = lattice_id.data() # type flex int
      self.data = data # type miller array with flex double data
    assert type(self.data.indices()) == type(flex.miller_index())
    assert type(self.data.data()) == type(flex.double())

    # construct a lookup for the separate lattices
    last_id = -1; self.lattices = flex.int()
    for n in xrange(len(self.lattice_id)):
      if self.lattice_id[n] != last_id:
        last_id = self.lattice_id[n]
        self.lattices.append(n)
예제 #19
0
def exercise_miller_array_data_types():
    miller_set = crystal.symmetry(unit_cell=(10, 10, 10, 90, 90, 90), space_group_symbol="P1").miller_set(
        indices=flex.miller_index([(1, 2, 3), (4, 5, 6)]), anomalous_flag=False
    )
    for data in [
        flex.bool([False, True]),
        flex.int([0, 1]),
        flex.size_t([0, 1]),
        flex.double([0, 1]),
        flex.complex_double([0, 1]),
    ]:
        miller_array = miller_set.array(data=data)
        if op.isfile("tmp_iotbx_mtz.mtz"):
            os.remove("tmp_iotbx_mtz.mtz")
        assert not op.isfile("tmp_iotbx_mtz.mtz")
        miller_array.as_mtz_dataset(column_root_label="DATA").mtz_object().write(file_name="tmp_iotbx_mtz.mtz")
        assert op.isfile("tmp_iotbx_mtz.mtz")
        mtz_obj = mtz.object(file_name="tmp_iotbx_mtz.mtz")
        miller_arrays_read_back = mtz_obj.as_miller_arrays()
        assert len(miller_arrays_read_back) == 1
        miller_array_read_back = miller_arrays_read_back[0]
        assert miller_array_read_back.indices().all_eq(miller_array.indices())
        if miller_array.is_integer_array() or miller_array.is_bool_array():
            assert miller_array_read_back.data().all_eq(flex.int([0, 1]))
        elif miller_array.is_real_array():
            assert miller_array_read_back.data().all_eq(flex.double([0, 1]))
        elif miller_array.is_complex_array():
            assert miller_array_read_back.data().all_eq(flex.complex_double([0, 1]))
        else:
            raise RuntimeError("Programming error.")
예제 #20
0
def test_grouped_observations():

    # some dummy observations for one reflection
    I1, I2, I3 = 101, 100, 99
    w1, w2, w3 = 0.9, 1.0, 0.8
    g1, g2, g3 = 1.01, 1.0, 0.99

    # combine with observations from some other group to make a dataset
    hkl = flex.miller_index([(0, 0, 1)] * 3 + [(0, 0, 2)] * 2)
    intensity = flex.double([I1, I2, I3, 10, 10])
    weight = flex.double([w1, w2, w3, 1.0, 1.0])
    phi = flex.double(len(hkl), 0)  # dummy
    scale = flex.double([g1, g2, g3, 1.0, 1.0])

    # group the observations by Miller index
    go = GroupedObservations(hkl, intensity, weight, phi, scale)

    # ensure there are two groups, the first of size 3, the second of size 2
    assert list(go.get_group_size()) == [3, 2]

    # the first group has an average intensity given by the HRS formula expanded:
    avI = (w1 * g1 * I1 + w2 * g2 * I2 +
           w3 * g3 * I3) / (w1 * g1 * g1 + w2 * g2 * g2 + w3 * g3 * g3)
    assert approx_equal(avI, go.get_average_intensity()[0])

    print "OK"
예제 #21
0
def df2m(df, cell, spgr, data=None, sigmas=None):
    """Constructs a miller.array from the columns specified by data/sigmas in the dataframe,
    if both are None, returns just the indices.
    needs cell and spgr to generate a symmetry object."""
    anomalous_flag = False

    if isinstance(df, pd.DataFrame):
        try:
            sel = df[data].notnull()  # select notnull data items for index
        except ValueError:
            index = df.index
        else:
            index = df.index[sel]
    else:
        index = df

    indices = flex.miller_index(index)

    if data:
        data = flex.double(df[data][sel])
    if sigmas:
        sigmas = flex.double(df[sigmas][sel])

    symm = make_symmetry(cell, spgr)
    ms = miller.set(
        crystal_symmetry=symm, indices=indices, anomalous_flag=anomalous_flag)
    return miller.array(ms, data=data, sigmas=sigmas)
예제 #22
0
def exercise_map_to_asu(sg_symbol):
  sg_type = sgtbx.space_group_type(sg_symbol)
  index_abs_range = (4,4,4)
  for anomalous_flag in (False,True):
    m = miller.index_generator(
      sg_type, anomalous_flag, index_abs_range).to_array()
    a = flex.double()
    p = flex.double()
    c = flex.hendrickson_lattman()
    for i in xrange(m.size()):
      a.append(random.random())
      p.append(random.random() * 2)
      c.append([random.random() for j in xrange(4)])
    f = flex.polar(a, p)
    p = [p, p*(180/math.pi)]
  m_random = flex.miller_index()
  p_random = [flex.double(), flex.double()]
  c_random = flex.hendrickson_lattman()
  f_random = flex.complex_double()
  for i,h_asym in enumerate(m):
    h_eq = miller.sym_equiv_indices(sg_type.group(), h_asym)
    i_eq = random.randrange(h_eq.multiplicity(anomalous_flag))
    h_i = h_eq(i_eq)
    m_random.append(h_i.h())
    for deg in (False,True):
      p_random[deg].append(h_i.phase_eq(p[deg][i], deg))
    f_random.append(h_i.complex_eq(f[i]))
    c_random.append(h_i.hendrickson_lattman_eq(c[i]))
  m_random_copy = m_random.deep_copy()
  miller.map_to_asu(sg_type, anomalous_flag, m_random_copy)
  for i,h_asym in enumerate(m):
    assert h_asym == m_random_copy[i]
  m_random_copy = m_random.deep_copy()
  miller.map_to_asu(sg_type, anomalous_flag, m_random_copy, f_random)
  for i,h_asym in enumerate(m):
    assert h_asym == m_random_copy[i]
  for i,f_asym in enumerate(f):
    assert abs(f_asym - f_random[i]) < 1.e-6
  m_random_copy = m_random.deep_copy()
  a_random = a.deep_copy()
  miller.map_to_asu(sg_type, anomalous_flag, m_random_copy, a_random)
  for i,h_asym in enumerate(m):
    assert h_asym == m_random_copy[i]
  for i,a_asym in enumerate(a):
    assert a_asym == a_random[i]
  for deg in (False,True):
    m_random_copy = m_random.deep_copy()
    miller.map_to_asu(
      sg_type, anomalous_flag, m_random_copy, p_random[deg], deg)
    for i,h_asym in enumerate(m):
      assert h_asym == m_random_copy[i]
    for i,p_asym in enumerate(p[deg]):
      assert scitbx.math.phase_error(p_asym, p_random[deg][i], deg) < 1.e-5
  m_random_copy = m_random.deep_copy()
  miller.map_to_asu(sg_type, anomalous_flag, m_random_copy, c_random)
  for i,h_asym in enumerate(m):
    assert h_asym == m_random_copy[i]
  for i,c_asym in enumerate(c):
    for j in xrange(4):
      assert abs(c_asym[j] - c_random[i][j]) < 1.e-5
예제 #23
0
    def predict(self, indices, angles):

        # extract required information from the models
        sensor = self._detector.sensors()[0]  # assume only one sensor for now
        axis = matrix.col(self._gonio.get_rotation_axis())
        s0 = matrix.col(self._beam.get_s0())
        UB = self._crystal.get_U() * self._crystal.get_B()

        # instantiate predictor
        rp = reflection_prediction(axis, s0, UB, sensor)

        # perform impact prediction
        # rp.predict does not like indices as miller_index. A conversion to
        # matrix.col fixes that
        temp = []
        for hkl in indices:
            hkl = matrix.col(hkl)
            temp.append(hkl)
        Hc, Xc, Yc, Phic, Sc = rp.predict(temp, angles)

        # Hc is now an an array of floating point vec3. How annoying! We want
        # integer Miller indices. Force that to be so.
        # Once we have new (fast) reflection prediction code that does not
        # return floating point indices then this whole class can be replaced
        temp = flex.miller_index()
        for hkl in Hc:
            hkl = map(lambda x: int(round(x)), hkl)
            temp.append(tuple(hkl))

        # Rescale normalised scattering vectors to the correct length
        wavelength = self._beam.get_wavelength()
        Sc = map(lambda s: matrix.col(s) / wavelength, Sc)

        return (temp, Xc, Yc, Phic, Sc)
예제 #24
0
def exercise_expand():
  sg = sgtbx.space_group("P 41 (1,-1,0)")
  h = flex.miller_index(((3,1,-2), (1,-2,0)))
  assert tuple(sg.is_centric(h)) == (0, 1)
  p1 = miller.expand_to_p1_iselection(
    space_group=sg, anomalous_flag=False, indices=h, build_iselection=False)
  p1_i0 = ((-3,-1,2), (-1, 3,2),(3,1,2),(1,-3,2),(1,-2, 0),(2,1,0))
  assert tuple(p1.indices) == p1_i0
  assert p1.iselection.size() == 0
  p1 = miller.expand_to_p1_iselection(
    space_group=sg, anomalous_flag=True, indices=h, build_iselection=False)
  assert tuple(p1.indices) \
      == ((3,1,-2), (1,-3,-2), (-3,-1,-2), (-1,3,-2),
          (1,-2,0), (-2,-1,0), (-1,2,0), (2,1,0))
  p1 = miller.expand_to_p1_iselection(
    space_group=sg, anomalous_flag=False, indices=h, build_iselection=True)
  assert tuple(p1.indices) == p1_i0
  assert tuple(p1.iselection) == (0,0,0,0,1,1)
  a = flex.double((1,2))
  p = flex.double((10,90))
  p1 = miller.expand_to_p1_phases(
    space_group=sg, anomalous_flag=False, indices=h, data=p, deg=True)
  assert approx_equal(tuple(p1.data), (-10,110,110,-10, 90,30))
  p1 = miller.expand_to_p1_phases(
    space_group=sg, anomalous_flag=True, indices=h, data=p, deg=True)
  assert approx_equal(tuple(p1.data), (10,-110,-110,10, 90,-30,-90,30))
  p = flex.double([x * math.pi/180 for x in p])
  v = [x * math.pi/180 for x in p1.data]
  p1 = miller.expand_to_p1_phases(
    space_group=sg, anomalous_flag=True, indices=h, data=p, deg=False)
  assert approx_equal(tuple(p1.data), v)
  f = flex.polar(a, p)
  p1 = miller.expand_to_p1_complex(
    space_group=sg, anomalous_flag=True, indices=h, data=f)
  assert approx_equal(tuple(flex.abs(p1.data)), (1,1,1,1,2,2,2,2))
  assert approx_equal(tuple(flex.arg(p1.data)), v)
  hl = flex.hendrickson_lattman([(1,2,3,4), (5,6,7,8)])
  p1 = miller.expand_to_p1_hendrickson_lattman(
    space_group=sg, anomalous_flag=True, indices=h, data=hl)
  assert approx_equal(p1.data, [
    [1,2,3,4],
    [1.232051,-1.866025,-4.964102,0.5980762],
    [1.232051,-1.866025,-4.964102,0.5980762],
    [1,2,3,4],
    [5,6,7,8],
    [2.696152,-7.330127,-10.4282,2.062178],
    [-5,-6,7,8],
    [7.696152,-1.330127,3.428203,-10.06218]])
  b = flex.bool([True,False])
  p1 = miller.expand_to_p1_iselection(
    space_group=sg, anomalous_flag=True, indices=h, build_iselection=True)
  assert b.select(p1.iselection).all_eq(
    flex.bool([True, True, True, True, False, False, False, False]))
  i = flex.int([13,17])
  p1 = miller.expand_to_p1_iselection(
    space_group=sg, anomalous_flag=True, indices=h, build_iselection=True)
  assert i.select(p1.iselection).all_eq(flex.int([13,13,13,13,17,17,17,17]))
  #
  assert approx_equal(miller.statistical_mean(sg, False, h, a), 4/3.)
  assert approx_equal(miller.statistical_mean(sg, True, h, a), 3/2.)
    def extend_symmetry(self,scale_factor,prefix):
    #This reads in an hkl map and returns a .sca map
        #Read in hkl file and populate miller array
        inf = open(self.diffuse_file, 'r')
        indices = flex.miller_index()
        i_obs = flex.double()
        sig_i = flex.double()
        for line in inf.readlines():
            assert len(line.split())==4
            line = line.strip().split()
            #####ATTENTION:SCALE FACTOR##############
            i_obs_ = float(line[3])/scale_factor #is a uniform scale factor meant to re-size all diffuse intensities (normally too large for scalepack)
            sig_i_ = math.sqrt(i_obs_) 
            #if(abs(i_obs_)>1.e-6): # perhaps you don't want zeros
            indices.append([int(line[0]),int(line[1]),int(line[2])])
            i_obs.append(i_obs_)
            sig_i.append(sig_i_)
        inf.close()

      # get miller array object
        cs = self.symmetry
        ma = miller.array(miller_set=miller.set(cs, indices), data=i_obs, sigmas=sig_i)
        ma.set_observation_type_xray_intensity()
        ma_anom = ma.customized_copy(anomalous_flag=False)
        ma_p1 = ma_anom.expand_to_p1()

        merge.write(file_name= prefix + '.sca', miller_array=ma_p1)

        self.p1_map = prefix + '.sca'
def exercise_f000():
  miller_indices = flex.miller_index([(0,0,0)])
  data = flex.complex_double([1-2j])
  n_real = [1,2,3]
  conjugate_flag = True
  for hall_symbol in ["P 1", "P 3", "R 3*"]:
    for is_centric in [False, True]:
      if (not is_centric):
        space_group = sgtbx.space_group(hall_symbol)
      else:
        space_group.expand_smx("-x,-y,-z")
      for anomalous_flag in [False, True]:
        if (not anomalous_flag):
          rfft = fftpack.real_to_complex_3d(n_real)
          n_complex = rfft.n_complex()
        else:
          cfft = fftpack.complex_to_complex_3d(n_real)
          n_complex = cfft.n()
        for treat_restricted in [False, True]:
          map = maptbx.structure_factors.to_map(
            space_group=space_group,
            anomalous_flag=anomalous_flag,
            miller_indices=miller_indices,
            structure_factors=data,
            n_real=n_real,
            map_grid=flex.grid(n_complex),
            conjugate_flag=conjugate_flag,
            treat_restricted=treat_restricted)
          if (treat_restricted):
            assert approx_equal(
              map.complex_map()[0], data[0])
          else:
            assert approx_equal(
              map.complex_map()[0], data[0]*space_group.order_p())
예제 #27
0
  def __init__(self):
    self.data_obs1 = flex.double(2,1.0)
    self.data_obs2 = flex.double(2,3.0)
    self.sigma_obs1 = flex.double(2,0.1)
    self.sigma_obs2 = flex.double(2,1)
    self.unit_cell = uctbx.unit_cell('20, 30, 40, 90.0, 90.0, 90.0')
    #mi = flex.miller_index(((1,2,3), (1,2,3)))
    self.mi = flex.miller_index(((1,2,3), (5,6,7)))
    self.xs = crystal.symmetry((20,30,40), "P 2 2 2")
    self.ms = miller.set(self.xs, self.mi)
    self.u = [1,2,3,4,5,6]
    self.p_scale = 0.40
    #self.u = [0,0,0,0,0,0]
    #self.p_scale = 0.00

    self.ls_i_wt = scaling.least_squares_on_i_wt(
      self.mi,
      self.data_obs1,
      self.sigma_obs1,
      self.data_obs2,
      self.sigma_obs2,
      self.p_scale,
      self.unit_cell,
      self.u)
    self.ls_i = scaling.least_squares_on_i(
      self.mi,
      self.data_obs1,
      self.sigma_obs1,
      self.data_obs2,
      self.sigma_obs2,
      self.p_scale,
      self.unit_cell,
      self.u)
    self.ls_f_wt = scaling.least_squares_on_f_wt(
      self.mi,
      self.data_obs1,
      self.sigma_obs1,
      self.data_obs2,
      self.sigma_obs2,
      self.p_scale,
      self.unit_cell,
      self.u)
    self.ls_f = scaling.least_squares_on_f(
      self.mi,
      self.data_obs1,
      self.sigma_obs1,
      self.data_obs2,
      self.sigma_obs2,
      self.p_scale,
      self.unit_cell,
      self.u)

    self.tst_ls_f_wt()
    self.tst_ls_i_wt()
    self.tst_ls_f()
    self.tst_ls_i()
    self.tst_hes_ls_i_wt()
    self.tst_hes_ls_f_wt()
    self.tst_hes_ls_i()
    self.tst_hes_ls_f()
 def __init__(self, file_name=None, file_object=None, max_header_lines=30):
   assert [file_name, file_object].count(None) == 1
   if (file_object is None):
     file_object = open(file_name)
   self._names = None
   self._indices = flex.miller_index()
   self._data = flex.double()
   self._sigmas = flex.double()
   have_data = False
   self.n_lines = 0
   for raw_line in file_object:
     self.n_lines += 1
     ifs = index_fobs_sigma_line(raw_line)
     if (not ifs.is_complete):
       if (raw_line.strip().lower() == "end"):
         break
       if (self.n_lines == max_header_lines or have_data):
         raise RuntimeError, "Unkown file format."
     else:
       if (self._names is None): self._names = ifs.names
       self._indices.append(ifs.index)
       self._data.append(ifs.fobs)
       self._sigmas.append(ifs.sigma)
       have_data = True
   if (not have_data):
     raise RuntimeError, "No data found in file."
예제 #29
0
def exercise_miller_array_data_types():
    miller_set = crystal.symmetry(unit_cell=(10, 10, 10, 90, 90, 90),
                                  space_group_symbol="P1").miller_set(
                                      indices=flex.miller_index([(1, 2, 3),
                                                                 (4, 5, 6)]),
                                      anomalous_flag=False)
    for data in [
            flex.bool([False, True]),
            flex.int([0, 1]),
            flex.size_t([0, 1]),
            flex.double([0, 1]),
            flex.complex_double([0, 1])
    ]:
        miller_array = miller_set.array(data=data)
        if (op.isfile("tmp_iotbx_mtz.mtz")): os.remove("tmp_iotbx_mtz.mtz")
        assert not op.isfile("tmp_iotbx_mtz.mtz")
        miller_array.as_mtz_dataset(
            column_root_label="DATA").mtz_object().write(
                file_name="tmp_iotbx_mtz.mtz")
        assert op.isfile("tmp_iotbx_mtz.mtz")
        mtz_obj = mtz.object(file_name="tmp_iotbx_mtz.mtz")
        miller_arrays_read_back = mtz_obj.as_miller_arrays()
        assert len(miller_arrays_read_back) == 1
        miller_array_read_back = miller_arrays_read_back[0]
        assert miller_array_read_back.indices().all_eq(miller_array.indices())
        if (miller_array.is_integer_array() or miller_array.is_bool_array()):
            assert miller_array_read_back.data().all_eq(flex.int([0, 1]))
        elif (miller_array.is_real_array()):
            assert miller_array_read_back.data().all_eq(flex.double([0, 1]))
        elif (miller_array.is_complex_array()):
            assert miller_array_read_back.data().all_eq(
                flex.complex_double([0, 1]))
        else:
            raise RuntimeError("Programming error.")
예제 #30
0
def exercise():
  ma = miller.array(
    miller.set(crystal.symmetry(unit_cell=(5,5,5, 90, 90, 90),
                                space_group=sgtbx.space_group('P 2x')),
               indices=flex.miller_index(
                 [(1,0,0), (0,1,0), (0,0,1),
                  (-1,0,0), (0,-1,0), (0,0,-1),
                  (1,1,0), (1,0,1), (0,1,1),
                  (-1,-1,0), (-1,0,-1), (0,-1,-1),
                  (1,-1,0), (1,0,-1), (0,1,-1),
                  (-1,1,0), (-1,0,1), (0,-1,1),
                  (1,1,1), (-1,1,1), (1,-1,1), (1,1,-1),
                  (-1,-1,-1), (1,-1,-1), (-1,1,-1), (-1,-1,1)])),
    data=flex.complex_double(flex.random_double(26), flex.random_double(26)))
  f_at_h = dict(zip(ma.indices(), ma.data()))
  for op in ("-x, y+1/2, -z", "x+1/2, -y, z-1/2"):
    op = sgtbx.rt_mx(op)
    original, transformed = ma.common_sets(
      ma.change_basis(sgtbx.change_of_basis_op(op.inverse())))
    for h, f in original:
      assert f == f_at_h[h]
    for h, op_f in transformed:
      assert approx_equal(
        op_f,
        f_at_h[h*op.r()]*exp(1j*2*pi*row(h).dot(col(op.t().as_double()))))
예제 #31
0
    def observed_indices_and_angles_from_angle_range(
        self, phi_start_rad, phi_end_rad, indices
    ):
        """For a list of indices, return those indices that can be rotated into
        diffracting position, along with the corresponding angles"""

        # calculate conversion matrix to rossmann frame.
        R_to_rossmann = self.align_reference_frame(
            self._beam.get_unit_s0(),
            (0.0, 0.0, 1.0),
            self._gonio.get_rotation_axis(),
            (0.0, 1.0, 0.0),
        )

        # Create a rotation_angles object for the current geometry
        ra = rotation_angles(
            self._dmin,
            R_to_rossmann * self._crystal.get_U() * self._crystal.get_B(),
            self._beam.get_wavelength(),
            R_to_rossmann * matrix.col(self._gonio.get_rotation_axis()),
        )

        (obs_indices, obs_angles) = ra.observed_indices_and_angles_from_angle_range(
            phi_start_rad=0.0, phi_end_rad=pi, indices=indices
        )

        # convert to integer miller indices
        obs_indices_int = flex.miller_index()
        for hkl in obs_indices:
            hkl = map(lambda x: int(round(x)), hkl)
            obs_indices_int.append(tuple(hkl))
        return obs_indices_int, obs_angles
예제 #32
0
def convert_to_sf(hkl, intensities, phases, cs):
    """
    Reformat intensities and phases into a CCTBX-style Miller array, with space group
    symmetry enforced. 

    Inputs:
    -------
    hkl: list of Miller indices, formatted as tuples
    intensities: array of intensities, with ordering matching hkl
    phases: array of phases with ordering matching hkl
    cs: CCTBX crystal.symmetry object

    Outputs:
    --------
    ma: CCTBX-style Miller array
    """
    # compute structure factors in complex number format
    if (phases.min() < -1*np.pi) or (phases.max() > np.pi):
        print "Error: Invalid phase values; may be in degrees rather than radians."
    A, B = np.sqrt(intensities)*np.cos(phases), np.sqrt(intensities)*np.sin(phases)
    B[np.abs(B)<1e-12] = 0

    # reformat miller indices and structure factor information into CCTBX format
    indices = flex.miller_index(hkl)
    sf_data = flex.complex_double(flex.double(A),flex.double(B))
    ma = miller.array(miller_set=miller.set(cs, indices, anomalous_flag=False), data=sf_data)

    return ma
예제 #33
0
def test_minimum_multiplicity_selection():

    # some groups of indices with increasing multiplicity
    hkl = flex.miller_index([(0, 0, 1), (0, 0, 2), (0, 0, 2), (0, 0, 3),
                             (0, 0, 3), (0, 0, 3), (0, 0, 4), (0, 0, 4),
                             (0, 0, 4), (0, 0, 4), (0, 0, 5), (0, 0, 5),
                             (0, 0, 5), (0, 0, 5), (0, 0, 5)])

    # test the various possible selections with multiplicity from 1 to 6
    sel = minimum_multiplicity_selection(hkl, 1)
    assert sel.count(True) == len(hkl)

    sel = minimum_multiplicity_selection(hkl, 2)
    assert (sel == flex.bool([
        False,
    ] + [True] * 14)).all_eq(True)

    sel = minimum_multiplicity_selection(hkl, 3)
    assert (sel == flex.bool([False] * 3 + [True] * 12)).all_eq(True)

    sel = minimum_multiplicity_selection(hkl, 4)
    assert (sel == flex.bool([False] * 6 + [True] * 9)).all_eq(True)

    sel = minimum_multiplicity_selection(hkl, 5)
    assert (sel == flex.bool([False] * 10 + [True] * 5)).all_eq(True)

    sel = minimum_multiplicity_selection(hkl, 6)
    assert sel.count(False) == len(hkl)

    print "OK"
예제 #34
0
파일: blend.py 프로젝트: nsls-ii-mx/yamtbx
    def cluster_completeness(self, clno, anomalous_flag, calc_redundancy=True):
        if clno not in self.clusters:
            print "Cluster No. %d not found" % clno
            return

        cls = self.clusters[clno][3]
        msets = map(lambda x: self.miller_sets[self.files[x-1]], cls)
        num_idx = sum(map(lambda x: x.size(), msets))
        all_idx = flex.miller_index()
        all_idx.reserve(num_idx)
        for mset in msets: all_idx.extend(mset.indices())

        # Calc median cell
        cells = numpy.array(map(lambda x: x.unit_cell().parameters(), msets))
        median_cell = map(lambda i: numpy.median(cells[:,i]), xrange(6))
        symm = msets[0].customized_copy(unit_cell=median_cell)

        assert anomalous_flag is not None
        # XXX all must belong to the same Laue group and appropriately reindexed..
        all_set = miller.set(indices=all_idx,
                             crystal_symmetry=symm, anomalous_flag=anomalous_flag)
        all_set = all_set.resolution_filter(d_min=self.d_min)

        # dummy for redundancy calculation. dirty way..
        if calc_redundancy:
            dummy_array = miller.array(miller_set=all_set, data=flex.int(all_set.size()))
            merge = dummy_array.merge_equivalents()
            cmpl = merge.array().completeness()
            redun = merge.redundancies().as_double().mean()
            return cmpl, redun
        else:
            cmpl = all_set.unique_under_symmetry().completeness()
            return cmpl
예제 #35
0
def load_sfall(fname):
    """
    special script for loading the structure factor file generated in main()
    :param fname: file generated in the main method above.. 
    :return: mil_ar, energies
        mil_ar: dict of miller arrays (complex) 
        energies: array of xray energies in electron volts
        such that  mil_ar[0] is Fhkl at energy energies[0]
    """

    f = h5py.File(fname, "r")
    data = f["data"][()]
    indices = f["indices"][()]
    hall = f["hall_symbol"][()]
    ucell_param = f["ucell_tuple"][()]
    energies = f["energies"][()]
    sg = sgtbx.space_group(hall)
    Symm = crystal.symmetry(unit_cell=ucell_param, space_group=sg)
    indices_flex = tuple(map(tuple, indices))
    mil_idx = flex.miller_index(indices_flex)
    mil_set = miller.set(crystal_symmetry=Symm,
                         indices=mil_idx,
                         anomalous_flag=True)

    mil_ar = {}  # load a dict of "sfall at each energy"
    for i_chan, data_chan in enumerate(data):
        data_flex = flex.complex_double(np.ascontiguousarray(data_chan))
        mil_ar[i_chan] = miller.array(mil_set, data=data_flex)

    return mil_ar, energies
예제 #36
0
def test_grouped_observations():

  # some dummy observations for one reflection
  I1, I2, I3 = 101, 100, 99
  w1, w2, w3 = 0.9, 1.0, 0.8
  g1, g2, g3 = 1.01, 1.0, 0.99

  # combine with observations from some other group to make a dataset
  hkl = flex.miller_index([(0,0,1)] * 3 + [(0,0,2)] * 2)
  intensity = flex.double([I1, I2, I3, 10, 10])
  weight = flex.double([w1, w2, w3, 1.0, 1.0])
  phi = flex.double(len(hkl), 0) # dummy
  scale = flex.double([g1, g2, g3, 1.0, 1.0])

  # group the observations by Miller index
  go = GroupedObservations(hkl,
                           intensity,
                           weight,
                           phi,
                           scale)

  # ensure there are two groups, the first of size 3, the second of size 2
  assert list(go.get_group_size()) == [3,2]

  # the first group has an average intensity given by the HRS formula expanded:
  avI = (w1*g1*I1 + w2*g2*I2 + w3*g3*I3) / (w1*g1*g1 + w2*g2*g2 + w3*g3*g3)
  assert approx_equal(avI, go.get_average_intensity()[0])

  print "OK"
예제 #37
0
def pha2mtz(phain, xs, mtzout):
    hkl, f, fom, phi, sigf = [], [], [], [], []

    for l in open(phain):
        sp = l.split()
        if len(sp) != 7: break
        hkl.append(tuple(map(int, sp[:3])))
        f.append(float(sp[3]))
        fom.append(float(sp[4]))
        phi.append(float(sp[5]))
        sigf.append(float(sp[6]))

    if not hkl:
        return

    f_array = miller.array(miller.set(xs, flex.miller_index(hkl)),
                           data=flex.double(f),
                           sigmas=flex.double(sigf))
    mtz_ds = f_array.as_mtz_dataset(
        column_root_label="ANOM", column_types="FQ"
    )  # To open with Coot, column type F is required (not D)
    mtz_ds.add_miller_array(f_array.customized_copy(data=flex.double(phi),
                                                    sigmas=None),
                            column_root_label="PANOM",
                            column_types="P")
    mtz_ds.add_miller_array(f_array.customized_copy(data=flex.double(fom),
                                                    sigmas=None),
                            column_root_label="FOM",
                            column_types="W")

    mtz_ds.mtz_object().write(mtzout)
예제 #38
0
 def get_miller_indices_containing_loops(self):
     loops = []
     for loop in self.cif_block.loops.values():
         for key in loop.keys():
             if 'index_h' not in key: continue
             hkl_str = [
                 loop.get(key.replace('index_h', 'index_%s' % i))
                 for i in 'hkl'
             ]
             if hkl_str.count(None) > 0:
                 raise CifBuilderError(
                     "Miller indices missing from current CIF block (%s)" %
                     key.replace('index_h',
                                 'index_%s' % 'hkl'[hkl_str.index(None)]))
             hkl_int = []
             for i, h_str in enumerate(hkl_str):
                 try:
                     h_int = flex.int(h_str)
                 except ValueError, e:
                     raise CifBuilderError(
                         "Invalid item for Miller index %s: %s" %
                         ("HKL"[i], str(e)))
                 hkl_int.append(h_int)
             indices = flex.miller_index(*hkl_int)
             loops.append((indices, loop))
             break
예제 #39
0
  def observed_indices_and_angles_from_angle_range(self, phi_start_rad,
          phi_end_rad, indices):
    """For a list of indices, return those indices that can be rotated into
    diffracting position, along with the corresponding angles"""

    # calculate conversion matrix to rossmann frame.
    R_to_rossmann = self.align_reference_frame(
                self._beam.get_unit_s0(), (0.0, 0.0, 1.0),
                self._gonio.get_rotation_axis(), (0.0, 1.0, 0.0))

    # Create a rotation_angles object for the current geometry
    ra = rotation_angles(self._dmin,
             R_to_rossmann * self._crystal.get_U() * self._crystal.get_B(),
             self._beam.get_wavelength(),
             R_to_rossmann * matrix.col(self._gonio.get_rotation_axis()))

    (obs_indices,
     obs_angles) = ra.observed_indices_and_angles_from_angle_range(
        phi_start_rad = 0.0, phi_end_rad = pi, indices = indices)

    # convert to integer miller indices
    obs_indices_int = flex.miller_index()
    for hkl in obs_indices:
      hkl = map(lambda x: int(round(x)), hkl)
      obs_indices_int.append(tuple(hkl))
    return obs_indices_int, obs_angles
예제 #40
0
파일: blend.py 프로젝트: keitaroyam/yamtbx
    def cluster_completeness(self, clno, anomalous_flag, calc_redundancy=True):
        if clno not in self.clusters:
            print "Cluster No. %d not found" % clno
            return

        cls = self.clusters[clno][3]
        msets = map(lambda x: self.miller_sets[self.files[x-1]], cls)
        num_idx = sum(map(lambda x: x.size(), msets))
        all_idx = flex.miller_index()
        all_idx.reserve(num_idx)
        for mset in msets: all_idx.extend(mset.indices())

        # Calc median cell
        cells = numpy.array(map(lambda x: x.unit_cell().parameters(), msets))
        median_cell = map(lambda i: numpy.median(cells[:,i]), xrange(6))
        symm = msets[0].customized_copy(unit_cell=median_cell)

        assert anomalous_flag is not None
        # XXX all must belong to the same Laue group and appropriately reindexed..
        all_set = miller.set(indices=all_idx,
                             crystal_symmetry=symm, anomalous_flag=anomalous_flag)
        all_set = all_set.resolution_filter(d_min=self.d_min)

        # dummy for redundancy calculation. dirty way..
        if calc_redundancy:
            dummy_array = miller.array(miller_set=all_set, data=flex.int(all_set.size()))
            merge = dummy_array.merge_equivalents()
            cmpl = merge.array().completeness()
            redun = merge.redundancies().as_double().mean()
            return cmpl, redun
        else:
            cmpl = all_set.unique_under_symmetry().completeness()
            return cmpl
예제 #41
0
def exercise_match_bijvoet_mates():
  h0 = flex.miller_index(((1,2,3), (-1,-2,-3), (2,3,4), (-2,-3,-4), (3,4,5)))
  d0 = flex.double((1,2,3,4,5))
  bm = miller.match_bijvoet_mates(
    sgtbx.space_group_type(),
    h0)
  bm = miller.match_bijvoet_mates(
    sgtbx.reciprocal_space_asu(sgtbx.space_group_type()),
    h0)
  bm = miller.match_bijvoet_mates(
    h0)
  assert tuple(bm.pairs()) == ((0,1), (2,3))
  assert tuple(bm.singles("+")) == (4,)
  assert tuple(bm.singles("-")) == ()
  assert bm.n_singles() != 0
  assert tuple(bm.pairs_hemisphere_selection("+")) == (0, 2)
  assert tuple(bm.pairs_hemisphere_selection("-")) == (1, 3)
  assert tuple(bm.singles_hemisphere_selection("+")) == (4,)
  assert tuple(bm.singles_hemisphere_selection("-")) == ()
  assert tuple(bm.miller_indices_in_hemisphere("+")) == ((1,2,3), (2,3,4))
  assert tuple(bm.miller_indices_in_hemisphere("-")) == ((-1,-2,-3),(-2,-3,-4))
  assert approx_equal(tuple(bm.minus(d0)), (-1, -1))
  assert approx_equal(tuple(bm.additive_sigmas(d0)),
                      [math.sqrt(x*x+y*y) for x,y in ((1,2), (3,4))])
  assert approx_equal(tuple(bm.average(d0)), (3/2., 7/2.))
  h0.append((1,2,3))
  try: miller.match_bijvoet_mates(h0)
  except Exception: pass
  else: raise Exception_expected
예제 #42
0
  def predict(self, indices, angles):

    # extract required information from the models
    sensor = self._detector.sensors()[0] # assume only one sensor for now
    axis = matrix.col(self._gonio.get_rotation_axis())
    s0 = matrix.col(self._beam.get_s0())
    UB = self._crystal.get_U() * self._crystal.get_B()

    # instantiate predictor
    rp = reflection_prediction(axis, s0, UB, sensor)

    # perform impact prediction
    # rp.predict does not like indices as miller_index. A conversion to
    # matrix.col fixes that
    temp = []
    for hkl in indices:
      hkl = matrix.col(hkl)
      temp.append(hkl)
    Hc, Xc, Yc, Phic, Sc = rp.predict(temp, angles)

    # Hc is now an an array of floating point vec3. How annoying! We want
    # integer Miller indices. Force that to be so.
    # Once we have new (fast) reflection prediction code that does not
    # return floating point indices then this whole class can be replaced
    temp = flex.miller_index()
    for hkl in Hc:
      hkl = map(lambda x: int(round(x)), hkl)
      temp.append(tuple(hkl))

    # Rescale normalised scattering vectors to the correct length
    wavelength = self._beam.get_wavelength()
    Sc = map(lambda s: matrix.col(s) / wavelength, Sc)

    return (temp, Xc, Yc, Phic, Sc)
def run(args):

  from dials.util.options import OptionParser
  from dials.util.options import flatten_experiments
  import libtbx.load_env

  usage = "%s [options] experiments.json" %libtbx.env.dispatcher_name

  parser = OptionParser(
    usage=usage,
    phil=phil_scope,
    read_experiments=True,
    check_format=False,
    epilog=help_message)

  params, options = parser.parse_args(show_diff_phil=True)
  experiments = flatten_experiments(params.input.experiments)
  if len(experiments) <= 1:
    parser.print_help()
    return

  hkl = flex.miller_index(params.hkl)

  from dials.algorithms.indexing.compare_orientation_matrices import \
       show_rotation_matrix_differences
  crystals = []
  for experiment in experiments:
    crystal = experiment.crystal
    if params.space_group is not None:
      crystal.set_space_group(params.space_group.group())
    crystals.append(crystal)

  show_rotation_matrix_differences(crystals, miller_indices=hkl, comparison=params.comparison)
예제 #44
0
def generate_table(complex_data, indices, numpy_args=False, anom=True):
    """

    :param complex_data: structure factors
    :param indices: miller indices in a list, Nx3
    :param numpy_args: are the complex data and indices numpy type, if not
        assume flex
    :param anom: return a miller array with +H and -H ?
    :return: dictionary whose keys are miller index tuple and values are structure fact
    """
    sg = sgtbx.space_group(" P 4nw 2abw")
    Symm = crystal.symmetry(unit_cell=(79, 79, 38, 90, 90, 90), space_group=sg)
    if numpy_args:
        assert type(indices) == tuple
        assert (type(indices[0]) == tuple)
        indices = flex.miller_index(indices)

    mil_set = miller.set(crystal_symmetry=Symm,
                         indices=indices,
                         anomalous_flag=anom)
    if numpy_args:
        complex_data = flex.complex_double(np.ascontiguousarray(complex_data))
    mil_ar = miller.array(mil_set, data=complex_data)

    mil_dict = {h: val for h, val in izip(mil_ar.indices(), mil_ar.data())}
    return mil_dict
예제 #45
0
def run(args=None):
    usage = "dials.compare_orientation_matrices [options] models.expt"

    parser = ArgumentParser(
        usage=usage,
        phil=phil_scope,
        read_experiments=True,
        check_format=False,
        epilog=help_message,
    )

    params, options = parser.parse_args(args, show_diff_phil=True)
    experiments = flatten_experiments(params.input.experiments)
    if len(experiments) <= 1:
        parser.print_help()
        return

    hkl = flex.miller_index(params.hkl)

    crystals = []
    for experiment in experiments:
        crystal = experiment.crystal
        if params.space_group is not None:
            crystal.set_space_group(params.space_group.group())
        crystals.append(crystal)

    rmd = dials.algorithms.indexing.compare_orientation_matrices.rotation_matrix_differences(
        crystals, miller_indices=hkl, comparison=params.comparison)

    print(rmd)
def tst_pgtools():
    unit_cell = uctbx.unit_cell('40, 40, 60, 90.0, 90.0, 90.0')
    mi = flex.miller_index(((2, 4, 6), (2, 4, 8)))
    xs = crystal.symmetry(unit_cell, "P 1 2 1")
    ms = miller.set(xs, mi)

    # Go to the minimum cell, for safety
    cob_min_cell = ms.change_of_basis_op_to_minimum_cell()

    ms_new = ms.change_basis(cob_min_cell)

    lattice_group = sgtbx.lattice_symmetry.group(ms_new.unit_cell(),
                                                 max_delta=5.0)

    point_group_low = ms_new.space_group().build_derived_point_group()
    point_group_high = lattice_group.build_derived_point_group()

    pgtree = pt.point_group_graph(point_group_low, point_group_high)

    # find the possible routes from 'P 2' to 'P 4 2 2'
    atlas = pgtree.graph.find_all_paths('P 1 2 1', 'P 4 2 2')
    route_1 = ['P 1 2 1', 'P 4 2 2']
    route_2 = ['P 1 2 1', 'P 2 2 2', 'P 4 2 2']
    assert route_1 in atlas
    assert route_2 in atlas
    assert len(atlas) == 2

    # Now lets 'disqualify' point group 'P 2 2 2'
    pgtree.remove_point_group_and_its_super_groups_from_graph(
        str(sgtbx.space_group_info(16)))
    assert len(pgtree.graph.node_objects) == 1
    assert pgtree.graph.node_objects.has_key('P 1 2 1')
예제 #47
0
def aniso_convert(uc,sg,map,res):

  os.system('hkl2vtk %s_friedel.hkl %s_friedel.vtk %s_raw.vtk' %(map,map,map))
  os.system('vtk2lat %s_friedel.vtk %s_friedel.lat' %(map,map))
  os.system('avgrlt %s_friedel.lat %s_friedel.rf' %(map,map))
  os.system('subrflt %s_friedel.rf %s_friedel.lat anisotropic.lat' %(map,map))
  os.system('lat2hkl anisotropic.lat anisotropic.hkl')

  #Read in hkl file and populate miller array
  from cctbx import crystal
  inf = open('anisotropic.hkl', "r")
  indices = flex.miller_index()
  i_obs = flex.double()
  #sig_i = flex.double()
  for line in inf.readlines():
    assert len(line.split())==4
    line = line.strip().split()
    i_obs_ = float(line[3])#/10000 #10000 is a uniform scale factor meant to re-size all diffuse intensities (normally too large for scalepack)
    #sig_i_ = math.sqrt(i_obs_) 
    #if(abs(i_obs_)>1.e-6): # perhaps you don't want zeros

    if i_obs_ != -32768.0:
      indices.append([int(line[0]),int(line[1]),int(line[2])])
      i_obs.append(i_obs_)
    #sig_i.append(sig_i_)
  inf.close()

  #Get miller array object
  cs = crystal.symmetry(unit_cell=(float(uc[0]), float(uc[1]), float(uc[2]), float(uc[3]), float(uc[4]), float(uc[5])), space_group=sg)
  miller_set=miller.set(cs, indices)
  ma = miller.array(miller_set=miller_set, data=i_obs, sigmas=None)
  mtz_dataset = ma.as_mtz_dataset(column_root_label="Amplitude")
  mtz_dataset.mtz_object().write('%s_anisotropic.mtz' %map)
예제 #48
0
def test_minimum_multiplicity_selection():

  # some groups of indices with increasing multiplicity
  hkl = flex.miller_index(
        [(0,0,1),
         (0,0,2), (0,0,2),
         (0,0,3), (0,0,3), (0,0,3),
         (0,0,4), (0,0,4), (0,0,4), (0,0,4),
         (0,0,5), (0,0,5), (0,0,5), (0,0,5), (0,0,5)])

  # test the various possible selections with multiplicity from 1 to 6
  sel = minimum_multiplicity_selection(hkl, 1)
  assert sel.count(True) == len(hkl)

  sel = minimum_multiplicity_selection(hkl, 2)
  assert (sel == flex.bool([False,] + [True] * 14)).all_eq(True)

  sel = minimum_multiplicity_selection(hkl, 3)
  assert (sel == flex.bool([False] * 3 + [True] * 12)).all_eq(True)

  sel = minimum_multiplicity_selection(hkl, 4)
  assert (sel == flex.bool([False] * 6 + [True] * 9)).all_eq(True)

  sel = minimum_multiplicity_selection(hkl, 5)
  assert (sel == flex.bool([False] * 10 + [True] * 5)).all_eq(True)

  sel = minimum_multiplicity_selection(hkl, 6)
  assert sel.count(False) == len(hkl)

  print "OK"
예제 #49
0
def read_x(xfile, take_full=False):
    """
    according to http://www.hkl-xray.com/denzo-output

Regular (film output file, Denzo _ip) imaging plate output format (i.e. the format you would you to read in in FORTRAN) is:

format (3i4,i2,2f8.0,f7.0,f6.0,f6.0,2f7.0,f6.0,f8.0)
h,k,l
Flag 0 - full 1 - partial
Intensity (F**2) by profile fitting
s of intensity (F**2)
c2 of profile fitting
Intensity (F**2) by profile summation
Cosine of incidence angle at detector
Predicted pixel position of spot centroid (slow, fast) directions
Lorentz, polarization, obliquity combined factor
Strength of averaged profile in arbitrary units
    """

    lines = open(xfile).readlines()

    indices = flex.miller_index()
    data = flex.double()
    sigmas = flex.double()
    full_flags = flex.bool()
    cell, sg_str = None, None

    read_hkl = True

    for l in lines[5:]:
        if l.startswith(" 999") and len(l.split()) == 3:
            read_hkl = False

        if read_hkl:
            hkl = map(int, (l[0:4], l[4:8], l[8:12]))
            ispart = int(l[13])
            iobs, sigma = map(float, (l[14:22], l[22:30]))

            indices.append(hkl)
            data.append(iobs)
            sigmas.append(sigma)
            full_flags.append(ispart==0)
        else:
            if l.startswith("unit cell"):
                cell = map(float, l.split()[2:])
            elif l.startswith("space group"):
                sg_str = l.split()[-1]

    #sg_str="p1"
    symm = crystal.symmetry(unit_cell=cell, space_group=sg_str)

    array = miller.array(miller_set=miller.set(crystal_symmetry=symm,
                                               indices=indices,
                                               anomalous_flag=True),
                         data=data, sigmas=sigmas).set_observation_type_xray_intensity()

    if take_full:
        array = array.select(full_flags)

    return array
예제 #50
0
def exercise(prefix="tst_models_to_from_chains"):
  # inputs
  expected_n = 5
  xrs = iotbx.pdb.input(source_info=None, lines=pdb_str).xray_structure_simple()
  input_file_name = "%s.pdb"%prefix
  of = open(input_file_name,"w")
  print >> of, pdb_str
  of.close()
  mi = flex.miller_index(((0,0,1), ))
  ms = miller.set(xrs.crystal_symmetry(), mi,  anomalous_flag=False)
  complete_set = ms.complete_set(d_min=3)
  fc = complete_set.structure_factors_from_scatterers(
    xray_structure=xrs).f_calc()
  # models -> chains
  easy_run.call("phenix.models_as_chains %s"%input_file_name)
  pdb_inp = iotbx.pdb.input(file_name="chains_"+input_file_name)
  h = pdb_inp.construct_hierarchy()
  assert len(list(h.chains()))==expected_n
  assert len(list(h.models()))==1
  xrs_c = pdb_inp.xray_structure_simple()
  fc_c = complete_set.structure_factors_from_scatterers(
    xray_structure=xrs_c).f_calc()
  #
  easy_run.call("phenix.chains_as_models chains_%s"%input_file_name)
  pdb_inp = iotbx.pdb.input(file_name="models_chains_"+input_file_name)
  h = pdb_inp.construct_hierarchy()
  assert len(list(h.chains()))==expected_n
  assert len(list(h.models()))==expected_n
  xrs_m = pdb_inp.xray_structure_simple()
  fc_m = complete_set.structure_factors_from_scatterers(
    xray_structure=xrs_m).f_calc()
  #
  assert approx_equal(0, r(fc, fc_c)  )
  assert approx_equal(0, r(fc, fc_m)  )
  assert approx_equal(0, r(fc_c, fc_m))
예제 #51
0
    def __init__(self, data, lattice_id, resort=False, verbose=True):
        self.verbose = verbose
        ######  INPUTS #######
        #       data = miller array: ASU miller index & intensity
        #       lattice_id = flex double: assignment of each miller index to a lattice number
        ######################

        if resort:
            order = flex.sort_permutation(lattice_id.data())
            sorted_lattice_id = flex.select(lattice_id.data(), order)
            sorted_data = data.data().select(order)
            sorted_indices = data.indices().select(order)
            self.lattice_id = sorted_lattice_id
            self.data = data.customized_copy(indices=sorted_indices,
                                             data=sorted_data)
        else:
            self.lattice_id = lattice_id.data()  # type flex int
            self.data = data  # type miller array with flex double data
        assert type(self.data.indices()) == type(flex.miller_index())
        assert type(self.data.data()) == type(flex.double())

        # construct a lookup for the separate lattices
        last_id = -1
        self.lattices = flex.int()
        for n in xrange(len(self.lattice_id)):
            if self.lattice_id[n] != last_id:
                last_id = self.lattice_id[n]
                self.lattices.append(n)
예제 #52
0
    def as_mtz(self,scale_factor,prefix):
    #This reads in an hkl map and returns a .mtz map
        #Read in hkl file and populate miller array
        inf = open(self.diffuse_file, 'r')
        indices = flex.miller_index()
        i_obs = flex.double()
        sig_i = flex.double()
        for line in inf.readlines():
            assert len(line.split())==4
            line = line.strip().split()
            #####ATTENTION:SCALE FACTOR##############
            i_obs_ = float(line[3])/scale_factor #is a uniform scale factor meant to re-size all diffuse intensities (normally too large for scalepack)
            sig_i_ = math.sqrt(i_obs_) 
            #if(abs(i_obs_)>1.e-6): # perhaps you don't want zeros
            indices.append([int(line[0]),int(line[1]),int(line[2])])
            i_obs.append(i_obs_)
            sig_i.append(sig_i_)
        inf.close()

      # get miller array object
        cs = self.symmetry
        ma = miller.array(miller_set=miller.set(cs, indices), data=i_obs, sigmas=sig_i)
        ma.set_observation_type_xray_intensity()
        mtz_dataset = ma.as_mtz_dataset(column_root_label="I")
        mtz_dataset.mtz_object().write(prefix + '.mtz')
예제 #53
0
def as_miller_array(gsas_exp, gsas_rfl, divide_pr, phase_id=1, histogram_id=1):
    from cctbx import miller
    from cctbx import crystal
    from cctbx.array_family import flex
    from scitbx.python_utils import easy_pickle
    info = gsas_exp.DESCR
    if (divide_pr):
        info += ", FIPS partitioning"
    indices = flex.miller_index()
    data = flex.double()
    if (not divide_pr):
        sigmas = flex.double()
        for r in gsas_rfl.records:
            indices.append(r.ihkl)
            data.append(r.fosq)
            sigmas.append(r.sig)
    else:
        sigmas = None
        for r in divide_pr.records:
            indices.append(r.hkl)
            data.append(r.fnew**2)
    miller_array = miller.array(
        miller_set=miller.set(crystal_symmetry=crystal.symmetry(
            unit_cell=gsas_exp.get_unit_cell_parameters(phase_id),
            space_group_symbol=gsas_exp.get_space_group_symbol(phase_id)),
                              indices=indices,
                              anomalous_flag=00000),
        data=data,
        sigmas=sigmas).set_info(info).set_observation_type_xray_intensity()
    miller_array.show_comprehensive_summary()
    print "Writing file: miller_array.pickle"
    easy_pickle.dump("miller_array.pickle", miller_array)
예제 #54
0
파일: sf_times.py 프로젝트: whhxp/fable
def compare_with_cctbx_structure_factors(n_scatt, n_refl, output_lines):
    from cctbx import xray
    from cctbx import miller
    from cctbx import crystal
    from cctbx.array_family import flex
    crystal_symmetry = crystal.symmetry(unit_cell=(11, 12, 13, 90, 90, 90),
                                        space_group_symbol="P1")
    scatterers = flex.xray_scatterer()
    miller_indices = flex.miller_index()
    f_calc = flex.complex_double()
    for line in output_lines:
        flds = line.split()
        assert len(flds) in [4, 5]
        if (len(flds) == 4):
            x, y, z, b_iso = [float(s) for s in flds]
            scatterers.append(
                xray.scatterer(site=(x, y, z),
                               b=b_iso,
                               scattering_type="const"))
        else:
            miller_indices.append([int(s) for s in flds[:3]])
            f_calc.append(complex(float(flds[3]), float(flds[4])))
    assert scatterers.size() == n_scatt
    assert miller_indices.size() == n_refl
    xs = xray.structure(crystal_symmetry=crystal_symmetry,
                        scatterers=scatterers)
    fc = miller_array = miller.set(crystal_symmetry=crystal_symmetry,
                                   indices=miller_indices,
                                   anomalous_flag=False).array(data=f_calc)
    fc2 = fc.structure_factors_from_scatterers(xray_structure=xs,
                                               algorithm="direct",
                                               cos_sin_table=False).f_calc()
    for f1, f2 in zip(fc.data(), fc2.data()):
        assert approx_equal(f1, f2, eps=1e-5)
예제 #55
0
def tst_pgtools():
  unit_cell = uctbx.unit_cell('40, 40, 60, 90.0, 90.0, 90.0')
  mi = flex.miller_index(((2,4,6), (2,4,8)))
  xs = crystal.symmetry(unit_cell, "P 1 2 1")
  ms = miller.set(xs, mi)

  # Go to the minimum cell, for safety
  cob_min_cell = ms.change_of_basis_op_to_minimum_cell()

  ms_new = ms.change_basis( cob_min_cell )

  lattice_group = sgtbx.lattice_symmetry.group(
    ms_new.unit_cell(),
    max_delta=5.0)

  point_group_low = ms_new.space_group().build_derived_point_group()
  point_group_high = lattice_group.build_derived_point_group()

  pgtree = pt.point_group_graph(point_group_low,point_group_high)

  # find the possible routes from 'P 2' to 'P 4 2 2'
  atlas = pgtree.graph.find_all_paths( 'P 1 2 1', 'P 4 2 2')
  route_1 = ['P 1 2 1', 'P 4 2 2']
  route_2 = ['P 1 2 1', 'P 2 2 2', 'P 4 2 2']
  assert route_1 in atlas
  assert route_2 in atlas
  assert len(atlas)==2

  # Now lets 'disqualify' point group 'P 2 2 2'
  pgtree.remove_point_group_and_its_super_groups_from_graph(
    str(sgtbx.space_group_info(16)))
  assert len(pgtree.graph.node_objects)==1
  assert pgtree.graph.node_objects.has_key ( 'P 1 2 1' )
예제 #56
0
파일: DeltaCcHalf.py 프로젝트: isikhar/xia2
    def _compute_delta_ccs(self):
        delta_cc = flex.double()
        for (group_start, group_end), test_k in zip(self._group_to_batches,
                                                    self._group_to_dataset_id):
            batches = self.batches[test_k].data()
            group_sel = (batches >= group_start) & (batches <= group_end)
            indices_i = flex.miller_index()
            data_i = flex.double()
            sigmas_i = flex.double()
            for k, unmerged in enumerate(self.intensities):
                if k == test_k:
                    unmerged = unmerged.select(~group_sel)
                indices_i.extend(unmerged.indices())
                data_i.extend(unmerged.data())
                sigmas_i.extend(unmerged.sigmas())

            unmerged_i = self.intensities[0].customized_copy(indices=indices_i,
                                                             data=data_i,
                                                             sigmas=sigmas_i)

            delta_cc.append(self._compute_delta_cc_for_dataset(unmerged_i))
            logger.debug(
                u"Delta CC½ excluding batches %i-%i: %.3f",
                group_start,
                group_end,
                delta_cc[-1],
            )
        return delta_cc
예제 #57
0
def exercise_systematic(verbose):
  from cctbx import miller
  from cctbx import crystal
  from cctbx.array_family import flex
  cs = crystal.symmetry(
    unit_cell=(13,15,14,90,90,100),
    space_group_symbol="P112")
  ms = miller.set(
    crystal_symmetry=cs,
    indices=flex.miller_index([
      (0,0,1),(0,0,-1),
      (0,1,1),
      (1,0,0),
      (-1,-1,-1)]),
    anomalous_flag=True).map_to_asu()
  cf = ms.centric_flags().data()
  assert cf.count(True) == 1
  mt = flex.mersenne_twister(seed=0)
  ma = ms.array(
    data=mt.random_double(size=5)+0.1,
    sigmas=mt.random_double(size=5)+0.1)
  def recycle(expected_column_data):
    mtz_obj = ma.as_mtz_dataset(column_root_label="X").mtz_object()
    sio = StringIO()
    mtz_obj.show_column_data_human_readable(out=sio)
    from libtbx.test_utils import show_diff
    if (verbose): sys.stdout.write(sio.getvalue())
    assert not show_diff(sio.getvalue(), expected_column_data)
    ma_2 = only_element(mtz_obj.as_miller_arrays())
    assert_equal_data_and_sigmas(ma, ma_2)
  recycle("""\
Column data:
-------------------------------------------------------------------------------
                    X(+)         SIGX(+)            X(-)         SIGX(-)

 0  0  1        0.517022        0.192339        0.820324         0.28626
 0  1  1        0.100114        0.445561            None            None
 1  0  0        0.402333        0.496767            None            None
 1  1  1            None            None        0.246756        0.638817
-------------------------------------------------------------------------------
""")
  from cctbx.xray import observation_types
  ma.set_observation_type(observation_types.reconstructed_amplitude())
  recycle("""\
Column data:
-------------------------------------------------------------------------------
                       X            SIGX           DANOX        SIGDANOX
                   ISYMX

 0  0  1        0.668673        0.172438       -0.303302        0.344875
                       0
 0  1  1        0.100114        0.445561            None            None
                       1
 1  0  0        0.402333        0.496767            None            None
                       0
 1  1  1        0.246756        0.638817            None            None
                       2
-------------------------------------------------------------------------------
""")
예제 #58
0
def dummy_miller_set(crystal_symmetry, log_n_reflections):
  indices = flex.miller_index(((1,2,3),))
  for i in xrange(log_n_reflections):
    indices.append(indices)
  return miller.set(
    crystal_symmetry=crystal_symmetry,
    indices=indices,
    anomalous_flag=False)
예제 #59
0
def exercise_flex_miller_index():
  from scitbx.array_family.flex import exercise_triple
  exercise_triple(flex_triple=flex.miller_index, flex_order=flex.order)
  a = flex.miller_index([(1,2,3), (2,3,4)])
  assert approx_equal(a.as_vec3_double(), [(1,2,3), (2,3,4)])
  h, k, l = [flex.int((0,1,2,3)),
             flex.int((1,2,3,4)),
             flex.int((2,3,4,5))]
  b = flex.miller_index(h, k, l)
  assert approx_equal(b, ((0,1,2),(1,2,3),(2,3,4),(3,4,5)))
  #
  i = flex.miller_index([(1,-2,3), (-2,3,4)])
  c = flex.complex_double([3-4j, -7+8j])
  x = (0.9284, -1.2845, -0.2293)
  assert approx_equal(
    i.fourier_transform_real_part_at_x(fourier_coeffs=c, x=x),
    15.4357188164)