import os
import pycbf
import libtbx.phil
from cctbx.eltbx import attenuation_coefficient
from scitbx import matrix
from dxtbx.model.detector_helpers import (
detector_helper_sensors,
find_gain_value,
find_undefined_value,
set_detector_distance,
set_fast_slow_beam_centre_mm,
set_mosflm_beam_centre,
)
from dxtbx_model_ext import (
Detector,
Panel,
ParallaxCorrectedPxMmStrategy,
SimplePxMmStrategy,
)
# N.B. this should probably be generalized for non
# flat detectors, or composite detectors constructed from a number of flat
# elements.
dxtbx_overload_scale = float(os.getenv("DXTBX_OVERLOAD_SCALE", "1"))
detector_phil_scope = libtbx.phil.parse(
"""
detector
.expert_level = 1
.short_caption = "Detector overrides"
{
panel
.multiple = True
{
id = 0
.type = int
.help = "The panel number"
.short_caption = "Panel ID"
name = None
.type = str
.help = "Override the panel name"
.short_caption = "Panel name"
type = None
.type = str
.help = "Override the panel type"
.short_caption = "Panel type"
gain = None
.type = float(value_min=0)
.help = "The gain of the detector panel"
.short_caption = "Gain value"
pedestal = None
.type = float
.help = "The pedestal of the detector panel"
.short_caption = "Pedestal value"
pixel_size = None
.type = floats(size=2)
.help = "Override the panel pixel size"
.short_caption = "Panel pixel size"
image_size = None
.type = ints(size=2)
.help = "Override the panel image size"
.short_caption= "Panel image size"
trusted_range = None
.type = floats(size=2)
.help = "Override the panel trusted range"
.short_caption = "Panel trusted range"
thickness = None
.type = float
.help = "Override the panel thickness"
.short_caption = "Panel thickness"
material = None
.type = str
.help = "Override the panel material"
.short_caption = "Panel material"
fast_axis = None
.type = floats(size=3)
.help = "Override the panel fast axis. Requires slow_axis and origin."
.short_caption = "Panel fast axis direction"
slow_axis = None
.type = floats(size=3)
.help = "Override the panel slow axis. Requires fast_axis and origin."
.short_caption = "Panel slow axis direction"
origin = None
.type = floats(size=3)
.help = "Override the panel origin. Requires fast_axis and slow_axis."
.short_caption = "Panel origin vector"
parallax_correction = None
.type = bool
.help = "Enable parallax correction. By default in overwrite mode, the"
"value of None does nothing."
.short_caption = "Enable parallax correction"
}
hierarchy
.expert_level = 2
{
name = None
.type = str
.help = "Override the group name"
.short_caption = "group name"
fast_axis = None
.type = floats(size=3)
.help = "Override the panel fast axis. Requires slow_axis and origin."
.short_caption = "Panel fast axis direction"
slow_axis = None
.type = floats(size=3)
.help = "Override the panel slow axis. Requires fast_axis and origin."
.short_caption = "Panel slow axis direction"
origin = None
.type = floats(size=3)
.help = "Override the panel origin. Requires fast_axis and slow_axis."
.short_caption = "Panel origin vector"
group
.multiple = True
{
id = None
.type = ints
.help = "The group identifier specifying the place in the hierarchy"
.short_caption = "Group ID"
name = None
.type = str
.help = "Override the group name"
.short_caption = "Group name"
fast_axis = None
.type = floats(size=3)
.help = "Override the group fast axis. Requires slow_axis and origin."
.short_caption = "Group fast axis direction"
slow_axis = None
.type = floats(size=3)
.help = "Override the group slow axis. Requires fast_axis and origin."
.short_caption = "Group slow axis direction"
origin = None
.type = floats(size=3)
.help = "Override the group origin. Requires fast_axis and slow_axis."
.short_caption = "Group origin vector"
panel = None
.multiple = True
.type = int
.help = "The panel id"
.short_caption = "Panel ID"
}
}
mosflm_beam_centre = None
.type = floats(size=2)
.help = "Override the beam centre from the image headers, following "
"the mosflm convention."
.short_caption = "Beam centre coordinates (mm, mm) using the Mosflm convention"
distance = None
.type = float
.help = "The detector distance (used when mosflm_beam_centre is set)"
.short_caption = "Detector distance"
fast_slow_beam_centre = None
.type = ints(size_min=2, size_max=3)
.help = "Override the beam centre from the image headers."
"The first two values are the fast and slow pixel coordinate."
"If the third is supplied it specifies a panel number."
.short_caption = "Beam centre coordinates (px fast, px slow, [panel id])"
slow_fast_beam_centre = None
.type = ints(size_min=2, size_max=3)
.help = "Alternative to fast_slow_beam_centre in which the coordinates"
"are given in order (px slow, px fast, [panel id]). If"
"fast_slow_beam_centre is set it will take priority over any"
"values set here."
.short_caption = "Beam centre coordinates (px slow, px fast, [panel id])"
}
"""
)
[docs]class DetectorFactory:
"""A factory class for detector objects, which will encapsulate standard
detector designs to make it a little easier to get started with these. In
cases where a CBF image is provided a full description can be used, in
other cases assumptions will be made about the experiment configuration.
In all cases information is provided in the CBF coordinate frame."""
[docs] @staticmethod
def generate_from_phil(params, beam=None):
"""
Create a new detector model from phil parameters
"""
detector = Detector()
# Create a list of panels
panel_list = {}
for panel_params in params.detector.panel:
panel = Panel()
if panel_params.name is not None:
panel.set_name(panel_params.name)
if panel_params.type is not None:
panel.set_type(panel_params.type)
if panel_params.gain is not None:
panel.set_gain(panel_params.gain)
if panel_params.pedestal is not None:
panel.set_pedestal(panel_params.pedestal)
if panel_params.pixel_size is not None:
panel.set_pixel_size(panel_params.pixel_size)
else:
raise RuntimeError("No pixel size set")
if panel_params.image_size is not None:
panel.set_image_size(panel_params.image_size)
else:
raise RuntimeError("No image size set")
if panel_params.trusted_range is not None:
panel.set_trusted_range(panel_params.trusted_range)
else:
raise RuntimeError("No trusted range set")
if panel_params.thickness is not None:
panel.set_thickness(panel_params.thickness)
if panel_params.material is not None:
panel.set_material(panel_params.material)
if panel_params.parallax_correction is True:
if panel_params.material is None:
raise RuntimeError("No material for parallax correction")
if panel_params.thickness is None:
raise RuntimeError("No thickness for parallax correction")
if beam is None:
raise RuntimeError("No beam for parallax correction")
table = attenuation_coefficient.get_table(panel_params.material)
mu = table.mu_at_angstrom(beam.get_wavelength()) / 10.0
t0 = panel_params.thickness
panel.set_px_mm_strategy(ParallaxCorrectedPxMmStrategy(mu, t0))
if panel_params.fast_axis is None:
panel_params.fast_axis = (1, 0, 0)
if panel_params.slow_axis is None:
panel_params.slow_axis = (0, 1, 0)
if panel_params.origin is None:
panel_params.origin = (0, 0, 0)
panel.set_local_frame(
panel_params.fast_axis, panel_params.slow_axis, panel_params.origin
)
if panel_params.id in panel_list:
raise RuntimeError("Multiple panels with id=%d" % panel_params.id)
panel_list[panel_params.id] = panel
# Create the hierarchy
panel_counter = 0
root = detector.hierarchy()
if params.detector.hierarchy.name is not None:
root.set_name(params.detector.hierarchy.name)
if params.detector.hierarchy.fast_axis is None:
params.detector.hierarchy.fast_axis = (1, 0, 0)
if params.detector.hierarchy.slow_axis is None:
params.detector.hierarchy.slow_axis = (0, 1, 0)
if params.detector.hierarchy.origin is None:
params.detector.hierarchy.origin = (0, 0, 0)
root.set_frame(
params.detector.hierarchy.fast_axis,
params.detector.hierarchy.slow_axis,
params.detector.hierarchy.origin,
)
def get_parent(node, index):
if len(index) == 0:
return node
return get_parent(node[index[0]], index[1:])
for group_params in params.detector.hierarchy.group:
parent = get_parent(root, group_params.id[:-1])
assert len(parent) == group_params.id[-1]
group = parent.add_group()
if group_params.name is not None:
group.set_name(group_params.name)
if group_params.fast_axis is None:
group_params.fast_axis = (1, 0, 0)
if group_params.slow_axis is None:
group_params.slow_axis = (0, 1, 0)
if group_params.origin is None:
group_params.origin = (0, 0, 0)
group.set_local_frame(
group_params.fast_axis, group_params.slow_axis, group_params.origin
)
for panel_id in group_params.panel:
assert panel_id == panel_counter
group.add_panel(panel_list[panel_id])
panel_counter += 1
if panel_counter == 0:
for panel_id in range(max(panel_list.keys()) + 1):
detector.add_panel(panel_list[panel_id])
elif panel_counter != len(panel_list):
raise RuntimeError("Inconsistent number of panels in hierarchy")
# Return detector
return detector
[docs] @staticmethod
def overwrite_from_phil(params, detector, beam=None):
"""
Overwrite from phil parameters
"""
# Override any panel parameters
for panel_params in params.detector.panel:
panel = detector[panel_params.id]
if panel_params.name is not None:
panel.set_name(panel_params.name)
if panel_params.type is not None:
panel.set_type(panel_params.type)
if panel_params.gain is not None:
panel.set_gain(panel_params.gain)
if panel_params.pedestal is not None:
panel.set_pedestal(panel_params.pedestal)
if panel_params.pixel_size is not None:
panel.set_pixel_size(panel_params.pixel_size)
if panel_params.image_size is not None:
panel.set_image_size(panel_params.image_size)
if panel_params.trusted_range is not None:
panel.set_trusted_range(panel_params.trusted_range)
if panel_params.thickness is not None:
panel.set_thickness(panel_params.thickness)
if panel_params.material is not None:
panel.set_material(panel_params.material)
if panel_params.parallax_correction is None:
if isinstance(
panel.get_px_mm_strategy(), ParallaxCorrectedPxMmStrategy
):
panel_params.parallax_correction = True
else:
panel_params.parallax_correction = False
if panel_params.parallax_correction is True:
if beam is None:
raise RuntimeError("No beam for parallax correction")
table = attenuation_coefficient.get_table(panel.get_material())
mu = table.mu_at_angstrom(beam.get_wavelength()) / 10.0
t0 = panel.get_thickness()
panel.set_px_mm_strategy(ParallaxCorrectedPxMmStrategy(mu, t0))
else:
panel.set_px_mm_strategy(SimplePxMmStrategy())
axes = [panel_params.fast_axis, panel_params.slow_axis, panel_params.origin]
if axes.count(None) != 3:
if panel_params.fast_axis is None:
panel_params.fast_axis = panel.get_local_fast_axis()
if panel_params.slow_axis is None:
panel_params.slow_axis = panel.get_local_slow_axis()
if panel_params.origin is None:
panel_params.origin = panel.get_local_origin()
panel.set_local_frame(
panel_params.fast_axis, panel_params.slow_axis, panel_params.origin
)
# Create the hierarchy
if params.detector.hierarchy is not None:
root = detector.hierarchy()
if params.detector.hierarchy.name is not None:
root.set_name(params.detector.hierarchy.name)
if (
params.detector.hierarchy.fast_axis is not None
or params.detector.hierarchy.slow_axis is not None
or params.detector.hierarchy.origin is not None
):
if params.detector.hierarchy.fast_axis is None:
params.detector.hierarchy.fast_axis = root.get_fast_axis()
if params.detector.hierarchy.slow_axis is None:
params.detector.hierarchy.slow_axis = root.get_slow_axis()
if params.detector.hierarchy.origin is None:
params.detector.hierarchy.origin = root.get_origin()
root.set_frame(
params.detector.hierarchy.fast_axis,
params.detector.hierarchy.slow_axis,
params.detector.hierarchy.origin,
)
def get_group(node, index):
if len(index) == 0:
return node
return get_group(node[index[0]], index[1:])
for group_params in params.detector.hierarchy.group:
group = get_group(root, group_params.id)
if group_params.name is not None:
group.set_name(group_params.name)
if (
group_params.fast_axis is not None
or group_params.slow_axis is not None
or group_params.origin is not None
):
if group_params.fast_axis is None:
group_params.fast_axis = group.get_local_fast_axis()
if group_params.slow_axis is None:
group_params.slow_axis = group.get_local_slow_axis()
if group_params.origin is None:
group_params.origin = group.get_local_origin()
group.set_local_frame(
group_params.fast_axis,
group_params.slow_axis,
group_params.origin,
)
if len(group_params.panel) != 0:
raise RuntimeError("Can't reassign panels in groups")
return detector
[docs] @staticmethod
def from_phil(params, reference=None, beam=None):
"""
Convert phil parameters into detector model
"""
# Check the input. If no reference detector is provided then
# Create the detector model from scratch from the parameters
if reference is None:
detector = DetectorFactory.generate_from_phil(params, beam)
else:
detector = DetectorFactory.overwrite_from_phil(params, reference, beam)
# If the distance is set
if params.detector.distance is not None:
set_detector_distance(detector, params.detector.distance)
# If the mosflm beam centre is set then update
if params.detector.mosflm_beam_centre is not None:
assert beam is not None
set_mosflm_beam_centre(detector, beam, params.detector.mosflm_beam_centre)
fast_slow_beam_centre = None
if (
params.detector.fast_slow_beam_centre
and params.detector.slow_fast_beam_centre
):
raise RuntimeError(
"Can only set one of fast_slow_beam_centre or slow_fast_beam_centre"
)
if params.detector.slow_fast_beam_centre:
fast_slow_beam_centre = list(params.detector.slow_fast_beam_centre)
fast_slow_beam_centre[0], fast_slow_beam_centre[1] = (
fast_slow_beam_centre[1],
fast_slow_beam_centre[0],
)
if params.detector.fast_slow_beam_centre:
fast_slow_beam_centre = params.detector.fast_slow_beam_centre
# If the fast slow beam centre is set then update
if fast_slow_beam_centre is not None:
panel_id = 0
if len(fast_slow_beam_centre) > 2:
panel_id = fast_slow_beam_centre[2]
if panel_id >= len(detector):
raise IndexError(f"Detector does not have panel index {panel_id}")
px_size_f, px_size_s = detector[0].get_pixel_size()
fast_slow_beam_centre_mm = (
fast_slow_beam_centre[0] * px_size_f,
fast_slow_beam_centre[1] * px_size_s,
)
assert beam is not None
set_fast_slow_beam_centre_mm(
detector, beam, fast_slow_beam_centre_mm, panel_id=panel_id
)
return detector
[docs] @staticmethod
def from_dict(d, t=None):
"""Convert the dictionary to a detector model
Params:
d The dictionary of parameters
t The template dictionary to use
Returns:
The detector model
"""
if d is None and t is None:
return None
joint = t.copy() if t else {}
if isinstance(d, list):
d = {"panels": d}
joint.update(d)
# Create the model from the joint dictionary
return Detector.from_dict(joint)
[docs] @staticmethod
def make_detector(
stype,
fast_axis,
slow_axis,
origin,
pixel_size,
image_size,
trusted_range=(0.0, 1.0e6),
px_mm=None,
name="Panel",
thickness=0.0,
material="",
mu=0.0,
gain=None,
pedestal=None,
identifier="",
):
"""Ensure all types are correct before creating c++ detector class."""
if px_mm is None:
px_mm = SimplePxMmStrategy()
d = Detector()
p = d.add_panel()
p.set_type(str(stype))
p.set_name(str(name))
p.set_local_frame(
tuple(map(float, fast_axis)),
tuple(map(float, slow_axis)),
tuple(map(float, origin)),
)
p.set_pixel_size(tuple(map(float, pixel_size)))
p.set_image_size(tuple(map(int, image_size)))
p.set_trusted_range(tuple(map(float, trusted_range)))
p.set_thickness(thickness)
p.set_material(material)
p.set_mu(mu)
p.set_px_mm_strategy(px_mm)
p.set_identifier(identifier)
if gain is not None:
p.set_gain(gain)
if pedestal is not None:
p.set_pedestal(pedestal)
return d
[docs] @staticmethod
def simple(
sensor,
distance,
beam_centre,
fast_direction,
slow_direction,
pixel_size,
image_size,
trusted_range=(0.0, 0.0),
mask=[],
px_mm=None,
mu=0.0,
gain=None,
pedestal=None,
identifier="",
):
"""Construct a simple detector at a given distance from the sample
along the direct beam presumed to be aligned with -z, offset by the
beam centre - the directions of which are given by the fast and slow
directions, which are themselves given as +x, +y, -x, -y. The pixel
size is given in mm in the fast and slow directions and the image size
is given in pixels in the same order. Everything else is the same as
for the main reference frame."""
assert fast_direction in ["-x", "+y", "+x", "-y"]
assert slow_direction in ["-x", "+y", "+x", "-y"]
assert fast_direction[1] != slow_direction[1]
direction_map = {
"+x": (1.0, 0.0, 0.0),
"-x": (-1.0, 0.0, 0.0),
"+y": (0.0, 1.0, 0.0),
"-y": (0.0, -1.0, 0.0),
}
fast = matrix.col(direction_map[fast_direction])
slow = matrix.col(direction_map[slow_direction])
origin = (
matrix.col((0, 0, -1)) * distance
- fast * beam_centre[0]
- slow * beam_centre[1]
)
detector = DetectorFactory.make_detector(
DetectorFactory.sensor(sensor),
fast,
slow,
origin,
pixel_size,
image_size,
trusted_range,
px_mm,
mu=mu,
gain=gain,
pedestal=pedestal,
identifier=identifier,
)
detector[0].mask = mask
return detector
[docs] @staticmethod
def two_theta(
sensor,
distance,
beam_centre,
fast_direction,
slow_direction,
two_theta_direction,
two_theta_angle,
pixel_size,
image_size,
trusted_range=(0.0, 0.0),
mask=[],
px_mm=None,
mu=0.0,
gain=None,
pedestal=None,
identifier="",
):
"""Construct a simple detector at a given distance from the sample
along the direct beam presumed to be aligned with -z, offset by the
beam centre - the directions of which are given by the fast and slow
directions, which are themselves given as +x, +y, -x, -y. The pixel
size is given in mm in the fast and slow directions and the image size
is given in pixels in the same order. Everything else is the same as
for the main reference frame. Also given are the direction of the
two-theta axis and the angle in degrees by which the detector is
moved."""
assert fast_direction in ["-x", "+y", "+x", "-y"]
assert slow_direction in ["-x", "+y", "+x", "-y"]
assert two_theta_direction in ["-x", "+y", "+x", "-y"]
assert fast_direction[1] != slow_direction[1]
direction_map = {
"+x": (1.0, 0.0, 0.0),
"-x": (-1.0, 0.0, 0.0),
"+y": (0.0, 1.0, 0.0),
"-y": (0.0, -1.0, 0.0),
}
fast = matrix.col(direction_map[fast_direction])
slow = matrix.col(direction_map[slow_direction])
origin = (
matrix.col((0, 0, -1)) * distance
- fast * beam_centre[0]
- slow * beam_centre[1]
)
two_theta = matrix.col(direction_map[two_theta_direction])
R = two_theta.axis_and_angle_as_r3_rotation_matrix(two_theta_angle, deg=True)
detector = DetectorFactory.make_detector(
DetectorFactory.sensor(sensor),
(R * fast),
(R * slow),
(R * origin),
pixel_size,
image_size,
trusted_range,
px_mm,
mu=mu,
gain=gain,
pedestal=pedestal,
identifier=identifier,
)
detector.mask = mask
return detector
[docs] @staticmethod
def complex(
sensor,
origin,
fast,
slow,
pixel,
size,
trusted_range=(0.0, 0.0),
mask=[],
px_mm=None,
mu=0.0,
gain=None,
pedestal=None,
identifier="",
):
"""A complex detector model, where you know exactly where everything
is. This is useful for implementation of the Rigaku Saturn header
format, as that is exactly what is in there. Origin, fast and slow are
vectors in the CBF reference frame, pixel is the dimensions as a tuple
as is size."""
assert len(origin) == 3
assert len(fast) == 3
assert len(slow) == 3
assert len(pixel) == 2
assert len(size) == 2
detector = DetectorFactory.make_detector(
DetectorFactory.sensor(sensor),
fast,
slow,
origin,
pixel,
size,
trusted_range,
px_mm,
mu=mu,
gain=gain,
pedestal=pedestal,
identifier=identifier,
)
detector[0].mask = mask
return detector
[docs] @staticmethod
def imgCIF(cif_file, sensor):
"""Initialize a detector model from an imgCIF file."""
cbf_handle = pycbf.cbf_handle_struct()
cbf_handle.read_file(cif_file.encode(), pycbf.MSG_DIGEST)
return DetectorFactory.imgCIF_H(cbf_handle, sensor)
[docs] @staticmethod
def imgCIF_H(cbf_handle, sensor):
"""Initialize a detector model from an imgCIF file handle, where it
is assumed that the file has already been read."""
cbf_detector = cbf_handle.construct_detector(0)
pixel = (
cbf_detector.get_inferred_pixel_size(1),
cbf_detector.get_inferred_pixel_size(2),
)
origin = tuple(cbf_detector.get_pixel_coordinates(0, 0))
fast = cbf_detector.get_detector_axis_fast()
slow = cbf_detector.get_detector_axis_slow()
size = tuple(reversed(cbf_handle.get_image_size(0)))
try:
underload = find_undefined_value(cbf_handle)
overload = cbf_handle.get_overload(0)
trusted_range = (underload, overload * dxtbx_overload_scale)
except Exception:
trusted_range = (0.0, 1.0e6)
gain = find_gain_value(cbf_handle)
cbf_detector.__swig_destroy__(cbf_detector)
del cbf_detector
return DetectorFactory.make_detector(
DetectorFactory.sensor(sensor),
fast,
slow,
origin,
pixel,
size,
trusted_range,
gain=gain,
)
[docs] @staticmethod
def sensor(name):
"""Return the correct sensor token for a given name, for example:
ccd, CCD
image_plate, IMAGE_PLATE
pad, PAD
to the appropriate static token which will be used as a handle
everywhere else in this. Also allow existing token to be passed in."""
if detector_helper_sensors.check_sensor(name):
return name
if name is None:
return detector_helper_sensors.SENSOR_UNKNOWN
if name.upper() == "PAD":
return detector_helper_sensors.SENSOR_PAD
elif name.upper() == "CCD":
return detector_helper_sensors.SENSOR_CCD
elif name.upper() == "IMAGE_PLATE":
return detector_helper_sensors.SENSOR_IMAGE_PLATE
elif name.upper() == "UNKNOWN":
return detector_helper_sensors.SENSOR_UNKNOWN
raise RuntimeError("name %s not known" % name)
