def _detector(self):
""" Create an Eiger detector profile (taken from FormatCBFMiniEiger) """
configuration = self.header["configuration"]
info = self.header["info"]
distance = configuration["detector_distance"]
wavelength = configuration["wavelength"]
beam_x = configuration["beam_center_x"]
beam_y = configuration["beam_center_y"]
pixel_x = configuration["x_pixel_size"]
pixel_y = configuration["y_pixel_size"]
material = configuration["sensor_material"]
thickness = configuration["sensor_thickness"] * 1000
nx = configuration["x_pixels_in_detector"]
ny = configuration["y_pixels_in_detector"]
if "count_rate_correction_count_cutoff" in configuration:
overload = configuration["count_rate_correction_count_cutoff"]
else:
# hard-code if missing from Eiger stream header
overload = 4001400
underload = -1
try:
identifier = configuration["description"]
except KeyError:
identifier = "Unknown Eiger"
table = attenuation_coefficient.get_table(material)
mu = table.mu_at_angstrom(wavelength) / 10.0
t0 = thickness
detector = self._detector_factory.simple(
sensor="PAD",
distance=distance * 1000.0,
beam_centre=(beam_x * pixel_x * 1000.0, beam_y * pixel_y * 1000.0),
fast_direction="+x",
slow_direction="-y",
pixel_size=(1000 * pixel_x, 1000 * pixel_y),
image_size=(nx, ny),
trusted_range=(underload, overload),
mask=[],
px_mm=ParallaxCorrectedPxMmStrategy(mu, t0),
mu=mu,
)
for f0, f1, s0, s1 in determine_eiger_mask(detector):
detector[0].add_mask(f0 - 1, s0 - 1, f1, s1)
for panel in detector:
panel.set_thickness(thickness)
panel.set_material(material)
panel.set_identifier(identifier)
panel.set_mu(mu)
return detector
def _start(self):
# Read the file structure
temp_file = "tmp_master_%s.nxs" % uuid.uuid1().hex
fixer = EigerNXmxFixer(self._image_file, temp_file)
reader = NXmxReader(handle=fixer.handle)
# Only support 1 set of models at the moment
assert len(reader.entries) == 1, "Currently only supports 1 NXmx entry"
assert len(reader.entries[0].data) == 1, "Currently only supports 1 NXdata"
assert (
len(reader.entries[0].instruments) == 1
), "Currently only supports 1 NXinstrument"
assert len(reader.entries[0].samples) == 1, "Currently only supports 1 NXsample"
assert (
len(reader.entries[0].instruments[0].detectors) == 1
), "Currently only supports 1 NXdetector"
assert (
len(reader.entries[0].instruments[0].detectors[0].modules) == 1
), "Currently only supports 1 NXdetector_module"
assert (
len(reader.entries[0].samples[0].beams) == 1
or len(reader.entries[0].instruments[0].beams) == 1
), "Currently only supports 1 NXbeam"
# Get the NXmx model objects
entry = reader.entries[0]
self.instrument = instrument = entry.instruments[0]
detector = instrument.detectors[0]
sample = entry.samples[0]
beam = sample.beams[0] if sample.beams else instrument.beams[0]
# Use data from original master file
data = NXdata(fixer.handle_orig[entry.data[0].handle.name])
self._raw_data = DataFactory(data, cached_information=fixer.data_factory_cache)
# Construct the models
self._beam_factory = BeamFactory(beam)
self._beam_factory.load_model(0)
self._detector_model = DetectorFactory(
detector, self._beam_factory.model, shape=self._raw_data.shape()
).model
# Override the minimum trusted value - for Eiger should be -1
for panel in self._detector_model:
trusted = panel.get_trusted_range()
panel.set_trusted_range((-1, trusted[1]))
self._goniometer_model = GoniometerFactory(sample).model
self._scan_model = generate_scan_model(sample, detector)
# update model for masking Eiger detectors
for f0, f1, s0, s1 in determine_eiger_mask(self._detector_model):
self._detector_model[0].add_mask(f0 - 1, s0 - 1, f1, s1)
def _start(self):
# Read the file structure
import uuid
temp_file = "tmp_master_%s.nxs" % uuid.uuid1().hex
fixer = EigerNXmxFixer(self._image_file, temp_file)
reader = NXmxReader(handle=fixer.handle)
# Only support 1 set of models at the moment
assert len(reader.entries) == 1, "Currently only supports 1 NXmx entry"
assert len(reader.entries[0].data) == 1, "Currently only supports 1 NXdata"
assert (
len(reader.entries[0].instruments) == 1
), "Currently only supports 1 NXinstrument"
assert len(reader.entries[0].samples) == 1, "Currently only supports 1 NXsample"
assert (
len(reader.entries[0].instruments[0].detectors) == 1
), "Currently only supports 1 NXdetector"
assert (
len(reader.entries[0].instruments[0].detectors[0].modules) == 1
), "Currently only supports 1 NXdetector_module"
assert (
len(reader.entries[0].samples[0].beams) == 1
), "Currently only supports 1 NXbeam"
# Get the NXmx model objects
entry = reader.entries[0]
self.instrument = instrument = entry.instruments[0]
detector = instrument.detectors[0]
sample = entry.samples[0]
beam = sample.beams[0]
# Use data from original master file
data = NXdata(fixer.handle_orig[entry.data[0].handle.name])
# Construct the models
self._beam_model = BeamFactory(beam).model
self._detector_model = DetectorFactory(detector, self._beam_model).model
self._goniometer_model = GoniometerFactory(sample).model
self._scan_model = ScanFactory(sample, detector).model
self._raw_data = DataFactory(data).model
# update model for masking Eiger detectors
from dxtbx.format.FormatPilatusHelpers import determine_eiger_mask
for f0, f1, s0, s1 in determine_eiger_mask(self._detector_model):
self._detector_model[0].add_mask(f0 - 1, s0 - 1, f1, s1)
def _detector(self):
distance = float(
self._cif_header_dictionary["Detector_distance"].split()[0])
beam_xy = (self._cif_header_dictionary["Beam_xy"].replace(
"(", "").replace(")", "").replace(",", "").split()[:2])
wavelength = float(
self._cif_header_dictionary["Wavelength"].split()[0])
beam_x, beam_y = map(float, beam_xy)
pixel_xy = (self._cif_header_dictionary["Pixel_size"].replace(
"m", "").replace("x", "").split())
pixel_x, pixel_y = map(float, pixel_xy)
if "Silicon" in self._cif_header_dictionary:
thickness = (
float(self._cif_header_dictionary["Silicon"].split()[2]) *
1000.0)
material = "Si"
elif "CdTe" in self._cif_header_dictionary:
thickness = float(
self._cif_header_dictionary["CdTe"].split()[2]) * 1000.0
material = "CdTe"
else:
thickness = 0.450
material = "Si"
nx = int(
self._cif_header_dictionary["X-Binary-Size-Fastest-Dimension"])
ny = int(self._cif_header_dictionary["X-Binary-Size-Second-Dimension"])
if "Count_cutoff" in self._cif_header_dictionary:
overload = int(
self._cif_header_dictionary["Count_cutoff"].split()[0])
else:
# missing from data transformed with GPhL converter - dials#376
overload = 100000000
underload = -1
try:
identifier = self._cif_header_dictionary["Detector"].encode()
except KeyError:
identifier = "Unknown Eiger"
table = attenuation_coefficient.get_table(material)
mu = table.mu_at_angstrom(wavelength) / 10.0
t0 = thickness
detector = self._detector_factory.simple(
"PAD",
distance * 1000.0,
(beam_x * pixel_x * 1000.0, beam_y * pixel_y * 1000.0),
"+x",
"-y",
(1000 * pixel_x, 1000 * pixel_y),
(nx, ny),
(underload, overload),
[],
px_mm=ParallaxCorrectedPxMmStrategy(mu, t0),
mu=mu,
)
for f0, f1, s0, s1 in determine_eiger_mask(detector):
detector[0].add_mask(f0 - 1, s0 - 1, f1, s1)
for panel in detector:
panel.set_thickness(thickness)
panel.set_material(material)
panel.set_identifier(identifier)
panel.set_mu(mu)
return detector