def experiment():
beam = BeamFactory.make_beam(wavelength=0.97625, sample_to_source=(0, 0, 1))
detector = DetectorFactory.simple(
sensor="PAD",
distance=265.27,
beam_centre=(210.7602, 205.27684),
fast_direction="+x",
slow_direction="-y",
pixel_size=(0.172, 0.172),
image_size=(2463, 2527),
trusted_range=(-1, 1e8),
)
goniometer = GoniometerFactory.single_axis()
scan = ScanFactory.make_scan(
image_range=(1, 20),
exposure_times=0.067,
oscillation=(82, 0.15),
epochs=[0] * 20,
)
isetdata = ImageSetData(
reader=Format.Reader(None, ["path"] * len(scan)), masker=None
)
iset = ImageSequence(
isetdata, beam=beam, detector=detector, goniometer=goniometer, scan=scan
)
return Experiment(
imageset=iset, beam=beam, detector=detector, goniometer=goniometer, scan=scan
)
def expt_detector_maker(self):
"""Construct the detector object for the experiments file. This function generates a monolithic flattening of the
CSPAD detector if not supplied with an image file."""
self.distance = self.data['distance']
self.xbeam, self.ybeam = self.data['xbeam'], self.data['ybeam']
if len(self.img_location) > 0 and not dxtbx.load(self.img_location[0])._image_file.endswith("_00000.pickle"):
self.detector = dxtbx.load(self.img_location[0])._detector()
else:
self.detector = DetectorFactory.simple('SENSOR_UNKNOWN',self.distance,(self.xbeam, self.ybeam),'+x','-y',
(self.pixel_size, self.pixel_size),(1765,1765))
def __init__(self, filename, experiment, HKL, i_sigi, measurements, params):
from libtbx import adopt_init_args
adopt_init_args(self, locals())
self.stash_type = None
self.stash_res_filter = None
from dxtbx.model import DetectorFactory
self.dummy_detector = DetectorFactory.simple(
sensor = DetectorFactory.sensor("PAD"),
distance = 100,
beam_centre = [1000, 1000],
fast_direction = "+x",
slow_direction = "+y",
pixel_size = [0.2,0.2],
image_size = [2000,2000],
)
def prepare_dxtbx_models(self, setting_specific_ai, sg, isoform=None):
from dxtbx.model import BeamFactory
beam = BeamFactory.simple(wavelength=self.inputai.wavelength)
from dxtbx.model import DetectorFactory
detector = DetectorFactory.simple(
sensor=DetectorFactory.sensor("PAD"),
distance=setting_specific_ai.distance(),
beam_centre=[
setting_specific_ai.xbeam(),
setting_specific_ai.ybeam()
],
fast_direction="+x",
slow_direction="+y",
pixel_size=[self.pixel_size, self.pixel_size],
image_size=[self.inputpd['size1'], self.inputpd['size1']],
)
direct = matrix.sqr(
setting_specific_ai.getOrientation().direct_matrix())
from dxtbx.model import Crystal
crystal = Crystal(
real_space_a=matrix.row(direct[0:3]),
real_space_b=matrix.row(direct[3:6]),
real_space_c=matrix.row(direct[6:9]),
space_group_symbol=sg,
)
crystal.set_mosaicity(setting_specific_ai.getMosaicity())
if isoform is not None:
newB = matrix.sqr(isoform.fractionalization_matrix()).transpose()
crystal.set_B(newB)
from dxtbx.model import Experiment, ExperimentList
experiments = ExperimentList()
experiments.append(
Experiment(beam=beam, detector=detector, crystal=crystal))
print beam
print detector
print crystal
return experiments
def __init__(self, params):
import cPickle as pickle
from dxtbx.model import BeamFactory
from dxtbx.model import DetectorFactory
from dxtbx.model.crystal import crystal_model
from cctbx.crystal_orientation import crystal_orientation, basis_type
from dxtbx.model import Experiment, ExperimentList
from scitbx import matrix
self.experiments = ExperimentList()
self.unique_file_names = []
self.params = params
data = pickle.load(
open(self.params.output.prefix + "_frame.pickle", "rb"))
frames_text = data.split("\n")
for item in frames_text:
tokens = item.split(' ')
wavelength = float(tokens[order_dict["wavelength"]])
beam = BeamFactory.simple(wavelength=wavelength)
detector = DetectorFactory.simple(
sensor=DetectorFactory.sensor(
"PAD"), # XXX shouldn't hard code for XFEL
distance=float(tokens[order_dict["distance"]]),
beam_centre=[
float(tokens[order_dict["beam_x"]]),
float(tokens[order_dict["beam_y"]])
],
fast_direction="+x",
slow_direction="+y",
pixel_size=[self.params.pixel_size, self.params.pixel_size],
image_size=[1795,
1795], # XXX obviously need to figure this out
)
reciprocal_matrix = matrix.sqr([
float(tokens[order_dict[k]]) for k in [
'res_ori_1', 'res_ori_2', 'res_ori_3', 'res_ori_4',
'res_ori_5', 'res_ori_6', 'res_ori_7', 'res_ori_8',
'res_ori_9'
]
])
ORI = crystal_orientation(reciprocal_matrix, basis_type.reciprocal)
direct = matrix.sqr(ORI.direct_matrix())
crystal = crystal_model(
real_space_a=matrix.row(direct[0:3]),
real_space_b=matrix.row(direct[3:6]),
real_space_c=matrix.row(direct[6:9]),
space_group_symbol=self.params.target_space_group.type().
lookup_symbol(),
mosaicity=float(tokens[order_dict["half_mosaicity_deg"]]),
)
crystal.domain_size = float(tokens[order_dict["domain_size_ang"]])
#if isoform is not None:
# newB = matrix.sqr(isoform.fractionalization_matrix()).transpose()
# crystal.set_B(newB)
self.experiments.append(
Experiment(
beam=beam,
detector=None, #dummy for now
crystal=crystal))
self.unique_file_names.append(
tokens[order_dict["unique_file_name"]])
self.show_summary()
def run(args):
distance = 125
centre = (97.075, 97.075)
pix_size = (0.11, 0.11)
image_size = (1765, 1765)
wavelength = args.w or 1.0
# 1. Make a dummy detector
detector = DetectorFactory.simple(
'SENSOR_UNKNOWN', # Sensor
distance,
centre,
'+x',
'-y', # fast/slow direction
pix_size,
image_size)
# 2. Get the miller array!
mill_array = process_mtz(args.mtzfile[0]).as_intensity_array()
ortho = sqr(mill_array.crystal_symmetry().unit_cell().reciprocal() \
.orthogonalization_matrix())
# 3.Create some image_pickle dictionairies that contain 'full' intensities,
# but are otherwise complete.
im = 0
while im < args.n:
im += 1
A = sqr(flex.random_double_r3_rotation_matrix()) * ortho
orientation = crystal_orientation(A, basis_type.reciprocal)
pix_coords, miller_set = get_pix_coords(wavelength, A, mill_array,
detector)
if len(miller_set) > 10: # at least 10 reflections
miller_set = cctbx.miller.set(mill_array.crystal_symmetry(),
miller_set,
anomalous_flag=False)
obs = mill_array.common_set(miller_set)
temp_dict = {
'observations': [obs],
'mapped_predictions': [pix_coords],
'pointgroup': None,
'current_orientation': [orientation],
'xbeam': centre[0],
'ybeam': centre[1],
'wavelength': wavelength
}
old_node = ImageNode(dicti=temp_dict, scale=False)
# Remove all reflection that are not at least p partial
partial_sel = (old_node.partialities > p_threshold)
temp_dict['full_observations'] = [obs.select(partial_sel)]
temp_dict['observations'] = [
obs.select(partial_sel) *
old_node.partialities.select(partial_sel)
]
temp_dict['mapped_predictions'] = \
[temp_dict['mapped_predictions'][0].select(partial_sel)]
if logging.Logger.root.level <= logging.DEBUG: # debug!
before = temp_dict['full_observations'][0]
after = temp_dict['observations'][0] / old_node.partialities
assert sum(abs(before.data() - after.data())) < eps
if args.r:
partials = list(temp_dict['observations'][0].data())
jiggled_partials = flex.double(
[random.gauss(obs, args.r * obs) for obs in partials])
temp_dict['observations'][0] = temp_dict['observations'][0] \
.customized_copy(data=jiggled_partials)
pkl_name = "simulated_data_{0:04d}.pickle".format(im)
with (open(pkl_name, 'wb')) as pkl:
pickle.dump(temp_dict, pkl)
''' Only works with no noise: