def test_detector():
"""A test class for the detector class."""
assert DetectorFactory.simple(
"CCD",
100.0,
(45.0, 52.0),
"+x",
"-y",
(0.172, 0.172),
(516, 590),
(0, 1024),
[],
)
assert DetectorFactory.two_theta(
"CCD",
60.0,
(35.0, 34.0),
"+x",
"+y",
"+x",
30,
(0.07, 0.07),
(1042, 1042),
(0, 1024),
[],
)
image = Path(__file__).parent / "phi_scan_001.cbf"
assert DetectorFactory.imgCIF(str(image), "CCD")
def test_detector():
"""A test class for the detector class."""
assert DetectorFactory.simple(
"CCD",
100.0,
(45.0, 52.0),
"+x",
"-y",
(0.172, 0.172),
(516, 590),
(0, 1024),
[],
)
assert DetectorFactory.two_theta(
"CCD",
60.0,
(35.0, 34.0),
"+x",
"+y",
"+x",
30,
(0.07, 0.07),
(1042, 1042),
(0, 1024),
[],
)
dxtbx_dir = libtbx.env.dist_path("dxtbx")
image = os.path.join(dxtbx_dir, "tests", "phi_scan_001.cbf")
# xparm = os.path.join(dxtbx_dir, "tests", "example-xparm.xds")
assert DetectorFactory.imgCIF(image, "CCD")
def get_values(invert_y):
beam = BeamFactory.simple(wavelength=1)
if invert_y:
y_direction = "-y"
else:
y_direction = "+y"
detector = DetectorFactory.simple(
sensor=DetectorFactory.sensor("PAD"),
distance=100,
beam_centre=[50, 50],
fast_direction="+x",
slow_direction=y_direction,
pixel_size=[0.1, 0.1],
image_size=[1000, 1000],
)[0]
wavelength = beam.get_wavelength()
thickness = 0.5
table = attenuation_coefficient.get_table("Si")
mu = table.mu_at_angstrom(wavelength) / 10.0
t0 = thickness
for panel in detector:
panel.set_px_mm_strategy(ParallaxCorrectedPxMmStrategy(mu, t0))
v1 = detector.pixel_to_millimeter((0, 0))
v2 = detector.pixel_to_millimeter((1000, 1000))
return v1, v2
def __init__(self):
import dxtbx
detector_lib = os.path.join(
os.path.split(dxtbx.__file__)[0], 'data', 'detectors.lib')
if not os.path.exists(detector_lib):
raise RuntimeError, 'detector library not found'
self._detectors = {}
for record in open(detector_lib):
if 'Sensor' in record[:6]:
continue
if '------' in record[:6]:
continue
text = record.split('#')[0].strip()
if not text:
continue
tokens = text.split()
assert (len(tokens) == 6)
sensor = DetectorFactory.sensor(tokens[0])
fast, slow, df, ds = map(int, tokens[1:5])
self._detectors[(sensor, fast, slow, df, ds)] = tokens[5]
return
def make_images(data, tag):
pixel_size = 0.1 # mm/pixel
detector = DetectorFactory.simple(
'PAD', 100,
(pixel_size * data.focus()[1] / 2, pixel_size * data.focus()[2] / 2),
'+x', '-y', (pixel_size, pixel_size),
(data.focus()[2], data.focus()[1]), (-1, 1e6 - 1), [], None)
beam = BeamFactory.simple(1.0)
sf = ScanFactory()
scan = sf.make_scan(image_range=(1, 180),
exposure_times=0.1,
oscillation=(0, 1.0),
epochs=range(180),
deg=True)
# write images in each of three directions
for slice_id in [0, 1, 2]:
for idx in xrange(data.focus()[slice_id]):
if slice_id == 0: # slow
data_slice = data[idx:idx + 1, :, :]
data_slice.reshape(flex.grid(data.focus()[1], data.focus()[2]))
filename = "fft_frame_%s_mf_%04d.cbf" % (tag, idx)
elif slice_id == 1: # med
data_slice = data[:, idx:idx + 1, :]
data_slice.reshape(flex.grid(data.focus()[0], data.focus()[2]))
filename = "fft_frame_%s_sf_%04d.cbf" % (tag, idx)
elif slice_id == 2: # fast
data_slice = data[:, :, idx:idx + 1]
data_slice.reshape(flex.grid(data.focus()[0], data.focus()[1]))
filename = "fft_frame_%s_sm_%04d.cbf" % (tag, idx)
print['slow', 'med', 'fast'][slice_id], idx
FormatCBFMini.as_file(detector, beam, None, scan, data_slice,
filename)
def make_images(data, tag):
pixel_size = 0.1
detector = DetectorFactory.simple(
'PAD', 100,
(pixel_size * data.focus()[1] / 2, pixel_size * data.focus()[2] / 2),
'+x', '-y', (pixel_size, pixel_size),
(data.focus()[2], data.focus()[1]), (-1, 1e6 - 1), [], None)
beam = BeamFactory.simple(1.0)
for slice_id in [0, 1, 2]:
for idx in xrange(data.focus()[slice_id]):
if slice_id == 0: # slow
data_slice = data[idx:idx + 1, :, :]
data_slice.reshape(flex.grid(data.focus()[1], data.focus()[2]))
filename = "fft_frame_%s_mf_%04d.cbf" % (tag, idx)
elif slice_id == 1: # med
data_slice = data[:, idx:idx + 1, :]
data_slice.reshape(flex.grid(data.focus()[0], data.focus()[2]))
filename = "fft_frame_%s_sf_%04d.cbf" % (tag, idx)
elif slice_id == 2: # fast
data_slice = data[:, :, idx:idx + 1]
data_slice.reshape(flex.grid(data.focus()[0], data.focus()[1]))
filename = "fft_frame_%s_sm_%04d.cbf" % (tag, idx)
print['slow', 'med', 'fast'][slice_id], idx
FormatCBFMini.as_file(detector, beam, None, None, data_slice,
filename)
def get(self, sensor, fast, slow, df, ds):
"""Look up a name for a detector with this sensor type (listed in
detector_helpers) these image dimensions in the fast and slow
directions, these corresponding pixel sizes, in microns (integers).
If the sensor is unknown, all sensor types will be tested - be warned
if there are duplicates."""
sensor = DetectorFactory.sensor(sensor)
if sensor == detector_helper_sensors.SENSOR_UNKNOWN:
for s in detector_helper_sensors.all():
try:
return self.get(s, fast, slow, df, ds)
except ValueError:
pass
raise ValueError("detector %s %d %d %d %d unknown" %
(sensor, fast, slow, df, ds))
if (sensor, fast, slow, df, ds) in self._detectors:
return self._detectors[(sensor, fast, slow, df, ds)]
# OK allow for small variations in the recorded pixel dimensions
for ddf in -2, -1, 1, 2:
for dds in -2, -1, 1, 2:
if (sensor, fast, slow, df + ddf, ds + dds) in self._detectors:
return self._detectors[(sensor, fast, slow, df + ddf,
ds + dds)]
raise ValueError("detector %s %d %d %d %d unknown" %
(sensor, fast, slow, df, ds))
def __init__(self):
detector_lib = os.path.join(
os.path.split(dxtbx.__file__)[0], "data", "detectors.lib")
if not os.path.exists(detector_lib):
raise RuntimeError("detector library not found")
self._detectors = {}
for record in open(detector_lib):
if "Sensor" in record[:6]:
continue
if "------" in record[:6]:
continue
text = record.split("#")[0].strip()
if not text:
continue
tokens = text.split()
assert len(tokens) == 6
sensor = DetectorFactory.sensor(tokens[0])
fast, slow, df, ds = map(int, tokens[1:5])
self._detectors[(sensor, fast, slow, df, ds)] = tokens[5]
def __init__(self):
#unit cell and space group for lysozyme
known_symmetry = crystal.symmetry("78,78,37,90,90,90", "P43212")
data = two_color_still_sim.two_color_still_sim(symm=known_symmetry,
rot=None)
self.data = data
wavelength1 = 12398 / 7400 #wavelength for 2 color experiment in Angstroms
wavelength2 = 12398 / 7500 #wavelength for 2 color experiment in Angstroms
#get detector with a single panel
detector = detector_factory.simple('SENSOR_UNKNOWN', 125,
(97.075, 97.075), '+x', '-y',
(0.11, 0.11), (1765, 1765))
self.detector = detector
beam1 = beam_factory.simple_directional((0, 0, 1), wavelength1)
beam2 = beam_factory.simple_directional((0, 0, 1), wavelength2)
beams = [beam1, beam2]
self.beams = beams
hkl_list = data.hkl_list
self.hkl_list = hkl_list
A = data.A
self.A = A
two_color_sim = data.ewald_proximity_test(beams, hkl_list, A, detector)
self.two_color_sim = two_color_sim
def __init__(self):
detector_lib = os.path.join(
os.path.split(dxtbx.__file__)[0], "data", "detectors.lib")
if not os.path.exists(detector_lib):
raise RuntimeError("detector library not found")
self._detectors = {}
with io.open(detector_lib, "r", encoding="ascii") as fh:
for record in fh:
if record.startswith(("Sensor", "-----")):
continue
text = record.split("#")[0].strip()
if not text:
continue
tokens = text.split()
assert len(tokens) == 6
sensor = DetectorFactory.sensor(tokens[0])
fast, slow, df, ds = map(int, tokens[1:5])
self._detectors[(sensor, fast, slow, df, ds)] = tokens[5]
def test_unique_hkl():
'''tests the uniqueness of hkl values associated with each experiment for
100 simulated randomly oriented thermolysin diffraction images prior to indexing.'''
flex.set_random_seed(42) # the meaning of life
known_symmetry = crystal.symmetry("78,78,37,90,90,90", "P43212")
detector = detector_factory.simple('SENSOR_UNKNOWN', 125, (97.075, 97.075),
'+x', '-y', (0.11, 0.11), (1765, 1765))
wavelength1 = 12398 / 7400 #wavelength for 2 color experiment in Angstroms
wavelength2 = 12398 / 7500 #wavelength for 2 color experiment in Angstroms
beam1 = beam_factory.simple_directional((0, 0, 1), wavelength1)
beam2 = beam_factory.simple_directional((0, 0, 1), wavelength2)
beams = [beam1, beam2]
for i in range(100):
data = two_color_still_sim.two_color_still_sim(known_symmetry,
rot=None)
hkl_list = data.hkl_list
A = data.A
sim_data = data.ewald_proximity_test(beams, hkl_list, A, detector)
refl = sim_data.get('reflection_table')
refl1 = refl.select(refl['set_id'] == 0)
refl2 = refl.select(refl['set_id'] == 1)
# unit test to make sure all miller indices are unique for each experiment id
assert len(refl1['miller_index']) == len(set(refl1['miller_index']))
assert len(refl2['miller_index']) == len(set(refl2['miller_index']))
print "ok"
def _detector(self):
"""
Create the detector model
"""
from scitbx import matrix
from dxtbx.model.detector import DetectorFactory
configuration = self.header["configuration"]
info = self.header["info"]
# from pprint import pprint
# pprint(configuration)
# Set the trusted range
# trusted_range = 0, configuration['countrate_correction_count_cutoff']
trusted_range = 0, 2**configuration["bit_depth_readout"] - 1
# Get the sensor material and thickness
sensor_material = str(configuration["sensor_material"])
sensor_thickness = configuration["sensor_thickness"]
beam_center = configuration["beam_center_x"], configuration[
"beam_center_y"]
distance = configuration["detector_distance"]
# Get the pixel and image sizes
pixel_size = (configuration["x_pixel_size"],
configuration["y_pixel_size"])
# Image size is not x/y_pixels_in_detector, which are likely the physical dimensions
image_size = (info["shape"][0], info["shape"][1])
# Get the detector axes
# TODO Spec doesn't have detector_orientation
# TODO THIS NEEDS FIXING
# fast_axis = (1, 0, 0)
# slow_axis = (0, 1, 0)
# origin = (0, 0, -1)
fast_axis = configuration["detector_orientation"][0:3]
slow_axis = configuration["detector_orientation"][3:6]
origin = matrix.col(
configuration["detector_translation"]) + matrix.col(
(0, 0, -distance))
# Create the detector model
return DetectorFactory.make_detector(
"SENSOR_PAD",
fast_axis,
slow_axis,
origin,
pixel_size,
image_size,
trusted_range,
px_mm=None,
name="Panel",
thickness=sensor_thickness,
material=sensor_material,
mu=0.0,
)
def test_detector():
'''A test class for the detector class.'''
d = DetectorFactory.simple('CCD', 100.0, (45.0, 52.0), '+x', '-y',
(0.172, 0.172), (516, 590), (0, 1024), [])
t = DetectorFactory.two_theta(
'CCD', 60.0, (35.0, 34.0), '+x', '+y', '+x', 30,
(0.07, 0.07), (1042, 1042), (0, 1024), [])
import libtbx.load_env
import os
dxtbx_dir = libtbx.env.dist_path('dxtbx')
image = os.path.join(dxtbx_dir, 'tests', 'phi_scan_001.cbf')
xparm = os.path.join(dxtbx_dir, 'tests', 'example-xparm.xds')
c = DetectorFactory.imgCIF(image, 'CCD')
def __init__(self, image_file, **kwargs):
from dxtbx import IncorrectFormatError
if not self.understand(image_file):
raise IncorrectFormatError(self, image_file)
FormatHDF5.__init__(self, image_file, **kwargs)
self.DET64 = DetectorFactory.from_dict(multi_det_dict.D)
self._h5_handle = h5py.File(self.get_image_file(), 'r')
self._geometry_define()
def test_cbf_buffer(dials_regression):
filename = os.path.join(dials_regression, "image_examples", "dials-190",
"whatev1_01_00001.cbf")
with open(filename, "rb") as f:
contents = f.read()
handle = pycbf.cbf_handle_struct()
cbf_read_buffer(handle, contents, pycbf.MSG_DIGEST)
det = DetectorFactory.imgCIF_H(handle, "unknown")
assert det
def _construct_detector(distance):
return DetectorFactory.simple(
sensor="PAD",
distance=distance,
beam_centre=(41.20, 51.69),
fast_direction="+x",
slow_direction="-y",
pixel_size=(0.172, 0.172),
image_size=(487, 619),
trusted_range=(-1, 1e8),
)
def __init__(self, start, num):
self.start = start
self.num = num
assert self.start > 0 and self.num > 1
# Set up detector
distance = 1590.00
pixel_size = 0.055
image_size = (1024, 1024)
beam_centre_mm = (
pixel_size * image_size[0] / 2,
pixel_size * image_size[1] / 2,
)
self.detector = DetectorFactory().simple(
"PAD",
distance,
beam_centre_mm,
"+x",
"-y",
(pixel_size, pixel_size),
image_size,
trusted_range=(-1, 1000000),
)
# Set up unpolarized 200 keV beam
wavelength = 0.02508
self.beam = BeamFactory().make_polarized_beam(
sample_to_source=(0.0, 0.0, 1.0),
wavelength=wavelength,
polarization=(0, 1, 0),
polarization_fraction=0.5,
)
# Set up simulated structure factors
self.sfall = self.fcalc_from_pdb(resolution=2.0)
self._unit_cell = self.cell_from_pdb()
a, b, c, aa, bb, cc = self._unit_cell.parameters()
self.experiments = ExperimentList()
for _ in range(self.num):
# Set up crystal - does not need to be correct, it is overwritten anyway
crystal = Crystal(
real_space_a=(a, 0, 0),
real_space_b=(0, b, 0),
real_space_c=(0, 0, c),
space_group_symbol="P 43 21 2",
)
self.experiments.append(
Experiment(beam=self.beam,
detector=self.detector,
crystal=crystal))
def _construct_detector(distance):
return DetectorFactory.simple(
sensor="PAD",
distance=distance,
beam_centre=(216.87, 211.32),
fast_direction="+x",
slow_direction="-y",
pixel_size=(0.172, 0.172),
image_size=(2463, 2527),
trusted_range=(-1, 1e8),
)
def simple_detector(detector_distance_mm, pixelsize_mm, image_shape, fast=(1, 0, 0), slow=(0, -1, 0)):
from dxtbx.model.detector import DetectorFactory
import numpy as np
trusted_range = (0, 200000000000000.0)
detsize_s = image_shape[0] * pixelsize_mm
detsize_f = image_shape[1] * pixelsize_mm
cent_s = (detsize_s + pixelsize_mm * 2) / 2.0
cent_f = (detsize_f + pixelsize_mm * 2) / 2.0
beam_axis = np.cross(fast, slow)
origin = -np.array(fast) * cent_f - np.array(slow) * cent_s + beam_axis * detector_distance_mm
return DetectorFactory.make_detector('', fast, slow, origin, (
pixelsize_mm, pixelsize_mm), image_shape, trusted_range)
def _detector(self):
'''
Create the detector model
'''
from scitbx import matrix
from dxtbx.model.detector import DetectorFactory
configuration = self.header['configuration']
# Set the trusted range
trusted_range = 0, configuration['countrate_correction_count_cutoff']
# Get the sensor material and thickness
sensor_material = str(configuration['sensor_material'])
sensor_thickness = configuration['sensor_thickness']
beam_center = configuration['beam_center_x'], configuration[
'beam_center_y']
distance = configuration['detector_distance']
# Get the pixel and image sizes
pixel_size = (configuration['x_pixel_size'],
configuration['y_pixel_size'])
image_size = (configuration['x_pixels_in_detector'],
configuration['y_pixels_in_detector'])
# Get the detector axes
# TODO Spec doesn't have detector_orientation
# TODO THIS NEEDS FIXING
fast_axis = (1, 0, 0)
slow_axis = (0, 1, 0)
origin = (0, 0, -1)
# fast_axis = configuration['detector_orientation'][0:3]
# slow_axis = configuration['detector_orientation'][3:6]
#origin = matrix.col(configuration['detector_translation']) + matrix.col((0,0,-distance))
# Create the detector model
return DetectorFactory.make_detector('SENSOR_PAD',
fast_axis,
slow_axis,
origin,
pixel_size,
image_size,
trusted_range,
px_mm=None,
name='Panel',
thickness=sensor_thickness,
material=sensor_material,
mu=0.0)
def _detector(self):
"""
Create the detector model
"""
configuration = self.header["configuration"]
info = self.header["info"]
# from pprint import pprint
# pprint(configuration)
# Set the trusted range
trusted_range = 0, 2**configuration["bit_depth_readout"] - 1
# Get the sensor material and thickness
sensor_material = str(configuration["sensor_material"])
sensor_thickness = configuration["sensor_thickness"]
distance = configuration["detector_distance"]
# Get the pixel and image sizes
pixel_size = (configuration["x_pixel_size"],
configuration["y_pixel_size"])
# Image size is not x/y_pixels_in_detector, which are likely the physical dimensions
image_size = (info["shape"][0], info["shape"][1])
# Get the detector axes
fast_axis = configuration["detector_orientation"][0:3]
slow_axis = configuration["detector_orientation"][3:6]
origin = matrix.col(
configuration["detector_translation"]) + matrix.col(
(0, 0, -distance))
# Create the detector model
return DetectorFactory.make_detector(
"SENSOR_PAD",
fast_axis,
slow_axis,
origin,
pixel_size,
image_size,
trusted_range,
px_mm=None,
name="Panel",
thickness=sensor_thickness,
material=sensor_material,
mu=0.0,
)
def get_basis():
'''gets the input basis vectors of 100 simulated diffraction images'''
flex.set_random_seed(42)
known_symmetry = crystal.symmetry("78,78,37,90,90,90", "P43212")
detector = detector_factory.simple('SENSOR_UNKNOWN', 125, (97.075, 97.075),
'+x', '-y', (0.11, 0.11), (1765, 1765))
wavelength1 = 12398 / 7400 #wavelength for 2 color experiment in Angstroms
wavelength2 = 12398 / 7500 #wavelength for 2 color experiment in Angstroms
beam1 = beam_factory.simple_directional((0, 0, 1), wavelength1)
beam2 = beam_factory.simple_directional((0, 0, 1), wavelength2)
a_basis = []
b_basis = []
c_basis = []
unique_vectors = []
# refiner resets random number seed so in order to get the same 100 images
#generated each time the random seed is set
# the implementation is as follows
sims = [merge_close_spots.merge_close_spots() for i in range(2)]
for data in sims:
A = data.A
A_inv = A.inverse()
a = col(A_inv[:3])
b = col(A_inv[3:6])
c = col(A_inv[6:])
a_basis.append(a)
b_basis.append(b)
c_basis.append(c)
res = data.two_color_sim
info = data.spot_proximity(res)
refl = info[0]
candidate_basis_vectors = index(refl, detector, known_symmetry,
[beam1, beam2])
unique_vectors.append(candidate_basis_vectors)
return a_basis, b_basis, c_basis, unique_vectors
def basic_detector(
): # from development, not actually used here but useful for reference
# make a detector panel
# monolithic camera description
print("Make a dxtbx detector")
detdist = 141.7
pixsize = 0.088 # Rayonix MX340-XFEL, 2x2 binning mode
im_shape = 3840, 3840
det_descr = {
'panels': [{
'fast_axis': (1.0, 0.0, 0.0),
'slow_axis': (0.0, -1.0, 0.0),
'gain':
1.0,
'identifier':
'',
'image_size':
im_shape,
'mask': [],
'material':
'',
'mu':
0.0,
'name':
'Panel',
'origin': (-im_shape[0] * pixsize / 2., im_shape[1] * pixsize / 2.,
-detdist),
'pedestal':
0.0,
'pixel_size': (pixsize, pixsize),
'px_mm_strategy': {
'type': 'SimplePxMmStrategy'
},
'raw_image_offset': (0, 0),
'thickness':
0.0,
'trusted_range': (-1e7, 1e7),
'type':
''
}]
}
return DetectorFactory.from_dict(det_descr)
def basic_detector():
# make a detector panel
# monolithic camera description
print("Make a dxtbx detector")
detdist = 100.
pixsize = 0.1
im_shape = 1536, 1536
det_descr = {
'panels': [{
'fast_axis': (1.0, 0.0, 0.0),
'slow_axis': (0.0, -1.0, 0.0),
'gain':
1.0,
'identifier':
'',
'image_size':
im_shape,
'mask': [],
'material':
'',
'mu':
0.0,
'name':
'Panel',
'origin': (-im_shape[0] * pixsize / 2., im_shape[1] * pixsize / 2.,
-detdist),
'pedestal':
0.0,
'pixel_size': (pixsize, pixsize),
'px_mm_strategy': {
'type': 'SimplePxMmStrategy'
},
'raw_image_offset': (0, 0),
'thickness':
0.0,
'trusted_range': (-1e7, 1e7),
'type':
''
}]
}
return DetectorFactory.from_dict(det_descr)
'mask': [],
'material': '',
'mu': 0.0,
'name': 'Panel',
'origin': (-im_shape[0]*pixsize/2., im_shape[1]*pixsize/2., -detdist),
'pedestal': 0.0,
'pixel_size': (pixsize, pixsize),
'px_mm_strategy': {'type': 'SimplePxMmStrategy'},
'raw_image_offset': (0, 0),
'thickness': 0.0,
'trusted_range': (-1e7, 1e7),
'type': ''}]}
# make the dxtbx objects
BEAM = BeamFactory.from_dict(beam_descr)
DETECTOR = DetectorFactory.from_dict(det_descr)
CRYSTAL = CrystalFactory.from_dict(cryst_descr)
# make a dummie HKL table with constant HKL intensity
# this is just to make spots
DEFAULT_F = 1e2
symbol = CRYSTAL.get_space_group().info().type().lookup_symbol() # this is just P43212
sgi = sgtbx.space_group_info(symbol)
symm = symmetry(unit_cell=CRYSTAL.get_unit_cell(), space_group_info=sgi)
miller_set = symm.build_miller_set(anomalous_flag=True, d_min=1.6, d_max=999)
Famp = flex.double(np.ones(len(miller_set.indices())) * DEFAULT_F)
Famp = miller.array(miller_set=miller_set, data=Famp).set_observation_type_xray_amplitude()
Ncells_abc = 20, 20, 20
oversmaple = 2
def test_indexed_hkl():
'''tests the uniqueness of hkl values associated with each experiment for
100 simulated randomly oriented thermolysin diffraction images indexed using
two color indexer'''
flex.set_random_seed(42)
known_symmetry = crystal.symmetry("78,78,37,90,90,90", "P43212")
detector = detector_factory.simple('SENSOR_UNKNOWN', 125, (97.075, 97.075),
'+x', '-y', (0.11, 0.11), (1765, 1765))
wavelength1 = 12398 / 7400 #wavelength for 2 color experiment in Angstroms
wavelength2 = 12398 / 7500 #wavelength for 2 color experiment in Angstroms
beam1 = beam_factory.simple_directional((0, 0, 1), wavelength1)
beam2 = beam_factory.simple_directional((0, 0, 1), wavelength2)
a_basis = []
b_basis = []
c_basis = []
# refiner resets random number seed so in order to get the same 100 images
#generated each time the random seed is set
# the implementation is as follows
# gets simulated images
sims = [merge_close_spots.merge_close_spots() for i in range(2)]
for data in sims:
A = data.A
A_inv = A.inverse()
a = col(A_inv[:3])
b = col(A_inv[3:6])
c = col(A_inv[6:])
crystinp = Crystal(a, b, c, space_group=known_symmetry.space_group())
a_basis.append(a)
b_basis.append(b)
c_basis.append(c)
res = data.two_color_sim
info = data.spot_proximity(res)
refl = info[0]
result = index(refl, detector, known_symmetry, [beam1, beam2])
cm = result.refined_experiments.crystals()[0]
R, best_axis, best_angle, change_of_basis = difference_rotation_matrix_axis_angle(
crystal_a=cm, crystal_b=crystinp)
# cmd_line = command_line.argument_interpreter(master_params=master_phil_scope)
# working_phil = cmd_line.process_and_fetch(args=[])
params = master_phil_scope.extract()
params.refinement.parameterisation.beam.fix = "all"
params.refinement.parameterisation.detector.fix = "all"
params.indexing.known_symmetry.space_group = known_symmetry.space_group_info(
)
params.refinement.verbosity = 3
params.indexing.refinement_protocol.d_min_start = 3
params.indexing.refinement_protocol.n_macro_cycles = 1
params.indexing.known_symmetry.unit_cell = known_symmetry.unit_cell()
params.indexing.multiple_lattice_search.max_lattices = 1
params.indexing.debug = True
params.indexing.known_symmetry.absolute_angle_tolerance = 5.0
params.indexing.known_symmetry.relative_length_tolerance = 0.3
params.indexing.stills.rmsd_min_px = 3.5
expts = copy.deepcopy(result.refined_experiments)
expts.crystals()[0].change_basis(change_of_basis)
reflections_exp0 = result.refined_reflections.select(
result.refined_reflections['id'] == 0)
reflections_exp1 = result.refined_reflections.select(
result.refined_reflections['id'] == 1)
assert len(reflections_exp0['miller_index']) == len(
set(reflections_exp0['miller_index']))
assert len(reflections_exp1['miller_index']) == len(
set(reflections_exp1['miller_index']))
print "OK"
def test_from_phil():
from dxtbx.model.detector import detector_phil_scope
from dxtbx.model.detector import DetectorFactory, ParallaxCorrectedPxMmStrategy
from libtbx.phil import parse
from dxtbx.model import Beam
beam = Beam((0, 0, 1))
params = detector_phil_scope.fetch(
parse('''
detector {
panel {
id = 0
origin = (1, 1, 1)
pixel_size = (0.001,0.001)
image_size = (1000,1000)
trusted_range = (-1, 1000)
material = "Si"
thickness = 0.01
parallax_correction = True
}
panel {
id = 1
origin = (2, 2, 2)
pixel_size = (0.001,0.001)
image_size = (1000,1000)
trusted_range = (-1, 1000)
}
panel {
id = 2
origin = (3, 3, 3)
pixel_size = (0.001,0.001)
image_size = (1000,1000)
trusted_range = (-1, 1000)
}
panel {
id = 3
origin = (4, 4, 4)
pixel_size = (0.001,0.001)
image_size = (1000,1000)
trusted_range = (-1, 1000)
}
hierarchy {
name = "Root"
origin = (100, 100, 100)
group {
id = 0
origin = (10, 10, 10)
}
group {
id = 0,0
origin = (1, 1, 1)
panel = 0
}
group {
id = 0,1
origin = (2, 2, 2)
panel = 1
}
group {
id = 1
origin = (20, 20, 20)
}
group {
id = 1,0
origin = (1, 1, 1)
panel = 2
}
group {
id = 1,1
origin = (2, 2, 2)
panel = 3
}
}
}
''')).extract()
# Test create model
d1 = DetectorFactory.from_phil(params, beam=beam)
root = d1.hierarchy()
# Check hierarchy origins
assert root.get_origin() == (100, 100, 100)
assert root[0].get_origin() == (110, 110, 110)
assert root[1].get_origin() == (120, 120, 120)
assert root[0][0].get_origin() == (111, 111, 111)
assert root[0][1].get_origin() == (112, 112, 112)
assert root[1][0].get_origin() == (121, 121, 121)
assert root[1][1].get_origin() == (122, 122, 122)
assert root[0][0][0].get_origin() == (112, 112, 112)
assert root[0][1][0].get_origin() == (114, 114, 114)
assert root[1][0][0].get_origin() == (124, 124, 124)
assert root[1][1][0].get_origin() == (126, 126, 126)
# Check panels are correct in hierarchy
assert root[0][0][0].is_(d1[0])
assert root[0][1][0].is_(d1[1])
assert root[1][0][0].is_(d1[2])
assert root[1][1][0].is_(d1[3])
# Check panel attributes
assert d1[0].get_image_size() == (1000, 1000)
assert d1[0].get_pixel_size() == (0.001, 0.001)
assert d1[0].get_trusted_range() == (-1, 1000)
assert d1[0].get_material() == "Si"
assert d1[0].get_thickness() == 0.01
assert isinstance(d1[0].get_px_mm_strategy(),
ParallaxCorrectedPxMmStrategy)
assert d1[1].get_image_size() == (1000, 1000)
assert d1[1].get_pixel_size() == (0.001, 0.001)
assert d1[1].get_trusted_range() == (-1, 1000)
assert d1[2].get_image_size() == (1000, 1000)
assert d1[2].get_pixel_size() == (0.001, 0.001)
assert d1[2].get_trusted_range() == (-1, 1000)
assert d1[3].get_image_size() == (1000, 1000)
assert d1[3].get_pixel_size() == (0.001, 0.001)
assert d1[3].get_trusted_range() == (-1, 1000)
params = detector_phil_scope.fetch(
parse('''
detector {
panel {
id = 0
parallax_correction = False
}
panel {
id = 1
material = "Si"
thickness = 0.01
parallax_correction = True
}
hierarchy {
name = "Root"
origin = (200, 200, 200)
group {
id = 0
origin = (20, 20, 20)
}
group {
id = 0,0
origin = (2, 2, 2)
}
group {
id = 0,1
origin = (3, 3, 3)
}
group {
id = 1
origin = (30, 30, 30)
}
group {
id = 1,0
origin = (2, 2, 2)
}
group {
id = 1,1
origin = (3, 3, 3)
}
}
}
''')).extract()
# Test overwrite model
d2 = DetectorFactory.from_phil(params, reference=d1, beam=beam)
root = d2.hierarchy()
# Check hierarchy origins
assert root.get_origin() == (200, 200, 200)
assert root[0].get_origin() == (220, 220, 220)
assert root[1].get_origin() == (230, 230, 230)
assert root[0][0].get_origin() == (222, 222, 222)
assert root[0][1].get_origin() == (223, 223, 223)
assert root[1][0].get_origin() == (232, 232, 232)
assert root[1][1].get_origin() == (233, 233, 233)
assert root[0][0][0].get_origin() == (223, 223, 223)
assert root[0][1][0].get_origin() == (225, 225, 225)
assert root[1][0][0].get_origin() == (235, 235, 235)
assert root[1][1][0].get_origin() == (237, 237, 237)
# Check panels are correct in hierarchy
assert root[0][0][0].is_(d2[0])
assert root[0][1][0].is_(d2[1])
assert root[1][0][0].is_(d2[2])
assert root[1][1][0].is_(d2[3])
# Check panel attributes
assert not isinstance(d2[0].get_px_mm_strategy(),
ParallaxCorrectedPxMmStrategy)
assert d2[1].get_material() == "Si"
assert d2[1].get_thickness() == 0.01
assert isinstance(d2[1].get_px_mm_strategy(),
ParallaxCorrectedPxMmStrategy)
# ------------------------
if lab_geom == "canonical":
s = 1 # scale factor, divide pixel size by this factor
pixsize = .10992/s # mm
detdist = 125 # mm
wavelen = 1.385
orig = col((-s*1536*pixsize/2.,
s*1536*pixsize/2.,
-detdist))
# Initialise detector frame
fast = col((1.0, 0.0, 0.0))
slow = col((0.0, -1.0, 0.0))
det = DetectorFactory.make_detector(
"", fast, slow, orig,
(pixsize, pixsize), (s*1536,s*1536)) #, trusted_range=(0, 10000000))
beam_descr = {
'direction': (7.010833160725592e-06, -3.710515413340211e-06, 0.9999999999685403),
'divergence': 0.0,
'flux': 0.0,
'polarization_fraction': 0.999,
'polarization_normal': (0.0, 1.0, 0.0),
'sigma_divergence': 0.0,
'transmission': 1.0,
'wavelength': 1.385}
#beam = BeamFactory.simple(wavelen)
beam = BeamFactory.from_dict(beam_descr)
elif lab_geom == "cspad":
det = DetectorFactory.from_dict(dxtbx_cspad.cspad)
def main():
from cxid9114.sim import sim_utils
from dxtbx.model.crystal import CrystalFactory
from dxtbx_model_ext import flex_Beam
from dxtbx.model.detector import DetectorFactory
from dxtbx.model.beam import BeamFactory
from simtbx.nanoBragg.tst_nanoBragg_basic import fcalc_from_pdb
import numpy as np
from cxid9114.parameters import ENERGY_CONV
energies = np.arange(8920, 8930)
fluxes = np.ones(len(energies)) * 5e11
patt_args = {"Ncells_abc": (20, 20, 20), "profile": "square", "verbose": 0}
beam_descr = {
'direction': (0.0, 0.0, 1.0),
'divergence': 0.0,
'flux': 5e11,
'polarization_fraction': 1.,
'polarization_normal': (0.0, 1.0, 0.0),
'sigma_divergence': 0.0,
'transmission': 1.0,
'wavelength': ENERGY_CONV / energies[0]
}
cryst_descr = {
'__id__': 'crystal',
'real_space_a': (79, 0, 0),
'real_space_b': (0, 79, 0),
'real_space_c': (0, 0, 38),
'space_group_hall_symbol': '-P 4 2'
}
det_descr = {
'panels': [{
'fast_axis': (-1.0, 0.0, 0.0),
'gain': 1.0,
'identifier': '',
'image_size': (196, 196),
'mask': [],
'material': '',
'mu': 0.0,
'name': 'Panel',
'origin': (19.6, -19.6, -550),
'pedestal': 0.0,
'pixel_size': (0.1, 0.1),
'px_mm_strategy': {
'type': 'SimplePxMmStrategy'
},
'raw_image_offset': (0, 0),
'slow_axis': (0.0, 1.0, 0.0),
'thickness': 0.0,
'trusted_range': (0.0, 65536.0),
'type': ''
}]
}
DET = DetectorFactory.from_dict(det_descr)
BEAM = BeamFactory.from_dict(beam_descr)
crystal = CrystalFactory.from_dict(cryst_descr)
Patt = sim_utils.PatternFactory(crystal=crystal,
detector=DET,
beam=BEAM,
**patt_args)
img = None
Fens = []
xrbeams = flex_Beam()
for fl, en in zip(fluxes, energies):
wave = ENERGY_CONV / en
F = fcalc_from_pdb(resolution=4, algorithm="fft", wavelength=wave)
Patt.primer(crystal, energy=en, flux=fl, F=F)
if img is None:
img = Patt.sim_rois(reset=True) # defaults to full detector
else:
img += Patt.sim_rois(reset=True)
Fens.append(F)
xrb = BeamFactory.from_dict(beam_descr)
xrb.set_wavelength(wave *
1e-10) # need to fix the necessity to do this..
xrb.set_flux(fl)
xrb.set_direction(BEAM.get_direction())
xrbeams.append(xrb)
#import pylab as plt
#def plot_img(ax,img):
# m = img[img >0].mean()
# s = img[img > 0].std()
# vmax = m+5*s
# vmin = 0
# ax.imshow(img, vmin=vmin, vmax=vmax, cmap='gnuplot')
print("\n\n\n")
print("<><><><><><><><><><>")
print("NEXT TRIAL")
print("<><><><><><><><><><>")
#
patt2 = sim_utils.PatternFactory(crystal=crystal,
detector=DET,
beam=xrbeams,
**patt_args)
patt2.prime_multi_Fhkl(multisource_Fhkl=Fens)
img2 = patt2.sim_rois(reset=True)
#plt.figure()
#ax1 = plt.gca()
#plt.figure()
#ax2 = plt.gca()
#plot_img(ax1, img)
#plot_img(ax2, img2)
#plt.show()
assert (np.allclose(img, img2))
'material': '',
'mu': 0.0,
'name': 'Panel',
'origin': (-99.165, 99.05499999999999, -125.0),
'pedestal': 0.0,
'pixel_size': (0.11, 0.11),
'px_mm_strategy': {
'type': 'SimplePxMmStrategy'
},
'raw_image_offset': (0, 0),
'slow_axis': (0.0, -1.0, 0.0),
'thickness': 0.0,
'trusted_range': (-29.0, 65505.0),
'type': 'SENSOR_CCD'
}]
}
beamDict = {
'direction': (0.0, 0.0, 1.0),
'divergence': 0.0,
'flux': 0.0,
'polarization_fraction': 0.999,
'polarization_normal': (0.0, 1.0, 0.0),
'sigma_divergence': 0.0,
'transmission': 1.0,
'wavelength': 1.37095
}
BEAM = BeamFactory.from_dict(beamDict)
DET = DetectorFactory.from_dict(detDict)