def get_indexing_offset_correlation_coefficients(
reflections, crystal, grid_search_scope, d_min=None, d_max=None, map_to_asu=False
):
from copy import deepcopy
from dials.array_family import flex
space_group = crystal.get_space_group()
unit_cell = crystal.get_unit_cell()
from cctbx.crystal import symmetry as crystal_symmetry
cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol())
from cctbx.miller import set as miller_set
data = reflections["intensity.sum.value"] / flex.sqrt(reflections["intensity.sum.variance"])
ccs = flex.double()
offsets = flex.vec3_int()
nref = flex.size_t()
original_miller_indices = reflections["miller_index"]
ms = miller_set(cs, original_miller_indices)
ms = ms.array(data)
if d_min is not None or d_max is not None:
ms = ms.resolution_filter(d_min=d_min, d_max=d_max)
if map_to_asu:
ms = ms.map_to_asu()
g = grid_search_scope
for h in range(-g, g + 1):
for k in range(-g, g + 1):
for l in range(-g, g + 1):
for smx in ["-x,-y,-z"]:
# reindexed = deepcopy(reflections)
# hkl offset doubled as equivalent of h0 + 1, hI - 1
miller_indices = offset_miller_indices(ms.indices(), (2 * h, 2 * k, 2 * l))
reindexed_miller_indices = sgtbx.change_of_basis_op(smx).apply(miller_indices)
rms = miller_set(cs, reindexed_miller_indices)
rms = rms.array(data)
# if params.d_min or params.d_max:
# rms = rms.resolution_filter(d_min=params.d_min, d_max=params.d_max)
# if map_to_asu:
# rms = rms.map_to_asu()
intensity, intensity_rdx = rms.common_sets(ms)
cc = intensity.correlation(intensity_rdx).coefficient()
ccs.append(cc)
offsets.append((h, k, l))
nref.append(intensity.size())
return offsets, ccs, nref
def get_hkl_offset_correlation_coefficients(
dials_reflections,
dials_crystal,
map_to_asu=False,
grid_h=0,
grid_k=0,
grid_l=0,
reference=None,
):
# N.B. deliberately ignoring d_min, d_max as these are inconsistent with
# changing the miller indices
from cctbx import sgtbx
from cctbx.miller import set as miller_set
from dials.array_family import flex
cs = cctbx_crystal_from_dials(dials_crystal)
ms = cctbx_i_over_sigi_ms_from_dials_data(dials_reflections, cs)
if reference:
reference_ms = cctbx_i_over_sigi_ms_from_dials_data(reference, cs)
else:
reference_ms = None
ccs = flex.double()
offsets = flex.vec3_int()
nref = flex.size_t()
if reference:
cb_op = sgtbx.change_of_basis_op("x,y,z")
else:
cb_op = sgtbx.change_of_basis_op("-x,-y,-z")
hkl_test = [
(h, k, l)
for h in range(-grid_h, grid_h + 1)
for k in range(-grid_k, grid_k + 1)
for l in range(-grid_l, grid_l + 1)
]
for hkl in hkl_test:
indices = offset_miller_indices(ms.indices(), hkl)
reindexed_indices = cb_op.apply(indices)
rms = miller_set(cs, reindexed_indices).array(ms.data())
if reference_ms:
_ms = reference_ms
else:
_ms = miller_set(cs, indices).array(ms.data())
n, cc = compute_miller_set_correlation(_ms, rms, map_to_asu=map_to_asu)
ccs.append(cc)
offsets.append(hkl)
nref.append(n)
return offsets, ccs, nref
def cctbx_i_over_sigi_ms_from_dials_data(reflections, cctbx_crystal_symmetry):
from dials.array_family import flex
from cctbx.miller import set as miller_set
refl = reflections.select(reflections['intensity.sum.variance'] > 0)
return miller_set(cctbx_crystal_symmetry, refl['miller_index']).array(
data=refl['intensity.sum.value'],
sigmas=flex.sqrt(refl['intensity.sum.variance']))
def cctbx_i_over_sigi_ms_from_dials_data(reflections, cctbx_crystal_symmetry):
from dials.array_family import flex
from cctbx.miller import set as miller_set
refl = reflections.select(reflections['intensity.sum.variance'] > 0)
return miller_set(cctbx_crystal_symmetry, refl['miller_index']).array(
data=refl['intensity.sum.value'],
sigmas=flex.sqrt(refl['intensity.sum.variance']))
def test_crystal_pointgroup_symmetry(reflections, experiment, params):
crystal = experiment.crystal
# in case we pass in reflections from integration
reflections = reflections.select(reflections["intensity.sum.variance"] > 0)
reflections = reflections.select(reflections["intensity.sum.value"] > 0)
original_miller_indices = reflections["miller_index"]
space_group = crystal.get_space_group()
unit_cell = crystal.get_unit_cell()
cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol())
ms = miller_set(cs, original_miller_indices)
ms = ms.array(reflections["intensity.sum.value"] /
flex.sqrt(reflections["intensity.sum.variance"]))
if params.d_min or params.d_max:
d_spacings = ms.d_spacings().data()
sel = (d_spacings >= params.d_min) & (d_spacings <= params.d_max)
ms = ms.select(sel)
if params.normalise:
if params.normalise_bins:
ms = normalise_intensities(ms, n_bins=params.normalise_bins)
else:
ms = normalise_intensities(ms)
logger.info("Check symmetry operations on %d reflections:" % ms.size())
logger.info("")
logger.info("%20s %6s %5s" % ("Symop", "Nref", "CC"))
true_symops = []
ccs, n_refs = get_symop_correlation_coefficients(ms)
ses = standard_error_of_pearson_cc(ccs, n_refs)
for smx, cc, n_ref, se in zip(space_group.smx(), ccs, n_refs, ses):
accept = ""
if params.symop_threshold:
if (cc - 2.0 * se) > params.symop_threshold:
true_symops.append(smx)
accept = "***"
cc_str = format_cc_with_standard_error(cc, se)
logger.info("%20s %6d %s %s" % (smx, n_ref, cc_str, accept))
if params.symop_threshold:
sg = sgtbx_space_group()
for symop in true_symops:
sg = sg.expand_smx(symop)
for ltr in space_group.ltr():
sg = sg.expand_ltr(ltr)
sg_symbols = sg.match_tabulated_settings()
logger.info("")
logger.info("Derived point group from symmetry operations: %s" %
sg_symbols.hermann_mauguin())
logger.info("")
return
def get_hkl_offset_correlation_coefficients(
dials_reflections, dials_crystal, map_to_asu=False,
grid_h=0, grid_k=0, grid_l=0, reference=None):
# N.B. deliberately ignoring d_min, d_max as these are inconsistent with
# changing the miller indices
from dials.array_family import flex
from cctbx.miller import set as miller_set
from cctbx import sgtbx
cs = cctbx_crystal_from_dials(dials_crystal)
ms = cctbx_i_over_sigi_ms_from_dials_data(dials_reflections, cs)
if reference:
reference_ms = cctbx_i_over_sigi_ms_from_dials_data(reference, cs)
else:
reference_ms = None
ccs = flex.double()
offsets = flex.vec3_int()
nref = flex.size_t()
if reference:
cb_op = sgtbx.change_of_basis_op('x,y,z')
else:
cb_op = sgtbx.change_of_basis_op('-x,-y,-z')
hkl_test = [(h, k, l) for h in range(-grid_h, grid_h + 1) \
for k in range(-grid_k, grid_k + 1) \
for l in range(-grid_l, grid_l + 1)]
for hkl in hkl_test:
indices = offset_miller_indices(ms.indices(), hkl)
reindexed_indices = cb_op.apply(indices)
rms = miller_set(cs, reindexed_indices).array(ms.data())
if reference_ms:
_ms = reference_ms
else:
_ms = miller_set(cs, indices).array(ms.data())
n, cc = compute_miller_set_correlation(_ms, rms, map_to_asu=map_to_asu)
ccs.append(cc)
offsets.append(hkl)
nref.append(n)
return offsets, ccs, nref
def get_amplitudes(self, dials_model, refl_table, test_without_mpi=True):
D = dials_model
R = refl_table
from cctbx.crystal import symmetry
from cctbx.miller import array, set as miller_set
uc = D.crystal.get_unit_cell()
sg = D.crystal.get_space_group()
MS = miller_set(symmetry(unit_cell=uc, space_group=sg),
anomalous_flag=True,
indices=R["miller_index"].select(R["spots_order"]))
self.amplitudes = array(MS,
data=flex.sqrt(
R["spots_mockup_shoebox_sum"].select(
R["spots_order"])))
from simtbx.gpu import gpu_energy_channels
recommend_device = int(os.environ.get("CCTBX_RECOMMEND_DEVICE", 0))
self.gpu_channels_singleton = gpu_energy_channels(
deviceId=recommend_device)
def get_amplitudes(self, dials_model, refl_table, test_without_mpi=True):
from LS49.adse13_187.cyto_batch import parse_input
self.params, options = parse_input()
D = dials_model
R = refl_table
from cctbx.crystal import symmetry
from cctbx.miller import array, set as miller_set
uc = D.crystal.get_unit_cell()
sg = D.crystal.get_space_group()
MS = miller_set(symmetry(unit_cell=uc, space_group=sg),
anomalous_flag=True,
indices=R["miller_index"].select(R["spots_order"]))
self.amplitudes = array(MS,
data=flex.sqrt(
R["spots_mockup_shoebox_sum"].select(
R["spots_order"])))
from simtbx.gpu import gpu_energy_channels
self.gpu_channels_singleton = gpu_energy_channels(
deviceId=0) # determine device by rank id later
def get_indexing_offset_correlation_coefficients(reflections,
crystal,
grid,
d_min=None,
d_max=None,
map_to_asu=False,
grid_h=0,
grid_k=0,
grid_l=0,
reference=None):
from dials.algorithms.symmetry import origin
if grid:
if grid_h == 0: grid_h = grid
if grid_k == 0: grid_k = grid
if grid_l == 0: grid_l = grid
if True:
return origin.get_hkl_offset_correlation_coefficients(
reflections,
crystal,
map_to_asu=map_to_asu,
grid_h=grid_h,
grid_k=grid_k,
grid_l=grid_l,
reference=reference)
from copy import deepcopy
from dials.array_family import flex
space_group = crystal.get_space_group()
unit_cell = crystal.get_unit_cell()
from cctbx.crystal import symmetry as crystal_symmetry
cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol())
from cctbx.miller import set as miller_set
data = reflections['intensity.sum.value'] / \
flex.sqrt(reflections['intensity.sum.variance'])
if reference:
reference = reference.select(reference['intensity.sum.variance'] > 0)
reference_data = reference['intensity.sum.value'] / \
flex.sqrt(reference['intensity.sum.variance'])
reference_ms = miller_set(
cs, reference['miller_index']).array(reference_data)
else:
reference_ms = None
ccs = flex.double()
offsets = flex.vec3_int()
nref = flex.size_t()
original_miller_indices = reflections['miller_index']
ms = miller_set(cs, original_miller_indices).array(data)
if d_min is not None or d_max is not None:
ms = ms.resolution_filter(d_min=d_min, d_max=d_max)
gh = gk = gl = grid
if grid_h: gh = grid_h
if grid_k: gk = grid_k
if grid_l: gl = grid_l
# essentially just inversion operation - this *should* have good CC - unless
# we are working on a reference set where we don't reindex
if reference:
cb_op = sgtbx.change_of_basis_op('x,y,z')
else:
cb_op = sgtbx.change_of_basis_op('-x,-y,-z')
for h in range(-gh, gh + 1):
for k in range(-gk, gk + 1):
for l in range(-gl, gl + 1):
miller_indices = offset_miller_indices(ms.indices(), (h, k, l))
reindexed_miller_indices = cb_op.apply(miller_indices)
rms = miller_set(cs, reindexed_miller_indices).array(data)
if reference_ms:
_ms = reference_ms
else:
_ms = miller_set(cs, miller_indices).array(data)
if map_to_asu:
rms = rms.map_to_asu()
_ms = _ms.map_to_asu()
intensity, intensity_rdx = rms.common_sets(_ms)
cc = intensity.correlation(intensity_rdx).coefficient()
ccs.append(cc)
offsets.append((h, k, l))
nref.append(intensity.size())
return offsets, ccs, nref
def test_crystal_pointgroup_symmetry(reflections, experiment, params):
crystal = experiment.crystal
from dials.array_family import flex
# in case we pass in reflections from integration
reflections = reflections.select(reflections['intensity.sum.variance'] > 0)
reflections = reflections.select(reflections['intensity.sum.value'] > 0)
original_miller_indices = reflections['miller_index']
space_group = crystal.get_space_group()
unit_cell = crystal.get_unit_cell()
from cctbx.crystal import symmetry as crystal_symmetry
cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol())
from cctbx.miller import set as miller_set
ms = miller_set(cs, original_miller_indices)
ms = ms.array(reflections['intensity.sum.value'] /
flex.sqrt(reflections['intensity.sum.variance']))
if params.d_min or params.d_max:
d_spacings = ms.d_spacings().data()
sel = (d_spacings >= params.d_min) & (d_spacings <= params.d_max)
ms = ms.select(sel)
reflections = reflections.select(sel)
if params.normalise:
if params.normalise_bins:
ms = normalise_intensities(ms, n_bins=params.normalise_bins)
else:
ms = normalise_intensities(ms)
logger.info('Check symmetry operations on %d reflections:' % ms.size())
logger.info('')
logger.info('%20s %6s %5s' % ('Symop', 'Nref', 'CC'))
true_symops = []
ccs, n_refs = get_symop_correlation_coefficients(ms)
for smx, cc, n_ref in zip(space_group.smx(), ccs, n_refs):
accept = ''
if params.symop_threshold:
if cc > params.symop_threshold:
true_symops.append(smx)
accept = '***'
logger.info('%20s %6d %.3f %s' % (smx, n_ref, cc, accept))
if params.symop_threshold:
from cctbx.sgtbx import space_group as sgtbx_space_group
sg = sgtbx_space_group()
for symop in true_symops:
sg = sg.expand_smx(symop)
for ltr in space_group.ltr():
sg = sg.expand_ltr(ltr)
sg_symbols = sg.match_tabulated_settings()
logger.info('')
logger.info('Derived point group from symmetry operations: %s' % \
sg_symbols.hermann_mauguin())
logger.info('')
return
def test_crystal_pointgroup_symmetry(reflections, experiment, params):
crystal = experiment.crystal
from dials.array_family import flex
# in case we pass in reflections from integration
reflections = reflections.select(reflections["intensity.sum.variance"] > 0)
reflections = reflections.select(reflections["intensity.sum.value"] > 0)
original_miller_indices = reflections["miller_index"]
space_group = crystal.get_space_group()
unit_cell = crystal.get_unit_cell()
from cctbx.crystal import symmetry as crystal_symmetry
cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol())
from cctbx.miller import set as miller_set
ms = miller_set(cs, original_miller_indices)
ms = ms.array(reflections["intensity.sum.value"] / flex.sqrt(reflections["intensity.sum.variance"]))
if params.d_min or params.d_max:
d_spacings = ms.d_spacings().data()
sel = (d_spacings >= params.d_min) & (d_spacings <= params.d_max)
ms = ms.select(sel)
reflections = reflections.select(sel)
if params.normalise:
if params.normalise_bins:
ms = normalise_intensities(ms, n_bins=params.normalise_bins)
else:
ms = normalise_intensities(ms)
print "Check symmetry operations on %d reflections:" % ms.size()
print ""
print "%20s %6s %5s" % ("Symop", "Nref", "CC")
true_symops = []
ccs, n_refs = get_symop_correlation_coefficients(ms)
for smx, cc, n_ref in zip(space_group.smx(), ccs, n_refs):
accept = ""
if params.symop_threshold:
if cc > params.symop_threshold:
true_symops.append(smx)
accept = "***"
print "%20s %6d %.3f %s" % (smx, n_ref, cc, accept)
if params.symop_threshold:
from cctbx.sgtbx import space_group as sgtbx_space_group
sg = sgtbx_space_group()
for symop in true_symops:
sg = sg.expand_smx(symop)
for ltr in space_group.ltr():
sg = sg.expand_ltr(ltr)
sg_symbols = sg.match_tabulated_settings()
print ""
print "Derived point group from symmetry operations: %s" % sg_symbols.hermann_mauguin()
print ""
return
def integrate_coset(self, experiments, indexed):
TRANS = self.params.integration.coset.transformation
# here get a deepcopy that we are not afraid to modify:
experiments_local = copy.deepcopy(experiments)
print("*" * 80)
print("Coset Reflections for modeling or validating the background")
print("*" * 80)
from dials.algorithms.profile_model.factory import ProfileModelFactory
from dials.algorithms.integration.integrator import create_integrator
# XXX Fixme later implement support for non-primitive lattices NKS
base_set = miller_set( crystal_symmetry = symmetry(
unit_cell = experiments_local[0].crystal.get_unit_cell(),
space_group = experiments_local[0].crystal.get_space_group()),
indices = indexed["miller_index"]
)
triclinic = base_set.customized_copy(
crystal_symmetry=symmetry(unit_cell = experiments_local[0].crystal.get_unit_cell(),space_group="P1"))
# ================
# Compute the profile model
# Predict the reflections
# Create the integrator
# This creates a reference to the experiment, not a copy:
experiments_local = ProfileModelFactory.create(self.params, experiments_local, indexed)
# for debug SLT[TRANS].show_summary()
for e in experiments_local:
e.crystal.set_space_group(triclinic.space_group())
Astar = e.crystal.get_A()
# debug OriAstar = crystal_orientation(Astar,True)
# debug OriAstar.show(legend="old ")
Astarprime = sqr(Astar)* ( sqr(SLT[TRANS]._reindex_N).transpose().inverse() )
e.crystal.set_A(Astarprime)
# debug OriAstarprime = crystal_orientation(Astarprime,True)
# debug OriAstarprime.show(legend="new ")
print("Predicting coset reflections")
print("")
predicted = flex.reflection_table.from_predictions_multi(
experiments_local,
dmin=self.params.prediction.d_min,
dmax=self.params.prediction.d_max,
margin=self.params.prediction.margin,
force_static=self.params.prediction.force_static,
)
print("sublattice total predictions %d"%len(predicted))
# filter the sublattice, keep only the coset indices
miller = predicted["miller_index"]
# coset of modulus 2, wherein there is a binary choice
# see Sauter & Zwart, Acta D (2009) 65:553, Table 1; select the valid coset using eqn(5).
coset_select_algorithm_2 = flex.bool()
M_mat = SLT[TRANS].matS() # the transformation
M_p = M_mat.inverse()
for idx in miller:
H_row = row(idx)
h_orig_setting = H_row * M_p
on_coset=False
for icom in h_orig_setting.elems:
if icom.denominator() > 1: on_coset=True; break
coset_select_algorithm_2.append(on_coset)
predicted = predicted.select(coset_select_algorithm_2)
print("of which %d are in coset %d"%(len(predicted), TRANS))
print("")
integrator = create_integrator(self.params, experiments_local, predicted)
# Integrate the reflections
integrated = integrator.integrate()
# Delete the shoeboxes used for intermediate calculations, if requested
if self.params.integration.debug.delete_shoeboxes and "shoebox" in integrated:
del integrated["shoebox"]
if self.params.output.composite_output:
if (
self.params.output.coset_experiments_filename
or self.params.output.coset_filename
):
assert (
self.params.output.coset_experiments_filename is not None
and self.params.output.coset_filename is not None
)
n = len(self.all_coset_experiments)
self.all_coset_experiments.extend(experiments_local)
for i, experiment in enumerate(experiments_local):
refls = integrated.select(integrated["id"] == i)
refls["id"] = flex.int(len(refls), n)
del refls.experiment_identifiers()[i]
refls.experiment_identifiers()[n] = experiment.identifier
self.all_coset_reflections.extend(refls)
n += 1
else:
# Dump experiments to disk
if self.params.output.coset_experiments_filename:
experiments_local.as_json(self.params.output.coset_experiments_filename)
if self.params.output.coset_filename:
# Save the reflections
self.save_reflections(
integrated, self.params.output.coset_filename
)
rmsd_indexed, _ = calc_2D_rmsd_and_displacements(indexed)
log_str = "coset RMSD indexed (px): %f\n" % (rmsd_indexed)
log_str += "integrated %d\n"%len(integrated)
for i in range(6):
bright_integrated = integrated.select(
(
integrated["intensity.sum.value"]
/ flex.sqrt(integrated["intensity.sum.variance"])
)
>= i
)
if len(bright_integrated) > 0:
rmsd_integrated, _ = calc_2D_rmsd_and_displacements(bright_integrated)
else:
rmsd_integrated = 0
log_str += (
"N reflections integrated at I/sigI >= %d: % 4d, RMSD (px): %f\n"
% (i, len(bright_integrated), rmsd_integrated)
)
for crystal_model in experiments_local.crystals():
if hasattr(crystal_model, "get_domain_size_ang"):
log_str += (
". Final ML model: domain size angstroms: %f, half mosaicity degrees: %f"
% (
crystal_model.get_domain_size_ang(),
crystal_model.get_half_mosaicity_deg(),
)
)
print(log_str)
print("")
def get_indexing_offset_correlation_coefficients(
reflections, crystal, grid, d_min=None, d_max=None,
map_to_asu=False, grid_h=0, grid_k=0, grid_l=0, reference=None):
from dials.algorithms.symmetry import origin
if grid:
if grid_h == 0: grid_h = grid
if grid_k == 0: grid_k = grid
if grid_l == 0: grid_l = grid
if True:
return origin.get_hkl_offset_correlation_coefficients(
reflections, crystal, map_to_asu=map_to_asu,
grid_h=grid_h, grid_k=grid_k, grid_l=grid_l, reference=reference)
from copy import deepcopy
from dials.array_family import flex
space_group = crystal.get_space_group()
unit_cell = crystal.get_unit_cell()
from cctbx.crystal import symmetry as crystal_symmetry
cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol())
from cctbx.miller import set as miller_set
data = reflections['intensity.sum.value'] / \
flex.sqrt(reflections['intensity.sum.variance'])
if reference:
reference = reference.select(reference['intensity.sum.variance'] > 0)
reference_data = reference['intensity.sum.value'] / \
flex.sqrt(reference['intensity.sum.variance'])
reference_ms = miller_set(cs, reference['miller_index']).array(
reference_data)
else:
reference_ms = None
ccs = flex.double()
offsets = flex.vec3_int()
nref = flex.size_t()
original_miller_indices = reflections['miller_index']
ms = miller_set(cs, original_miller_indices).array(data)
if d_min is not None or d_max is not None:
ms = ms.resolution_filter(d_min=d_min, d_max=d_max)
gh = gk = gl = grid
if grid_h: gh = grid_h
if grid_k: gk = grid_k
if grid_l: gl = grid_l
# essentially just inversion operation - this *should* have good CC - unless
# we are working on a reference set where we don't reindex
if reference:
cb_op = sgtbx.change_of_basis_op('x,y,z')
else:
cb_op = sgtbx.change_of_basis_op('-x,-y,-z')
for h in range(-gh, gh + 1):
for k in range(-gk, gk + 1):
for l in range(-gl, gl + 1):
miller_indices = offset_miller_indices(ms.indices(), (h, k, l))
reindexed_miller_indices = cb_op.apply(miller_indices)
rms = miller_set(cs, reindexed_miller_indices).array(data)
if reference_ms:
_ms = reference_ms
else:
_ms = miller_set(cs, miller_indices).array(data)
if map_to_asu:
rms = rms.map_to_asu()
_ms = _ms.map_to_asu()
intensity, intensity_rdx = rms.common_sets(_ms)
cc = intensity.correlation(intensity_rdx).coefficient()
ccs.append(cc)
offsets.append((h, k, l))
nref.append(intensity.size())
return offsets, ccs, nref
def run(self):
"""Parse the options."""
# Parse the command line arguments
params, options = self.parser.parse_args(show_diff_phil=True)
self.params = params
assert (len(params.input.experiments) == len(params.input.reflections)
== 1), "Provide one experiment list and one reflection table"
assert params.method == "summed_intensity"
experiments = params.input.experiments[0].data
reflections = params.input.reflections[0].data
# Find the aveage unit cell for the crystals in the experiments provided
weighted_relfs = flex.reflection_table()
all_uc = [flex.double() for i in xrange(6)]
space_group = None
for expt_id, experiment in enumerate(experiments):
refls = reflections.select(reflections["id"] == expt_id)
unit_cell = experiment.crystal.get_unit_cell()
for i in xrange(6):
all_uc[i].append(unit_cell.parameters()[i])
if space_group is None:
space_group = experiment.crystal.get_space_group()
else:
assert (space_group.type().lookup_symbol() == experiment.
crystal.get_space_group().type().lookup_symbol())
# Compute the average unit cell and build a miller array with it
unit_cell = uctbx.unit_cell([flex.mean(data) for data in all_uc])
cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol())
ms = miller_set(cs, reflections["miller_index"], anomalous_flag=False)
ma = ms.array(reflections["intensity.sum.value"] /
flex.sqrt(reflections["intensity.sum.variance"]))
ma.setup_binner(n_bins=10)
binner = ma.binner()
mean_i = flex.double()
reflections["delpsical.weights"] = flex.double(len(reflections), 0)
# Iterate through the bins and compute the Wilson plot, then use it compute the weights
for i in binner.range_all():
sel = binner.selection(i)
if sel.count(True) == 0:
mean_i.append(0)
continue
mean_i.append(
flex.mean(reflections["intensity.sum.value"].select(sel)))
reflections["delpsical.weights"].set_selected(
sel,
reflections["intensity.sum.value"].select(sel) *
(params.summed_intensity.scale_factor / mean_i[i]),
)
if params.show_weight_plots:
fig = plt.figure()
plt.title(str(i))
plt.hist(reflections["delpsical.weights"].select(sel))
# Show unit cell distribution and mean I
print("Average uc +/- std. deviation")
labels = [
"% 6s" % l for l in ["a", "b", "c", "alpha", "beta", "gamma"]
]
for label, data in zip(labels, all_uc):
stats = flex.mean_and_variance(data)
print("%s % 6.1f +/- %6.1f" %
(label, stats.mean(),
stats.unweighted_sample_standard_deviation()))
print("Mean I over all data")
binner.show_data(mean_i, data_fmt="%.1f", show_unused=False)
easy_pickle.dump(params.output.reflections, reflections)
if params.show_weight_plots:
plt.show()
