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 range(m.size()):
a.append(random.random())
p.append(random.random() * 2)
c.append([random.random() for j in range(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 range(4):
assert abs(c_asym[j] - c_random[i][j]) < 1.e-5
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
def get_val_at_hkl(hkl, val_map):
poss_equivs = [i.h() for i in
miller.sym_equiv_indices(sg96, hkl).indices()]
for hkl2 in poss_equivs:
if hkl2 in val_map: # fast lookup
break
return hkl2, val_map[hkl2]
def get_neg_equiv(hkl):
poss_equivs = [
i.h() for i in miller.sym_equiv_indices(sg96, neg_hkl(hkl)).indices()
]
for hkl2 in poss_equivs:
if hkl2 in HA_val_map: # fast lookup
break
return hkl2
def expand_indices(space_group, asu_indices):
result = {}
for hkl in asu_indices:
equiv = miller.sym_equiv_indices(space_group, hkl).indices()
for h_e in equiv:
h_s = h_e.h()
assert h_s == h_e.hr()
assert not result.has_key(h_s)
result[h_s] = 0
return flex.miller_index(result.keys())
def verify(crystal_symmetry, anomalous_flag, reflection_file):
assert reflection_file.anomalous == anomalous_flag
cns_m = reflection_file.reciprocal_space_objects["CNS_M"]
cns_e = reflection_file.reciprocal_space_objects["CNS_E"]
cns_c = reflection_file.reciprocal_space_objects["CNS_C"]
cns_a = reflection_file.reciprocal_space_objects["CNS_A"]
cns_p = reflection_file.reciprocal_space_objects["CNS_P"]
for cns_x in (cns_e, cns_c, cns_a, cns_p):
assert cns_x.indices.id() == cns_m.indices.id()
space_group = crystal_symmetry.space_group()
for i, h in enumerate(cns_m.indices):
m_i = cns_m.data[i]
e_i = cns_e.data[i]
c_i = cns_c.data[i]
a_i = cns_a.data[i]
p_i = cns_p.data[i]
if (p_i < 0 and p_i != -1.): p_i += 180.
assert (c_i == 0) == (a_i != 0)
assert (c_i == 0 and p_i == -1.) or (c_i != 0 and p_i != -1.), \
'c_i = %d, p_i = %g' % (c_i, p_i)
m = space_group.multiplicity(h, anomalous_flag)
e = space_group.epsilon(h)
c = space_group.is_centric(h)
p = space_group.phase_restriction(h).ht_angle(True)
if (c or anomalous_flag):
assert e == space_group.order_p() // m
else:
assert e == (2 * space_group.order_p()) // m
try:
assert m_i == m, 'multiplicity mismatch'
assert e_i == e, 'epsilon mismatch'
assert c_i == c, 'centric mismatch'
assert p_i == p, 'restricted phase mismatch'
except AssertionError, exc:
print crystal_symmetry.space_group_info()
print 'index=', h
print 'm:', m_i, m
print 'e:', e_i, e
print 'c:', c_i, c
print 'p:', p_i, p
raise AssertionError, exc
assert (not space_group.is_sys_absent(h))
assert (e == space_group.order_p() //
space_group.multiplicity(h, True))
eq = miller.sym_equiv_indices(space_group, h)
assert (eq.multiplicity(anomalous_flag) == m)
assert (eq.epsilon() == e)
assert (eq.is_centric() == c)
assert (eq.phase_restriction().ht_angle(True) == p)
def verify(crystal_symmetry, anomalous_flag, reflection_file):
assert reflection_file.anomalous == anomalous_flag
cns_m = reflection_file.reciprocal_space_objects["CNS_M"]
cns_e = reflection_file.reciprocal_space_objects["CNS_E"]
cns_c = reflection_file.reciprocal_space_objects["CNS_C"]
cns_a = reflection_file.reciprocal_space_objects["CNS_A"]
cns_p = reflection_file.reciprocal_space_objects["CNS_P"]
for cns_x in (cns_e, cns_c, cns_a, cns_p):
assert cns_x.indices.id() == cns_m.indices.id()
space_group = crystal_symmetry.space_group()
for i,h in enumerate(cns_m.indices):
m_i = cns_m.data[i]
e_i = cns_e.data[i]
c_i = cns_c.data[i]
a_i = cns_a.data[i]
p_i = cns_p.data[i]
if (p_i < 0 and p_i != -1.): p_i += 180.
assert (c_i == 0) == (a_i != 0)
assert (c_i == 0 and p_i == -1.) or (c_i != 0 and p_i != -1.), \
'c_i = %d, p_i = %g' % (c_i, p_i)
m = space_group.multiplicity(h, anomalous_flag)
e = space_group.epsilon(h)
c = space_group.is_centric(h)
p = space_group.phase_restriction(h).ht_angle(True)
if (c or anomalous_flag):
assert e == space_group.order_p() // m
else:
assert e == (2 * space_group.order_p()) // m
try:
assert m_i == m, 'multiplicity mismatch'
assert e_i == e, 'epsilon mismatch'
assert c_i == c, 'centric mismatch'
assert p_i == p, 'restricted phase mismatch'
except AssertionError, exc:
print crystal_symmetry.space_group_info()
print 'index=', h
print 'm:', m_i, m
print 'e:', e_i, e
print 'c:', c_i, c
print 'p:', p_i, p
raise AssertionError, exc
assert (not space_group.is_sys_absent(h))
assert (e == space_group.order_p() // space_group.multiplicity(h, True))
eq = miller.sym_equiv_indices(space_group, h)
assert (eq.multiplicity(anomalous_flag) == m)
assert (eq.epsilon() == e)
assert (eq.is_centric() == c)
assert (eq.phase_restriction().ht_angle(True) == p)
def get_val_at_hkl(hkl, val_map):
poss_equivs = [i.h() for i in
miller.sym_equiv_indices(sg96, hkl).indices()]
in_map=False
for hkl2 in poss_equivs:
if hkl2 in val_map: # fast lookup
in_map=True
break
if in_map:
return hkl2, val_map[hkl2]
else:
return (None,None,None),-1
def get_all_incides(space_group, abs_range):
result = {}
for h0 in xrange(-abs_range,abs_range+1):
for h1 in xrange(-abs_range,abs_range+1):
for h2 in xrange(-abs_range,abs_range+1):
h = (h0, h1, h2)
if (h == (0,0,0)): continue
equiv = miller.sym_equiv_indices(space_group, h).indices()
for h_e in equiv:
h_s = h_e.h()
assert h_s == h_e.hr()
result[h_s] = 0
return flex.miller_index(result.keys())
def get_all_incides(space_group, abs_range):
result = {}
for h0 in xrange(-abs_range, abs_range + 1):
for h1 in xrange(-abs_range, abs_range + 1):
for h2 in xrange(-abs_range, abs_range + 1):
h = (h0, h1, h2)
if (h == (0, 0, 0)): continue
equiv = miller.sym_equiv_indices(space_group, h).indices()
for h_e in equiv:
h_s = h_e.h()
assert h_s == h_e.hr()
result[h_s] = 0
return flex.miller_index(result.keys())
def _make_p1_equiv_mapping(self):
self.num_equivs_for_i_fcell = {}
self.update_indices = []
for i_fcell in range(self.n_global_fcell):
hkl_asu = self.asu_from_idx[i_fcell]
equivs = [
i.h() for i in miller.sym_equiv_indices(
self.space_group, hkl_asu).indices()
]
self.num_equivs_for_i_fcell[i_fcell] = len(equivs)
self.update_indices += equivs
self.update_indices = flex.miller_index(self.update_indices)
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_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 __init__(self, unmerged_intensities):
self._intensities_original_index = unmerged_intensities
self._observations = {}
from cctbx import miller, sgtbx
sg = self._intensities_original_index.space_group()
sg_type = sg.type()
asu = sgtbx.reciprocal_space_asu(sg_type)
anomalous_flag = self._intensities_original_index.anomalous_flag()
ma = self._intensities_original_index
original_indices = ma.indices()
unique_indices = original_indices.deep_copy()
isym = flex.int(unique_indices.size())
miller.map_to_asu_isym(sg_type, anomalous_flag, unique_indices, isym)
n_plus, n_minus = 0, 0
for iref in range(len(original_indices)):
h_orig = original_indices[iref]
h_uniq = unique_indices[iref]
h_isym = isym[iref]
h_eq = miller.sym_equiv_indices(sg, h_uniq)
if h_eq.is_centric():
flag = observation_group.CENTRIC
else:
asu_which = asu.which(h_uniq)
assert asu_which != 0
if asu_which == 1:
flag = observation_group.PLUS
else:
flag = observation_group.MINUS
h_uniq = tuple(-1*h for h in h_uniq)
group = self._observations.get(h_uniq)
if group is None:
group = observation_group(
h_uniq, is_centric=(flag == observation_group.CENTRIC))
self._observations[h_uniq] = group
if flag == observation_group.MINUS:
n_minus += 1
group.add_iminus(iref)
else:
n_plus += 1
group.add_iplus(iref)
def __init__(self, unmerged_intensities):
self._intensities_original_index = unmerged_intensities
self._observations = {}
from cctbx import miller, sgtbx
sg = self._intensities_original_index.space_group()
sg_type = sg.type()
asu = sgtbx.reciprocal_space_asu(sg_type)
anomalous_flag = self._intensities_original_index.anomalous_flag()
ma = self._intensities_original_index
original_indices = ma.indices()
unique_indices = original_indices.deep_copy()
isym = flex.int(unique_indices.size())
miller.map_to_asu_isym(sg_type, anomalous_flag, unique_indices, isym)
n_plus, n_minus = 0, 0
for iref in range(len(original_indices)):
h_orig = original_indices[iref]
h_uniq = unique_indices[iref]
h_isym = isym[iref]
h_eq = miller.sym_equiv_indices(sg, h_uniq)
if h_eq.is_centric():
flag = observation_group.CENTRIC
else:
asu_which = asu.which(h_uniq)
assert asu_which != 0
if asu_which == 1:
flag = observation_group.PLUS
else:
flag = observation_group.MINUS
h_uniq = tuple(-1*h for h in h_uniq)
group = self._observations.get(h_uniq)
if group is None:
group = observation_group(
h_uniq, is_centric=(flag == observation_group.CENTRIC))
self._observations[h_uniq] = group
if flag == observation_group.MINUS:
n_minus += 1
group.add_iminus(iref)
else:
n_plus += 1
group.add_iplus(iref)
def get_sym_equiv_angles(phase_settings, phase_data):
sg = phase_settings['structure'].space_group()
hkl = phase_settings['pref_orient_hkl']
uc_rec = phase_settings['unit_cell'].reciprocal()
angles = []
for index in phase_data['f_miller_indices']:
sei = sym_equiv_indices(sg, map(int, list(index)))
index_angles = []
for sym_equiv_index in sei.indices():
index_angles.append(
uc_rec.angle(hkl, (0, 0, 0), sym_equiv_index.h()))
angles.append(np.array(index_angles))
phase_data['md_cos_factors'] = [
np.cos(np.pi / 180 * sym_equiv_angles)**2
for sym_equiv_angles in angles
]
return angles
def get_val_at_hkl(hkl, val_map, sg=sgtbx.space_group(" P 4nw 2abw")):
"""
given a miller index, find its value in the miller dictionary array (val_map)
:param hkl: tuple
:param val_map: miller data dictionary
:param sg: space group
:return: miller value
"""
poss_equivs = [i.h() for i in miller.sym_equiv_indices(sg, hkl).indices()]
in_map = False
for hkl2 in poss_equivs:
if hkl2 in val_map: # fast lookup
in_map = True
break
if in_map:
return hkl2, val_map[hkl2]
else:
return (None, None, None), None
def exercise_index_generator():
uc = uctbx.unit_cell((11, 11, 13, 90, 90, 120))
sg_type = sgtbx.space_group_type("P 3 1 2")
for anomalous_flag in (False, True):
mig = miller.index_generator(uc, sg_type, anomalous_flag, 8)
assert mig.unit_cell().is_similar_to(uc)
assert mig.space_group_type().group() == sg_type.group()
assert mig.anomalous_flag() == anomalous_flag
assert mig.asu().reference_as_string(
) == "h>=k and k>=0 and (k>0 or l>=0)"
assert mig.next() == (0, 0, 1)
if (not anomalous_flag):
assert tuple(mig.to_array()) == ((1, 0, 0), )
else:
assert tuple(mig.to_array()) == ((1, 0, 0), (-1, 0, 0))
assert tuple(miller.index_generator(uc, sg_type, False, 8)) \
== ((0,0,1), (1, 0, 0))
index_abs_range = (4, 4, 4)
for sg_symbol in ("P 31 1 2", "P 31 2 1"):
sg_type = sgtbx.space_group_type(sg_symbol)
for anomalous_flag in (False, True):
miller_indices = miller.index_generator(sg_type, anomalous_flag,
index_abs_range)
miller_dict = {}
for h in miller_indices:
miller_dict[h] = 0
sg = sg_type.group()
h = [0, 0, 0]
for h[0] in range(-index_abs_range[0], index_abs_range[0] + 1):
for h[1] in range(-index_abs_range[1], index_abs_range[1] + 1):
for h[2] in range(-index_abs_range[2],
index_abs_range[2] + 1):
if (sg.is_sys_absent(h) or h == [0, 0, 0]): continue
h_eq = miller.sym_equiv_indices(sg, h)
found_h_asu = 0
for i_eq in xrange(h_eq.multiplicity(anomalous_flag)):
h_i = h_eq(i_eq).h()
if (h_i in miller_dict):
assert found_h_asu == 0
found_h_asu = 1
assert found_h_asu != 0
def exercise_index_generator():
uc = uctbx.unit_cell((11,11,13,90,90,120))
sg_type = sgtbx.space_group_type("P 3 1 2")
for anomalous_flag in (False,True):
mig = miller.index_generator(uc, sg_type, anomalous_flag, 8)
assert mig.unit_cell().is_similar_to(uc)
assert mig.space_group_type().group() == sg_type.group()
assert mig.anomalous_flag() == anomalous_flag
assert mig.asu().reference_as_string() == "h>=k and k>=0 and (k>0 or l>=0)"
assert mig.next() == (0,0,1)
if (not anomalous_flag):
assert tuple(mig.to_array()) == ((1, 0, 0),)
else:
assert tuple(mig.to_array()) == ((1, 0, 0), (-1, 0, 0))
assert tuple(miller.index_generator(uc, sg_type, False, 8)) \
== ((0,0,1), (1, 0, 0))
index_abs_range = (4,4,4)
for sg_symbol in ("P 31 1 2", "P 31 2 1"):
sg_type = sgtbx.space_group_type(sg_symbol)
for anomalous_flag in (False,True):
miller_indices = miller.index_generator(
sg_type, anomalous_flag, index_abs_range)
miller_dict = {}
for h in miller_indices: miller_dict[h] = 0
sg = sg_type.group()
h = [0,0,0]
for h[0] in range(-index_abs_range[0], index_abs_range[0]+1):
for h[1] in range(-index_abs_range[1], index_abs_range[1]+1):
for h[2] in range(-index_abs_range[2], index_abs_range[2]+1):
if (sg.is_sys_absent(h) or h == [0,0,0]): continue
h_eq = miller.sym_equiv_indices(sg, h)
found_h_asu = 0
for i_eq in xrange(h_eq.multiplicity(anomalous_flag)):
h_i = h_eq(i_eq).h()
if (h_i in miller_dict):
assert found_h_asu == 0
found_h_asu = 1
assert found_h_asu != 0
import common
from cctbx import miller
from cctbx import crystal
from cctbx import sgtbx
from pprint import pprint
ms = miller.build_set(
crystal_symmetry=crystal.symmetry(
space_group_symbol="P212121",
unit_cell=(6, 6, 6, 90, 90, 90)),
anomalous_flag=False,
d_min=3.0)
print ms.size()
s = sgtbx.space_group("P 31")
h = (10, 10, 10)
e = miller.sym_equiv_indices(s,h)
#pprint(list(e.indices()))
pprint(dir(e))
print e.indices()
def exercise_sym_equiv():
s = sgtbx.space_group("P 31")
e = miller.sym_equiv_indices(s, (0,0,0))
assert len(e.indices()) == 1
assert e.is_centric()
h = (3,5,2)
e = miller.sym_equiv_indices(s, h)
i = e.indices()
assert len(i) == 3
assert i[0].h() == h
assert i[0].hr() == h
assert i[0].ht() == 0
assert i[0].t_den() == s.t_den()
assert i[0].ht_angle() == 0
assert i[0].ht_angle(False) == 0
assert i[0].ht_angle(True) == 0
assert not i[0].friedel_flag()
m = i[0].mate()
assert m.h() == tuple([-x for x in h])
assert m.friedel_flag()
m = i[0].mate(1)
assert m.h() == tuple([-x for x in h])
assert m.friedel_flag()
m = i[0].mate(0)
assert m.h() == h
assert not m.friedel_flag()
for i_mate in (0,1):
m = i[1].mate(i_mate)
assert m.ht() == 8
assert m.friedel_flag() == (i_mate != 0)
assert approx_equal(m.phase_in(m.phase_eq(30)), 30)
assert approx_equal(m.phase_in(m.phase_eq(30, False), False), 30)
assert approx_equal(m.phase_in(m.phase_eq(30, True), True), 30)
assert approx_equal(m.phase_eq(30*math.pi/180),
m.phase_eq(30, True)*math.pi/180)
c = m.complex_in(m.complex_eq(1+2j))
assert approx_equal(c.real, 1)
assert approx_equal(c.imag, 2)
h = m.hendrickson_lattman_in(m.hendrickson_lattman_eq((1,2,3,4)))
for j in xrange(4):
assert approx_equal(h[j], j+1)
r = e.phase_restriction()
assert not r.sys_abs_was_tested()
assert r.ht() < 0
assert not e.is_centric()
assert e.multiplicity(False) == 6
assert e.multiplicity(True) == 3
assert e.f_mates(False) == 2
assert e.f_mates(True) == 1
assert e.epsilon() == 1
for j in xrange(e.multiplicity(False)):
if (j < e.multiplicity(True)):
assert e(j).h() == e.indices()[j].h()
else:
assert e(j).friedel_flag()
assert e.is_valid_phase(10)
assert e.is_valid_phase(10, False)
assert e.is_valid_phase(10, True)
assert e.is_valid_phase(10, True, 1.e-5)
for anomalous_flag in (False,True):
j = e.p1_listing(anomalous_flag)
assert len(j) == len(i)
s = sgtbx.space_group("P 41")
h = (3,5,0)
e = miller.sym_equiv_indices(s, h)
i = e.indices()
assert e.is_centric()
assert e.multiplicity(False) == 4
assert e.multiplicity(True) == 4
assert e.f_mates(False) == 1
assert e.f_mates(True) == 1
r = e.phase_restriction()
assert r.ht() == 0
j = e.p1_listing(False)
assert len(j) == len(i)//2
def exercise(space_group_info, anomalous_flag,
n_scatterers=8, d_min=2, verbose=0):
structure = random_structure.xray_structure(
space_group_info,
elements=["const"]*n_scatterers)
f_calc = structure.structure_factors(
d_min=d_min, anomalous_flag=anomalous_flag).f_calc()
f = abs(f_calc)
fs = miller.array(miller_set=f, data=f.data(), sigmas=flex.sqrt(f.data()))
assert fs.is_unique_set_under_symmetry()
for a in (f, fs):
for algorithm in ["gaussian", "shelx"]:
m = a.merge_equivalents(algorithm=algorithm)
m.show_summary(out=StringIO())
j = m.array().adopt_set(a)
assert flex.linear_correlation(
j.data(), a.data()).coefficient() > 1-1.e-6
if (a.sigmas() is not None):
assert flex.linear_correlation(
j.sigmas(), a.sigmas()).coefficient() > 1-1.e-6
redundancies = flex.size_t()
for i in xrange(fs.indices().size()):
redundancies.append(random.randrange(5)+1)
space_group = space_group_info.group()
r_indices = flex.miller_index()
r_data = flex.double()
r_sigmas = flex.double()
for i,n in enumerate(redundancies):
h = fs.indices()[i]
h_eq = miller.sym_equiv_indices(space_group, h).indices()
for j in xrange(n):
r_indices.append(h_eq[random.randrange(len(h_eq))].h())
r_data.append(fs.data()[i])
r_sigmas.append(fs.sigmas()[i])
r = miller.array(
miller_set=miller.set(
crystal_symmetry=fs,
indices=r_indices,
anomalous_flag=fs.anomalous_flag()),
data=r_data,
sigmas=r_sigmas)
assert not r.is_unique_set_under_symmetry()
noise = flex.random_double(size=r.indices().size())
r = r.sort(by_value=noise)
for algorithm in ["gaussian", "shelx"]:
m = r.merge_equivalents(algorithm=algorithm)
m.show_summary(out=StringIO())
j = m.array().adopt_set(fs)
assert j.is_unique_set_under_symmetry()
assert flex.linear_correlation(
j.data(), fs.data()).coefficient() > 1-1.e-6
fssr = fs.sigmas() / flex.sqrt(redundancies.as_double())
assert flex.linear_correlation(j.sigmas(), fssr).coefficient() > 1-1.e-6
#
if (anomalous_flag):
f_calc_ave = f_calc.average_bijvoet_mates() # uses merge_equivalents
f_calc_com = f_calc.as_non_anomalous_array().common_set(f_calc_ave)
assert f_calc_com.indices().all_eq(f_calc_ave.indices())
for part in [flex.real, flex.imag]:
assert flex.linear_correlation(
part(f_calc_com.data()),
part(f_calc_ave.data())).coefficient() > 1-1.e-6
# test use_internal_variance=False
m = r.merge_equivalents(algorithm="gaussian", use_internal_variance=False)
j = m.array().adopt_set(fs)
fssr = fs.sigmas() / flex.sqrt(redundancies.as_double())
assert flex.linear_correlation(j.sigmas(), fssr).coefficient() > 1-1.e-6
def exercise(space_group_info, anomalous_flag,
n_scatterers=8, d_min=2, verbose=0):
structure = random_structure.xray_structure(
space_group_info,
elements=["const"]*n_scatterers)
f_calc = structure.structure_factors(
d_min=d_min, anomalous_flag=anomalous_flag).f_calc()
f = abs(f_calc)
fs = miller.array(miller_set=f, data=f.data(), sigmas=flex.sqrt(f.data()))
assert fs.is_unique_set_under_symmetry()
for a in (f, fs):
for algorithm in ["gaussian", "shelx"]:
m = a.merge_equivalents(algorithm=algorithm)
m.show_summary(out=StringIO())
j = m.array().adopt_set(a)
assert flex.linear_correlation(
j.data(), a.data()).coefficient() > 1-1.e-6
if (a.sigmas() is not None):
assert flex.linear_correlation(
j.sigmas(), a.sigmas()).coefficient() > 1-1.e-6
redundancies = flex.size_t()
for i in range(fs.indices().size()):
redundancies.append(random.randrange(5)+1)
space_group = space_group_info.group()
r_indices = flex.miller_index()
r_data = flex.double()
r_sigmas = flex.double()
for i,n in enumerate(redundancies):
h = fs.indices()[i]
h_eq = miller.sym_equiv_indices(space_group, h).indices()
for j in range(n):
r_indices.append(h_eq[random.randrange(len(h_eq))].h())
r_data.append(fs.data()[i])
r_sigmas.append(fs.sigmas()[i])
r = miller.array(
miller_set=miller.set(
crystal_symmetry=fs,
indices=r_indices,
anomalous_flag=fs.anomalous_flag()),
data=r_data,
sigmas=r_sigmas)
assert not r.is_unique_set_under_symmetry()
noise = flex.random_double(size=r.indices().size())
r = r.sort(by_value=noise)
for algorithm in ["gaussian", "shelx"]:
m = r.merge_equivalents(algorithm=algorithm)
m.show_summary(out=StringIO())
j = m.array().adopt_set(fs)
assert j.is_unique_set_under_symmetry()
assert flex.linear_correlation(
j.data(), fs.data()).coefficient() > 1-1.e-6
fssr = fs.sigmas() / flex.sqrt(redundancies.as_double())
assert flex.linear_correlation(j.sigmas(), fssr).coefficient() > 1-1.e-6
#
if (anomalous_flag):
f_calc_ave = f_calc.average_bijvoet_mates() # uses merge_equivalents
f_calc_com = f_calc.as_non_anomalous_array().common_set(f_calc_ave)
assert f_calc_com.indices().all_eq(f_calc_ave.indices())
for part in [flex.real, flex.imag]:
assert flex.linear_correlation(
part(f_calc_com.data()),
part(f_calc_ave.data())).coefficient() > 1-1.e-6
# test use_internal_variance=False
m = r.merge_equivalents(algorithm="gaussian", use_internal_variance=False)
j = m.array().adopt_set(fs)
fssr = fs.sigmas() / flex.sqrt(redundancies.as_double())
assert flex.linear_correlation(j.sigmas(), fssr).coefficient() > 1-1.e-6
all_LA = np.hstack( all_LA)
all_LB = np.hstack( all_LB)
all_PA = np.hstack(all_PA)
all_PB = np.hstack(all_PB)
all_yobs = np.hstack( all_yobs)
print "Tuple-izing..."
all_hkl = tuple( all_hkl)
print "Tuple-izing..."
all_shotid = tuple( all_shotid)
print "Row mapping"
# always map to the same index for symm equivs
# just sort all equivs by h,k,l then return first sorted idx
Hequiv_map = { hkl:
sorted(
[h.h() for h in miller.sym_equiv_indices(sg96, hkl).indices()],
key=itemgetter(0,1,2)
)[0] # take the first item in sorted array of equivalents
for hkl in all_hkl}
unique_hkl = set(Hequiv_map.values())
Nhkl = len( unique_hkl)
# we need to map each gain and each Fhkl to
# a column index for the Jacobian!
rowmap_hkl = {hkl: i for i,hkl in enumerate(unique_hkl)}
# (NOTE: we have two unknown Fhkl per measurement, one per energy channel)
unique_shotid = set(all_shotid)
Ngain = len( unique_shotid)
rowmap_gain = {shotid: i for i,shotid in enumerate(unique_shotid)}
def exercise_sym_equiv():
s = sgtbx.space_group("P 31")
e = miller.sym_equiv_indices(s, (0,0,0))
assert len(e.indices()) == 1
assert e.is_centric()
h = (3,5,2)
e = miller.sym_equiv_indices(s, h)
i = e.indices()
assert len(i) == 3
assert i[0].h() == h
assert i[0].hr() == h
assert i[0].ht() == 0
assert i[0].t_den() == s.t_den()
assert i[0].ht_angle() == 0
assert i[0].ht_angle(False) == 0
assert i[0].ht_angle(True) == 0
assert not i[0].friedel_flag()
m = i[0].mate()
assert m.h() == tuple([-x for x in h])
assert m.friedel_flag()
m = i[0].mate(1)
assert m.h() == tuple([-x for x in h])
assert m.friedel_flag()
m = i[0].mate(0)
assert m.h() == h
assert not m.friedel_flag()
for i_mate in (0,1):
m = i[1].mate(i_mate)
assert m.ht() == 8
assert m.friedel_flag() == (i_mate != 0)
assert approx_equal(m.phase_in(m.phase_eq(30)), 30)
assert approx_equal(m.phase_in(m.phase_eq(30, False), False), 30)
assert approx_equal(m.phase_in(m.phase_eq(30, True), True), 30)
assert approx_equal(m.phase_eq(30*math.pi/180),
m.phase_eq(30, True)*math.pi/180)
c = m.complex_in(m.complex_eq(1+2j))
assert approx_equal(c.real, 1)
assert approx_equal(c.imag, 2)
h = m.hendrickson_lattman_in(m.hendrickson_lattman_eq((1,2,3,4)))
for j in range(4):
assert approx_equal(h[j], j+1)
r = e.phase_restriction()
assert not r.sys_abs_was_tested()
assert r.ht() < 0
assert not e.is_centric()
assert e.multiplicity(False) == 6
assert e.multiplicity(True) == 3
assert e.f_mates(False) == 2
assert e.f_mates(True) == 1
assert e.epsilon() == 1
for j in range(e.multiplicity(False)):
if (j < e.multiplicity(True)):
assert e(j).h() == e.indices()[j].h()
else:
assert e(j).friedel_flag()
assert e.is_valid_phase(10)
assert e.is_valid_phase(10, False)
assert e.is_valid_phase(10, True)
assert e.is_valid_phase(10, True, 1.e-5)
for anomalous_flag in (False,True):
j = e.p1_listing(anomalous_flag)
assert len(j) == len(i)
s = sgtbx.space_group("P 41")
h = (3,5,0)
e = miller.sym_equiv_indices(s, h)
i = e.indices()
assert e.is_centric()
assert e.multiplicity(False) == 4
assert e.multiplicity(True) == 4
assert e.f_mates(False) == 1
assert e.f_mates(True) == 1
r = e.phase_restriction()
assert r.ht() == 0
j = e.p1_listing(False)
assert len(j) == len(i)//2
