def test(dials_regression):
from iotbx.xds import xparm, integrate_hkl
from dials.util import ioutil
from dials.algorithms.spot_prediction import IndexGenerator
import numpy
from rstbx.cftbx.coordinate_frame_converter import \
coordinate_frame_converter
from scitbx import matrix
# The XDS files to read from
integrate_filename = os.path.join(dials_regression, 'data', 'sim_mx',
'INTEGRATE.HKL')
gxparm_filename = os.path.join(dials_regression, 'data', 'sim_mx',
'GXPARM.XDS')
# Read the XDS files
integrate_handle = integrate_hkl.reader()
integrate_handle.read_file(integrate_filename)
gxparm_handle = xparm.reader()
gxparm_handle.read_file(gxparm_filename)
# Get the parameters we need from the GXPARM file
d_min = 1.6
space_group_type = ioutil.get_space_group_type_from_xparm(gxparm_handle)
cfc = coordinate_frame_converter(gxparm_filename)
a_vec = cfc.get('real_space_a')
b_vec = cfc.get('real_space_b')
c_vec = cfc.get('real_space_c')
unit_cell = cfc.get_unit_cell()
UB = matrix.sqr(a_vec + b_vec + c_vec).inverse()
ub_matrix = UB
# Generate the indices
index_generator = IndexGenerator(unit_cell, space_group_type, d_min)
miller_indices = index_generator.to_array()
# Get individual generated hkl
gen_h = [hkl[0] for hkl in miller_indices]
gen_k = [hkl[1] for hkl in miller_indices]
gen_l = [hkl[2] for hkl in miller_indices]
# Get individual xds generated hkl
xds_h = [hkl[0] for hkl in integrate_handle.hkl]
xds_k = [hkl[1] for hkl in integrate_handle.hkl]
xds_l = [hkl[2] for hkl in integrate_handle.hkl]
# Get min/max generated hkl
min_gen_h, max_gen_h = numpy.min(gen_h), numpy.max(gen_h)
min_gen_k, max_gen_k = numpy.min(gen_k), numpy.max(gen_k)
min_gen_l, max_gen_l = numpy.min(gen_l), numpy.max(gen_l)
# Get min/max xds generated hkl
min_xds_h, max_xds_h = numpy.min(xds_h), numpy.max(xds_h)
min_xds_k, max_xds_k = numpy.min(xds_k), numpy.max(xds_k)
min_xds_l, max_xds_l = numpy.min(xds_l), numpy.max(xds_l)
# Ensure we have the whole xds range in the generated set
assert min_gen_h <= min_xds_h and max_gen_h >= max_xds_h
assert min_gen_k <= min_xds_k and max_gen_k >= max_xds_k
assert min_gen_l <= min_xds_l and max_gen_l >= max_xds_l
def test(dials_regression):
import numpy as np
from iotbx.xds import integrate_hkl, xparm
from rstbx.cftbx.coordinate_frame_converter import coordinate_frame_converter
from dials.algorithms.spot_prediction import IndexGenerator
from dials.util import ioutil
# The XDS files to read from
integrate_filename = os.path.join(dials_regression, "data", "sim_mx",
"INTEGRATE.HKL")
gxparm_filename = os.path.join(dials_regression, "data", "sim_mx",
"GXPARM.XDS")
# Read the XDS files
integrate_handle = integrate_hkl.reader()
integrate_handle.read_file(integrate_filename)
gxparm_handle = xparm.reader()
gxparm_handle.read_file(gxparm_filename)
# Get the parameters we need from the GXPARM file
d_min = 1.6
space_group_type = ioutil.get_space_group_type_from_xparm(gxparm_handle)
cfc = coordinate_frame_converter(gxparm_filename)
unit_cell = cfc.get_unit_cell()
# Generate the indices
index_generator = IndexGenerator(unit_cell, space_group_type, d_min)
miller_indices = index_generator.to_array()
# Get individual generated hkl
gen_h = [hkl[0] for hkl in miller_indices]
gen_k = [hkl[1] for hkl in miller_indices]
gen_l = [hkl[2] for hkl in miller_indices]
# Get individual xds generated hkl
xds_h = [hkl[0] for hkl in integrate_handle.hkl]
xds_k = [hkl[1] for hkl in integrate_handle.hkl]
xds_l = [hkl[2] for hkl in integrate_handle.hkl]
# Get min/max generated hkl
min_gen_h, max_gen_h = np.min(gen_h), np.max(gen_h)
min_gen_k, max_gen_k = np.min(gen_k), np.max(gen_k)
min_gen_l, max_gen_l = np.min(gen_l), np.max(gen_l)
# Get min/max xds generated hkl
min_xds_h, max_xds_h = np.min(xds_h), np.max(xds_h)
min_xds_k, max_xds_k = np.min(xds_k), np.max(xds_k)
min_xds_l, max_xds_l = np.min(xds_l), np.max(xds_l)
# Ensure we have the whole xds range in the generated set
assert min_gen_h <= min_xds_h and max_gen_h >= max_xds_h
assert min_gen_k <= min_xds_k and max_gen_k >= max_xds_k
assert min_gen_l <= min_xds_l and max_gen_l >= max_xds_l
def run():
from iotbx.xds import xparm, integrate_hkl
from dials.util import ioutil
from dials.algorithms.spot_prediction import IndexGenerator
from os.path import realpath, dirname, join
import numpy
from rstbx.cftbx.coordinate_frame_converter import \
coordinate_frame_converter
from scitbx import matrix
# The XDS files to read from
test_path = dirname(dirname(dirname(realpath(__file__))))
integrate_filename = join(test_path, 'data/sim_mx/INTEGRATE.HKL')
gxparm_filename = join(test_path, 'data/sim_mx/GXPARM.XDS')
# Read the XDS files
integrate_handle = integrate_hkl.reader()
integrate_handle.read_file(integrate_filename)
gxparm_handle = xparm.reader()
gxparm_handle.read_file(gxparm_filename)
# Get the parameters we need from the GXPARM file
d_min = 1.6
space_group_type = ioutil.get_space_group_type_from_xparm(gxparm_handle)
cfc = coordinate_frame_converter(gxparm_filename)
a_vec = cfc.get('real_space_a')
b_vec = cfc.get('real_space_b')
c_vec = cfc.get('real_space_c')
unit_cell = cfc.get_unit_cell()
UB = matrix.sqr(a_vec + b_vec + c_vec).inverse()
ub_matrix = UB
# Generate the indices
index_generator = IndexGenerator(unit_cell, space_group_type, d_min)
miller_indices = index_generator.to_array()
# Get individual generated hkl
gen_h = [hkl[0] for hkl in miller_indices]
gen_k = [hkl[1] for hkl in miller_indices]
gen_l = [hkl[2] for hkl in miller_indices]
# Get individual xds generated hkl
xds_h = [hkl[0] for hkl in integrate_handle.hkl]
xds_k = [hkl[0] for hkl in integrate_handle.hkl]
xds_l = [hkl[0] for hkl in integrate_handle.hkl]
# Get min/max generated hkl
min_gen_h, max_gen_h = numpy.min(gen_h), numpy.max(gen_h)
min_gen_k, max_gen_k = numpy.min(gen_k), numpy.max(gen_k)
min_gen_l, max_gen_l = numpy.min(gen_l), numpy.max(gen_l)
# Get min/max xds generated hkl
min_xds_h, max_xds_h = numpy.min(xds_h), numpy.max(xds_h)
min_xds_k, max_xds_k = numpy.min(xds_k), numpy.max(xds_k)
min_xds_l, max_xds_l = numpy.min(xds_l), numpy.max(xds_l)
# Ensure we have the whole xds range in the generated set
assert(min_gen_h <= min_xds_h and max_gen_h >= max_xds_h)
assert(min_gen_k <= min_xds_k and max_gen_k >= max_xds_k)
assert(min_gen_l <= min_xds_l and max_gen_l >= max_xds_l)
# Test Passed
print "OK"
def __init__(self):
from dials.algorithms.spot_prediction import IndexGenerator
from dials.algorithms.spot_prediction import ScanStaticRayPredictor
from dials.algorithms.spot_prediction import ray_intersection
from iotbx.xds import xparm, integrate_hkl
from dials.util import ioutil
from math import ceil
import dxtbx
from rstbx.cftbx.coordinate_frame_converter import \
coordinate_frame_converter
from scitbx import matrix
# The XDS files to read from
integrate_filename = join(dials_regression,
'data/sim_mx/INTEGRATE.HKL')
gxparm_filename = join(dials_regression, 'data/sim_mx/GXPARM.XDS')
# Read the XDS files
self.integrate_handle = integrate_hkl.reader()
self.integrate_handle.read_file(integrate_filename)
self.gxparm_handle = xparm.reader()
self.gxparm_handle.read_file(gxparm_filename)
# Get the parameters we need from the GXPARM file
models = dxtbx.load(gxparm_filename)
self.beam = models.get_beam()
self.gonio = models.get_goniometer()
self.detector = models.get_detector()
self.scan = models.get_scan()
assert (len(self.detector) == 1)
#print self.detector
# Get crystal parameters
self.space_group_type = ioutil.get_space_group_type_from_xparm(
self.gxparm_handle)
cfc = coordinate_frame_converter(gxparm_filename)
a_vec = cfc.get('real_space_a')
b_vec = cfc.get('real_space_b')
c_vec = cfc.get('real_space_c')
self.unit_cell = cfc.get_unit_cell()
self.ub_matrix = matrix.sqr(a_vec + b_vec + c_vec).inverse()
# Get the minimum resolution in the integrate file
self.d_min = self.detector[0].get_max_resolution_at_corners(
self.beam.get_s0())
# Get the number of frames from the max z value
xcal, ycal, zcal = zip(*self.integrate_handle.xyzcal)
self.scan.set_image_range(
(self.scan.get_image_range()[0],
self.scan.get_image_range()[0] + int(ceil(max(zcal)))))
# Create the index generator
generate_indices = IndexGenerator(self.unit_cell,
self.space_group_type, self.d_min)
s0 = self.beam.get_s0()
m2 = self.gonio.get_rotation_axis()
fixed_rotation = self.gonio.get_fixed_rotation()
setting_rotation = self.gonio.get_setting_rotation()
UB = self.ub_matrix
dphi = self.scan.get_oscillation_range(deg=False)
# Create the ray predictor
self.predict_rays = ScanStaticRayPredictor(s0, m2, fixed_rotation,
setting_rotation, dphi)
# Predict the spot locations
self.reflections = self.predict_rays(generate_indices.to_array(), UB)
# Calculate the intersection of the detector and reflection frames
success = ray_intersection(self.detector, self.reflections)
self.reflections.select(success)
def __init__(self, dials_regression):
import dxtbx
from iotbx.xds import integrate_hkl, xparm
from rstbx.cftbx.coordinate_frame_converter import coordinate_frame_converter
from dials.algorithms.spot_prediction import (
IndexGenerator,
ScanStaticRayPredictor,
)
from dials.util import ioutil
# The XDS files to read from
integrate_filename = os.path.join(dials_regression, "data", "sim_mx",
"INTEGRATE.HKL")
gxparm_filename = os.path.join(dials_regression, "data", "sim_mx",
"GXPARM.XDS")
# Read the XDS files
self.integrate_handle = integrate_hkl.reader()
self.integrate_handle.read_file(integrate_filename)
self.gxparm_handle = xparm.reader()
self.gxparm_handle.read_file(gxparm_filename)
# Get the parameters we need from the GXPARM file
models = dxtbx.load(gxparm_filename)
self.beam = models.get_beam()
self.gonio = models.get_goniometer()
self.detector = models.get_detector()
self.scan = models.get_scan()
# Get crystal parameters
self.space_group_type = ioutil.get_space_group_type_from_xparm(
self.gxparm_handle)
cfc = coordinate_frame_converter(gxparm_filename)
a_vec = cfc.get("real_space_a")
b_vec = cfc.get("real_space_b")
c_vec = cfc.get("real_space_c")
self.unit_cell = cfc.get_unit_cell()
self.ub_matrix = matrix.sqr(a_vec + b_vec + c_vec).inverse()
# Get the minimum resolution in the integrate file
d = [self.unit_cell.d(h) for h in self.integrate_handle.hkl]
self.d_min = min(d)
# extend the resolution shell by epsilon>0
# to account for rounding artifacts on 32-bit platforms
self.d_min = self.d_min - 1e-15
# Get the number of frames from the max z value
xcal, ycal, zcal = zip(*self.integrate_handle.xyzcal)
self.scan.set_image_range((
self.scan.get_image_range()[0],
self.scan.get_image_range()[0] + int(math.ceil(max(zcal))),
))
# Print stuff
# print self.beam
# print self.gonio
# print self.detector
# print self.scan
# Create the index generator
self.generate_indices = IndexGenerator(self.unit_cell,
self.space_group_type,
self.d_min)
s0 = self.beam.get_s0()
m2 = self.gonio.get_rotation_axis()
fixed_rotation = self.gonio.get_fixed_rotation()
setting_rotation = self.gonio.get_setting_rotation()
UB = self.ub_matrix
dphi = self.scan.get_oscillation_range(deg=False)
# Create the ray predictor
self.predict_rays = ScanStaticRayPredictor(s0, m2, fixed_rotation,
setting_rotation, dphi)
# Predict the spot locations
self.reflections = self.predict_rays(self.generate_indices.to_array(),
UB)
def __init__(self):
from dials.algorithms.spot_prediction import IndexGenerator
from dials.algorithms.spot_prediction import ScanStaticRayPredictor
from iotbx.xds import xparm, integrate_hkl
from dials.util import ioutil
from math import ceil
import dxtbx
from rstbx.cftbx.coordinate_frame_converter import \
coordinate_frame_converter
from scitbx import matrix
# The XDS files to read from
integrate_filename = join(dials_regression, 'data/sim_mx/INTEGRATE.HKL')
gxparm_filename = join(dials_regression, 'data/sim_mx/GXPARM.XDS')
# Read the XDS files
self.integrate_handle = integrate_hkl.reader()
self.integrate_handle.read_file(integrate_filename)
self.gxparm_handle = xparm.reader()
self.gxparm_handle.read_file(gxparm_filename)
# Get the parameters we need from the GXPARM file
models = dxtbx.load(gxparm_filename)
self.beam = models.get_beam()
self.gonio = models.get_goniometer()
self.detector = models.get_detector()
self.scan = models.get_scan()
# Get crystal parameters
self.space_group_type = ioutil.get_space_group_type_from_xparm(
self.gxparm_handle)
cfc = coordinate_frame_converter(gxparm_filename)
a_vec = cfc.get('real_space_a')
b_vec = cfc.get('real_space_b')
c_vec = cfc.get('real_space_c')
self.unit_cell = cfc.get_unit_cell()
self.ub_matrix = matrix.sqr(a_vec + b_vec + c_vec).inverse()
# Get the minimum resolution in the integrate file
d = [self.unit_cell.d(h) for h in self.integrate_handle.hkl]
self.d_min = min(d)
# extend the resolution shell by epsilon>0
# to account for rounding artifacts on 32-bit platforms
self.d_min = self.d_min - 1e-15
# Get the number of frames from the max z value
xcal, ycal, zcal = zip(*self.integrate_handle.xyzcal)
self.scan.set_image_range((self.scan.get_image_range()[0],
self.scan.get_image_range()[0] +
int(ceil(max(zcal)))))
# Print stuff
# print self.beam
# print self.gonio
# print self.detector
# print self.scan
# Create the index generator
self.generate_indices = IndexGenerator(self.unit_cell,
self.space_group_type, self.d_min)
s0 = self.beam.get_s0()
m2 = self.gonio.get_rotation_axis()
fixed_rotation = self.gonio.get_fixed_rotation()
setting_rotation = self.gonio.get_setting_rotation()
UB = self.ub_matrix
dphi = self.scan.get_oscillation_range(deg=False)
# Create the ray predictor
self.predict_rays = ScanStaticRayPredictor(s0, m2, fixed_rotation,
setting_rotation, dphi)
# Predict the spot locations
self.reflections = self.predict_rays(
self.generate_indices.to_array(), UB)
def run():
if not have_dials_regression:
print "Skipping test: dials_regression not available."
return
from scitbx import matrix
from iotbx.xds import xparm, integrate_hkl
from dials.util import ioutil
from math import ceil
from dials.algorithms.spot_prediction import RotationAngles
import dxtbx
from rstbx.cftbx.coordinate_frame_converter import \
coordinate_frame_converter
# The XDS files to read from
integrate_filename = join(dials_regression, 'data/sim_mx/INTEGRATE.HKL')
gxparm_filename = join(dials_regression, 'data/sim_mx/GXPARM.XDS')
# Read the XDS files
integrate_handle = integrate_hkl.reader()
integrate_handle.read_file(integrate_filename)
gxparm_handle = xparm.reader()
gxparm_handle.read_file(gxparm_filename)
# Get the parameters we need from the GXPARM file
models = dxtbx.load(gxparm_filename)
beam = models.get_beam()
gonio = models.get_goniometer()
detector = models.get_detector()
scan = models.get_scan()
# Get the crystal parameters
space_group_type = ioutil.get_space_group_type_from_xparm(gxparm_handle)
cfc = coordinate_frame_converter(gxparm_filename)
a_vec = cfc.get('real_space_a')
b_vec = cfc.get('real_space_b')
c_vec = cfc.get('real_space_c')
unit_cell = cfc.get_unit_cell()
UB = matrix.sqr(a_vec + b_vec + c_vec).inverse()
ub_matrix = UB
# Get the minimum resolution in the integrate file
d = [unit_cell.d(h) for h in integrate_handle.hkl]
d_min = min(d)
# Get the number of frames from the max z value
xcal, ycal, zcal = zip(*integrate_handle.xyzcal)
num_frames = int(ceil(max(zcal)))
scan.set_image_range((scan.get_image_range()[0],
scan.get_image_range()[0] + num_frames - 1))
# Create the rotation angle object
ra = RotationAngles(beam.get_s0(), gonio.get_rotation_axis())
# Setup the matrices
ub = matrix.sqr(ub_matrix)
s0 = matrix.col(beam.get_s0())
m2 = matrix.col(gonio.get_rotation_axis())
# For all the miller indices
for h in integrate_handle.hkl:
h = matrix.col(h)
# Calculate the angles
angles = ra(h, ub)
# For all the angles
for phi in angles:
r = m2.axis_and_angle_as_r3_rotation_matrix(angle=phi)
pstar = r * ub * h
s1 = s0 + pstar
assert(abs(s1.length() - s0.length()) < 1e-7)
print "OK"
# Create a dict of lists of xy for each hkl
gen_phi = {}
for h in integrate_handle.hkl:
# Calculate the angles
angles = ra(h, ub)
gen_phi[h] = angles
# for phi in angles:
# try:
# a = gen_phi[h]
# a.append(phi)
# gen_phi[h] = a
# except KeyError:
# gen_phi[h] = [phi]
# For each hkl in the xds file
for hkl, xyz in zip(integrate_handle.hkl,
integrate_handle.xyzcal):
# Calculate the XDS phi value
xds_phi = scan.get_oscillation(deg=False)[0] + \
xyz[2]*scan.get_oscillation(deg=False)[1]
# Select the nearest xy to use if there are 2
my_phi = gen_phi[hkl]
if len(my_phi) == 2:
my_phi0 = my_phi[0]
my_phi1 = my_phi[1]
diff0 = abs(xds_phi - my_phi0)
diff1 = abs(xds_phi - my_phi1)
if diff0 < diff1:
my_phi = my_phi0
else:
my_phi = my_phi1
else:
my_phi = my_phi[0]
# Check the Phi values are the same
assert(abs(xds_phi - my_phi) < 0.1)
# Test Passed
print "OK"
def run():
if not have_dials_regression:
print "Skipping test: dials_regression not available."
return
from scitbx import matrix
from iotbx.xds import xparm, integrate_hkl
from dials.util import ioutil
from math import ceil
from dials.algorithms.spot_prediction import RotationAngles
import dxtbx
from rstbx.cftbx.coordinate_frame_converter import \
coordinate_frame_converter
# The XDS files to read from
integrate_filename = join(dials_regression, 'data/sim_mx/INTEGRATE.HKL')
gxparm_filename = join(dials_regression, 'data/sim_mx/GXPARM.XDS')
# Read the XDS files
integrate_handle = integrate_hkl.reader()
integrate_handle.read_file(integrate_filename)
gxparm_handle = xparm.reader()
gxparm_handle.read_file(gxparm_filename)
# Get the parameters we need from the GXPARM file
models = dxtbx.load(gxparm_filename)
beam = models.get_beam()
gonio = models.get_goniometer()
detector = models.get_detector()
scan = models.get_scan()
# Get the crystal parameters
space_group_type = ioutil.get_space_group_type_from_xparm(gxparm_handle)
cfc = coordinate_frame_converter(gxparm_filename)
a_vec = cfc.get('real_space_a')
b_vec = cfc.get('real_space_b')
c_vec = cfc.get('real_space_c')
unit_cell = cfc.get_unit_cell()
UB = matrix.sqr(a_vec + b_vec + c_vec).inverse()
ub_matrix = UB
# Get the minimum resolution in the integrate file
d = [unit_cell.d(h) for h in integrate_handle.hkl]
d_min = min(d)
# Get the number of frames from the max z value
xcal, ycal, zcal = zip(*integrate_handle.xyzcal)
num_frames = int(ceil(max(zcal)))
scan.set_image_range((scan.get_image_range()[0],
scan.get_image_range()[0] + num_frames - 1))
# Create the rotation angle object
ra = RotationAngles(beam.get_s0(), gonio.get_rotation_axis())
# Setup the matrices
ub = matrix.sqr(ub_matrix)
s0 = matrix.col(beam.get_s0())
m2 = matrix.col(gonio.get_rotation_axis())
# For all the miller indices
for h in integrate_handle.hkl:
h = matrix.col(h)
# Calculate the angles
angles = ra(h, ub)
# For all the angles
for phi in angles:
r = m2.axis_and_angle_as_r3_rotation_matrix(angle=phi)
pstar = r * ub * h
s1 = s0 + pstar
assert(abs(s1.length() - s0.length()) < 1e-7)
print "OK"
# Create a dict of lists of xy for each hkl
gen_phi = {}
for h in integrate_handle.hkl:
# Calculate the angles
angles = ra(h, ub)
gen_phi[h] = angles
# for phi in angles:
# try:
# a = gen_phi[h]
# a.append(phi)
# gen_phi[h] = a
# except KeyError:
# gen_phi[h] = [phi]
# For each hkl in the xds file
for hkl, xyz in zip(integrate_handle.hkl,
integrate_handle.xyzcal):
# Calculate the XDS phi value
xds_phi = scan.get_oscillation(deg=False)[0] + \
xyz[2]*scan.get_oscillation(deg=False)[1]
# Select the nearest xy to use if there are 2
my_phi = gen_phi[hkl]
if len(my_phi) == 2:
my_phi0 = my_phi[0]
my_phi1 = my_phi[1]
diff0 = abs(xds_phi - my_phi0)
diff1 = abs(xds_phi - my_phi1)
if diff0 < diff1:
my_phi = my_phi0
else:
my_phi = my_phi1
else:
my_phi = my_phi[0]
# Check the Phi values are the same
assert(abs(xds_phi - my_phi) < 0.1)
# Test Passed
print "OK"
def __init__(self):
from dials.algorithms.spot_prediction import IndexGenerator
from dials.algorithms.spot_prediction import ScanStaticRayPredictor
from dials.algorithms.spot_prediction import ray_intersection
from iotbx.xds import xparm, integrate_hkl
from dials.util import ioutil
from math import ceil
from os.path import realpath, dirname, join
import dxtbx
from rstbx.cftbx.coordinate_frame_converter import \
coordinate_frame_converter
from scitbx import matrix
# The XDS files to read from
test_path = dirname(dirname(dirname(realpath(__file__))))
integrate_filename = join(test_path, 'data/sim_mx/INTEGRATE.HKL')
gxparm_filename = join(test_path, 'data/sim_mx/GXPARM.XDS')
# Read the XDS files
self.integrate_handle = integrate_hkl.reader()
self.integrate_handle.read_file(integrate_filename)
self.gxparm_handle = xparm.reader()
self.gxparm_handle.read_file(gxparm_filename)
# Get the parameters we need from the GXPARM file
models = dxtbx.load(gxparm_filename)
self.beam = models.get_beam()
self.gonio = models.get_goniometer()
self.detector = models.get_detector()
self.scan = models.get_scan()
assert(len(self.detector) == 1)
#print self.detector
# Get crystal parameters
self.space_group_type = ioutil.get_space_group_type_from_xparm(
self.gxparm_handle)
cfc = coordinate_frame_converter(gxparm_filename)
a_vec = cfc.get('real_space_a')
b_vec = cfc.get('real_space_b')
c_vec = cfc.get('real_space_c')
self.unit_cell = cfc.get_unit_cell()
self.ub_matrix = matrix.sqr(a_vec + b_vec + c_vec).inverse()
# Get the minimum resolution in the integrate file
self.d_min = self.detector[0].get_max_resolution_at_corners(
self.beam.get_s0())
# Get the number of frames from the max z value
xcal, ycal, zcal = zip(*self.integrate_handle.xyzcal)
self.scan.set_image_range((self.scan.get_image_range()[0],
self.scan.get_image_range()[0] +
int(ceil(max(zcal)))))
# Create the index generator
generate_indices = IndexGenerator(self.unit_cell, self.space_group_type,
self.d_min)
s0 = self.beam.get_s0()
m2 = self.gonio.get_rotation_axis()
fixed_rotation = self.gonio.get_fixed_rotation()
UB = self.ub_matrix
dphi = self.scan.get_oscillation_range(deg=False)
# Create the ray predictor
self.predict_rays = ScanStaticRayPredictor(s0, m2, fixed_rotation, dphi)
# Predict the spot locations
self.reflections = self.predict_rays(
generate_indices.to_array(), UB)
# Calculate the intersection of the detector and reflection frames
success = ray_intersection(self.detector, self.reflections)
self.reflections.select(success)
