def test_experimentlist_with_identifiers():
from dxtbx.model import Beam, Detector, Goniometer, Scan
# Initialise a list of experiments
experiments = ExperimentList()
experiments.append(
Experiment(beam=Beam(s0=(0, 0, -1)),
detector=Detector(),
identifier="bacon"))
experiments.append(
Experiment(beam=Beam(s0=(0, 0, -1)),
detector=Detector(),
identifier="sausage"))
with pytest.raises(Exception):
experiments.append(
Experiment(beam=Beam(), detector=Detector(), identifier="bacon"))
d = experiments.to_dict()
e2 = ExperimentListDict(d).decode()
assert experiments[0].identifier == e2[0].identifier
assert experiments[1].identifier == e2[1].identifier
assert tuple(experiments.identifiers()) == ("bacon", "sausage")
experiments[0].identifier = "spam"
assert tuple(experiments.identifiers()) == ("spam", "sausage")
def test_experimentlist_with_identifiers():
# Initialise a list of experiments
experiments = ExperimentList()
experiments.append(
Experiment(beam=Beam(s0=(0, 0, -1)),
detector=Detector(),
identifier="bacon"))
experiments.append(
Experiment(beam=Beam(s0=(0, 0, -1)),
detector=Detector(),
identifier="sausage"))
with pytest.raises(Exception):
experiments.append(
Experiment(beam=Beam(), detector=Detector(), identifier="bacon"))
d = experiments.to_dict()
e2 = ExperimentListDict(d).decode()
assert experiments[0].identifier == e2[0].identifier
assert experiments[1].identifier == e2[1].identifier
assert tuple(experiments.identifiers()) == ("bacon", "sausage")
experiments[0].identifier = "spam"
assert tuple(experiments.identifiers()) == ("spam", "sausage")
experiments.append(Experiment(identifier="bacon"))
experiments.select_on_experiment_identifiers(["spam", "bacon"])
assert list(experiments.identifiers()) == ["spam", "bacon"]
experiments.append(Experiment(identifier="ham"))
experiments.append(Experiment(identifier="jam"))
experiments.remove_on_experiment_identifiers(["spam", "jam"])
assert list(experiments.identifiers()) == ["bacon", "ham"]
def tst_equality(self):
from dxtbx.model import Beam, Detector, Goniometer, Scan
from dxtbx.model import Crystal
# Create a load of models
b1 = Beam()
d1 = Detector()
g1 = Goniometer()
s1 = Scan()
c1 = Crystal((1, 0, 0), (0, 1, 0), (0, 0, 1), space_group_symbol="P1")
# Create a load of models that look the same but aren't
b2 = Beam()
d2 = Detector()
g2 = Goniometer()
s2 = Scan()
c2 = Crystal((1, 0, 0), (0, 1, 0), (0, 0, 1), space_group_symbol="P1")
# Create an experiment
e1 = Experiment(beam=b1,
detector=d1,
goniometer=g1,
scan=s1,
crystal=c1,
imageset=None)
# Create an experiment
e2 = Experiment(beam=b1,
detector=d1,
goniometer=g1,
scan=s1,
crystal=c1,
imageset=None)
# Create an experiment
e3 = Experiment(beam=b2,
detector=d2,
goniometer=g2,
scan=s2,
crystal=c2,
imageset=None)
# Check e1 equals e2 but not e3
assert (e1 == e2)
assert (e1 != e3)
assert (e2 != e3)
# Test passed
print 'OK'
def _detector(self, index=None):
from dxtbx.model import Detector
if index is None: index = 0
d = Detector()
root = d.hierarchy()
all_addresses = self._src
def recursive_add_node(a, b):
# add a to b
if a.is_panel():
b.add_panel(a)
else:
g = b.add_group(a)
for child in a:
recursive_add_node(child, g)
for address in all_addresses:
self._src = [address]
sub_d = None
try:
if 'rayonix' in address.lower():
sub_d = FormatXTCRayonix._detector(self)
elif 'cspad' in address.lower():
sub_d = FormatXTCCspad._detector(self, index)
elif 'jungfrau' in address.lower():
sub_d = FormatXTCJungfrau._detector(self, index)
except Exception:
continue
assert sub_d is not None, address
recursive_add_node(sub_d.hierarchy(), root)
self._src = all_addresses
return d
def get_optimized_detector(x, SIM):
from dxtbx.model import Detector, Panel
new_det = Detector()
for pid in range(len(SIM.detector)):
panel = SIM.detector[pid]
panel_dict = panel.to_dict()
group_id = SIM.panel_group_from_id[pid]
if group_id in SIM.panel_groups_refined:
Oang = x["group%d_RotOrth" % group_id].value
Fang = x["group%d_RotFast" % group_id].value
Sang = x["group%d_RotSlow" % group_id].value
Xdist = x["group%d_ShiftX" % group_id].value
Ydist = x["group%d_ShiftY" % group_id].value
Zdist = x["group%d_ShiftZ" % group_id].value
origin_of_rotation = SIM.panel_reference_from_id[pid]
SIM.D.reference_origin = origin_of_rotation
SIM.D.update_dxtbx_geoms(SIM.detector, SIM.beam.nanoBragg_constructor_beam, pid,
Oang, Fang, Sang, Xdist, Ydist, Zdist,
force=False)
fdet = SIM.D.fdet_vector
sdet = SIM.D.sdet_vector
origin = SIM.D.get_origin()
else:
fdet = panel.get_fast_axis()
sdet = panel.get_slow_axis()
origin = panel.get_origin()
panel_dict["fast_axis"] = fdet
panel_dict["slow_axis"] = sdet
panel_dict["origin"] = origin
new_det.add_panel(Panel.from_dict(panel_dict))
return new_det
def tst_from_sweep(self):
from dxtbx.model import Beam, Detector, Goniometer, Scan
from dxtbx.model import Crystal
from dxtbx.format.Format import Format
filenames = ["filename_%01d.cbf" % (i + 1) for i in range(0, 2)]
imageset = Format.get_imageset(filenames,
beam=Beam(),
detector=Detector(),
goniometer=Goniometer(),
scan=Scan((1, 2), (0, 1)),
as_sweep=True)
crystal = Crystal((1, 0, 0), (0, 1, 0), (0, 0, 1),
space_group_symbol="P1")
experiments = ExperimentListFactory.from_imageset_and_crystal(
imageset, crystal)
assert (len(experiments) == 1)
assert (experiments[0].imageset is not None)
assert (experiments[0].beam is not None)
assert (experiments[0].detector is not None)
assert (experiments[0].goniometer is not None)
assert (experiments[0].scan is not None)
assert (experiments[0].crystal is not None)
print 'OK'
def tst_from_null_sweep(self):
from dxtbx.format.Format import Format
from dxtbx.imageset import ImageSweep
from dxtbx.model import Beam, Detector, Goniometer, Scan
filenames = ["template_%2d.cbf" % (i+1) for i in range(0, 10)]
sweep = Format.get_imageset(
filenames,
beam = Beam((0, 0, 1)),
detector = Detector(),
goniometer = Goniometer((1, 0, 0)),
scan = Scan((1, 10), (0, 0.1)))
# Create the datablock
datablock = DataBlockFactory.from_imageset(sweep)
assert(len(datablock) == 1)
datablock = datablock[0]
sweeps = datablock.extract_sweeps()
assert(len(sweeps) == 1)
assert(sweeps[0].get_beam() == sweep.get_beam())
assert(sweeps[0].get_detector() == sweep.get_detector())
assert(sweeps[0].get_goniometer() == sweep.get_goniometer())
assert(sweeps[0].get_scan() == sweep.get_scan())
print 'OK'
def generated_single_exp():
"""Generate an experiment object."""
experiments = ExperimentList()
exp_dict = {
"__id__": "crystal",
"real_space_a": [1.0, 0.0, 0.0],
"real_space_b": [0.0, 1.0, 0.0],
"real_space_c": [0.0, 0.0, 2.0],
"space_group_hall_symbol": " C 2y",
}
crystal = Crystal.from_dict(exp_dict)
scan = Scan(image_range=[0, 60], oscillation=[0.0, 1.0])
beam = Beam(s0=(0.0, 0.0, 1.01))
goniometer = Goniometer((1.0, 0.0, 0.0))
detector = Detector()
experiments.append(
Experiment(
beam=beam,
scan=scan,
goniometer=goniometer,
detector=detector,
crystal=crystal,
))
experiments[0].identifier = "0"
return experiments
def tst_set_models(imageset):
# Create some other models
beam = Beam((1, 0, 0), 0.5)
detector = Detector(
Panel(
"UNKNOWN",
"Panel",
(1, 0, 0),
(0, 1, 0),
(0, 0, 1),
(0.1, 0.1),
(1000, 1000),
(0, 1),
))
# Override sequence models
imageset.set_beam(beam)
imageset.set_detector(detector)
# Ensure this doens't interfere with reading
for i in imageset:
pass
# Get the models back and check they're ok
beam2 = imageset.get_beam()
detector2 = imageset.get_detector()
assert beam2 == beam
assert detector2 == detector
# Get the models from an index back and check they're not the same
beam2 = imageset.get_beam(0)
detector2 = imageset.get_detector(0)
assert beam2 != beam
assert detector2 != detector
def test_experimentlist_factory_from_datablock():
filenames = ["filename_%01d.cbf" % (i + 1) for i in range(0, 2)]
imageset = Format.get_imageset(
filenames,
beam=Beam(),
detector=Detector(),
goniometer=Goniometer(),
scan=Scan((1, 2), (0, 1)),
as_sequence=True,
)
crystal = Crystal((1, 0, 0), (0, 1, 0), (0, 0, 1), space_group_symbol="P1")
datablock = DataBlockFactory.from_imageset(imageset)
assert datablock[0].format_class()
experiments = ExperimentListFactory.from_datablock_and_crystal(
datablock, crystal)
assert len(experiments) == 1
assert experiments[0].imageset
assert experiments[0].beam
assert experiments[0].detector is not None
assert experiments[0].goniometer
assert experiments[0].scan
assert experiments[0].crystal
def _detector(self):
'''Return a working detector instance.'''
if self._panel_origin is not None:
from dxtbx.model import Detector
detector = Detector()
root = detector.hierarchy()
root.set_frame(self._fast_axis, self._slow_axis,
self._detector_origin)
i_panel = 0
for p_offset, p_size, origin, fast, slow in zip(
self._panel_offset, self._panel_size, self._panel_origin,
self._panel_fast, self._panel_slow):
# ensure mutual orthogonality in presence of numerical rounding errors
normal = fast.cross(slow)
slow = normal.cross(fast)
p = root.add_panel()
p.set_type('unknown')
p.set_raw_image_offset(p_offset)
p.set_image_size(p_size)
p.set_name('Panel%d' % i_panel)
p.set_pixel_size(self._pixel_size)
p.set_frame(fast.elems, slow.elems, origin.elems)
i_panel += 1
return detector
return self._detector_factory.complex(
self._detector_factory.sensor('unknown'), self._detector_origin,
self._fast_axis, self._slow_axis, self._pixel_size,
self._image_size, (0, 1.e9))
def test_experimentlist_dumper_dump_empty_sweep(tmpdir):
tmpdir.chdir()
from dxtbx.model import Beam, Detector, Goniometer, Scan
from dxtbx.model import Crystal
from dxtbx.format.Format import Format
filenames = ["filename_%01d.cbf" % (i+1) for i in range(0, 2)]
imageset = Format.get_imageset(
filenames,
beam = Beam((1, 0, 0)),
detector = Detector(),
goniometer = Goniometer(),
scan = Scan((1,2), (0.0, 1.0)),
as_sweep=True)
crystal = Crystal((1, 0, 0), (0, 1, 0), (0, 0, 1), space_group_symbol="P1")
experiments = ExperimentListFactory.from_imageset_and_crystal(
imageset, crystal)
dump = ExperimentListDumper(experiments)
filename = 'temp.json'
dump.as_json(filename)
experiments2 = ExperimentListFactory.from_json_file(filename,
check_format=False)
check(experiments, experiments2)
def tst_dump_empty_sweep(self):
from dxtbx.imageset import ImageSweep, NullReader, SweepFileList
from dxtbx.model import Beam, Detector, Goniometer, Scan
from dxtbx.model.crystal import crystal_model
from uuid import uuid4
imageset = ImageSweep(NullReader(SweepFileList("filename%01d.cbf", (0, 3))))
imageset.set_beam(Beam((1, 0, 0)))
imageset.set_detector(Detector())
imageset.set_goniometer(Goniometer())
imageset.set_scan(Scan((1, 3), (0.0, 1.0)))
crystal = crystal_model((1, 0, 0), (0, 1, 0), (0, 0, 1), space_group_symbol=1)
experiments = ExperimentListFactory.from_imageset_and_crystal(
imageset, crystal)
dump = ExperimentListDumper(experiments)
filename = 'temp%s.json' % uuid4().hex
dump.as_json(filename)
experiments2 = ExperimentListFactory.from_json_file(filename,
check_format=False)
self.check(experiments, experiments2)
print 'OK'
def tst_from_null_sweep(self):
from dxtbx.datablock import DataBlockFactory
from dxtbx.imageset import NullReader, ImageSweep, SweepFileList
from dxtbx.model import Beam, Detector, Goniometer, Scan
sweep = ImageSweep(
NullReader(SweepFileList("template_%2d.cbf", (0, 10))))
sweep.set_beam(Beam((0, 0, 1)))
sweep.set_detector(Detector())
sweep.set_goniometer(Goniometer((1, 0, 0)))
sweep.set_scan(Scan((1, 10), (0, 0.1)))
# Create the datablock
datablock = DataBlockFactory.from_imageset(sweep)
assert (len(datablock) == 1)
datablock = datablock[0]
sweeps = datablock.extract_sweeps()
assert (len(sweeps) == 1)
assert (sweeps[0].get_beam() == sweep.get_beam())
assert (sweeps[0].get_detector() == sweep.get_detector())
assert (sweeps[0].get_goniometer() == sweep.get_goniometer())
assert (sweeps[0].get_scan() == sweep.get_scan())
print 'OK'
def tst_contains(self):
from dxtbx.model import Beam, Detector, Goniometer, Scan
# Check all the models are found
for e in self.el:
assert(e.beam in self.el)
assert(e.detector in self.el)
assert(e.goniometer in self.el)
assert(e.scan in self.el)
# Create some more models
b = Beam()
d = Detector()
g = Goniometer()
s = Scan()
# Check that models not in are not found
assert(b not in self.el)
assert(d not in self.el)
assert(g not in self.el)
assert(s not in self.el)
# Test passed
print 'OK'
def tst_from_datablock(self):
from dxtbx.imageset import ImageSweep, NullReader, SweepFileList
from dxtbx.model import Beam, Detector, Goniometer, Scan
from dxtbx.datablock import DataBlockFactory
from dxtbx.model.crystal import crystal_model
imageset = ImageSweep(NullReader(SweepFileList("filename%01d.cbf", (0, 2))))
imageset.set_beam(Beam())
imageset.set_detector(Detector())
imageset.set_goniometer(Goniometer())
imageset.set_scan(Scan((1, 2), (0, 1)))
crystal = crystal_model((1, 0, 0), (0, 1, 0), (0, 0, 1), space_group_symbol=0)
datablock = DataBlockFactory.from_imageset(imageset)
experiments = ExperimentListFactory.from_datablock_and_crystal(
datablock, crystal)
assert(len(experiments) == 1)
assert(experiments[0].imageset is not None)
assert(experiments[0].beam is not None)
assert(experiments[0].detector is not None)
assert(experiments[0].goniometer is not None)
assert(experiments[0].scan is not None)
assert(experiments[0].crystal is not None)
print 'OK'
def test_parallax_correction():
# Attenuation length
table = attenuation_coefficient.get_table("Si")
mu = table.mu_at_angstrom(1) / 10.0
t0 = 0.320
# Create the detector
detector = Detector(
Panel(
"", # Type
"", # Name
(10, 0, 0), # Fast axis
(0, 10, 0), # Slow axis
(0, 0, 200), # Origin
(0.172, 0.172), # Pixel size
(512, 512), # Image size
(0, 1000), # Trusted range
0.0, # Thickness
"", # Material
ParallaxCorrectedPxMmStrategy(mu, t0),
)
)
for i in range(10000):
mm = (random.uniform(-1000, 1000), random.uniform(-1000, 1000))
px = detector[0].millimeter_to_pixel(mm)
mm2 = detector[0].pixel_to_millimeter(px)
assert abs(matrix.col(mm) - matrix.col(mm2)) < 1e-3
def create_multipanel_detector(offset, ncols=3, nrows=2):
reference_detector = create_detector(offset)
reference_panel = reference_detector[0]
panel_npix = reference_panel.get_image_size()
panel_npix = int(panel_npix[0] / ncols), int(panel_npix[1] / nrows)
multi_panel_detector = Detector()
for i in range(ncols):
for j in range(nrows):
origin_pix = i * panel_npix[0], j * panel_npix[1]
origin = reference_panel.get_pixel_lab_coord(origin_pix)
new_panel = Panel(
reference_panel.get_type(),
reference_panel.get_name() + str(j + i * nrows),
reference_panel.get_fast_axis(),
reference_panel.get_slow_axis(),
origin,
reference_panel.get_pixel_size(),
panel_npix,
reference_panel.get_trusted_range(),
reference_panel.get_thickness(),
reference_panel.get_material(),
identifier=reference_panel.get_identifier(),
)
multi_panel_detector.add_panel(new_panel)
return multi_panel_detector
def _detector(self, index=None):
if index is None:
index = 0
d = Detector()
root = d.hierarchy()
all_addresses = self.params.detector_address
def recursive_add_node(a, b):
# add a to b
if a.is_panel():
b.add_panel(a)
else:
g = b.add_group(a)
for child in a:
recursive_add_node(child, g)
for address in all_addresses:
self.params.detector_address = [address]
sub_d = None
try:
if "rayonix" in address.lower():
sub_d = FormatXTCRayonix._detector(self)
elif "cspad" in address.lower():
sub_d = FormatXTCCspad._detector(self, index)
elif "jungfrau" in address.lower():
sub_d = FormatXTCJungfrau._detector(self, index)
except Exception:
continue
assert sub_d is not None, address
recursive_add_node(sub_d.hierarchy(), root)
self.params.detector_address = all_addresses
return d
def generated_exp(n=1):
"""Generate an experiment list with two experiments."""
experiments = ExperimentList()
exp_dict = {
"__id__": "crystal",
"real_space_a": [1.0, 0.0, 0.0],
"real_space_b": [0.0, 1.0, 0.0],
"real_space_c": [0.0, 0.0, 2.0],
"space_group_hall_symbol": " C 2y",
}
crystal = Crystal.from_dict(exp_dict)
scan = Scan(image_range=[0, 90], oscillation=[0.0, 1.0])
beam = Beam(s0=(0.0, 0.0, 1.01))
goniometer = Goniometer((1.0, 0.0, 0.0))
detector = Detector()
experiments.append(
Experiment(
beam=beam,
scan=scan,
goniometer=goniometer,
detector=detector,
crystal=crystal,
))
if n > 1:
for _ in range(n - 1):
experiments.append(
Experiment(
beam=beam,
scan=scan,
goniometer=goniometer,
detector=detector,
crystal=crystal,
))
return experiments
def detector():
detector = Detector()
root = detector.hierarchy()
root.set_name("D1")
root.set_type("D")
quad1 = root.add_group()
quad1.set_name("Q1")
quad1.set_type("Q")
panel1 = quad1.add_panel()
panel1.set_name("P1")
panel1.set_type("P")
panel2 = quad1.add_panel()
panel2.set_name("P2")
panel2.set_type("P")
quad2 = root.add_group()
quad2.set_name("Q2")
quad2.set_type("Q")
panel3 = quad2.add_panel()
panel3.set_name("P3")
panel3.set_type("P")
panel4 = quad2.add_panel()
panel4.set_name("P4")
panel4.set_type("P")
return detector
def test_detector():
'''Test pickling the detector object.'''
p = Panel()
p.set_local_frame((1, 0, 0), (0, 1, 0), (0, 0, 1))
obj1 = Detector(p)
obj2 = pickle_then_unpickle(obj1)
assert obj1 == obj2
def test_experimentlist_factory_from_datablock():
from dxtbx.model import Beam, Detector, Goniometer, Scan
from dxtbx.datablock import DataBlockFactory
from dxtbx.model import Crystal
from dxtbx.format.Format import Format
filenames = ["filename_%01d.cbf" % (i+1) for i in range(0, 2)]
imageset = Format.get_imageset(
filenames,
beam = Beam(),
detector = Detector(),
goniometer = Goniometer(),
scan = Scan((1,2), (0,1)),
as_sweep=True)
crystal = Crystal((1, 0, 0), (0, 1, 0), (0, 0, 1), space_group_symbol="P1")
datablock = DataBlockFactory.from_imageset(imageset)
experiments = ExperimentListFactory.from_datablock_and_crystal(
datablock, crystal)
assert len(experiments) == 1
assert experiments[0].imageset is not None
assert experiments[0].beam is not None
assert experiments[0].detector is not None
assert experiments[0].goniometer is not None
assert experiments[0].scan is not None
assert experiments[0].crystal is not None
def experiment_list():
from dxtbx.model import Beam, Detector, Goniometer, Scan
# Initialise a list of experiments
experiments = ExperimentList()
# Create a few beams
b1 = Beam()
b2 = Beam()
b3 = Beam()
# Create a few detectors
d1 = Detector()
d2 = Detector()
d3 = Detector()
# Create a few goniometers
g1 = Goniometer()
g2 = Goniometer()
g3 = Goniometer()
# Create a few scans
s1 = Scan()
s2 = Scan()
s3 = Scan()
# Create a list of models
b = [b1, b2, b3, b2, b1]
d = [d1, d2, d3, d2, d1]
g = [g1, g2, g3, g2, g1]
s = [s1, s2, s3, s2, s1]
ident = ["sausage", "eggs", "bacon", "toast", "beans"]
# Populate with various experiments
for i in range(5):
experiments.append(Experiment(
beam=b[i],
detector=d[i],
goniometer=g[i],
scan=s[i],
identifier=ident[i]))
# Return the list of experiments
return experiments
def get_multi_panel_eiger(detdist_mm=200,
pixsize_mm=0.075,
as_single_panel=False):
"""
:param detdist_mm: sample to detector in mm
:param pixsize_mm: pix in mm
:param as_single_panel: whether to return as just a large single panel camera
:return: dxtbx detector
"""
# load a file specifying the gap positions
# this is a 2D array
# usually -1 is a gap, so you can create this array by doing
# is_a_gap = np.array(eiger_image)==-1 (pseudo)
is_a_gap = h5py.File("eiger_gaps.h5", "r")["is_a_gap"][()]
# to view:
#import pylab as plt
#plt.imshow( is_a_gap)
#plt.show()
# its not perfect, some small regions are also flagged, we shall filter them though
ydim, xdim = is_a_gap.shape
center_x = xdim / 2. * pixsize_mm
center_y = ydim / 2. * pixsize_mm
master_panel_dict = {
'type': 'SENSOR_PAD',
'fast_axis': (1.0, 0.0, 0.0),
'slow_axis': (0.0, -1.0, 0.0),
'origin': (-center_x, center_y, -detdist_mm),
'raw_image_offset': (0, 0),
'image_size': (xdim, ydim),
'pixel_size':
(pixsize_mm, pixsize_mm), # NOTE this will depend on your model
'trusted_range': (-1.0, 65535.0),
'thickness': 0.45,
'material': 'Si',
'mu': 3.969545947994824,
'identifier': '',
'mask': [],
'gain': 1.0,
'pedestal': 0.0,
'px_mm_strategy': {
'type': 'SimplePxMmStrategy'
}
}
master_panel = Panel.from_dict(master_panel_dict)
master_det = Detector()
master_det.add_panel(master_panel)
if as_single_panel:
return master_det
else:
return panelize_eiger(master_det, is_a_gap)
def test_experiment_equality():
# Create a load of models
b1 = Beam()
d1 = Detector()
g1 = Goniometer()
s1 = Scan()
c1 = Crystal((1, 0, 0), (0, 1, 0), (0, 0, 1), space_group_symbol="P1")
# Create a load of models that look the same but aren't
b2 = Beam()
d2 = Detector()
g2 = Goniometer()
s2 = Scan()
c2 = Crystal((1, 0, 0), (0, 1, 0), (0, 0, 1), space_group_symbol="P1")
# Create an experiment
e1 = Experiment(beam=b1,
detector=d1,
goniometer=g1,
scan=s1,
crystal=c1,
imageset=None)
# Create an experiment
e2 = Experiment(beam=b1,
detector=d1,
goniometer=g1,
scan=s1,
crystal=c1,
imageset=None)
# Create an experiment
e3 = Experiment(beam=b2,
detector=d2,
goniometer=g2,
scan=s2,
crystal=c2,
imageset=None)
# Check e1 equals e2 but not e3
assert e1 == e2
assert e1 != e3
assert e2 != e3
def tst_contains(self):
from dxtbx.model import Beam, Detector, Goniometer, Scan
from dxtbx.model import Crystal
# Create a load of models
b1 = Beam()
d1 = Detector()
g1 = Goniometer()
s1 = Scan()
c1 = Crystal((1, 0, 0), (0, 1, 0), (0, 0, 1), space_group_symbol="P1")
# Create an experiment
e = Experiment(beam=b1,
detector=d1,
goniometer=g1,
scan=s1,
crystal=c1,
imageset=None)
# Check experiment contains model
assert (b1 in e)
assert (d1 in e)
assert (g1 in e)
assert (s1 in e)
assert (c1 in e)
# Create a load of models that look the same but aren't
b2 = Beam()
d2 = Detector()
g2 = Goniometer()
s2 = Scan()
c2 = Crystal((1, 0, 0), (0, 1, 0), (0, 0, 1), space_group_symbol="P1")
# Check experiment doesn't contain model
assert (b2 not in e)
assert (d2 not in e)
assert (g2 not in e)
assert (s2 not in e)
assert (c2 not in e)
# Test passed
print 'OK'
def create_kapton_face(ori, fast, slow, image_size, pixel_size, name):
"""Create a face of the kapton as a dxtbx detector object"""
from dxtbx.model import Detector
d = Detector()
p = d.add_panel()
p.set_local_frame(fast.elems, slow.elems, ori.elems)
p.set_pixel_size((pixel_size, pixel_size))
p.set_image_size(image_size)
p.set_trusted_range((-1, 2e6))
p.set_name("KAPTON_%s" % name)
return d
def test_experimentlist_imagesequence_decode(mocker):
# These models are shared between experiments
beam = Beam(s0=(0, 0, -1))
detector = Detector()
gonio = Goniometer()
# Construct the experiment list
experiments = ExperimentList()
for i in range(3):
experiments.append(
Experiment(
beam=beam,
detector=detector,
scan=ScanFactory.make_scan(
image_range=(i + 1, i + 1),
exposure_times=[1],
oscillation=(0, 0),
epochs=[0],
),
goniometer=gonio,
))
# Convert experiment list to dict and manually insert a shared imageset
d = experiments.to_dict()
d["imageset"].append({
"__id__": "ImageSequence",
"template": "Puck3_10_1_####.cbf.gz"
})
for e in d["experiment"]:
e["imageset"] = 0
# Monkeypatch this function as we don't actually have an imageset
make_sequence = mocker.patch.object(ExperimentListDict, "_make_sequence")
# Ensure that if make_sequence is called more than once it returns a different
# value each time
make_sequence.side_effect = lambda *args, **kwargs: mocker.MagicMock()
# Decode the dict to get a new experiment list
experiments2 = ExperimentListDict(d).decode()
# This function should only be called once per imageset
make_sequence.assert_called_once()
# Verify that this experiment is as we expect
assert len(experiments2) == 3
assert len(experiments2.imagesets()) == 1
assert len(experiments2.goniometers()) == 1
assert len(experiments2.detectors()) == 1
assert len(experiments2.beams()) == 1
assert len(experiments2.scans()) == 3
for expt in experiments2:
assert expt.imageset is experiments2.imagesets()[0]
def test_hierarchical_detector():
'''Test pickling the detector object.'''
p = Panel()
p.set_local_frame((1, 0, 0), (0, 1, 0), (0, 0, 1))
obj1 = Detector()
root = obj1.hierarchy()
root.add_panel(p)
root.add_group()
obj2 = pickle_then_unpickle(obj1)
assert obj2.hierarchy()[0] == obj2[0]
assert obj2.hierarchy()[0] in obj2
assert obj2.hierarchy()[1].is_group()
assert obj1 == obj2
