def generate_predictions(self, N):
"""Generate some reflections."""
from dials.algorithms import filtering
from dials.algorithms.profile_model.gaussian_rs import MaskCalculator3D
from dials.algorithms.profile_model.gaussian_rs import Model as ProfileModel
from dials.algorithms.shoebox import MaskCode
from dials.util.command_line import Command
# Set the profile model
self.experiment.profile = ProfileModel(None, self.n_sigma,
self.sigma_b, self.sigma_m)
# Generate a list of reflections
refl = flex.reflection_table.from_predictions(self.experiment)
refl["id"] = flex.int(len(refl), 0)
# Filter by zeta
zeta = 0.05
Command.start(f"Filtering by zeta >= {zeta:f}")
mask = filtering.by_zeta(self.experiment.goniometer,
self.experiment.beam, refl["s1"], zeta)
refl.del_selected(~mask)
Command.end(f"Filtered {len(refl)} reflections by zeta >= {zeta:f}")
# Compute the bounding box
refl.compute_bbox([self.experiment])
index = []
image_size = self.experiment.detector[0].get_image_size()
array_range = self.experiment.scan.get_array_range()
bbox = refl["bbox"]
for i in range(len(refl)):
x0, x1, y0, y1, z0, z1 = bbox[i]
if (x0 < 0 or x1 > image_size[0] or y0 < 0 or y1 > image_size[1]
or z0 < array_range[0] or z1 > array_range[1]):
index.append(i)
refl.del_selected(flex.size_t(index))
# Sample if specified
index = random.sample(range(len(refl)), N)
refl = refl.select(flex.size_t(index))
# Compute the bounding box
# Create a load of shoeboxes
Command.start(f"Creating shoeboxes for {len(refl)} reflections")
refl["shoebox"] = flex.shoebox(refl["panel"], refl["bbox"])
refl["shoebox"].allocate_with_value(MaskCode.Valid)
Command.end(f"Created shoeboxes for {len(refl)} reflections")
# Get the function object to mask the foreground
Command.start(f"Masking Foreground for {len(refl)} reflections")
mask_foreground = MaskCalculator3D(
self.experiment.beam,
self.experiment.detector,
self.experiment.goniometer,
self.experiment.scan,
self.n_sigma * self.sigma_b,
self.n_sigma * self.sigma_m,
)
# Mask the foreground
mask_foreground(refl["shoebox"], refl["s1"],
refl["xyzcal.px"].parts()[2], refl["panel"])
Command.end(f"Masked foreground for {len(refl)} reflections")
# Return the reflections
return refl
class Test(object):
def __init__(self):
from os.path import join, isfile
import libtbx.load_env
try:
dials_regression = libtbx.env.dist_path('dials_regression')
except KeyError, e:
print 'SKIP: dials_regression not configured'
exit(0)
# The base path
path = join(dials_regression, 'integration_test_data', 'simulated')
# Set the experiment filename
expr_filename = join(path, 'experiments.json')
# The reference spots filesname
reference_filename = join(path, 'simulated_n10000_i10000_b0.pickle')
# The paths to the reflection files
self.refl_filenames = [
#join(path, 'simulated_n10000_i0_b10.pickle'),
#join(path, 'simulated_n10000_i0_b100.pickle'),
#join(path, 'simulated_n10000_i0_b1000.pickle'),
#join(path, 'simulated_r_n10000_i0_b1000.pickle'),
#join(path, 'simulated_n10000_i10_b0.pickle'),
#join(path, 'simulated_n10000_i100_b0.pickle'),
#join(path, 'simulated_n10000_i1000_b0.pickle'),
#join(path, 'simulated_r_n10000_i10000_b0.pickle'),
join(path, 'simulated_n10000_i10_b10.pickle'),
join(path, 'simulated_n10000_i100_b10.pickle'),
join(path, 'simulated_n10000_i1000_b10.pickle'),
join(path, 'simulated_n10000_i10000_b10.pickle'),
join(path, 'simulated_r_n10000_i10000_b10.pickle'),
join(path, 'simulated_n10000_i10_b100.pickle'),
join(path, 'simulated_n10000_i100_b100.pickle'),
join(path, 'simulated_n10000_i1000_b100.pickle'),
join(path, 'simulated_n10000_i10000_b100.pickle'),
join(path, 'simulated_r_n10000_i10000_b100.pickle'),
]
# Check the files exist
for filename in self.refl_filenames:
if not isfile(filename):
print 'SKIP: simulated test data does not exist'
print 'Generate by running the following commands:'
print ' cd dials_regression/integration_test_data/simulated'
print ' ./simulate'
exit(0)
# Load the experiments
from dxtbx.model.experiment.experiment_list import ExperimentListFactory
experiments = ExperimentListFactory.from_json_file(expr_filename,
check_format=False)
assert (len(experiments) == 1)
self.experiments = experiments
from dials.algorithms.profile_model.gaussian_rs import Model as ProfileModel
from dials.algorithms.profile_model.factory import phil_scope
from libtbx.phil import parse
params = phil_scope.fetch(parse('')).extract()
self.experiments[0].profile = ProfileModel(params.profile,
sigma_b=0.024,
sigma_m=0.044,
n_sigma=3,
deg=True)
# Load the reference spots
from dials.array_family import flex
self.reference = flex.reflection_table.from_pickle(reference_filename)
self.reference.compute_partiality(self.experiments)
mask = flex.bool(len(self.reference), True)
value = self.reference.flags.reference_spot
self.reference.set_flags(mask, value)
self.reference.set_flags(mask, self.reference.flags.integrated_sum)