def __init__(self, miller_array, settings, merge=None):
self.miller_array = miller_array
self.settings = settings
self.merge_equivalents = merge
from cctbx import miller
from cctbx import crystal
from cctbx.array_family import flex
self.multiplicities = None
self.process_input_array()
array = self.work_array
uc = array.unit_cell()
self.unit_cell = uc
self.slice_selection = None
self.axis_index = None
if (settings.slice_mode):
self.axis_index = ["h", "k", "l"].index(self.settings.slice_axis)
self.slice_selection = miller.simple_slice(
indices=array.indices(),
slice_axis=self.axis_index,
slice_index=settings.slice_index)
#if (self.slice_selection.count(True) == 0) :
#raise ValueError("No data selected!")
index_span = array.index_span()
self.d_min = array.d_min()
self.hkl_range = index_span.abs_range()
self.axes = [
uc.reciprocal_space_vector((self.hkl_range[0], 0, 0)),
uc.reciprocal_space_vector((0, self.hkl_range[1], 0)),
uc.reciprocal_space_vector((0, 0, self.hkl_range[2]))
]
self.generate_view_data()
if (self.slice_selection is not None):
self.indices = self.work_array.indices().select(
self.slice_selection)
self.data = self.data.select(self.slice_selection)
else:
self.indices = array.indices()
self.points = uc.reciprocal_space_vector(self.indices) * 100.
self.missing_flags = flex.bool(self.radii.size(), False)
self.sys_absent_flags = flex.bool(self.radii.size(), False)
if (settings.show_missing):
self.generate_missing_reflections()
if (settings.show_systematic_absences) and (
not settings.show_only_missing):
self.generate_systematic_absences()
# XXX hack for process_pick_points
self.visible_points = flex.bool(self.points.size(), True)
n_points = self.points.size()
assert (self.colors.size() == n_points)
assert (self.indices.size() == n_points)
assert (self.radii.size() == n_points)
assert (self.missing_flags.size() == n_points)
assert (self.sys_absent_flags.size() == n_points)
assert (self.data.size() == n_points)
self.clear_labels()
def generate_systematic_absences(self):
from cctbx import miller
from cctbx import crystal
from cctbx.array_family import flex
settings = self.settings
array = self.filtered_array # XXX use original array here!
absence_array = generate_systematic_absences(
array=self.filtered_array,
expand_to_p1=settings.expand_to_p1,
generate_bijvoet_mates=settings.expand_anomalous)
if (settings.slice_mode):
slice_selection = miller.simple_slice(
indices=absence_array.indices(),
slice_axis=self.axis_index,
slice_index=settings.slice_index)
absence_array = absence_array.select(slice_selection)
absence_flags = absence_array.data()
if (absence_flags.count(True) == 0):
print("No systematic absences found!")
else:
new_indices = flex.miller_index()
for i_seq in absence_flags.iselection():
hkl = absence_array.indices()[i_seq]
#if (hkl in self.indices):
# j_seq = self.indices.index(hkl)
# self.colors[j_seq] = (1.0, 0.5, 1.0)
# self.radii[j_seq] = self.max_radius
# self.missing_flags[j_seq] = False
# self.sys_absent_flags[j_seq] = True
#else :
if hkl in self.indices:
print(
"Systematically absent reflection %s is unexpectedly present in %s"
% (hkl, array.info().label_string()))
else:
new_indices.append(hkl)
if (new_indices.size() > 0):
uc = self.work_array.unit_cell()
points = uc.reciprocal_space_vector(new_indices) * 100
self.points.extend(points)
n_sys_absent = new_indices.size()
self.radii.extend(
flex.double(new_indices.size(), self.max_radius / 2.0))
self.indices.extend(new_indices)
self.missing_flags.extend(flex.bool(new_indices.size(), False))
self.sys_absent_flags.extend(
flex.bool(new_indices.size(), True))
self.ExtendData(n_sys_absent)
if (settings.color_scheme == "redblue"):
self.colors.extend(
flex.vec3_double(new_indices.size(), (1., 1.0, 0.)))
else:
self.colors.extend(
flex.vec3_double(new_indices.size(), (1., 0.5, 1.)))
def exercise_slices () :
i = flex.miller_index(((1,2,3), (3,0,3), (2,4,1),(0,1,2)))
s = miller.simple_slice(
indices=i,
slice_axis=2,
slice_index=3)
assert (list(s) == [True, True, False, False])
s = miller.multi_slice(
indices=i,
slice_axis=0,
slice_start=1,
slice_end=2)
assert (list(s) == [True, False, True, False])
def exercise_slices():
i = flex.miller_index(((1,2,3), (3,0,3), (2,4,1),(0,1,2)))
s = miller.simple_slice(
indices=i,
slice_axis=2,
slice_index=3)
assert (list(s) == [True, True, False, False])
s = miller.multi_slice(
indices=i,
slice_axis=0,
slice_start=1,
slice_end=2)
assert (list(s) == [True, False, True, False])
def __init__ (self, miller_array, settings, merge=None) :
self.miller_array = miller_array
self.settings = settings
self.merge_equivalents = merge
from cctbx import miller
from cctbx import crystal
from cctbx.array_family import flex
self.multiplicities = None
self.process_input_array()
array = self.work_array
uc = array.unit_cell()
self.unit_cell = uc
self.slice_selection = None
self.axis_index = None
if (settings.slice_mode) :
self.axis_index = ["h","k","l"].index(self.settings.slice_axis)
self.slice_selection = miller.simple_slice(
indices=array.indices(),
slice_axis=self.axis_index,
slice_index=settings.slice_index)
#if (self.slice_selection.count(True) == 0) :
#raise ValueError("No data selected!")
index_span = array.index_span()
self.d_min = array.d_min()
self.hkl_range = index_span.abs_range()
self.axes = [ uc.reciprocal_space_vector((self.hkl_range[0],0,0)),
uc.reciprocal_space_vector((0,self.hkl_range[1],0)),
uc.reciprocal_space_vector((0,0,self.hkl_range[2])) ]
self.generate_view_data()
if (self.slice_selection is not None) :
self.indices = self.work_array.indices().select(self.slice_selection)
self.data = self.data.select(self.slice_selection)
else :
self.indices = array.indices()
self.points = uc.reciprocal_space_vector(self.indices) * 100.
self.missing_flags = flex.bool(self.radii.size(), False)
self.sys_absent_flags = flex.bool(self.radii.size(), False)
if (settings.show_missing) :
self.generate_missing_reflections()
if (settings.show_systematic_absences) and (not settings.show_only_missing):
self.generate_systematic_absences()
# XXX hack for process_pick_points
self.visible_points = flex.bool(self.points.size(), True)
n_points = self.points.size()
assert (self.colors.size() == n_points)
assert (self.indices.size() == n_points)
assert (self.radii.size() == n_points)
assert (self.missing_flags.size() == n_points)
assert (self.sys_absent_flags.size() == n_points)
assert (self.data.size() == n_points)
self.clear_labels()
def generate_missing_reflections(self):
from cctbx import miller
from cctbx.array_family import flex
settings = self.settings
array = self.work_array
uc = array.unit_cell()
if (settings.show_only_missing):
self.colors = flex.vec3_double()
self.points = flex.vec3_double()
self.radii = flex.double()
self.missing_flags = flex.bool()
self.indices = flex.miller_index()
self.data = flex.double()
self.phases = flex.double()
self.ampl = flex.double()
self.foms = flex.double()
self.radians = flex.double()
self.sys_absent_flags = flex.bool()
if (settings.slice_mode):
slice_selection = miller.simple_slice(
indices=self.missing_set.indices(),
slice_axis=self.axis_index,
slice_index=settings.slice_index)
missing = self.missing_set.select(slice_selection).indices()
else:
missing = self.missing_set.indices()
n_missing = missing.size()
if (n_missing > 0):
points_missing = uc.reciprocal_space_vector(missing) * 100.
self.points.extend(points_missing)
if (settings.color_scheme == "heatmap"):
self.colors.extend(flex.vec3_double(n_missing, (0., 1., 0.)))
elif (not settings.color_scheme in ["rainbow", "redblue"]):
self.colors.extend(flex.vec3_double(n_missing, (1., 0, 0)))
else:
self.colors.extend(flex.vec3_double(n_missing, (1., 1., 1.)))
self.radii.extend(flex.double(n_missing, self.max_radius))
self.missing_flags.extend(flex.bool(n_missing, True))
self.indices.extend(missing)
#self.data.extend(flex.double(n_missing, -1.))
self.data = ExtendData(self.data, n_missing)
self.phases = ExtendData(self.phases, n_missing)
self.ampl = ExtendData(self.ampl, n_missing)
self.foms = ExtendData(self.foms, n_missing)
self.radians = ExtendData(self.radians, n_missing)
if self.sigmas:
self.sigmas = ExtendData(self.sigmas, n_missing)
self.sys_absent_flags.extend(flex.bool(n_missing, False))
def generate_systematic_absences (self) :
from cctbx import miller
from cctbx import crystal
from cctbx.array_family import flex
settings = self.settings
array = self.filtered_array # XXX use original array here!
absence_array = generate_systematic_absences(
array=self.filtered_array,
expand_to_p1=settings.expand_to_p1,
generate_bijvoet_mates=settings.expand_anomalous)
if (settings.slice_mode) :
slice_selection = miller.simple_slice(
indices=absence_array.indices(),
slice_axis=self.axis_index,
slice_index=settings.slice_index)
absence_array = absence_array.select(slice_selection)
absence_flags = absence_array.data()
if (absence_flags.count(True) == 0) :
print "No systematic absences found!"
else :
new_indices = flex.miller_index()
for i_seq in absence_flags.iselection() :
hkl = absence_array.indices()[i_seq]
#if (hkl in self.indices) :
# j_seq = self.indices.index(hkl)
# self.colors[j_seq] = (1.0, 0.5, 1.0)
# self.radii[j_seq] = self.max_radius
# self.missing_flags[j_seq] = False
# self.sys_absent_flags[j_seq] = True
#else :
new_indices.append(hkl)
if (new_indices.size() > 0) :
uc = self.work_array.unit_cell()
points = uc.reciprocal_space_vector(new_indices) * 100
self.points.extend(points)
n_sys_absent = new_indices.size()
self.radii.extend(flex.double(new_indices.size(), self.max_radius))
self.indices.extend(new_indices)
self.missing_flags.extend(flex.bool(new_indices.size(), False))
self.sys_absent_flags.extend(flex.bool(new_indices.size(), True))
self.data.extend(flex.double(n_sys_absent, -1.))
if (settings.color_scheme == "redblue") :
self.colors.extend(flex.vec3_double(new_indices.size(), (1.,1.0,0.)))
else :
self.colors.extend(flex.vec3_double(new_indices.size(), (1.,0.5,1.)))
def generate_missing_reflections (self) :
from cctbx import miller
from cctbx.array_family import flex
settings = self.settings
array = self.work_array
uc = array.unit_cell()
if (settings.show_only_missing) :
self.colors = flex.vec3_double()
self.points = flex.vec3_double()
self.radii = flex.double()
self.missing_flags = flex.bool()
self.indices = flex.miller_index()
self.data = flex.double()
self.sys_absent_flags = flex.bool()
if (settings.slice_mode) :
slice_selection = miller.simple_slice(
indices=self.missing_set.indices(),
slice_axis=self.axis_index,
slice_index=settings.slice_index)
missing = self.missing_set.select(slice_selection).indices()
else :
missing = self.missing_set.indices()
n_missing = missing.size()
if (n_missing > 0) :
points_missing = uc.reciprocal_space_vector(missing) * 100.
self.points.extend(points_missing)
if (settings.color_scheme == "heatmap") :
self.colors.extend(flex.vec3_double(n_missing, (0.,1.,0.)))
elif (not settings.color_scheme in ["rainbow","redblue"]) :
self.colors.extend(flex.vec3_double(n_missing, (1.,0,0)))
else :
self.colors.extend(flex.vec3_double(n_missing, (1.,1.,1.)))
self.radii.extend(flex.double(n_missing, self.max_radius / 2))
self.missing_flags.extend(flex.bool(n_missing, True))
self.indices.extend(missing)
self.data.extend(flex.double(n_missing, -1.))
self.sys_absent_flags.extend(flex.bool(n_missing, False))
def __init__(self, miller_array, settings, merge=None, foms_array=None):
self.miller_array = miller_array
self.renderscale = 100.0
self.foms_workarray = foms_array
self.settings = settings
self.merge_equivalents = merge
from cctbx import crystal
from cctbx.array_family import flex
self.multiplicities = None
self.foms = flex.double(self.miller_array.size(), float('nan'))
if self.miller_array.is_complex_array():
# want to display map coefficient as circular colours but weighted with FOMS
# so copy any provided foms in the empty list of sigmas
if foms_array:
assert (self.miller_array.size() == foms_array.size())
self.foms_workarray, dummy = self.process_input_array(
foms_array)
self.foms = self.foms_workarray.data().deep_copy()
self.work_array, self.multiplicities = self.process_input_array(
self.miller_array)
array = self.work_array
uc = array.unit_cell()
self.unit_cell = uc
self.slice_selection = None
self.axis_index = None
if (settings.slice_mode):
self.axis_index = ["h", "k", "l"].index(self.settings.slice_axis)
self.slice_selection = miller.simple_slice(
indices=array.indices(),
slice_axis=self.axis_index,
slice_index=settings.slice_index)
#if (self.slice_selection.count(True) == 0):
#raise ValueError("No data selected!")
index_span = array.index_span()
self.d_min = array.d_min()
self.hkl_range = index_span.abs_range()
self.axes = [
uc.reciprocal_space_vector((self.hkl_range[0], 0, 0)),
uc.reciprocal_space_vector((0, self.hkl_range[1], 0)),
uc.reciprocal_space_vector((0, 0, self.hkl_range[2]))
]
self.generate_view_data()
if (self.slice_selection is not None):
self.indices = self.work_array.indices().select(
self.slice_selection)
self.data = self.data.select(self.slice_selection)
self.phases = self.phases.select(self.slice_selection)
self.radians = self.radians.select(self.slice_selection)
self.ampl = self.ampl.select(self.slice_selection)
self.foms = self.foms.select(self.slice_selection)
else:
self.indices = array.indices()
self.points = uc.reciprocal_space_vector(
self.indices) * self.renderscale
self.missing_flags = flex.bool(self.radii.size(), False)
self.sys_absent_flags = flex.bool(self.radii.size(), False)
if (settings.show_missing):
self.generate_missing_reflections()
if (settings.show_systematic_absences) and (
not settings.show_only_missing):
self.generate_systematic_absences()
# XXX hack for process_pick_points
self.visible_points = flex.bool(self.points.size(), True)
n_points = self.points.size()
assert (self.colors.size() == n_points)
assert (self.indices.size() == n_points)
assert (self.radii.size() == n_points)
assert (self.missing_flags.size() == n_points)
assert (self.sys_absent_flags.size() == n_points)
assert (self.data.size() == n_points)
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
assert (self.phases.size() == n_points)
assert (self.radians.size() == n_points)
assert (self.ampl.size() == n_points)
if foms_array:
assert (self.foms.size() == n_points)
else:
self.foms = flex.double(n_points, float('nan'))
self.clear_labels()
def __init__(self,
miller_array,
settings,
merge=None,
foms_array=None,
fullprocessarray=True):
self.miller_array = miller_array
self.renderscale = 100.0
self.foms_workarray = foms_array
self.SceneCreated = False
self.settings = settings
self.merge_equivalents = False
if not self.miller_array.is_unique_set_under_symmetry():
self.merge_equivalents = merge
from cctbx import crystal
from cctbx.array_family import flex
self.multiplicities = None
self.fomlabel = ""
self.foms = flex.double(self.miller_array.size(), float('nan'))
self._is_using_foms = False
self.fullprocessarray = fullprocessarray
if self.miller_array.is_complex_array():
# Colour map coefficient as a circular rainbow with saturation as a function of FOMs
# process the foms miller array and store the foms data for later use when computing colours
if foms_array:
assert (self.miller_array.size() == foms_array.size())
self.foms_workarray, dummy = self.process_input_array(
foms_array)
if not self.foms_workarray:
return
self.foms = self.foms_workarray.data()
self.fomlabel = foms_array.info().label_string()
self._is_using_foms = True
self.work_array, self.multiplicities = self.process_input_array(
self.miller_array)
if not self.work_array:
return
array = self.work_array
uc = array.unit_cell()
self.unit_cell = uc
self.slice_selection = None
self.axis_index = None
if (settings.slice_mode):
self.axis_index = ["h", "k", "l"].index(self.settings.slice_axis)
self.slice_selection = miller.simple_slice(
indices=array.indices(),
slice_axis=self.axis_index,
slice_index=settings.slice_index)
#if (self.slice_selection.count(True) == 0):
#raise ValueError("No data selected!")
index_span = array.index_span()
self.colourlabel = self.miller_array.info().labels[0]
self.d_min = array.d_min()
self.min_dist = 0.0
self.nth_power_scale_radii = settings.nth_power_scale_radii
self.hkl_range = index_span.abs_range()
self.axes = [
uc.reciprocal_space_vector((self.hkl_range[0], 0, 0)),
uc.reciprocal_space_vector((0, self.hkl_range[1], 0)),
uc.reciprocal_space_vector((0, 0, self.hkl_range[2]))
]
self.generate_view_data()
if (self.slice_selection is not None):
self.indices = self.work_array.indices().select(
self.slice_selection).deep_copy()
self.data = self.data.select(self.slice_selection)
self.phases = self.phases.select(self.slice_selection)
self.radians = self.radians.select(self.slice_selection)
self.ampl = self.ampl.select(self.slice_selection)
if self.sigmas:
self.sigmas = self.sigmas.select(self.slice_selection)
if foms_array:
self.foms = self.foms.select(self.slice_selection)
else:
self.indices = array.indices()
self.points = uc.reciprocal_space_vector(
self.indices) * self.renderscale
n_points = self.points.size()
if not fullprocessarray:
self.radii = flex.double()
self.radii = ExtendAnyData(self.radii, n_points)
self.colors = flex.vec3_double()
self.colors = ExtendAnyData(self.colors, n_points)
self.missing_flags = flex.bool(self.radii.size(), False)
self.sys_absent_flags = flex.bool(self.radii.size(), False)
if (settings.show_missing):
self.generate_missing_reflections()
if (settings.show_systematic_absences) and (
not settings.show_only_missing):
self.generate_systematic_absences()
n_points = self.points.size()
assert (self.colors.size() == n_points)
assert (self.indices.size() == n_points)
assert (self.radii.size() == n_points)
assert (self.missing_flags.size() == n_points)
assert (self.sys_absent_flags.size() == n_points)
assert (self.data.size() == n_points)
assert (self.phases.size() == n_points)
assert (self.radians.size() == n_points)
assert (self.ampl.size() == n_points)
if self.sigmas:
assert (self.sigmas.size() == n_points)
if foms_array:
assert (self.foms.size() == n_points)
else:
self.foms = flex.double(n_points, float('nan'))
self.dres = uc.d(self.indices)
self.clear_labels()
self.SceneCreated = True
