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 calculate_exp_i_two_phi_peaks(xray_structure, d_min,
min_peak_distance,
max_reduced_peaks):
f_h = xray_structure.structure_factors(
anomalous_flag=False,
d_min=d_min).f_calc()
two_i_phi_h = miller.array(
miller_set=f_h,
data=flex.polar(1, flex.arg(f_h.data())*2))
fft_map = two_i_phi_h.fft_map(
d_min=d_min,
symmetry_flags=maptbx.use_space_group_symmetry)
real_map = fft_map.real_map()
real_map = maptbx.copy(real_map, flex.grid(real_map.focus()))
stats = maptbx.statistics(real_map)
if (stats.max() != 0):
real_map /= abs(stats.max())
grid_tags = maptbx.grid_tags(real_map.focus())
grid_tags.build(fft_map.space_group_info().type(), fft_map.symmetry_flags())
grid_tags.verify(real_map)
peak_list = maptbx.peak_list(
data=real_map,
tags=grid_tags.tag_array(),
max_peaks=10*max_reduced_peaks,
interpolate=True)
reduced_peaks = peak_cluster_reduction(
crystal_symmetry=xray_structure,
peak_list=peak_list,
min_peak_distance=min_peak_distance,
max_reduced_peaks=max_reduced_peaks)
return reduced_peaks
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 exercise_core_LS(target_class, verbose):
n_refl = 10
f_calc = flex.polar(
flex.random_double(n_refl) * 10 - 5,
flex.random_double(n_refl) * 10 - 5)
f_obs = flex.abs(f_calc) + (flex.random_double(n_refl) * 2 - 1)
weights = flex.random_double(n_refl)
r = xray.targets_least_squares_residual(f_obs, weights, f_calc, True, 0)
scale_factor = r.scale_factor()
gr_ana = r.derivatives()
gr_fin = flex.complex_double()
eps = 1.e-6
for i_refl in xrange(n_refl):
gc = []
for i_part in [0, 1]:
fc0 = f_calc[i_refl]
ts = []
for signed_eps in [eps, -eps]:
if (i_part == 0):
f_calc[i_refl] = complex(fc0.real + signed_eps, fc0.imag)
else:
f_calc[i_refl] = complex(fc0.real, fc0.imag + signed_eps)
r = xray.targets_least_squares_residual(
f_obs, weights, f_calc, False, scale_factor)
ts.append(r.target())
f_calc[i_refl] = fc0
gc.append((ts[0] - ts[1]) / (2 * eps))
gr_fin.append(complex(*gc))
if (verbose):
print "ana:", list(gr_ana)
print "fin:", list(gr_fin)
assert approx_equal(gr_fin, gr_ana)
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 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 exercise_core_LS(target_class, verbose):
n_refl = 10
f_calc = flex.polar(
flex.random_double(n_refl)*10-5,
flex.random_double(n_refl)*10-5)
f_obs = flex.abs(f_calc) + (flex.random_double(n_refl)*2-1)
weights = flex.random_double(n_refl)
r = xray.targets_least_squares_residual(
f_obs, weights, f_calc, True, 0)
scale_factor = r.scale_factor()
gr_ana = r.derivatives()
gr_fin = flex.complex_double()
eps = 1.e-6
for i_refl in xrange(n_refl):
gc = []
for i_part in [0,1]:
fc0 = f_calc[i_refl]
ts = []
for signed_eps in [eps,-eps]:
if (i_part == 0):
f_calc[i_refl] = complex(fc0.real + signed_eps, fc0.imag)
else:
f_calc[i_refl] = complex(fc0.real, fc0.imag + signed_eps)
r = xray.targets_least_squares_residual(
f_obs, weights, f_calc, False, scale_factor)
ts.append(r.target())
f_calc[i_refl] = fc0
gc.append((ts[0]-ts[1])/(2*eps))
gr_fin.append(complex(*gc))
if (verbose):
print "ana:", list(gr_ana)
print "fin:", list(gr_fin)
assert approx_equal(gr_fin, gr_ana)
def exercise(space_group_info, n_scatterers=8, d_min=2, verbose=0, e_min=1.5):
structure = random_structure.xray_structure(
space_group_info,
elements=["const"] * n_scatterers,
volume_per_atom=200,
min_distance=3.0,
general_positions_only=True,
u_iso=0.0,
)
if 0 or verbose:
structure.show_summary().show_scatterers()
f_calc = structure.structure_factors(d_min=d_min, anomalous_flag=False).f_calc()
f_obs = abs(f_calc)
q_obs = miller.array(
miller_set=f_obs,
data=f_obs.data() / math.sqrt(f_obs.space_group().order_p() * n_scatterers) / f_obs.space_group().n_ltr(),
)
q_obs = q_obs.sort(by_value="abs")
q_obs.setup_binner(auto_binning=True)
n_obs = q_obs.quasi_normalize_structure_factors()
r = flex.linear_regression(q_obs.data(), n_obs.data())
if 0 or verbose:
r.show_summary()
assert r.is_well_defined()
assert abs(r.y_intercept()) < 0.1
assert abs(r.slope() - 1) < 0.2
q_large = q_obs.select(q_obs.quasi_normalized_as_normalized().data() > e_min)
if 0 or verbose:
print "Number of e-values > %.6g: %d" % (e_min, q_large.size())
other_structure = random_structure.xray_structure(
space_group_info,
elements=["const"] * n_scatterers,
volume_per_atom=200,
min_distance=3.0,
general_positions_only=True,
u_iso=0.0,
)
assert other_structure.unit_cell().is_similar_to(structure.unit_cell())
q_calc = q_large.structure_factors_from_scatterers(other_structure, algorithm="direct").f_calc()
start = q_large.phase_transfer(q_calc.data())
for selection_fixed in (None, flex.double([random.random() for i in xrange(start.size())]) < 0.4):
from_map_data = direct_space_squaring(start, selection_fixed)
direct_space_result = start.phase_transfer(phase_source=from_map_data)
new_phases = reciprocal_space_squaring(start, selection_fixed, verbose)
reciprocal_space_result = start.phase_transfer(phase_source=flex.polar(1, new_phases))
mwpe = direct_space_result.mean_weighted_phase_error(reciprocal_space_result)
if 0 or verbose:
print "mwpe: %.2f" % mwpe, start.space_group_info()
for i, h in enumerate(direct_space_result.indices()):
amp_d, phi_d = complex_math.abs_arg(direct_space_result.data()[i], deg=True)
amp_r, phi_r = complex_math.abs_arg(reciprocal_space_result.data()[i], deg=True)
phase_err = scitbx.math.phase_error(phi_d, phi_r, deg=True)
assert phase_err < 1.0 or abs(from_map_data[i]) < 1.0e-6
exercise_truncate(q_large)
def ft_dp(self, dp, u_extra):
multiplier = (self.unit_cell().volume() /
matrix.row(self.rfft().n_real()).product() *
self.space_group().order_z() /
dp.multiplicities().data().as_double())
coeff = dp.deep_copy()
xray.apply_u_extra(self.unit_cell(), u_extra, coeff.indices(),
coeff.data())
coeff_data = coeff.data()
coeff_data *= flex.polar(multiplier, 0)
return miller.fft_map(crystal_gridding=self.crystal_gridding(),
fourier_coefficients=coeff)
def exercise_basic():
a = flex.double((10, 20))
p = flex.double((-25, 355))
c = flex.polar(a, p, True)
f = flex.double((0.3, 0.9))
s = miller.set(crystal_symmetry=crystal.symmetry(unit_cell=(10, 10, 10, 90,
90, 90),
space_group_symbol="P1"),
indices=flex.miller_index([(1, 2, 3), (-3, 4, -6)]),
anomalous_flag=False)
out = StringIO()
s.array(data=c).as_phases_phs(out=out)
assert not show_diff(
out.getvalue(), """\
1 2 3 4999.99 1.00 -25.00
-3 4 -6 9999.99 1.00 -5.00
""")
out = StringIO()
s.array(data=c).as_phases_phs(out=out, scale_amplitudes=False)
assert not show_diff(
out.getvalue(), """\
1 2 3 10.00 1.00 -25.00
-3 4 -6 20.00 1.00 -5.00
""")
for phases in [s.array(data=p), p]:
out = StringIO()
s.array(data=c).amplitudes().as_phases_phs(out=out,
phases=phases,
phases_deg=True)
assert not show_diff(
out.getvalue(), """\
1 2 3 4999.99 1.00 -25.00
-3 4 -6 9999.99 1.00 355.00
""")
for phases in [s.array(data=p * (math.pi / 180)), p * (math.pi / 180)]:
out = StringIO()
s.array(data=c).amplitudes().as_phases_phs(out=out,
phases=phases,
phases_deg=False)
assert not show_diff(
out.getvalue(), """\
1 2 3 4999.99 1.00 -25.00
-3 4 -6 9999.99 1.00 355.00
""")
for figures_of_merit in [s.array(data=f), f]:
out = StringIO()
s.array(data=c).as_phases_phs(out=out,
figures_of_merit=figures_of_merit)
assert not show_diff(
out.getvalue(), """\
1 2 3 4999.99 0.30 -25.00
-3 4 -6 9999.99 0.90 -5.00
""")
def ft_dp(self, dp, u_extra):
multiplier = ( self.unit_cell().volume()
/ matrix.row(self.rfft().n_real()).product()
* self.space_group().order_z()
/ dp.multiplicities().data().as_double())
coeff = dp.deep_copy()
xray.apply_u_extra(
self.unit_cell(),
u_extra,
coeff.indices(),
coeff.data())
coeff_data = coeff.data()
coeff_data *= flex.polar(multiplier, 0)
return miller.fft_map(
crystal_gridding=self.crystal_gridding(),
fourier_coefficients=coeff)
def exercise_basic():
a = flex.double((10,20))
p = flex.double((-25,355))
c = flex.polar(a, p, True)
f = flex.double((0.3,0.9))
s = miller.set(
crystal_symmetry=crystal.symmetry(
unit_cell=(10,10,10,90,90,90),
space_group_symbol="P1"),
indices=flex.miller_index([(1,2,3),(-3,4,-6)]),
anomalous_flag=False)
out = StringIO()
s.array(data=c).as_phases_phs(out=out)
assert not show_diff(out.getvalue(), """\
1 2 3 4999.99 1.00 -25.00
-3 4 -6 9999.99 1.00 -5.00
""")
out = StringIO()
s.array(data=c).as_phases_phs(out=out, scale_amplitudes=False)
assert not show_diff(out.getvalue(), """\
1 2 3 10.00 1.00 -25.00
-3 4 -6 20.00 1.00 -5.00
""")
for phases in [s.array(data=p), p]:
out = StringIO()
s.array(data=c).amplitudes().as_phases_phs(
out=out, phases=phases, phases_deg=True)
assert not show_diff(out.getvalue(), """\
1 2 3 4999.99 1.00 -25.00
-3 4 -6 9999.99 1.00 355.00
""")
for phases in [s.array(data=p*(math.pi/180)), p*(math.pi/180)]:
out = StringIO()
s.array(data=c).amplitudes().as_phases_phs(
out=out, phases=phases, phases_deg=False)
assert not show_diff(out.getvalue(), """\
1 2 3 4999.99 1.00 -25.00
-3 4 -6 9999.99 1.00 355.00
""")
for figures_of_merit in [s.array(data=f), f]:
out = StringIO()
s.array(data=c).as_phases_phs(out=out, figures_of_merit=figures_of_merit)
assert not show_diff(out.getvalue(), """\
1 2 3 4999.99 0.30 -25.00
-3 4 -6 9999.99 0.90 -5.00
""")
def run():
crystal_symmetry = crystal.symmetry(unit_cell=(10, 11, 12, 85, 95, 100),
space_group_symbol="P 1")
miller_set = miller.build_set(crystal_symmetry=crystal_symmetry,
anomalous_flag=False,
d_min=3)
f_calc = miller_set.array(data=flex.polar(
flex.random_double(miller_set.size()) * 10 - 5,
flex.random_double(miller_set.size()) * 10 - 5))
scale_factor = flex.random_double()
obs = miller_set.array(data=scale_factor * flex.norm(f_calc.data()) +
(flex.random_double(miller_set.size()) * 2 - 1),
sigmas=flex.random_double(miller_set.size()))
obs.set_observation_type_xray_intensity()
exercise_shelx_weighting(f_calc, obs, scale_factor)
exercise_quasi_unit_weighting(obs)
print('OK')
def run(args):
assert args in [[], ["--verbose"]]
verbose = "--verbose" in args
exercise_least_squares_residual()
exercise_core_LS(xray.targets_least_squares_residual, verbose)
exercise_core_LS(xray.targets_least_squares_residual_for_intensity, verbose)
crystal_symmetry = crystal.symmetry(
unit_cell=(10,11,12,85,95,100),
space_group_symbol="P 1")
miller_set = miller.build_set(
crystal_symmetry=crystal_symmetry,
anomalous_flag=False,
d_min=3)
f_calc = miller_set.array(
data=flex.polar(
flex.random_double(miller_set.size())*10-5,
flex.random_double(miller_set.size())*10-5))
obs = miller_set.array(
data=flex.abs(f_calc.data()) + (flex.random_double(miller_set.size())*2-1),
sigmas=flex.random_double(miller_set.size()))
obs.set_observation_type_xray_amplitude()
weighting = xray.weighting_schemes.amplitude_unit_weighting()
exercise_py_LS(obs, f_calc, weighting, verbose)
obs = miller_set.array(
data=flex.norm(f_calc.data()) + (flex.random_double(miller_set.size())*2-1),
sigmas=flex.random_double(miller_set.size()))
obs.set_observation_type_xray_intensity()
weighting = xray.weighting_schemes.intensity_quasi_unit_weighting()
exercise_py_LS(obs, f_calc, weighting, verbose)
weighting = xray.weighting_schemes.simple_shelx_weighting(a=100, b=150)
exercise_py_LS(obs, f_calc, weighting, verbose)
weighting = xray.weighting_schemes.shelx_weighting(a=100, b=150)
exercise_py_LS(obs, f_calc, weighting, verbose)
print "OK"
def run(args):
assert args in [[], ["--verbose"]]
verbose = "--verbose" in args
exercise_least_squares_residual()
exercise_core_LS(xray.targets_least_squares_residual, verbose)
exercise_core_LS(xray.targets_least_squares_residual_for_intensity,
verbose)
crystal_symmetry = crystal.symmetry(unit_cell=(10, 11, 12, 85, 95, 100),
space_group_symbol="P 1")
miller_set = miller.build_set(crystal_symmetry=crystal_symmetry,
anomalous_flag=False,
d_min=3)
f_calc = miller_set.array(data=flex.polar(
flex.random_double(miller_set.size()) * 10 - 5,
flex.random_double(miller_set.size()) * 10 - 5))
obs = miller_set.array(data=flex.abs(f_calc.data()) +
(flex.random_double(miller_set.size()) * 2 - 1),
sigmas=flex.random_double(miller_set.size()))
obs.set_observation_type_xray_amplitude()
weighting = xray.weighting_schemes.amplitude_unit_weighting()
exercise_py_LS(obs, f_calc, weighting, verbose)
obs = miller_set.array(data=flex.norm(f_calc.data()) +
(flex.random_double(miller_set.size()) * 2 - 1),
sigmas=flex.random_double(miller_set.size()))
obs.set_observation_type_xray_intensity()
weighting = xray.weighting_schemes.intensity_quasi_unit_weighting()
exercise_py_LS(obs, f_calc, weighting, verbose)
weighting = xray.weighting_schemes.simple_shelx_weighting(a=100, b=150)
exercise_py_LS(obs, f_calc, weighting, verbose)
weighting = xray.weighting_schemes.shelx_weighting(a=100, b=150)
exercise_py_LS(obs, f_calc, weighting, verbose)
print "OK"
def run():
crystal_symmetry = crystal.symmetry(
unit_cell=(10,11,12,85,95,100),
space_group_symbol="P 1")
miller_set = miller.build_set(
crystal_symmetry=crystal_symmetry,
anomalous_flag=False,
d_min=3)
f_calc = miller_set.array(
data=flex.polar(
flex.random_double(miller_set.size())*10-5,
flex.random_double(miller_set.size())*10-5))
scale_factor = flex.random_double()
obs = miller_set.array(
data=scale_factor * flex.norm(f_calc.data()) + (flex.random_double(miller_set.size())*2-1),
sigmas=flex.random_double(miller_set.size()))
obs.set_observation_type_xray_intensity()
exercise_shelx_weighting(f_calc, obs, scale_factor)
exercise_quasi_unit_weighting(obs)
print 'OK'
def exercise_get_amplitudes_and_get_phases_deg():
crystal_symmetry = crystal.symmetry(
unit_cell=(10,11,12,85,95,100),
space_group_symbol="P 1")
miller_set = miller.build_set(
crystal_symmetry=crystal_symmetry,
anomalous_flag=False,
d_min=3)
input_arrays = [miller_set.array(
data=flex.random_double(size=miller_set.indices().size()))
.set_observation_type_xray_amplitude()
for i in [0,1]]
mtz_dataset = input_arrays[0].as_mtz_dataset(column_root_label="F0")
mtz_dataset.mtz_object().write("tmp_rfu1.mtz")
reflection_files = [reflection_file_reader.any_reflection_file(
file_name="tmp_rfu1.mtz")]
reflection_file_srv = reflection_file_server(
crystal_symmetry=crystal_symmetry,
force_symmetry=True,
reflection_files=reflection_files)
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=None,
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
assert str(ampl.info()) == "tmp_rfu1.mtz:F0"
ampl = reflection_file_srv.get_miller_array(labels="F0")
assert str(ampl.info()) == "tmp_rfu1.mtz:F0"
mtz_dataset.add_miller_array(
miller_array=input_arrays[1], column_root_label="F1")
mtz_dataset.mtz_object().write("tmp_rfu2.mtz")
reflection_files = [reflection_file_reader.any_reflection_file(
file_name="tmp_rfu2.mtz")]
err = StringIO()
reflection_file_srv = reflection_file_server(
crystal_symmetry=crystal_symmetry,
force_symmetry=True,
reflection_files=reflection_files,
err=err)
try:
reflection_file_srv.get_amplitudes(
file_name=None,
labels=None,
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
except Sorry:
assert not show_diff(err.getvalue(), """\
Multiple equally suitable arrays of amplitudes found.
Possible choices:
tmp_rfu2.mtz:F0
tmp_rfu2.mtz:F1
Please use amplitudes.labels
to specify an unambiguous substring of the target label.
""")
err = reflection_file_srv.err = StringIO()
else:
raise Exception_expected
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=["F1"],
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
assert str(ampl.info()) == "tmp_rfu2.mtz:F1"
try:
reflection_file_srv.get_amplitudes(
file_name=None,
labels=["F2"],
convert_to_amplitudes_if_necessary=True,
parameter_name="labels",
parameter_scope=None)
except Sorry:
assert not show_diff(err.getvalue(), """\
No matching array: labels=F2
Possible choices:
tmp_rfu2.mtz:F0
tmp_rfu2.mtz:F1
Please use labels
to specify an unambiguous substring of the target label.
""")
err = reflection_file_srv.err = StringIO()
else:
raise Exception_expected
assert len(reflection_file_srv.file_name_miller_arrays) == 1
ampl = reflection_file_srv.get_amplitudes(
file_name="tmp_rfu1.mtz",
labels=None,
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
assert len(reflection_file_srv.file_name_miller_arrays) == 2
assert str(ampl.info()) == "tmp_rfu1.mtz:F0"
ampl = reflection_file_srv.get_amplitudes(
file_name=os.path.abspath("tmp_rfu1.mtz"),
labels=["f0"],
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
assert len(reflection_file_srv.file_name_miller_arrays) == 2
assert str(ampl.info()) == "tmp_rfu1.mtz:F0"
try:
reflection_file_srv.get_amplitudes(
file_name=None,
labels=None,
convert_to_amplitudes_if_necessary=True,
parameter_scope=None,
parameter_name=None)
except Sorry:
assert not show_diff(err.getvalue(), """\
Multiple equally suitable arrays of amplitudes found.
Possible choices:
tmp_rfu2.mtz:F0
tmp_rfu2.mtz:F1
Please specify an unambiguous substring of the target label.
""")
err = reflection_file_srv.err = StringIO()
else:
raise Exception_expected
#
mtz_dataset.add_miller_array(
miller_array=miller_set.array(
data=flex.polar(
flex.random_double(size=miller_set.indices().size()),
flex.random_double(size=miller_set.indices().size()))),
column_root_label="F2")
mtz_dataset.add_miller_array(
miller_array=miller_set.array(
data=flex.random_double(size=miller_set.indices().size()),
sigmas=flex.random_double(size=miller_set.indices().size())/10)
.set_observation_type_xray_intensity(),
column_root_label="F3")
mtz_dataset.add_miller_array(
miller_array=miller_set.array(
data=flex.hendrickson_lattman(miller_set.indices().size(), (0,0,0,0))),
column_root_label="P")
mtz_dataset.mtz_object().write("tmp_rfu3.mtz")
reflection_files = [reflection_file_reader.any_reflection_file(
file_name="tmp_rfu3.mtz")]
err = StringIO()
reflection_file_srv = reflection_file_server(
crystal_symmetry=crystal_symmetry,
force_symmetry=True,
reflection_files=reflection_files,
err=err)
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=["f2"],
convert_to_amplitudes_if_necessary=False,
parameter_scope="amplitudes",
parameter_name="labels")
assert str(ampl.info()) == "tmp_rfu3.mtz:F2,PHIF2"
assert ampl.is_complex_array()
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=["f2"],
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
assert str(ampl.info()) == "tmp_rfu3.mtz:F2"
assert ampl.is_real_array()
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=["f3"],
convert_to_amplitudes_if_necessary=False,
parameter_scope="amplitudes",
parameter_name="labels")
assert str(ampl.info()) == "tmp_rfu3.mtz:F3,SIGF3"
assert ampl.is_xray_intensity_array()
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=["f3"],
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
assert str(ampl.info()) == "tmp_rfu3.mtz:F3,as_amplitude_array"
assert ampl.is_real_array()
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=None,
convert_to_amplitudes_if_necessary=False,
parameter_scope="amplitudes",
parameter_name="labels",
return_all_valid_arrays=True,
strict=True)
assert (len(ampl) == 2)
for f in ampl :
assert (not f.is_xray_intensity_array()) and (not f.is_complex_array())
#
phases = reflection_file_srv.get_phases_deg(
file_name=None,
labels=["f2"],
convert_to_phases_if_necessary=False,
original_phase_units=None,
parameter_scope="phases",
parameter_name="labels")
assert str(phases.info()) == "tmp_rfu3.mtz:F2,PHIF2"
assert phases.is_complex_array()
phases = reflection_file_srv.get_phases_deg(
file_name=None,
labels=["f2"],
convert_to_phases_if_necessary=True,
original_phase_units=None,
parameter_scope=None,
parameter_name="labels")
assert str(phases.info()) == "tmp_rfu3.mtz:PHIF2"
assert phases.is_real_array()
assert flex.mean(phases.data()) > 5
phases = reflection_file_srv.get_phases_deg(
file_name=None,
labels=["PA"],
convert_to_phases_if_necessary=False,
original_phase_units=None,
parameter_scope="phases",
parameter_name="labels")
assert str(phases.info()) == "tmp_rfu3.mtz:PA,PB,PC,PD"
phases = reflection_file_srv.get_phases_deg(
file_name=None,
labels=["PA"],
convert_to_phases_if_necessary=True,
original_phase_units=None,
parameter_scope="phases",
parameter_name="labels")
assert str(phases.info()) \
== "tmp_rfu3.mtz:PA,PB,PC,PD,converted_to_centroid_phases"
assert phases.is_real_array()
for original_phase_units in [None, "deg", "rad"]:
phases = reflection_file_srv.get_phases_deg(
file_name=None,
labels=["F0"],
convert_to_phases_if_necessary=False,
original_phase_units=original_phase_units,
parameter_scope=None,
parameter_name="labels")
if (original_phase_units != "rad"):
assert str(phases.info()) == "tmp_rfu3.mtz:F0"
else:
assert str(phases.info()) == "tmp_rfu3.mtz:F0,converted_to_deg"
def exercise(space_group_info, n_scatterers=8, d_min=2, verbose=0, e_min=1.5):
structure = random_structure.xray_structure(space_group_info,
elements=["const"] *
n_scatterers,
volume_per_atom=200,
min_distance=3.,
general_positions_only=True,
u_iso=0.0)
if (0 or verbose):
structure.show_summary().show_scatterers()
f_calc = structure.structure_factors(d_min=d_min,
anomalous_flag=False).f_calc()
f_obs = abs(f_calc)
q_obs = miller.array(
miller_set=f_obs,
data=f_obs.data() /
math.sqrt(f_obs.space_group().order_p() * n_scatterers) /
f_obs.space_group().n_ltr())
q_obs = q_obs.sort(by_value="abs")
q_obs.setup_binner(auto_binning=True)
n_obs = q_obs.quasi_normalize_structure_factors()
r = flex.linear_regression(q_obs.data(), n_obs.data())
if (0 or verbose):
r.show_summary()
assert r.is_well_defined()
assert abs(r.y_intercept()) < 0.1
assert abs(r.slope() - 1) < 0.2
q_large = q_obs.select(
q_obs.quasi_normalized_as_normalized().data() > e_min)
if (0 or verbose):
print("Number of e-values > %.6g: %d" % (e_min, q_large.size()))
other_structure = random_structure.xray_structure(
space_group_info,
elements=["const"] * n_scatterers,
volume_per_atom=200,
min_distance=3.,
general_positions_only=True,
u_iso=0.0)
assert other_structure.unit_cell().is_similar_to(structure.unit_cell())
q_calc = q_large.structure_factors_from_scatterers(
other_structure, algorithm="direct").f_calc()
start = q_large.phase_transfer(q_calc.data())
for selection_fixed in (None,
flex.double(
[random.random()
for i in range(start.size())]) < 0.4):
from_map_data = direct_space_squaring(start, selection_fixed)
direct_space_result = start.phase_transfer(phase_source=from_map_data)
new_phases = reciprocal_space_squaring(start, selection_fixed, verbose)
reciprocal_space_result = start.phase_transfer(
phase_source=flex.polar(1, new_phases))
mwpe = direct_space_result.mean_weighted_phase_error(
reciprocal_space_result)
if (0 or verbose):
print("mwpe: %.2f" % mwpe, start.space_group_info())
for i, h in enumerate(direct_space_result.indices()):
amp_d, phi_d = complex_math.abs_arg(direct_space_result.data()[i],
deg=True)
amp_r, phi_r = complex_math.abs_arg(
reciprocal_space_result.data()[i], deg=True)
phase_err = scitbx.math.phase_error(phi_d, phi_r, deg=True)
assert phase_err < 1.0 or abs(from_map_data[i]) < 1.e-6
exercise_truncate(q_large)
def exercise_get_amplitudes_and_get_phases_deg():
crystal_symmetry = crystal.symmetry(
unit_cell=(10,11,12,85,95,100),
space_group_symbol="P 1")
miller_set = miller.build_set(
crystal_symmetry=crystal_symmetry,
anomalous_flag=False,
d_min=3)
input_arrays = [miller_set.array(
data=flex.random_double(size=miller_set.indices().size()))
.set_observation_type_xray_amplitude()
for i in [0,1]]
mtz_dataset = input_arrays[0].as_mtz_dataset(column_root_label="F0")
mtz_dataset.mtz_object().write("tmp_rfu1.mtz")
reflection_files = [reflection_file_reader.any_reflection_file(
file_name="tmp_rfu1.mtz")]
reflection_file_srv = reflection_file_server(
crystal_symmetry=crystal_symmetry,
force_symmetry=True,
reflection_files=reflection_files)
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=None,
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
assert str(ampl.info()) == "tmp_rfu1.mtz:F0"
ampl = reflection_file_srv.get_miller_array(labels="F0")
assert str(ampl.info()) == "tmp_rfu1.mtz:F0"
mtz_dataset.add_miller_array(
miller_array=input_arrays[1], column_root_label="F1")
mtz_dataset.mtz_object().write("tmp_rfu2.mtz")
reflection_files = [reflection_file_reader.any_reflection_file(
file_name="tmp_rfu2.mtz")]
err = StringIO()
reflection_file_srv = reflection_file_server(
crystal_symmetry=crystal_symmetry,
force_symmetry=True,
reflection_files=reflection_files,
err=err)
try:
reflection_file_srv.get_amplitudes(
file_name=None,
labels=None,
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
except Sorry:
assert not show_diff(err.getvalue(), """\
Multiple equally suitable arrays of amplitudes found.
Possible choices:
tmp_rfu2.mtz:F0
tmp_rfu2.mtz:F1
Please use amplitudes.labels
to specify an unambiguous substring of the target label.
""")
err = reflection_file_srv.err = StringIO()
else:
raise Exception_expected
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=["F1"],
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
assert str(ampl.info()) == "tmp_rfu2.mtz:F1"
try:
reflection_file_srv.get_amplitudes(
file_name=None,
labels=["F2"],
convert_to_amplitudes_if_necessary=True,
parameter_name="labels",
parameter_scope=None)
except Sorry:
assert not show_diff(err.getvalue(), """\
No matching array: labels=F2
Possible choices:
tmp_rfu2.mtz:F0
tmp_rfu2.mtz:F1
Please use labels
to specify an unambiguous substring of the target label.
""")
err = reflection_file_srv.err = StringIO()
else:
raise Exception_expected
assert len(reflection_file_srv.file_name_miller_arrays) == 1
ampl = reflection_file_srv.get_amplitudes(
file_name="tmp_rfu1.mtz",
labels=None,
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
assert len(reflection_file_srv.file_name_miller_arrays) == 2
assert str(ampl.info()) == "tmp_rfu1.mtz:F0"
ampl = reflection_file_srv.get_amplitudes(
file_name=os.path.abspath("tmp_rfu1.mtz"),
labels=["f0"],
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
assert len(reflection_file_srv.file_name_miller_arrays) == 2
assert str(ampl.info()) == "tmp_rfu1.mtz:F0"
try:
reflection_file_srv.get_amplitudes(
file_name=None,
labels=None,
convert_to_amplitudes_if_necessary=True,
parameter_scope=None,
parameter_name=None)
except Sorry:
assert not show_diff(err.getvalue(), """\
Multiple equally suitable arrays of amplitudes found.
Possible choices:
tmp_rfu2.mtz:F0
tmp_rfu2.mtz:F1
Please specify an unambiguous substring of the target label.
""")
err = reflection_file_srv.err = StringIO()
else:
raise Exception_expected
#
mtz_dataset.add_miller_array(
miller_array=miller_set.array(
data=flex.polar(
flex.random_double(size=miller_set.indices().size()),
flex.random_double(size=miller_set.indices().size()))),
column_root_label="F2")
mtz_dataset.add_miller_array(
miller_array=miller_set.array(
data=flex.random_double(size=miller_set.indices().size()),
sigmas=flex.random_double(size=miller_set.indices().size())/10)
.set_observation_type_xray_intensity(),
column_root_label="F3")
mtz_dataset.add_miller_array(
miller_array=miller_set.array(
data=flex.hendrickson_lattman(miller_set.indices().size(), (0,0,0,0))),
column_root_label="P")
mtz_dataset.mtz_object().write("tmp_rfu3.mtz")
reflection_files = [reflection_file_reader.any_reflection_file(
file_name="tmp_rfu3.mtz")]
err = StringIO()
reflection_file_srv = reflection_file_server(
crystal_symmetry=crystal_symmetry,
force_symmetry=True,
reflection_files=reflection_files,
err=err)
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=["f2"],
convert_to_amplitudes_if_necessary=False,
parameter_scope="amplitudes",
parameter_name="labels")
assert str(ampl.info()) == "tmp_rfu3.mtz:F2,PHIF2"
assert ampl.is_complex_array()
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=["f2"],
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
assert str(ampl.info()) == "tmp_rfu3.mtz:F2"
assert ampl.is_real_array()
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=["f3"],
convert_to_amplitudes_if_necessary=False,
parameter_scope="amplitudes",
parameter_name="labels")
assert str(ampl.info()) == "tmp_rfu3.mtz:F3,SIGF3"
assert ampl.is_xray_intensity_array()
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=["f3"],
convert_to_amplitudes_if_necessary=True,
parameter_scope="amplitudes",
parameter_name="labels")
assert str(ampl.info()) == "tmp_rfu3.mtz:F3,as_amplitude_array"
assert ampl.is_real_array()
ampl = reflection_file_srv.get_amplitudes(
file_name=None,
labels=None,
convert_to_amplitudes_if_necessary=False,
parameter_scope="amplitudes",
parameter_name="labels",
return_all_valid_arrays=True,
strict=True)
assert (len(ampl) == 2)
for f in ampl :
assert (not f.is_xray_intensity_array()) and (not f.is_complex_array())
#
phases = reflection_file_srv.get_phases_deg(
file_name=None,
labels=["f2"],
convert_to_phases_if_necessary=False,
original_phase_units=None,
parameter_scope="phases",
parameter_name="labels")
assert str(phases.info()) == "tmp_rfu3.mtz:F2,PHIF2"
assert phases.is_complex_array()
phases = reflection_file_srv.get_phases_deg(
file_name=None,
labels=["f2"],
convert_to_phases_if_necessary=True,
original_phase_units=None,
parameter_scope=None,
parameter_name="labels")
assert str(phases.info()) == "tmp_rfu3.mtz:PHIF2"
assert phases.is_real_array()
assert flex.mean(phases.data()) > 5
phases = reflection_file_srv.get_phases_deg(
file_name=None,
labels=["PA"],
convert_to_phases_if_necessary=False,
original_phase_units=None,
parameter_scope="phases",
parameter_name="labels")
assert str(phases.info()) == "tmp_rfu3.mtz:PA,PB,PC,PD"
phases = reflection_file_srv.get_phases_deg(
file_name=None,
labels=["PA"],
convert_to_phases_if_necessary=True,
original_phase_units=None,
parameter_scope="phases",
parameter_name="labels")
assert str(phases.info()) \
== "tmp_rfu3.mtz:PA,PB,PC,PD,converted_to_centroid_phases"
assert phases.is_real_array()
for original_phase_units in [None, "deg", "rad"]:
phases = reflection_file_srv.get_phases_deg(
file_name=None,
labels=["F0"],
convert_to_phases_if_necessary=False,
original_phase_units=original_phase_units,
parameter_scope=None,
parameter_name="labels")
if (original_phase_units != "rad"):
assert str(phases.info()) == "tmp_rfu3.mtz:F0"
else:
assert str(phases.info()) == "tmp_rfu3.mtz:F0,converted_to_deg"