def create(cls, data, detector_space=False, deconvolution=False):
from dials.algorithms.profile_model.gaussian_rs.algorithm import (
GaussianRSIntensityCalculatorFactory,
)
from dials.algorithms.integration.parallel_integrator import (
GaussianRSReferenceProfileData,
)
from dials.algorithms.integration.parallel_integrator import (
GaussianRSMultiCrystalReferenceProfileData,
)
from dials.algorithms.integration.parallel_integrator import (
ReferenceProfileData,
)
from dials.algorithms.profile_model.modeller import CircleSampler
from dials.algorithms.profile_model.gaussian_rs.transform import TransformSpec
reference = data.reference[0]
experiments = data.experiments
assert len(reference) % 9 == 0
num_scan_points = len(reference) // 9
data_spec = GaussianRSMultiCrystalReferenceProfileData()
for e in experiments:
sampler = CircleSampler(
e.detector[0].get_image_size(),
e.scan.get_array_range(),
num_scan_points,
)
spec = TransformSpec(
e.beam,
e.detector,
e.goniometer,
e.scan,
e.profile.sigma_b(deg=False),
e.profile.sigma_m(deg=False),
e.profile.n_sigma() * 1.5,
5,
)
temp = reference
reference = ReferenceProfileData()
for d, m in temp:
reference.append(d, m)
spec = GaussianRSReferenceProfileData(reference, sampler, spec)
data_spec.append(spec)
return GaussianRSIntensityCalculatorFactory.create(
data_spec, detector_space, deconvolution
)
def test_gaussianrs_profile_data_pickling(data):
from dials.algorithms.integration.parallel_integrator import (
GaussianRSReferenceProfileData,
)
from dials.algorithms.integration.parallel_integrator import (
GaussianRSMultiCrystalReferenceProfileData,
)
from dials.algorithms.integration.parallel_integrator import ReferenceProfileData
from dials.algorithms.profile_model.modeller import CircleSampler
from dials.algorithms.profile_model.gaussian_rs.transform import TransformSpec
reference = data.reference[0]
experiments = data.experiments
assert len(reference) % 9 == 0
num_scan_points = len(reference) // 9
data_spec = GaussianRSMultiCrystalReferenceProfileData()
for e in experiments:
sampler = CircleSampler(
e.detector[0].get_image_size(), e.scan.get_array_range(), num_scan_points
)
spec = TransformSpec(
e.beam,
e.detector,
e.goniometer,
e.scan,
e.profile.sigma_b(deg=False),
e.profile.sigma_m(deg=False),
e.profile.n_sigma() * 1.5,
5,
)
temp = reference
reference = ReferenceProfileData()
for d, m in temp:
reference.append(d, m)
spec = GaussianRSReferenceProfileData(reference, sampler, spec)
data_spec.append(spec)
s = pickle.dumps(data_spec)
pickle.loads(s)
def construct_reference(experiments, reference):
from dials.algorithms.integration.parallel_integrator import (
GaussianRSReferenceProfileData, )
from dials.algorithms.integration.parallel_integrator import (
GaussianRSMultiCrystalReferenceProfileData, )
from dials.algorithms.integration.parallel_integrator import ReferenceProfileData
from dials.algorithms.profile_model.modeller import CircleSampler
from dials.array_family import flex
from dials.algorithms.profile_model.gaussian_rs.transform import TransformSpec
assert len(reference) % 9 == 0
num_scan_points = len(reference) // 9
data_spec = GaussianRSMultiCrystalReferenceProfileData()
for e in experiments:
sampler = CircleSampler(e.detector[0].get_image_size(),
e.scan.get_array_range(), num_scan_points)
spec = TransformSpec(
e.beam,
e.detector,
e.goniometer,
e.scan,
e.profile.sigma_b(deg=False),
e.profile.sigma_m(deg=False),
e.profile.n_sigma() * 1.5,
grid_size,
)
temp = reference
reference = ReferenceProfileData()
for d, m in temp:
reference.append(d, m)
spec = GaussianRSReferenceProfileData(reference, sampler, spec)
data_spec.append(spec)
return data_spec
def create(cls,
experiments,
grid_size=5,
scan_step=5,
grid_method="circular_grid"):
"""
Create the intensity calculator
"""
from dials.algorithms.integration.parallel_integrator import (
GaussianRSReferenceCalculator, )
from dials.algorithms.profile_model.modeller import SingleSampler
from dials.algorithms.profile_model.modeller import CircleSampler
from dials.algorithms.profile_model.modeller import GridSampler
from dials.algorithms.profile_model.modeller import EwaldSphereSampler
from dials.algorithms.profile_model.gaussian_rs.transform import TransformSpec
from math import ceil
# Assume the detector and scan are the same in each case
detector = experiments[0].detector
scan = experiments[0].scan
# Get the number of scan points
scan_range = scan.get_oscillation_range(deg=True)
scan_range = abs(scan_range[1] - scan_range[0])
num_scan_points = int(ceil(scan_range / scan_step))
# If multi panel then set to single
if grid_method in ["regular_grid", "circular_grid"
] and len(detector) > 1:
grid_method = "single"
# Create the sampler
if grid_method == "single":
sampler = SingleSampler(scan.get_array_range(), num_scan_points)
elif grid_method == "regular_grid":
sampler = GridSampler(
detector[0].get_image_size(),
scan.get_array_range(),
(3, 3, num_scan_points),
)
elif grid_method == "circular_grid":
sampler = CircleSampler(detector[0].get_image_size(),
scan.get_array_range(), num_scan_points)
elif grid_method == "spherical_grid":
sampler = EwaldSphereGridSampler(
experiments[0].beam,
experiments[0].detector,
experiments[0].goniometer,
experiments[0].scan,
num_scan_points,
)
else:
raise RuntimeError("Unknown grid type")
# Create the spec list
spec_list = []
for experiment in experiments:
spec = TransformSpec(
experiment.beam,
experiment.detector,
experiment.goniometer,
experiment.scan,
experiment.profile.sigma_b(deg=False),
experiment.profile.sigma_m(deg=False),
experiment.profile.n_sigma() * 1.5,
grid_size,
)
spec_list.append(spec)
# Return the intensity algorithm
return GaussianRSReferenceCalculator(sampler, spec_list)
def compute_reference(experiments, reflections):
from dials.algorithms.profile_model.modeller import CircleSampler
from dials.array_family import flex
from dials.algorithms.profile_model.gaussian_rs.transform import TransformForward
from dials.algorithms.profile_model.gaussian_rs.transform import TransformSpec
from dials.algorithms.profile_model.gaussian_rs import CoordinateSystem
reflections = select_strong(reflections)
print("Selected %d strong spots" % len(reflections))
sampler = CircleSampler(
experiments[0].detector[0].get_image_size(),
experiments[0].scan.get_array_range(),
1,
)
n_sigma = 4.0
grid_size = 25
spec = TransformSpec(
experiments[0].beam,
experiments[0].detector,
experiments[0].goniometer,
experiments[0].scan,
experiments[0].profile.sigma_b(deg=False),
experiments[0].profile.sigma_m(deg=False),
n_sigma,
grid_size,
)
m2 = experiments[0].goniometer.get_rotation_axis()
s0 = experiments[0].beam.get_s0()
reference = [
flex.double(
flex.grid(1 + 2 * grid_size, 1 + 2 * grid_size, 1 + 2 * grid_size))
for i in range(len(sampler))
]
count = [0] * len(sampler)
for r in reflections:
s1 = r["s1"]
phi = r["xyzcal.mm"][2]
xyz = r["xyzcal.px"]
bbox = r["bbox"]
panel = r["panel"]
image = r["shoebox"].data.as_double()
mask = r["shoebox"].mask.as_1d() == 5
mask.reshape(image.accessor())
cs = CoordinateSystem(m2, s0, s1, phi)
try:
transform = TransformForward(spec, cs, bbox, panel, image, mask)
d = transform.profile()
d /= flex.sum(d)
index = sampler.nearest(0, xyz)
indices = sampler.nearest_n(0, xyz)
for i in indices:
w = sampler.weight(i, 0, xyz)
reference[i] += w * d
count[i] += 1
except Exception:
pass
for i in range(len(reference)):
r = reference[i]
if flex.sum(r) > 0:
print(flex.max(r))
g = r.accessor()
r = r.as_1d()
s = r > 0.02 * flex.max(r)
r.set_selected(~s, flex.double(len(r), 0))
r = r / flex.sum(r)
r.reshape(g)
reference[i] = r
for i in range(len(reference)):
from matplotlib import pylab
print(count[i])
r = reference[i]
d = r.as_numpy_array()[11, :, :]
pylab.imshow(d, interpolation="None")
pylab.show()
return reference
def integrate(experiments, reflections, reference):
from dials.algorithms.profile_model.modeller import CircleSampler
from dials.array_family import flex
from dials.algorithms.profile_model.gaussian_rs.transform import TransformReverse
from dials.algorithms.profile_model.gaussian_rs.transform import TransformForward
from dials.algorithms.profile_model.gaussian_rs.transform import (
TransformReverseNoModel, )
from dials.algorithms.profile_model.gaussian_rs.transform import TransformSpec
from dials.algorithms.profile_model.gaussian_rs import CoordinateSystem
selection = reflections.get_flags(reflections.flags.integrated_sum)
reflections = reflections.select(selection)
print("Selected %d reflections to integrate" % len(reflections))
sampler = CircleSampler(
experiments[0].detector[0].get_image_size(),
experiments[0].scan.get_array_range(),
1,
)
n_sigma = 4.0
grid_size = 25
spec = TransformSpec(
experiments[0].beam,
experiments[0].detector,
experiments[0].goniometer,
experiments[0].scan,
experiments[0].profile.sigma_b(deg=False),
experiments[0].profile.sigma_m(deg=False),
n_sigma,
grid_size,
)
m2 = experiments[0].goniometer.get_rotation_axis()
s0 = experiments[0].beam.get_s0()
Iprf = flex.double(len(reflections))
Vprf = flex.double(len(reflections))
Cprf = flex.double(len(reflections))
Fprf = flex.bool(len(reflections))
for i, r in enumerate(reflections):
s1 = r["s1"]
phi = r["xyzcal.mm"][2]
xyz = r["xyzcal.px"]
bbox = r["bbox"]
panel = r["panel"]
image = r["shoebox"].data.as_double()
background = r["shoebox"].background.as_double()
mask = r["shoebox"].mask.as_1d(
) == 5 # | (r['shoebox'].mask.as_1d() == 3)
mask.reshape(image.accessor())
cs = CoordinateSystem(m2, s0, s1, phi)
index = sampler.nearest(0, xyz)
profile = reference[index]
# print flex.sum(profile)
# print r['partiality']
if False:
from dials.algorithms.integration.maximum_likelihood import (
ProfileFittingDouble as ProfileFitting, )
transform = TransformReverseNoModel(spec, cs, bbox, panel, profile)
p = transform.profile()
d = image
m = mask
b = background
# print flex.sum(p)
ysize, xsize = p.all()[1:3]
p1 = flex.double(flex.grid(1, ysize, xsize))
d1 = flex.double(flex.grid(1, ysize, xsize))
b1 = flex.double(flex.grid(1, ysize, xsize))
m1 = flex.double(flex.grid(1, ysize, xsize))
for k in range(p.all()[0]):
p1 += p[k:k + 1, :, :]
d1 += d[k:k + 1, :, :]
b1 += b[k:k + 1, :, :]
m1 = m[k:k + 1, :, :]
try:
fit = ProfileFitting(p1, m1, d1, b1, 1e-3, 1000)
assert fit.niter() < 1000
Iprf[i] = fit.intensity()
Vprf[i] = fit.variance()
Cprf[i] = fit.correlation()
Fprf[i] = True
print(i, fit.intensity(), flex.sum(p1))
# from matplotlib import pylab
# pylab.imshow(p1.as_numpy_array()[0,:,:], interpolation='none')
# pylab.show()
except Exception:
pass
else:
from dials.algorithms.integration.fit import (
ProfileFittingDouble as ProfileFitting, )
try:
transform = TransformForward(spec, cs, bbox, panel, image,
background, mask)
index = sampler.nearest(0, xyz)
p = reference[index]
d = transform.profile()
b = transform.background()
m = p > 0
fit = ProfileFitting(p, m, d, b, 1e-3, 1000)
assert fit.niter() < 1000
Iprf[i] = fit.intensity()
Vprf[i] = fit.variance()
Cprf[i] = fit.correlation()
Fprf[i] = True
print(i, fit.intensity(), flex.sum(p))
# from matplotlib import pylab
# pylab.imshow(p1.as_numpy_array()[0,:,:], interpolation='none')
# pylab.show()
except Exception:
pass
reflections["intensity.prf.value"] = Iprf
reflections["intensity.prf.variance"] = Vprf
reflections["intensity.prf.correlation"] = Cprf
reflections.set_flags(Fprf, reflections.flags.integrated_prf)
return reflections
def integrate_job(block,
experiments,
reflections,
reference,
grid_size=5,
detector_space=False):
from dials.algorithms.profile_model.modeller import CircleSampler
from dials.array_family import flex
from dials.algorithms.profile_model.gaussian_rs.transform import TransformReverse
from dials.algorithms.profile_model.gaussian_rs.transform import TransformForward
from dials.algorithms.profile_model.gaussian_rs.transform import (
TransformReverseNoModel, )
from dials.algorithms.profile_model.gaussian_rs.transform import TransformSpec
from dials.algorithms.profile_model.gaussian_rs import CoordinateSystem
from dials.algorithms.integration.fit import ProfileFitter
from dials.array_family import flex
from dials.model.data import make_image
reflections["shoebox"] = flex.shoebox(reflections["panel"],
reflections["bbox"],
allocate=True)
frame0, frame1 = experiments[0].scan.get_array_range()
frame0 = frame0 + block[0]
frame1 = frame0 + block[1]
reflections["shoebox"] = flex.shoebox(reflections["panel"],
reflections["bbox"],
allocate=True)
extractor = flex.ShoeboxExtractor(reflections, 1, frame0, frame1)
iset = experiments[0].imageset[block[0]:block[1]]
for i in range(len(iset)):
print("Reading image %d" % i)
data = iset.get_raw_data(i)
mask = iset.get_mask(i)
extractor.next(make_image(data, mask))
print("Computing mask")
reflections.compute_mask(experiments)
print("Computing background")
reflections.compute_background(experiments)
print("Computing centroid")
reflections.compute_centroid(experiments)
print("Computing summed intensity")
reflections.compute_summed_intensity()
assert len(reference) % 9 == 0
num_scan_points = len(reference) // 9
sampler = CircleSampler(
experiments[0].detector[0].get_image_size(),
experiments[0].scan.get_array_range(),
num_scan_points,
)
spec = TransformSpec(
experiments[0].beam,
experiments[0].detector,
experiments[0].goniometer,
experiments[0].scan,
experiments[0].profile.sigma_b(deg=False),
experiments[0].profile.sigma_m(deg=False),
experiments[0].profile.n_sigma() * 1.5,
grid_size,
)
m2 = experiments[0].goniometer.get_rotation_axis()
s0 = experiments[0].beam.get_s0()
Iprf = flex.double(len(reflections))
Vprf = flex.double(len(reflections))
Cprf = flex.double(len(reflections))
Fprf = flex.bool(len(reflections))
Part = reflections["partiality"]
reflections["intensity.prf_old.value"] = reflections["intensity.prf.value"]
reflections["intensity.prf_old.variance"] = reflections[
"intensity.prf.variance"]
selection = reflections.get_flags(reflections.flags.integrated_prf)
reflections.unset_flags(~Fprf, reflections.flags.integrated_prf)
for i, r in enumerate(reflections):
if selection[i] == False:
continue
s1 = r["s1"]
phi = r["xyzcal.mm"][2]
xyz = r["xyzcal.px"]
bbox = r["bbox"]
panel = r["panel"]
image = r["shoebox"].data.as_double()
background = r["shoebox"].background.as_double()
mask = r["shoebox"].mask.as_1d(
) == 5 # | (r['shoebox'].mask.as_1d() == 3)
mask.reshape(image.accessor())
cs = CoordinateSystem(m2, s0, s1, phi)
index = sampler.nearest(0, xyz)
profile, profile_mask = reference[index]
# print flex.sum(profile)
# print r['partiality']
if detector_space:
transform = TransformReverseNoModel(spec, cs, bbox, panel, profile)
p = transform.profile()
d = image
m = mask
b = background
# print flex.sum(p)
Part[i] = flex.sum(p)
# ysize, xsize = p.all()[1:3]
# p1 = flex.double(flex.grid(1, ysize , xsize))
# d1 = flex.double(flex.grid(1, ysize , xsize))
# b1 = flex.double(flex.grid(1, ysize , xsize))
# m1 = flex.double(flex.grid(1, ysize , xsize))
# for k in range(p.all()[0]):
# p1 += p[k:k+1,:,:]
# d1 += d[k:k+1,:,:]
# b1 += b[k:k+1,:,:]
# m1 = m[k:k+1,:,:]
try:
fit = ProfileFitter(d, b, m, p, 1e-3, 100)
assert fit.niter() < 100
Iprf[i] = fit.intensity()
Vprf[i] = fit.variance()
Cprf[i] = fit.correlation()
Fprf[i] = True
# if r['intensity.sum.value'] > 10 and abs(fit.intensity()) < 1e-3:
print(
r["miller_index"],
i,
fit.intensity(),
r["intensity.sum.value"],
r["intensity.prf_old.value"],
Part[i],
fit.niter(),
)
# from matplotlib import pylab
# pylab.imshow(p1.as_numpy_array()[0,:,:], interpolation='none')
# pylab.show()
except Exception as e:
print(e)
pass
else:
try:
transform = TransformForward(spec, cs, bbox, panel, image,
background, mask)
p = profile
d = transform.profile()
b = transform.background()
m = transform.mask() & profile_mask
# if r['miller_index'] == (9, -25, 74):
# print list(p)
# print list(m)
# print list(b)
# print list(d)
# exit(0)
fit = ProfileFitter(d, b, m, p, 1e-3, 100)
assert fit.niter() < 100
Iprf[i] = fit.intensity()[0]
Vprf[i] = fit.variance()[0]
Cprf[i] = fit.correlation()
Fprf[i] = True
print(r["miller_index"], i, fit.intensity(),
r["intensity.prf_old.value"])
# from matplotlib import pylab
# pylab.imshow(p1.as_numpy_array()[0,:,:], interpolation='none')
# pylab.show()
except Exception as e:
pass
reflections["intensity.prf.value"] = Iprf
reflections["intensity.prf.variance"] = Vprf
reflections["intensity.prf.correlation"] = Cprf
reflections.set_flags(Fprf, reflections.flags.integrated_prf)
del reflections["shoebox"]
return reflections