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 = detector.detector_factory.simple('SENSOR_UNKNOWN',self.distance,(self.xbeam, self.ybeam),'+x','-y', (self.pixel_size, self.pixel_size),(1765,1765))
def main(filename, threshold, images): '''Read and sum all images, define those pixels which are POSITIVE but which come out below threshold as mask, write this mask in a format useful for DIALS.''' from dxtbx import load from dials.array_family import flex from cPickle import dump image_data = None for image in images: i = load(image) d = i.get_raw_data() if image_data is None: image_data = i.get_raw_data() else: image_data += i.get_raw_data() mask_inverse = (image_data >= 0) & (image_data < threshold) mask = ~ mask_inverse dump((mask,), open(filename, 'w')) print 'Mask written to %s' % filename return
def dumpImages(imagePaths): for path in imagePaths: print "Dumping image:", path rootname = splitext(basename(path))[0] imageName = rootname + '.img' if (os.path.exists(imageName)): print "Image", imageName, "already dumped - skipping." continue ext = splitext(basename(path))[1] if not ext == ".pickle": print "Warning: not a pickle file. Converting to pickle first." command = "cxi.image2pickle " + path os.system(command) db = dxtbx.load(rootname + ".pickle").get_detectorbase() data = db.get_raw_data() data_array = array.array('i') for i in range(0, len(data)): data_array.append(data[i]) string = data_array.tostring() newFile = open(imageName, 'wb') newFile.write(string) newFile.close()
def to_imageset(input_filename, extra_filename=None): '''Get an image set from the xds input filename plus an extra filename Params: input_filename The XDS.INP file extra_filename A (G)XPARM.XDS, INTGRATE.HKL or XDS_ASCII.HKL file Returns: The imageset ''' from iotbx.xds import xds_inp from dxtbx.imageset import ImageSetFactory import dxtbx # Read the input filename handle = xds_inp.reader() handle.read_file(input_filename) # Get the template template = handle.name_template_of_data_frames[0].replace('?', '#') image_range = handle.data_range detector_name = handle.detector if extra_filename is not None: # we can get all the extra dxtbx models from extra_filename check_format = False else: # we need the image files present to get the dxtbx models check_format = True # Create the imageset imageset = ImageSetFactory.from_template( template, image_range=image_range, check_format=False)[0] # If an extra filename has been specified, try to load models if extra_filename: models = dxtbx.load(extra_filename) detector = models.get_detector() if detector_name.strip() == 'PILATUS': from dxtbx.model import ParallaxCorrectedPxMmStrategy from cctbx.eltbx import attenuation_coefficient table = attenuation_coefficient.get_table("Si") wavelength = models.get_beam().get_wavelength() mu = table.mu_at_angstrom(wavelength) / 10.0 t0 = handle.sensor_thickness for panel in detector: panel.set_px_mm_strategy(ParallaxCorrectedPxMmStrategy(mu, t0)) panel.set_trusted_range( (handle.minimum_valid_pixel_value, handle.overload)) imageset.set_beam(models.get_beam()) imageset.set_detector(detector) imageset.set_goniometer(models.get_goniometer()) # take the image range from XDS.INP scan = models.get_scan() scan.set_image_range(image_range) imageset.set_scan(scan) # Return the imageset return imageset
def read_image(image_name): import dxtbx from scitbx.array_family import flex data = dxtbx.load(image_name).get_raw_data() data.reshape(flex.grid(2527, 2463)) subset = data[1055:1473,984:1478] return subset
def run(self): params, options = self.parser.parse_args(show_diff_phil=True) assert params.input.single_img is not None filebase = os.path.splitext(params.input.single_img)[0] for item in dir(params.output): value = getattr(params.output, item) try: if "%s" in value: setattr(params.output, item, value % filebase) except Exception: pass self.params = params self.options = options # load the image img = dxtbx.load(params.input.single_img) imgset = MemImageSet([img]) datablock = DataBlockFactory.from_imageset(imgset)[0] # Cannot export MemImageSets # if self.params.output.datablock_filename: # from dxtbx.datablock import DataBlockDumper # dump = DataBlockDumper(datablock) # dump.as_json(self.params.output.datablock_filename) observed = self.find_spots(datablock) experiments, indexed = self.index(datablock, observed) experiments = self.refine(experiments, indexed) integrated = self.integrate(experiments, indexed)
def main(): frame = sys.argv[1] powers = [2 ** n for n in range(20)] for j in range(powers[-1] + 1): i = dxtbx.load(frame) mem = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss if j in powers: print j, mem
def main(xparm_file, spot_file): import dxtbx from dxtbx.serialize.xds import to_crystal models = dxtbx.load(xparm_file) crystal_model = to_crystal(xparm_file) from dxtbx.model.experiment.experiment_list import Experiment, ExperimentList experiment = Experiment(beam=models.get_beam(), detector=models.get_detector(), goniometer=models.get_goniometer(), scan=models.get_scan(), crystal=crystal_model) detector = experiment.detector beam = experiment.beam goniometer = experiment.goniometer scan = experiment.scan from iotbx.xds import spot_xds spot_xds_handle = spot_xds.reader() spot_xds_handle.read_file(spot_file) from cctbx.array_family import flex centroids_px = flex.vec3_double(spot_xds_handle.centroid) miller_indices = flex.miller_index(spot_xds_handle.miller_index) # only those reflections that were actually indexed centroids_px = centroids_px.select(miller_indices != (0,0,0)) miller_indices = miller_indices.select(miller_indices != (0,0,0)) ub = crystal_model.get_A() d_spacings = [1.0 / (ub * mi).length() for mi in miller_indices] print max(d_spacings) # Convert Pixel coordinate into mm/rad x, y, z = centroids_px.parts() x_mm, y_mm = detector[0].pixel_to_millimeter(flex.vec2_double(x, y)).parts() z_rad = scan.get_angle_from_array_index(z, deg=False) centroids_mm = flex.vec3_double(x_mm, y_mm, z_rad) # then convert detector position to reciprocal space position # based on code in dials/algorithms/indexing/indexer2.py s1 = detector[0].get_lab_coord(flex.vec2_double(x_mm, y_mm)) s1 = s1/s1.norms() * (1/beam.get_wavelength()) S = s1 - beam.get_s0() reciprocal_space_points = S.rotate_around_origin( goniometer.get_rotation_axis(), -z_rad) d_spacings = 1/reciprocal_space_points.norms() dmax = flex.max(d_spacings) print dmax
def load_pars_from_file(self, path=None) : """ Use the dxtbx object model to build a GeometryObject hierarchy @param path Path to the CSPAD CBF file """ if path is not None : self.path = path if self.pbits & 32 : print 'Load file: %s' % self.path img = dxtbx.load(self.path) cbf = img._cbf_handle cbf.find_category("diffrn_source") cbf.find_column("type") self.dict_of_comments = { "TITLE" : "Geometry parameters of CSPAD", "DATE_TIME" : evt_timestamp(), "AUTHOR" : getpass.getuser(), "EXPERIMENT": cbf.get_value(), "DETECTOR" : "CSPAD", "CALIB_TYPE": "geometry", "COMMENT:01": "Table contains the list of geometry parameters for alignment of 2x1 sensors, quads, CSPAD, etc", "COMMENT:02": " translation and rotation pars of the object are defined w.r.t. parent object Cartesian frame", "PARAM:01" : "PARENT - name and version of the parent object", "PARAM:02" : "PARENT_IND - index of the parent object", "PARAM:03" : "OBJECT - name and version of the object", "PARAM:04" : "OBJECT_IND - index of the new object", "PARAM:05" : "X0 - x-coordinate [um] of the object origin in the parent frame", "PARAM:06" : "Y0 - y-coordinate [um] of the object origin in the parent frame", "PARAM:07" : "Z0 - z-coordinate [um] of the object origin in the parent frame", "PARAM:08" : "ROT_Z - object design rotation angle [deg] around Z axis of the parent frame", "PARAM:09" : "ROT_Y - object design rotation angle [deg] around Y axis of the parent frame", "PARAM:10" : "ROT_X - object design rotation angle [deg] around X axis of the parent frame", "PARAM:11" : "TILT_Z - object tilt angle [deg] around Z axis of the parent frame", "PARAM:12" : "TILT_Y - object tilt angle [deg] around Y axis of the parent frame", "PARAM:13" : "TILT_X - object tilt angle [deg] around X axis of the parent frame" } self.list_of_geos = [] detector = img.get_detector() hierarchy = detector.hierarchy() for q, quad in enumerate(hierarchy): for s, sensor in enumerate(quad): self.list_of_geos.append(self._load_geo(q,"QUAD:V1",s,"SENS2X1:V1",sensor)) for q, quad in enumerate(hierarchy): self.list_of_geos.append(self._load_geo(0,"CSPAD:V1",q,"QUAD:V1",quad)) # Add placeholder RAIL and IP vectors, including the XY component of the hierarchy's d0 vector go = self._load_geo(0,'RAIL',0,'CSPAD:V1',hierarchy) go.move_geo(0,0,-go.z0+1000000) # Placeholder self.list_of_geos.append(go) self.list_of_geos.append(self._null_geo(0,"IP",0,"RAIL")) self._set_relations()
def overload(image_file): from dxtbx import load i = load(image_file) data = i.get_raw_data() if not isinstance(data, tuple): data = (data,) detector = i.get_detector() for pid, (d, p) in enumerate(zip(data, detector)): if max(d) > p.get_trusted_range()[1]: return True return False
def generate_dials_corrections(image_filename, sensor_thickness_mm, energy_ev = None, method=compute_absolute_offset): '''Generate equivalent correction tables equivalent to those from XDS, but using the equations above.''' from dxtbx import load from scitbx import matrix from scitbx.array_family import flex import math import random import os image = load(image_filename) beam = matrix.col(image.get_beam().get_s0()).normalize() if energy_ev: energy_kev = energy_ev * 0.001 else: wavelength = image.get_beam().get_wavelength() energy_kev = 12.3985 / wavelength mu = derive_absorption_coefficient_Si(energy_kev) d = image.get_detector()[0] fast = matrix.col(d.get_fast_axis()) slow = matrix.col(d.get_slow_axis()) normal = matrix.col(d.get_normal()) origin = matrix.col(d.get_origin()) distance = origin.dot(normal) offset = distance * normal - origin offset_fast = offset.dot(fast) offset_slow = offset.dot(slow) pixel_size = d.get_pixel_size() # this is in order slow, fast i.e. C order image_size = image.get_raw_data().focus() F = fast * pixel_size[0] S = slow * pixel_size[1] fast_parallax = flex.double(flex.grid(image_size)) slow_parallax = flex.double(flex.grid(image_size)) for i in range(image_size[0]): for j in range(image_size[1]): p = (origin + i * S + j * F).normalize() theta = p.angle(normal) dot_f = - p.dot(fast) dot_s = - p.dot(slow) offset = method(sensor_thickness_mm, theta, mu) fast_parallax[i, j] = dot_f * offset slow_parallax[i, j] = dot_s * offset return fast_parallax, slow_parallax
def load_image(self): """ Reads raw image file and extracts data for conversion into pickle format. Also estimates gain if turned on.""" # Load raw image or image pickle try: with misc.Capturing() as junk_output: loaded_img = dxtbx.load(self.raw_img) except IOError, e: loaded_img = None pass
def saturation(image_file): from dxtbx import load i = load(image_file) d = i.get_detector() raw_data = i.get_raw_data() if not isinstance(raw_data, tuple): raw_data = (raw_data,) if i.get_scan() is None: return 0, \ max([max(raw_data[pid]) / d[pid].get_trusted_range()[1] for pid in xrange(len(d))]) else: return i.get_scan().get_image_range()[0], \ max([max(raw_data[pid]) / d[pid].get_trusted_range()[1] for pid in xrange(len(d))])
def set_general_variables(self): self.frame = load(self.raw) self.detector = self.frame.get_detector() self.beam = self.frame.get_beam() self.s0 = self.beam.get_s0() self.gonio = self.frame.get_goniometer() self.scan = self.frame.get_scan() self.lab_coordinates = flex.vec3_double() for panel in self.detector: self.beam_center_mm_x, self.beam_center_mm_y = col(panel.get_beam_centre(self.s0)) pixels = flex.vec2_double(panel.get_image_size()) mms = panel.pixel_to_millimeter(pixels) self.lab_coordinates.extend(panel.get_lab_coord(mms)) self.Isizex, self.Isizey = panel.get_image_size() self.beam_center_x, self.beam_center_y = col(panel.get_beam_centre_px(self.s0)) self.detector_distance = panel.get_distance() thrshim_min, thrshim_max = panel.get_trusted_range() self.pixel_size = panel.get_pixel_size()[0] self.raw_data = self.frame.get_raw_data() if thrshim_min < 0 : self.thrshim_min = int(0) else: self.thrshim_min = thrshim_min if thrshim_max > 32767: self.thrshim_max = int(32767) else: self.thrshim_max = int(thrshim_max) self.polarization_fraction = self.beam.get_polarization_fraction() self.polarization_offset = 0.0 self.cassette_x = 0.0 self.cassette_y = 0.0 self.windim_xmax = int(self.Isizex)-100 # right border for processed image (pixels) self.windim_xmin = 100 # left border for processed image (pixels) self.windim_ymax = int(self.Isizey)-100 # top border for processed image (pixels) self.windim_ymin = 100 # bottom border for processed image (pixels) ### beamstop borders self.punchim_xmax = int(self.Isizex) # right border of beam stop shadow (pixels) self.punchim_xmin = int(self.beam_center_x)-80 # left border of beam stop shadow (pixels) self.punchim_ymax = int(self.beam_center_y)+100 # top border of beam stop shadow (pixels) self.punchim_ymin = int(self.beam_center_y)-40 # bottom border of beam stop shadow (pixels) self.mode_filter_footprint = int(20) return
def model(dials_regression): filename = os.path.join(dials_regression, "image_examples", "XDS", "XPARM.XDS") models = dxtbx.load(filename) detector = models.get_detector() assert len(detector) == 1 detector = detector[0] t0 = 0.320 table = attenuation_coefficient.get_table("Si") mu = table.mu_at_angstrom(models.get_beam().get_wavelength()) / 10.0 pixel_size = detector.get_pixel_size() return {"mu": mu, "t0": t0, "detector": detector, "pixel_size": pixel_size}
def run(argv=None): if argv is None: argv = sys.argv[1:] command_line = libtbx.option_parser.option_parser( usage="%s files" % libtbx.env.dispatcher_name).process(args=argv) paths = command_line.args if len(paths) <= 0: raise Usage("No files specified") for path in paths: # Load the metrology dictionary, containting basis shifts for each item in the hierarchy metro = cbf_file_to_basis_dict(path) # Remove from the hiearchy all but the central sensors (sensor 1 of each quadrant). # Need to remove the sesnor basis shifts and the corresponding asic shifts for quad in range(4): for sensor in [0,2,3,4,5,6,7]: metro.pop((0,quad,sensor)) for asic in range(2): metro.pop((0,quad,sensor,asic)) # Renumber the sensors to 0 instead of 1 for key in metro: if len(key) == 3: detector, quad, sensor = key metro[(detector,quad,0)] = metro.pop(key) elif len(key) == 4: detector, quad, sensor, asic = key metro[(detector,quad,0,asic)] = metro.pop(key) # Build the tiles dictionary for only sensor 1 of each quadrant. Rename that sensor to zero. img = dxtbx.load(path) tiles = {} for quad in range(4): src_sensor = 1 dest_sensor = 0 for asic in range(2): tiles[(0,quad,dest_sensor,asic)] = img.get_raw_data()[(quad*16)+(src_sensor*2)+asic] # FIXME get the panel ID from dxtbx destpath = os.path.splitext(path)[0] + "_pinwheel.cbf" hierarchy = img.get_detector().hierarchy() beam = img.get_beam() # write the result. Have to call abs on the root distance because of a bug with the hierarchy matrix. write_cspad_cbf(tiles, metro, 'cbf', None, destpath, beam.get_wavelength(), hierarchy.get_distance())
def test_custom_scheme_handler(registry): class SchemeHandler(Format): schemes = ["scheme"] @classmethod def understand(cls, endpoint): assert endpoint.startswith("scheme://") return True assert not Registry.get_format_class_for_file("scheme://something") registry.register(SchemeHandler) assert Registry.get_format_class_for_file( "scheme://something") is SchemeHandler # Check dxtbx.load instance = dxtbx.load("scheme://something") assert isinstance(instance, SchemeHandler)
def read_image(in_image): from scitbx.array_family import flex import binascii import os from dxtbx import load assert(os.path.exists(in_image)) start_tag = binascii.unhexlify('0c1a04d5') data = gz_open(in_image, 'rb').read() data_offset = data.find(start_tag) cbf_header = data[:data_offset] pixel_values = load(in_image).get_raw_data() return pixel_values, cbf_header
def read_image(in_image): from scitbx.array_family import flex import binascii import os from dxtbx import load assert (os.path.exists(in_image)) start_tag = binascii.unhexlify('0c1a04d5') data = gz_open(in_image, 'rb').read() data_offset = data.find(start_tag) cbf_header = data[:data_offset] pixel_values = load(in_image).get_raw_data() return pixel_values, cbf_header
def read_image_to_flex_array(in_image): '''Looks like this works *only* for CBF images from a Pilatus detector; oh well - should still do something useful.''' from scitbx.array_family import flex import binascii import os from dxtbx import load assert (os.path.exists(in_image)) start_tag = binascii.unhexlify('0c1a04d5') data = open(in_image, 'rb').read() data_offset = data.find(start_tag) cbf_header = data[:data_offset] pixel_values = load(in_image).get_raw_data() return pixel_values, cbf_header
def read_image_to_flex_array(in_image): '''Looks like this works *only* for CBF images from a Pilatus detector; oh well - should still do something useful.''' from scitbx.array_family import flex import binascii import os from dxtbx import load assert(os.path.exists(in_image)) start_tag = binascii.unhexlify('0c1a04d5') data = open(in_image, 'rb').read() data_offset = data.find(start_tag) cbf_header = data[:data_offset] pixel_values = load(in_image).get_raw_data() return pixel_values, cbf_header
def test_cspad_cbf_in_memory(dials_regression, run_in_tmpdir, composite_output): # Check the data files for this test exist image_path = os.path.join( dials_regression, "image_examples", "LCLS_cspad_nexus", "idx-20130301060858801.cbf", ) assert os.path.isfile(image_path) with open("process_lcls.phil", "w") as f: f.write(cspad_cbf_in_memory_phil) params = phil_scope.fetch(parse(file_name="process_lcls.phil")).extract() params.output.experiments_filename = None params.output.composite_output = composite_output if composite_output: processor = Processor(params, composite_tag="memtest") else: processor = Processor(params) mem_img = dxtbx.load(image_path) raw_data = mem_img.get_raw_data( ) # cache the raw data to prevent swig errors mem_img = FormatCBFCspadInMemory(mem_img._cbf_handle) mem_img._raw_data = raw_data mem_img._cbf_handle = None # drop the file handle to prevent swig errors imgset = ImageSet(ImageSetData(MemReader([mem_img]), None)) imgset.set_beam(mem_img.get_beam()) imgset.set_detector(mem_img.get_detector()) experiments = ExperimentListFactory.from_imageset_and_crystal(imgset, None) processor.process_experiments("20130301060858801", experiments) # index/integrate the image if composite_output: processor.finalize() result = "idx-memtest_integrated.refl" else: result = "idx-20130301060858801_integrated.refl" n_refls = list(range( 140, 152)) # large ranges to handle platform-specific differences table = flex.reflection_table.from_file(result) assert len(table) in n_refls, len(table) assert "id" in table assert (table["id"] == 0).count(False) == 0
def calculate_parameters(self, experiments=None): ''' Image modification for current cctbx.xfel ''' if not experiments: # If data are given, apply modifications as specified below error = 'IOTA IMPORT ERROR: Experiment list not found!' return None, error else: error = [] # Calculate auto-threshold # TODO: Revisit this; I REALLY don't like it. if self.auto_threshold: beamX = self.img_object.final['beamX'] beamY = self.img_object.final['beamY'] px_size = self.img_object.final['pixel'] try: img = dxtbx.load(self.img_object.img_path) raw_data = img.get_raw_data() beam_x_px = int(beamX / px_size) beam_y_px = int(beamY / px_size) data_array = raw_data.as_numpy_array().astype(float) self.center_int = np.nanmax(data_array[beam_y_px - 20:beam_y_px + 20, beam_x_px - 20:beam_x_px + 20]) except Exception as e: error.append('IOTA IMPORT ERROR: Auto-threshold failed! {}'.format(e)) # Estimate gain (or set gain to 1.00 if cannot calculate) if self.estimate_gain: with util.Capturing() as junk_output: try: assert self.img_object.experiments # Must have experiments here imageset = self.img_object.experiments.extract_imagesets()[0] self.img_object.gain = estimate_gain(imageset) except Exception as e: error.append('IOTA IMPORT ERROR: Estimate gain failed! '.format(e)) # Collect error messages for logging if error: error_message = '\n'.join(error) else: error_message = None return experiments, error_message
def __init__(self): import os dials_regression = libtbx.env.dist_path('dials_regression') filename = os.path.join(dials_regression, 'image_examples', 'XDS', 'XPARM.XDS') import dxtbx models = dxtbx.load(filename) self.detector = models.get_detector() self.beam = models.get_beam() assert (len(self.detector) == 1) self.t0 = 0.320 from cctbx.eltbx import attenuation_coefficient table = attenuation_coefficient.get_table("Si") self.mu = table.mu_at_angstrom(self.beam.get_wavelength()) / 10.0 self.distance = self.detector[0].get_distance() self.origin = self.detector[0].get_ray_intersection( self.detector[0].get_normal())[1] self.pixel_size = self.detector[0].get_pixel_size()
def saturation(image_file): i = load(image_file) d = i.get_detector() raw_data = i.get_raw_data() if not isinstance(raw_data, tuple): raw_data = (raw_data, ) if i.get_scan() is None: return ( 0, max( max(raw_data[pid]) / detector.get_trusted_range()[1] for pid, detector in enumerate(d)), ) else: return ( i.get_scan().get_image_range()[0], max( max(raw_data[pid]) / detector.get_trusted_range()[1] for pid, detector in enumerate(d)), )
def main(filename, threshold, images): """Read and sum all images, define those pixels which are POSITIVE but which come out below threshold as mask, write this mask in a format useful for DIALS.""" image_data = None for image in images: i = load(image) if image_data is None: image_data = i.get_raw_data() else: image_data += i.get_raw_data() mask_inverse = (image_data >= 0) & (image_data < threshold) mask = ~mask_inverse with open(filename, "wb") as fh: pickle.dump((mask, ), fh, pickle.HIGHEST_PROTOCOL) print(f"Mask written to {filename}")
class Test(object): def __init__(self): import os import libtbx.load_env try: dials_regression = libtbx.env.dist_path('dials_regression') except KeyError, e: print 'FAIL: dials_regression not configured' exit(0) filename = os.path.join(dials_regression, 'image_examples', 'XDS', 'XPARM.XDS') import dxtbx models = dxtbx.load(filename) self.detector = models.get_detector() assert (len(self.detector) == 1) self.attlen = 0.252500934883 self.distance = self.detector[0].get_distance() self.origin = self.detector[0].get_ray_intersection( self.detector[0].get_normal())
def test_run(dials_regression): filename = os.path.join(dials_regression, "image_examples", "XDS", "XPARM.XDS") models = dxtbx.load(filename) detector = models.get_detector() assert len(detector) == 1 detector = detector[0] attlen = 0.252500934883 distance = detector.get_distance() origin = detector.get_ray_intersection(detector.get_normal()) for i in range(10000): # Generate some random coordinates xy = matrix.col((random.uniform(-1000, 1000), random.uniform(-1000, 1000))) # Do the forward and reverse corrections corr_gold = matrix.col(correct_gold(detector, attlen, xy)) corr = matrix.col(parallax_correction(distance, attlen, origin, xy)) corr_inv = matrix.col(parallax_correction_inv(distance, attlen, origin, corr)) # Check the values assert abs(corr_gold - corr) < 1e-7 assert abs(corr_inv - xy) < 1e-3
def saturation(image_file): from dxtbx import load i = load(image_file) d = i.get_detector() raw_data = i.get_raw_data() if not isinstance(raw_data, tuple): raw_data = (raw_data, ) if i.get_scan() is None: return ( 0, max([ max(raw_data[pid]) / d[pid].get_trusted_range()[1] for pid in xrange(len(d)) ]), ) else: return ( i.get_scan().get_image_range()[0], max([ max(raw_data[pid]) / d[pid].get_trusted_range()[1] for pid in xrange(len(d)) ]), )
def main(filename, threshold, images): '''Read and sum all images, define those pixels which are POSITIVE but which come out below threshold as mask, write this mask in a format useful for DIALS.''' from dxtbx import load from dials.array_family import flex from cPickle import dump image_data = None for image in images: i = load(image) d = i.get_raw_data() if image_data is None: image_data = i.get_raw_data() else: image_data += i.get_raw_data() mask_inverse = (image_data >= 0) & (image_data < threshold) mask = ~mask_inverse dump((mask, ), open(filename, 'w')) print 'Mask written to %s' % filename
def resolution_corners(frame): '''Compute the resolution limit corresponding to the corners of the detector surface.''' import math from scitbx import matrix detector = frame.get_detector() beam = frame.get_beam() nfast, nslow = map(int, detector.get_image_size()) dfast, dslow = detector.get_pixel_size() F = matrix.col(detector.get_fast_axis()) S = matrix.col(detector.get_slow_axis()) origin = matrix.col(detector.get_origin()) s0 = -1 * matrix.col(beam.get_direction()) for ds in 0, 1: for df in 0, 1: corner = origin + nfast * dfast * F * df + nslow * dslow * S * ds theta = 0.5 * corner.angle(s0) print '%.3f' % (beam.get_wavelength() / (2 * math.sin(theta))) if __name__ == '__main__': import sys import dxtbx resolution_corners(dxtbx.load(sys.argv[1]))
def run(argv=None): if argv is None: argv = sys.argv[1:] command_line = ( libtbx.option_parser.option_parser( usage="%s [-v] [-c] [-s] [-w wavelength] [-d distance] [-p pixel_size] [-x beam_x] [-y beam_y] [-o overload] files" % libtbx.env.dispatcher_name ) .option( None, "--verbose", "-v", action="store_true", default=False, dest="verbose", help="Print more information about progress", ) .option( None, "--crop", "-c", action="store_true", default=False, dest="crop", help="Crop the image such that the beam center is in the middle", ) .option( None, "--skip_converted", "-s", action="store_true", default=False, dest="skip_converted", help="Skip converting if an image already exist that matches the destination file name", ) .option( None, "--wavelength", "-w", type="float", default=None, dest="wavelength", help="Override the image's wavelength (angstroms)", ) .option( None, "--distance", "-d", type="float", default=None, dest="distance", help="Override the detector distance (mm)", ) .option( None, "--pixel_size", "-p", type="float", default=None, dest="pixel_size", help="Override the detector pixel size (mm)", ) .option( None, "--beam_x", "-x", type="float", default=None, dest="beam_center_x", help="Override the beam x position (pixels)", ) .option( None, "--beam_y", "-y", type="float", default=None, dest="beam_center_y", help="Override the beam y position (pixels)", ) .option( None, "--overload", "-o", type="float", default=None, dest="overload", help="Override the detector overload value (ADU)", ) ).process(args=argv) paths = command_line.args if len(paths) <= 0: raise Usage("No files specified") for imgpath in paths: destpath = os.path.join(os.path.dirname(imgpath), os.path.splitext(os.path.basename(imgpath))[0] + ".pickle") if command_line.options.skip_converted and os.path.isfile(destpath): if command_line.options.verbose: print "Skipping %s, file exists" % imgpath continue if command_line.options.verbose: print "Converting %s to %s..." % (imgpath, destpath) try: img = dxtbx.load(imgpath) except IOError: img = None pass if img is None: import numpy as np try: raw_data = np.loadtxt(imgpath) from scitbx.array_family import flex raw_data = flex.double(raw_data.astype(np.double)) except ValueError: raise Usage("Couldn't load %s, no supported readers" % imgpath) detector = None beam = None scan = None else: raw_data = img.get_raw_data() detector = img.get_detector() beam = img.get_beam() scan = img.get_scan() if detector is None: if command_line.options.distance is None: raise Usage("Can't get distance from image. Override with -d") if command_line.options.pixel_size is None: raise Usage("Can't get pixel size from image. Override with -p") if command_line.options.overload is None: raise Usage("Can't get overload value from image. Override with -o") distance = command_line.options.distance pixel_size = command_line.options.pixel_size overload = command_line.options.overload else: detector = detector[0] if command_line.options.distance is None: distance = detector.get_distance() else: distance = command_line.options.distance if command_line.options.pixel_size is None: pixel_size = detector.get_pixel_size()[0] else: pixel_size = command_line.options.pixel_size if command_line.options.overload is None: overload = detector.get_trusted_range()[1] else: overload = command_line.options.overload if beam is None: if command_line.options.wavelength is None: raise Usage("Can't get wavelength from image. Override with -w") wavelength = command_line.options.wavelength else: if command_line.options.wavelength is None: wavelength = beam.get_wavelength() else: wavelength = command_line.options.wavelength if beam is None and detector is None: if command_line.options.beam_center_x is None: print "Can't get beam x position from image. Using image center. Override with -x" beam_x = raw_data.focus()[0] * pixel_size else: beam_x = command_line.options.beam_center_x * pixel_size if command_line.options.beam_center_y is None: print "Can't get beam y position from image. Using image center. Override with -y" beam_y = raw_data.focus()[1] * pixel_size else: beam_y = command_line.options.beam_center_y * pixel_size else: if command_line.options.beam_center_x is None: beam_x = detector.get_beam_centre(beam.get_s0())[0] else: beam_x = command_line.options.beam_center_x * pixel_size if command_line.options.beam_center_y is None: beam_y = detector.get_beam_centre(beam.get_s0())[1] else: beam_y = command_line.options.beam_center_y * pixel_size if scan is None: timestamp = None else: msec, sec = math.modf(scan.get_epochs()[0]) timestamp = evt_timestamp((sec, msec)) data = dpack( data=raw_data, distance=distance, pixel_size=pixel_size, wavelength=wavelength, beam_center_x=beam_x, beam_center_y=beam_y, ccd_image_saturation=overload, saturated_value=overload, timestamp=timestamp, ) if scan is not None: osc_start, osc_range = scan.get_oscillation() if osc_start != osc_range: data["OSC_START"] = osc_start data["OSC_RANGE"] = osc_range data["TIME"] = scan.get_exposure_times()[0] if command_line.options.crop: data = crop_image_pickle(data) easy_pickle.dump(destpath, data)
spot_par.spotfinder.threshold.dispersion.sigma_background = 6. spot_par.spotfinder.filter.min_spot_size = 2 spot_par.spotfinder.force_2d = True spot_par.spotfinder.lookup.mask = mask_file #spot_par_moder.spotfinder.threshold.dispersion.global_threshold = 56. #spot_par_moder.spotfinder.threshold.dispersion.gain = 28. #spot_par_moder.spotfinder.threshold.dispersion.kernel_size = [1,1] #spot_par_moder.spotfinder.threshold.dispersion.sigma_strong = 2.5 #spot_par_moder.spotfinder.threshold.dispersion.sigma_background = 2.5 #spot_par_moder.spotfinder.filter.min_spot_size = 1 #spot_par_moder.spotfinder.force_2d = True #spot_par_moder.spotfinder.lookup.mask = mask_file #try_fft1d = False loader = dxtbx.load(img_f) #info_f = utils.open_flex("../index/run62_idx_processed.pkl") #hit_idx = info_f.keys() ENERGIES = [parameters.ENERGY_LOW, parameters.ENERGY_HIGH] # colors of the beams FF = [5000, None] # Setting structure factors takes long time in nanoBragg, so # unless you want energy-dependent structure factors # you need only provide one number -or- one structure factor flex miller table # and the computer will know to preserve that for all beam colors FLUX = [1e14, 1e14] # fluxes of the beams #from cxid9114.sim import scattering_factors #Fcalcs = scattering_factors.get_scattF( parameters.WAVELEN_LOW, # pdb_name="../sim/4bs7.pdb",
from __future__ import division import sys, os, dxtbx from xfel.cxi.cspad_ana import cspad_tbx from libtbx import easy_pickle from libtbx import easy_mp from xfel.command_line.cxi_image2pickle import crop_image_pickle # Jiffy script to dump SACLA data processed by Cheetah into image pickles. Usage: # libtbx.python dump_sacla_data.py <path to h5 file> <destination directory for pickles>. # Uses 4 processors, hardcoded at the end of the file data_path = sys.argv[1] dest_dir = sys.argv[2] data = dxtbx.load(data_path) detector = data.get_detector() distance = detector[0].get_directed_distance() beam = data.get_beam() wavelength = beam.get_wavelength() pixel_size = detector[0].get_pixel_size()[0] beam_x, beam_y = detector[0].get_beam_centre_px(beam.get_s0()) beam_x *= pixel_size beam_y += 0 #earlier work required a 3 pixel shift based on powder pattern/fit to unit cell beam_y *= pixel_size overload = detector[0].get_trusted_range()[1] from xfel.cxi.cspad_ana.cspad_tbx import xpp_active_areas active_areas = xpp_active_areas["Sacla.MPCCD.8tile"]["active_areas"] # the active areas are already determined for the cropped size # (ran once without active areas, then measured cropped active areas on image viewer) dest_base = os.path.basename(os.path.splitext(data_path)[0])
def generate_xds_corrections(image_filename, sensor_thickness_mm, energy_ev=None): '''Generate an XYCORR input file from an image header via dxtbx, noting well that this will *tell lies* as the image is rescaled to give a 1:1 correction table in 0.025 rather than 0.1 (original) pixel increments.''' from dxtbx import load from scitbx import matrix image = load(image_filename) beam = matrix.col(image.get_beam().get_s0()).normalize() if energy_ev: wavelength = 12398.5 / energy_ev else: wavelength = image.get_beam().get_wavelength() energy_ev = 12398.5 / wavelength from mu_Si import derive_absorption_coefficient_Si silicon = derive_absorption_coefficient_Si(0.001 * energy_ev) d = image.get_detector()[0] fast = matrix.col(d.get_fast_axis()) slow = matrix.col(d.get_slow_axis()) normal = matrix.col(d.get_normal()) origin = matrix.col(d.get_origin()) distance = origin.dot(normal) offset = distance * normal - origin offset_fast = offset.dot(fast) offset_slow = offset.dot(slow) trusted = d.get_trusted_range() pixel_size = d.get_pixel_size() # this is in order slow, fast i.e. C order image_size = image.get_raw_data().focus() open('XDS.INP', 'w').write(xds_template % { 'overload':trusted[1], 'fast_x':fast.elems[0], 'fast_y':fast.elems[1], 'fast_z':fast.elems[2], 'slow_x':slow.elems[0], 'slow_y':slow.elems[1], 'slow_z':slow.elems[2], 'n_fast':image_size[1] * 4, 'n_slow':image_size[0] * 4, 'pixel_fast':pixel_size[0] / 4.0, 'pixel_slow':pixel_size[1] / 4.0, 'distance':distance, 'wavelength':wavelength, 'beam_x':beam.elems[0], 'beam_y':beam.elems[1], 'beam_z':beam.elems[2], 'silicon':silicon, 'thickness':sensor_thickness_mm, 'origin_fast':offset_fast / (pixel_size[0] / 4.0), 'origin_slow':offset_slow / (pixel_size[1] / 4.0) }) output = run_job('xds_par') # now read the correction tables in and scale to mm - recall pixel size / 4 # above.. x_corrections_parallax = read_xds_calibration_file( 'X-CORRECTIONS.cbf').as_double() * (pixel_size[1] / 40.0) y_corrections_parallax = read_xds_calibration_file( 'Y-CORRECTIONS.cbf').as_double() * (pixel_size[0] / 40.0) return x_corrections_parallax, y_corrections_parallax
def run(): parser = OptionParser( phil = phil_scope) params, options = parser.parse_args(show_diff_phil=True) assert params.input.single_img is not None assert params.output_dir is not None # load the image img = dxtbx.load(params.input.single_img) imgset = MemImageSet([img]) datablock = DataBlockFactory.from_imageset(imgset)[0] spotfinder = SpotFinderFactory.from_parameters(params) reflections = spotfinder(datablock) base_name = os.path.splitext(params.input.single_img)[0] reflections.as_pickle(os.path.join(params.output_dir, base_name + "_strong.pickle")) # DGW commented out as reflections.minimum_number_of_reflections no longer exists #if len(reflections) < params.refinement.reflections.minimum_number_of_reflections: # print "Not enough spots to index" # return # create the spot finder print "Spotfinder spots found:", len(reflections) if params.indexing.method == "fft3d": from dials.algorithms.indexing.fft3d import indexer_fft3d as indexer elif params.indexing.method == "fft1d": from dials.algorithms.indexing.fft1d import indexer_fft1d as indexer elif params.method == "real_space_grid_search": from dials.algorithms.indexing.real_space_grid_search \ import indexer_real_space_grid_search as indexer try: idxr = indexer(reflections, [imgset], params=params.indexing) except (RuntimeError, Sorry) as e: print str(e) return indexed = idxr.refined_reflections experiments = idxr.refined_experiments #from dxtbx.model.experiment.experiment_list import ExperimentListDumper #dump = ExperimentListDumper(experiments) #dump.as_json(os.path.join(params.output_dir, base_name + "_experiments.json")) indexed.as_pickle(os.path.join(params.output_dir, base_name + "_indexed.pickle")) refiner = RefinerFactory.from_parameters_data_experiments( params, indexed, experiments) refiner.run() refined_experiments = refiner.get_experiments() #dump = ExperimentListDumper(refined_experiments) #dump.as_json(os.path.join(params.output_dir, base_name + "_refined.json")) # Compute the profile model # Predict the reflections # Match the predictions with the reference # Create the integrator reference = indexed reference = process_reference(reference) profile_model = ProfileModelFactory.create(params, refined_experiments, reference) predicted = flex.reflection_table.from_predictions_multi( refined_experiments, dmin=params.prediction.dmin, dmax=params.prediction.dmax, margin=params.prediction.margin, force_static=params.prediction.force_static) predicted.match_with_reference(reference) integrator = IntegratorFactory.create(params, experiments, profile_model, predicted) # Integrate the reflections integrated = integrator.integrate() integrated.as_pickle(os.path.join(params.output_dir, base_name + "_integrated.pickle"))
pool = Pool(processes=nproc) for line in lines: # parse the input file line into a diffuse image file name and scale factor words = line.split() imgname = os.path.join(procpath+"/"+words[1]) scale = float(words[2]) print "processing file %s with scale factor %f"%(imgname,scale) # I = QuickImage(imgname) # I.read() # DATA = I.linearintdata import dxtbx img = dxtbx.load(imgname) detector = img.get_detector() beam = img.get_beam() scan = img.get_scan() gonio = img.get_goniometer() print "transform pixel numbers to mm positions and rotational degrees" # from iotbx.detectors.context.spot_xy_convention import spot_xy_convention # SF = results.spotfinder_results # SXYC = spot_xy_convention(SF.pixel_size*SF.size1,SF.pixel_size*SF.size2) # from spotfinder.math_support import pixels_to_mmPos # this_frame_phi_deg = I.deltaphi/2.0+I.osc_start print "Creating pixel map..." t0 = time() """
if (__name__ == "__main__"): if len(sys.argv) == 1 or '-h' in sys.argv or '--help' in sys.argv or '-c' in sys.argv: raise Usage("%s files"%libtbx.env.dispatcher_name) files = [arg for arg in sys.argv[1:] if os.path.isfile(arg)] arguments = [arg for arg in sys.argv[1:] if not os.path.isfile(arg)] for file in files: message="""Based on the file %s, this program will compute incremental quadrant translations to circularize powder rings on the inner four sensors. The algorithm treats each quadrant independently and scores based on self-correlation upon 45-degree rotation. """%file print message image = dxtbx.load(file) detector = image.get_detector() beam = image.get_beam() from xfel.metrology.quadrant import one_panel for i_quad, quad in enumerate(detector.hierarchy()): # find panel closest to the beam center panels = [] def recursive_get_panels(group): if hasattr(group, "children"): for child in group: recursive_get_panels(child) else: panels.append(group) recursive_get_panels(quad)
def run(argv=None): if argv is None: argv = sys.argv[1:] command_line = (libtbx.option_parser.option_parser( usage="%s [-v] [-c] [-s] [-w wavelength] [-d distance] [-p pixel_size] [-x beam_x] [-y beam_y] [-o overload] files" % libtbx.env.dispatcher_name) .option(None, "--verbose", "-v", action="store_true", default=False, dest="verbose", help="Print more information about progress") .option(None, "--crop", "-c", action="store_true", default=False, dest="crop", help="Crop the image such that the beam center is in the middle") .option(None, "--skip_converted", "-s", action="store_true", default=False, dest="skip_converted", help="Skip converting if an image already exist that matches the destination file name") .option(None, "--wavelength", "-w", type="float", default=None, dest="wavelength", help="Override the image's wavelength (angstroms)") .option(None, "--distance", "-d", type="float", default=None, dest="distance", help="Override the detector distance (mm)") .option(None, "--pixel_size", "-p", type="float", default=None, dest="pixel_size", help="Override the detector pixel size (mm)") .option(None, "--beam_x", "-x", type="float", default=None, dest="beam_center_x", help="Override the beam x position (pixels)") .option(None, "--beam_y", "-y", type="float", default=None, dest="beam_center_y", help="Override the beam y position (pixels)") .option(None, "--overload", "-o", type="float", default=None, dest="overload", help="Override the detector overload value (ADU)") ).process(args=argv) paths = command_line.args if len(paths) <= 0: raise Usage("No files specified") for imgpath in paths: if command_line.options.verbose: print "Reading %s"%(imgpath) try: img = dxtbx.load(imgpath) except IOError: img = None pass if img is None: import numpy as np try: raw_data = np.loadtxt(imgpath) from scitbx.array_family import flex raw_data = flex.double(raw_data.astype(np.double)) except ValueError: raise Usage("Couldn't load %s, no supported readers"%imgpath) detector = None beam = None scan = None is_multi_image = False else: try: raw_data = img.get_raw_data() is_multi_image = False except TypeError: raw_data = img.get_raw_data(0) is_multi_image = True detector = img.get_detector() beam = img.get_beam() scan = img.get_scan() if detector is None: if command_line.options.distance is None: raise Usage("Can't get distance from image. Override with -d") if command_line.options.pixel_size is None: raise Usage("Can't get pixel size from image. Override with -p") if command_line.options.overload is None: raise Usage("Can't get overload value from image. Override with -o") distance = command_line.options.distance pixel_size = command_line.options.pixel_size overload = command_line.options.overload else: detector = detector[0] if command_line.options.distance is None: distance = detector.get_distance() else: distance = command_line.options.distance if command_line.options.pixel_size is None: pixel_size = detector.get_pixel_size()[0] else: pixel_size = command_line.options.pixel_size if command_line.options.overload is None: overload = detector.get_trusted_range()[1] else: overload = command_line.options.overload if beam is None: if command_line.options.wavelength is None: raise Usage("Can't get wavelength from image. Override with -w") wavelength = command_line.options.wavelength else: if command_line.options.wavelength is None: wavelength = beam.get_wavelength() else: wavelength = command_line.options.wavelength if beam is None and detector is None: if command_line.options.beam_center_x is None: print "Can't get beam x position from image. Using image center. Override with -x" beam_x = raw_data.focus()[0] * pixel_size else: beam_x = command_line.options.beam_center_x * pixel_size if command_line.options.beam_center_y is None: print "Can't get beam y position from image. Using image center. Override with -y" beam_y = raw_data.focus()[1] * pixel_size else: beam_y = command_line.options.beam_center_y * pixel_size else: if command_line.options.beam_center_x is None: beam_x = detector.get_beam_centre(beam.get_s0())[0] else: beam_x = command_line.options.beam_center_x * pixel_size if command_line.options.beam_center_y is None: beam_y = detector.get_beam_centre(beam.get_s0())[1] else: beam_y = command_line.options.beam_center_y * pixel_size if scan is None: timestamp = None else: msec, sec = math.modf(scan.get_epochs()[0]) timestamp = evt_timestamp((sec,msec)) if is_multi_image: for i in xrange(img.get_num_images()): save_image(command_line, imgpath, scan, img.get_raw_data(i), distance, pixel_size, wavelength, beam_x, beam_y, overload, timestamp, image_number = i) else: save_image(command_line, imgpath, scan, raw_data, distance, pixel_size, wavelength, beam_x, beam_y, overload, timestamp)
def xds_check_indexer_solution(xparm_file, spot_file): '''Read XPARM file from XDS IDXREF (assumes that this is in the putative correct symmetry, not P1! and test centring operations if present. Note that a future version will boost to the putative correct symmetry (or an estimate of it) and try this if it is centred. Returns tuple (space_group_number, cell).''' from dxtbx.serialize.xds import to_crystal as xparm_to_crystal cm = xparm_to_crystal(xparm_file) sg = cm.get_space_group() spacegroup = sg.type().hall_symbol() space_group_number = sg.type().number() A_inv = cm.get_A().inverse() cell = cm.get_unit_cell().parameters() import dxtbx models = dxtbx.load(xparm_file) detector = models.get_detector() beam = models.get_beam() goniometer = models.get_goniometer() scan = models.get_scan() from iotbx.xds import spot_xds spot_xds_handle = spot_xds.reader() spot_xds_handle.read_file(spot_file) from cctbx.array_family import flex centroids_px = flex.vec3_double(spot_xds_handle.centroid) miller_indices = flex.miller_index(spot_xds_handle.miller_index) # Convert Pixel coordinate into mm/rad x, y, z = centroids_px.parts() x_mm, y_mm = detector[0].pixel_to_millimeter(flex.vec2_double(x, y)).parts() z_rad = scan.get_angle_from_array_index(z, deg=False) centroids_mm = flex.vec3_double(x_mm, y_mm, z_rad) # then convert detector position to reciprocal space position # based on code in dials/algorithms/indexing/indexer2.py s1 = detector[0].get_lab_coord(flex.vec2_double(x_mm, y_mm)) s1 = s1/s1.norms() * (1/beam.get_wavelength()) S = s1 - beam.get_s0() # XXX what about if goniometer fixed rotation is not identity? reciprocal_space_points = S.rotate_around_origin( goniometer.get_rotation_axis(), -z_rad) # now index the reflections hkl_float = tuple(A_inv) * reciprocal_space_points hkl_int = hkl_float.iround() # check if we are within 0.1 lattice spacings of the closest # lattice point - a for a random point this will be about 0.8% of # the time... differences = hkl_float - hkl_int.as_vec3_double() dh, dk, dl = [flex.abs(d) for d in differences.parts()] tolerance = 0.1 sel = (dh < tolerance) and (dk < tolerance) and (dl < tolerance) is_sys_absent = sg.is_sys_absent( flex.miller_index(list(hkl_int.select(sel)))) total = is_sys_absent.size() absent = is_sys_absent.count(True) present = total - absent # now, if the number of absences is substantial, need to consider # transforming this to a primitive basis Debug.write('Absent: %d vs. Present: %d Total: %d' % \ (absent, present, total)) # now see if this is compatible with a centred lattice or suggests # a primitive basis is correct sd = math.sqrt(absent) if (absent - 3 * sd) / total < 0.008: # everything is peachy return s2l(space_group_number), tuple(cell) # ok if we are here things are not peachy, so need to calculate the # spacegroup number without the translation operators sg_new = sg.build_derived_group(True, False) space_group_number_primitive = sg_new.type().number() # also determine the best setting for the new cell ... symm = crystal.symmetry(unit_cell = cell, space_group = sg_new) rdx = symm.change_of_basis_op_to_best_cell() symm_new = symm.change_basis(rdx) cell_new = symm_new.unit_cell().parameters() return s2l(space_group_number_primitive), tuple(cell_new)
def load_image(self): """ Reads raw image file and extracts data for conversion into pickle format. Also estimates gain if turned on.""" # Load raw image or image pickle try: with misc.Capturing() as junk_output: loaded_img = dxtbx.load(self.raw_img) except IOError: loaded_img = None pass # Extract image information if loaded_img is not None: raw_data = loaded_img.get_raw_data() detector = loaded_img.get_detector()[0] beam = loaded_img.get_beam() scan = loaded_img.get_scan() distance = detector.get_distance() pixel_size = detector.get_pixel_size()[0] overload = detector.get_trusted_range()[1] wavelength = beam.get_wavelength() beam_x = detector.get_beam_centre(beam.get_s0())[0] beam_y = detector.get_beam_centre(beam.get_s0())[1] if scan is None: timestamp = None if abs(beam_x - beam_y) <= 0.1 or self.params.image_conversion.square_mode == "None": img_type = 'converted' else: img_type = 'unconverted' else: msec, sec = math.modf(scan.get_epochs()[0]) timestamp = evt_timestamp((sec,msec)) if self.params.image_conversion.beamstop != 0 or\ self.params.image_conversion.beam_center.x != 0 or\ self.params.image_conversion.beam_center.y != 0 or\ self.params.image_conversion.rename_pickle_prefix != 'Auto' or\ self.params.image_conversion.rename_pickle_prefix != None: img_type = 'unconverted' # Assemble datapack data = dpack(data=raw_data, distance=distance, pixel_size=pixel_size, wavelength=wavelength, beam_center_x=beam_x, beam_center_y=beam_y, ccd_image_saturation=overload, saturated_value=overload, timestamp=timestamp ) #print "data: ", type(raw_data) #print "pixel size: ", type(pixel_size) #print 'wavelength: ', type(wavelength) #print "beamX: ", type(beam_x) #print "saturation: ", type(overload) #print "timestamp: ", type(timestamp) #for i in dir(raw_data): print i #exit() if scan is not None: osc_start, osc_range = scan.get_oscillation() img_type = 'unconverted' if osc_start != osc_range: data['OSC_START'] = osc_start data['OSC_RANGE'] = osc_range data['TIME'] = scan.get_exposure_times()[0] # Estimate gain (or set gain to 1.00 if cannot calculate) # Cribbed from estimate_gain.py by Richard Gildea if self.params.advanced.estimate_gain: try: from dials.algorithms.image.threshold import KabschDebug raw_data = [raw_data] gain_value = 1 kernel_size=(10,10) gain_map = [flex.double(raw_data[i].accessor(), gain_value) for i in range(len(loaded_img.get_detector()))] mask = loaded_img.get_mask() min_local = 0 # dummy values, shouldn't affect results nsigma_b = 6 nsigma_s = 3 global_threshold = 0 kabsch_debug_list = [] for i_panel in range(len(loaded_img.get_detector())): kabsch_debug_list.append( KabschDebug( raw_data[i_panel].as_double(), mask[i_panel], gain_map[i_panel], kernel_size, nsigma_b, nsigma_s, global_threshold, min_local)) dispersion = flex.double() for kabsch in kabsch_debug_list: dispersion.extend(kabsch.coefficient_of_variation().as_1d()) sorted_dispersion = flex.sorted(dispersion) from libtbx.math_utils import nearest_integer as nint q1 = sorted_dispersion[nint(len(sorted_dispersion)/4)] q2 = sorted_dispersion[nint(len(sorted_dispersion)/2)] q3 = sorted_dispersion[nint(len(sorted_dispersion)*3/4)] iqr = q3-q1 inlier_sel = (sorted_dispersion > (q1 - 1.5*iqr)) & (sorted_dispersion < (q3 + 1.5*iqr)) sorted_dispersion = sorted_dispersion.select(inlier_sel) self.gain = sorted_dispersion[nint(len(sorted_dispersion)/2)] except IndexError: self.gain = 1.0 else: self.gain = 1.0 else: data = None return data, img_type
f = open(ifname, "r") lines = [] linenum = 1 framenum = -1 for line in f: if ((line.strip() != "") and (line[0] != '.')): if ((framenum == -1) or (framenum == linenum)): lines.append(line) linenum = linenum + 1 f.close() imgname = filenames[0] # import dxtbx t0 = time() # img = FormatSMVADSCNoDateStamp(imgname) img = dxtbx.load(imgname) detector = img.get_detector() beam = img.get_beam() scan = img.get_scan() gonio = img.get_goniometer() print "transform pixel numbers to mm positions and rotational degrees" print "Creating pixel map..." t0 = time() lab_coordinates = flex.vec3_double() for panel in detector: pixels = flex.vec2_double(panel.get_image_size()) mms = panel.pixel_to_millimeter(pixels) lab_coordinates.extend(panel.get_lab_coord(mms))
def run(): if not have_dials_regression: print "Skipping test: dials_regression not available." return from scitbx import matrix from iotbx.xds import xparm, integrate_hkl from dials.util import ioutil from math import ceil from dials.algorithms.spot_prediction import RotationAngles import dxtbx from rstbx.cftbx.coordinate_frame_converter import \ coordinate_frame_converter # The XDS files to read from integrate_filename = join(dials_regression, 'data/sim_mx/INTEGRATE.HKL') gxparm_filename = join(dials_regression, 'data/sim_mx/GXPARM.XDS') # Read the XDS files integrate_handle = integrate_hkl.reader() integrate_handle.read_file(integrate_filename) gxparm_handle = xparm.reader() gxparm_handle.read_file(gxparm_filename) # Get the parameters we need from the GXPARM file models = dxtbx.load(gxparm_filename) beam = models.get_beam() gonio = models.get_goniometer() detector = models.get_detector() scan = models.get_scan() # Get the crystal parameters space_group_type = ioutil.get_space_group_type_from_xparm(gxparm_handle) cfc = coordinate_frame_converter(gxparm_filename) a_vec = cfc.get('real_space_a') b_vec = cfc.get('real_space_b') c_vec = cfc.get('real_space_c') unit_cell = cfc.get_unit_cell() UB = matrix.sqr(a_vec + b_vec + c_vec).inverse() ub_matrix = UB # Get the minimum resolution in the integrate file d = [unit_cell.d(h) for h in integrate_handle.hkl] d_min = min(d) # Get the number of frames from the max z value xcal, ycal, zcal = zip(*integrate_handle.xyzcal) num_frames = int(ceil(max(zcal))) scan.set_image_range((scan.get_image_range()[0], scan.get_image_range()[0] + num_frames - 1)) # Create the rotation angle object ra = RotationAngles(beam.get_s0(), gonio.get_rotation_axis()) # Setup the matrices ub = matrix.sqr(ub_matrix) s0 = matrix.col(beam.get_s0()) m2 = matrix.col(gonio.get_rotation_axis()) # For all the miller indices for h in integrate_handle.hkl: h = matrix.col(h) # Calculate the angles angles = ra(h, ub) # For all the angles for phi in angles: r = m2.axis_and_angle_as_r3_rotation_matrix(angle=phi) pstar = r * ub * h s1 = s0 + pstar assert(abs(s1.length() - s0.length()) < 1e-7) print "OK" # Create a dict of lists of xy for each hkl gen_phi = {} for h in integrate_handle.hkl: # Calculate the angles angles = ra(h, ub) gen_phi[h] = angles # for phi in angles: # try: # a = gen_phi[h] # a.append(phi) # gen_phi[h] = a # except KeyError: # gen_phi[h] = [phi] # For each hkl in the xds file for hkl, xyz in zip(integrate_handle.hkl, integrate_handle.xyzcal): # Calculate the XDS phi value xds_phi = scan.get_oscillation(deg=False)[0] + \ xyz[2]*scan.get_oscillation(deg=False)[1] # Select the nearest xy to use if there are 2 my_phi = gen_phi[hkl] if len(my_phi) == 2: my_phi0 = my_phi[0] my_phi1 = my_phi[1] diff0 = abs(xds_phi - my_phi0) diff1 = abs(xds_phi - my_phi1) if diff0 < diff1: my_phi = my_phi0 else: my_phi = my_phi1 else: my_phi = my_phi[0] # Check the Phi values are the same assert(abs(xds_phi - my_phi) < 0.1) # Test Passed print "OK"
dq_min = 0.005 nom_gain = 28 # nominal photon gain for corrected CSPAD # ------------------ fnames = glob.glob("results/run%d/*resid.pkl" % run) mask = [ m.as_numpy_array() for m in utils.open_flex("dials_mask_64panels_2.pkl") ] spec_df = pandas.read_pickle('ana_result/run%d/run%d_overview_wspec.pdpkl' % (run, run)) all_spec_hist = [] all_raw_spec = [] loader = dxtbx.load("image_files/_autogen_run%d.loc" % run) PSANA_ENV = loader.run_mapping[run][2].env() # important to use this env! # these values in the dataframe represent nominal values, but sometimes # attenuators were pulled or inserted mid-run, hence # these are not trustworthy, and we resort to per-event attenuation checks atten = pandas.read_pickle("atten_cxid9114.pdpkl") thick, trans = atten.loc[atten.run == run, ['thickness', 'transmission']].iloc[0].values det_ids = range(2, 12) # need reference to the motors themselves atten_dets = { det_id: psana.Detector("XRT:DIA:MMS:%02d.RBV" % det_id, PSANA_ENV) for det_id in det_ids } # each motor represents a piece of Silicon foil, of varying thickness atten_vals = {det_id: 20 * 2**i
def test(dials_regression, run_in_tmpdir): import dxtbx from iotbx.xds import integrate_hkl, xparm from rstbx.cftbx.coordinate_frame_converter import coordinate_frame_converter from dials.algorithms.spot_prediction import RotationAngles # The XDS files to read from integrate_filename = os.path.join(dials_regression, "data/sim_mx/INTEGRATE.HKL") gxparm_filename = os.path.join(dials_regression, "data/sim_mx/GXPARM.XDS") # Read the XDS files integrate_handle = integrate_hkl.reader() integrate_handle.read_file(integrate_filename) gxparm_handle = xparm.reader() gxparm_handle.read_file(gxparm_filename) # Get the parameters we need from the GXPARM file models = dxtbx.load(gxparm_filename) beam = models.get_beam() gonio = models.get_goniometer() scan = models.get_scan() # Get the crystal parameters cfc = coordinate_frame_converter(gxparm_filename) a_vec = cfc.get("real_space_a") b_vec = cfc.get("real_space_b") c_vec = cfc.get("real_space_c") UB = matrix.sqr(a_vec + b_vec + c_vec).inverse() ub_matrix = UB # Get the number of frames from the max z value xcal, ycal, zcal = zip(*integrate_handle.xyzcal) num_frames = int(math.ceil(max(zcal))) scan.set_image_range((scan.get_image_range()[0], scan.get_image_range()[0] + num_frames - 1)) # Create the rotation angle object ra = RotationAngles(beam.get_s0(), gonio.get_rotation_axis()) # Setup the matrices ub = matrix.sqr(ub_matrix) s0 = matrix.col(beam.get_s0()) m2 = matrix.col(gonio.get_rotation_axis()) # For all the miller indices for h in integrate_handle.hkl: h = matrix.col(h) # Calculate the angles angles = ra(h, ub) # For all the angles for phi in angles: r = m2.axis_and_angle_as_r3_rotation_matrix(angle=phi) pstar = r * ub * h s1 = s0 + pstar assert s1.length() == pytest.approx(s0.length(), abs=1e-7) # Create a dict of lists of xy for each hkl gen_phi = {} for h in integrate_handle.hkl: # Calculate the angles angles = ra(h, ub) gen_phi[h] = angles # for phi in angles: # try: # a = gen_phi[h] # a.append(phi) # gen_phi[h] = a # except KeyError: # gen_phi[h] = [phi] # For each hkl in the xds file for hkl, xyz in zip(integrate_handle.hkl, integrate_handle.xyzcal): # Calculate the XDS phi value xds_phi = (scan.get_oscillation(deg=False)[0] + xyz[2] * scan.get_oscillation(deg=False)[1]) # Select the nearest xy to use if there are 2 my_phi = gen_phi[hkl] if len(my_phi) == 2: my_phi0 = my_phi[0] my_phi1 = my_phi[1] diff0 = abs(xds_phi - my_phi0) diff1 = abs(xds_phi - my_phi1) if diff0 < diff1: my_phi = my_phi0 else: my_phi = my_phi1 else: my_phi = my_phi[0] # Check the Phi values are the same assert xds_phi == pytest.approx(my_phi, abs=0.1)
logger = open(params.output_file, 'w') logger.write("%s " % params.output_file) if params.show_plots: from matplotlib import pyplot as plt import numpy as np colormap = plt.cm.gist_ncar plt.gca().set_color_cycle( [colormap(i) for i in np.linspace(0, 0.9, len(params.file_path))]) if params.mask is not None: params.mask = easy_pickle.load(params.mask) if image is None: iterable = params.file_path load_func = lambda x: dxtbx.load(x) else: iterable = [image] load_func = lambda x: x # Iterate over each file provided for item in iterable: img = load_func(item) beam = img.get_beam() detector = img.get_detector() # Search the detector for the panel farthest from the beam. The number of bins in the radial average will be # equal to the farthest point from the beam on the detector, in pixels, unless overridden at the command line extent = 0 extent_two_theta = 0 for panel in detector:
def __init__(self, dials_regression): import dxtbx from iotbx.xds import integrate_hkl, xparm from rstbx.cftbx.coordinate_frame_converter import coordinate_frame_converter from dials.algorithms.spot_prediction import ( IndexGenerator, ScanStaticRayPredictor, ) from dials.util import ioutil # The XDS files to read from integrate_filename = os.path.join(dials_regression, "data", "sim_mx", "INTEGRATE.HKL") gxparm_filename = os.path.join(dials_regression, "data", "sim_mx", "GXPARM.XDS") # Read the XDS files self.integrate_handle = integrate_hkl.reader() self.integrate_handle.read_file(integrate_filename) self.gxparm_handle = xparm.reader() self.gxparm_handle.read_file(gxparm_filename) # Get the parameters we need from the GXPARM file models = dxtbx.load(gxparm_filename) self.beam = models.get_beam() self.gonio = models.get_goniometer() self.detector = models.get_detector() self.scan = models.get_scan() # Get crystal parameters self.space_group_type = ioutil.get_space_group_type_from_xparm( self.gxparm_handle) cfc = coordinate_frame_converter(gxparm_filename) a_vec = cfc.get("real_space_a") b_vec = cfc.get("real_space_b") c_vec = cfc.get("real_space_c") self.unit_cell = cfc.get_unit_cell() self.ub_matrix = matrix.sqr(a_vec + b_vec + c_vec).inverse() # Get the minimum resolution in the integrate file d = [self.unit_cell.d(h) for h in self.integrate_handle.hkl] self.d_min = min(d) # extend the resolution shell by epsilon>0 # to account for rounding artifacts on 32-bit platforms self.d_min = self.d_min - 1e-15 # Get the number of frames from the max z value xcal, ycal, zcal = zip(*self.integrate_handle.xyzcal) self.scan.set_image_range(( self.scan.get_image_range()[0], self.scan.get_image_range()[0] + int(math.ceil(max(zcal))), )) # Print stuff # print self.beam # print self.gonio # print self.detector # print self.scan # Create the index generator self.generate_indices = IndexGenerator(self.unit_cell, self.space_group_type, self.d_min) s0 = self.beam.get_s0() m2 = self.gonio.get_rotation_axis() fixed_rotation = self.gonio.get_fixed_rotation() setting_rotation = self.gonio.get_setting_rotation() UB = self.ub_matrix dphi = self.scan.get_oscillation_range(deg=False) # Create the ray predictor self.predict_rays = ScanStaticRayPredictor(s0, m2, fixed_rotation, setting_rotation, dphi) # Predict the spot locations self.reflections = self.predict_rays(self.generate_indices.to_array(), UB)
from scitbx import matrix import dxtbx def resolution_corners(frame): """Compute the resolution limit corresponding to the corners of the detector surface.""" detector = frame.get_detector() beam = frame.get_beam() nfast, nslow = map(int, detector.get_image_size()) dfast, dslow = detector.get_pixel_size() F = matrix.col(detector.get_fast_axis()) S = matrix.col(detector.get_slow_axis()) origin = matrix.col(detector.get_origin()) s0 = -1 * matrix.col(beam.get_sample_to_source_direction()) for ds in 0, 1: for df in 0, 1: corner = origin + nfast * dfast * F * df + nslow * dslow * S * ds theta = 0.5 * corner.angle(s0) print("%.3f" % (beam.get_wavelength() / (2 * math.sin(theta)))) if __name__ == "__main__": resolution_corners(dxtbx.load(sys.argv[1]))
def __init__(self): from dials.algorithms.spot_prediction import IndexGenerator from dials.algorithms.spot_prediction import ScanStaticRayPredictor from dials.algorithms.spot_prediction import ray_intersection from iotbx.xds import xparm, integrate_hkl from dials.util import ioutil from math import ceil import dxtbx from rstbx.cftbx.coordinate_frame_converter import \ coordinate_frame_converter from scitbx import matrix # The XDS files to read from integrate_filename = join(dials_regression, 'data/sim_mx/INTEGRATE.HKL') gxparm_filename = join(dials_regression, 'data/sim_mx/GXPARM.XDS') # Read the XDS files self.integrate_handle = integrate_hkl.reader() self.integrate_handle.read_file(integrate_filename) self.gxparm_handle = xparm.reader() self.gxparm_handle.read_file(gxparm_filename) # Get the parameters we need from the GXPARM file models = dxtbx.load(gxparm_filename) self.beam = models.get_beam() self.gonio = models.get_goniometer() self.detector = models.get_detector() self.scan = models.get_scan() assert (len(self.detector) == 1) #print self.detector # Get crystal parameters self.space_group_type = ioutil.get_space_group_type_from_xparm( self.gxparm_handle) cfc = coordinate_frame_converter(gxparm_filename) a_vec = cfc.get('real_space_a') b_vec = cfc.get('real_space_b') c_vec = cfc.get('real_space_c') self.unit_cell = cfc.get_unit_cell() self.ub_matrix = matrix.sqr(a_vec + b_vec + c_vec).inverse() # Get the minimum resolution in the integrate file self.d_min = self.detector[0].get_max_resolution_at_corners( self.beam.get_s0()) # Get the number of frames from the max z value xcal, ycal, zcal = zip(*self.integrate_handle.xyzcal) self.scan.set_image_range( (self.scan.get_image_range()[0], self.scan.get_image_range()[0] + int(ceil(max(zcal))))) # Create the index generator generate_indices = IndexGenerator(self.unit_cell, self.space_group_type, self.d_min) s0 = self.beam.get_s0() m2 = self.gonio.get_rotation_axis() fixed_rotation = self.gonio.get_fixed_rotation() setting_rotation = self.gonio.get_setting_rotation() UB = self.ub_matrix dphi = self.scan.get_oscillation_range(deg=False) # Create the ray predictor self.predict_rays = ScanStaticRayPredictor(s0, m2, fixed_rotation, setting_rotation, dphi) # Predict the spot locations self.reflections = self.predict_rays(generate_indices.to_array(), UB) # Calculate the intersection of the detector and reflection frames success = ray_intersection(self.detector, self.reflections) self.reflections.select(success)
def xds_check_indexer_solution(xparm_file, spot_file): '''Read XPARM file from XDS IDXREF (assumes that this is in the putative correct symmetry, not P1! and test centring operations if present. Note that a future version will boost to the putative correct symmetry (or an estimate of it) and try this if it is centred. Returns tuple (space_group_number, cell).''' from scitbx import matrix from dxtbx.serialize.xds import to_crystal as xparm_to_crystal cm = xparm_to_crystal(xparm_file) sg = cm.get_space_group() spacegroup = sg.type().hall_symbol() space_group_number = sg.type().number() A_inv = matrix.sqr(cm.get_A()).inverse() cell = cm.get_unit_cell().parameters() import dxtbx models = dxtbx.load(xparm_file) detector = models.get_detector() beam = models.get_beam() goniometer = models.get_goniometer() scan = models.get_scan() from iotbx.xds import spot_xds spot_xds_handle = spot_xds.reader() spot_xds_handle.read_file(spot_file) from cctbx.array_family import flex centroids_px = flex.vec3_double(spot_xds_handle.centroid) miller_indices = flex.miller_index(spot_xds_handle.miller_index) # Convert Pixel coordinate into mm/rad x, y, z = centroids_px.parts() x_mm, y_mm = detector[0].pixel_to_millimeter(flex.vec2_double(x, y)).parts() z_rad = scan.get_angle_from_array_index(z, deg=False) centroids_mm = flex.vec3_double(x_mm, y_mm, z_rad) # then convert detector position to reciprocal space position # based on code in dials/algorithms/indexing/indexer2.py s1 = detector[0].get_lab_coord(flex.vec2_double(x_mm, y_mm)) s1 = s1 / s1.norms() * (1 / beam.get_wavelength()) S = s1 - beam.get_s0() # XXX what about if goniometer fixed rotation is not identity? reciprocal_space_points = S.rotate_around_origin( goniometer.get_rotation_axis(), -z_rad) # now index the reflections hkl_float = tuple(A_inv) * reciprocal_space_points hkl_int = hkl_float.iround() # check if we are within 0.1 lattice spacings of the closest # lattice point - a for a random point this will be about 0.8% of # the time... differences = hkl_float - hkl_int.as_vec3_double() dh, dk, dl = [flex.abs(d) for d in differences.parts()] tolerance = 0.1 sel = (dh < tolerance) and (dk < tolerance) and (dl < tolerance) is_sys_absent = sg.is_sys_absent( flex.miller_index(list(hkl_int.select(sel)))) total = is_sys_absent.size() absent = is_sys_absent.count(True) present = total - absent # now, if the number of absences is substantial, need to consider # transforming this to a primitive basis Debug.write('Absent: %d vs. Present: %d Total: %d' % \ (absent, present, total)) # now see if this is compatible with a centred lattice or suggests # a primitive basis is correct sd = math.sqrt(absent) if (absent - 3 * sd) / total < 0.008: # everything is peachy return s2l(space_group_number), tuple(cell) # ok if we are here things are not peachy, so need to calculate the # spacegroup number without the translation operators sg_new = sg.build_derived_group(True, False) space_group_number_primitive = sg_new.type().number() # also determine the best setting for the new cell ... symm = crystal.symmetry(unit_cell=cell, space_group=sg_new) rdx = symm.change_of_basis_op_to_best_cell() symm_new = symm.change_basis(rdx) cell_new = symm_new.unit_cell().parameters() return s2l(space_group_number_primitive), tuple(cell_new)
def __init__(self, filename): self.image = dxtbx.load(filename)
if (__name__ == "__main__"): files = [arg for arg in sys.argv[1:] if os.path.isfile(arg)] arguments = [libtbx.phil.parse(arg) for arg in sys.argv[1:] if not os.path.isfile(arg)] params = master_phil.fetch(sources=arguments).extract() rot45 = sqr((sin(pi/4.),-cos(pi/4.),cos(pi/4.),sin(pi/4.))) for file in files: message="""Based on the file %s, this program will compute incremental translations to circularize powder rings. The algorithm scores based on self-correlation upon 45-degree rotation. Increments are determined ON TOP OF beam center value in image header. Output is given in the form of delta to that value."""%file print message img = dxtbx.load(file) beam = img.get_beam() s0 = beam.get_s0() raw_data = img.get_raw_data() if not isinstance(raw_data, tuple): raw_data = (raw_data,) for panel_id, panel in enumerate(img.get_detector()): beam_center = col(panel.get_beam_centre_px(s0)) data = raw_data[panel_id] print "Assembling mask...",; sys.stdout.flush() mask = panel.get_trusted_range_mask(data) trusted_min = panel.get_trusted_range()[0]
import matplotlib.pyplot as plt def cost(params): x0, y0, r = params coords = draw.circle(y0, x0, r, shape=image.shape) template = np.zeros_like(image) template[coords] = mean_i print x0, y0, r return np.sum((template[coords] - image[coords])**2) if (__name__ == "__main__"): imgpath = sys.argv[1] img = dxtbx.load('mccd/E1_0_00006_106.mccd') raw_data = img.get_raw_data() image = raw_data.as_numpy_array() detector = img.get_detector() detector = detector[0] beam = img.get_beam() pixel_size = detector.get_pixel_size()[0] x0 = int(round(detector.get_beam_centre(beam.get_s0())[0] / pixel_size)) y0 = int(round(detector.get_beam_centre(beam.get_s0())[1] / pixel_size)) r = 1400 coords = draw.circle(y0, x0, r, shape=image.shape) mean_i = np.mean(image[coords]) print x0, y0, r, mean_i """ img = io.imread(imgpath)
def __init__(self): from dials.algorithms.spot_prediction import IndexGenerator from dials.algorithms.spot_prediction import ScanStaticRayPredictor from iotbx.xds import xparm, integrate_hkl from dials.util import ioutil from math import ceil import dxtbx from rstbx.cftbx.coordinate_frame_converter import \ coordinate_frame_converter from scitbx import matrix # The XDS files to read from integrate_filename = join(dials_regression, 'data/sim_mx/INTEGRATE.HKL') gxparm_filename = join(dials_regression, 'data/sim_mx/GXPARM.XDS') # Read the XDS files self.integrate_handle = integrate_hkl.reader() self.integrate_handle.read_file(integrate_filename) self.gxparm_handle = xparm.reader() self.gxparm_handle.read_file(gxparm_filename) # Get the parameters we need from the GXPARM file models = dxtbx.load(gxparm_filename) self.beam = models.get_beam() self.gonio = models.get_goniometer() self.detector = models.get_detector() self.scan = models.get_scan() # Get crystal parameters self.space_group_type = ioutil.get_space_group_type_from_xparm( self.gxparm_handle) cfc = coordinate_frame_converter(gxparm_filename) a_vec = cfc.get('real_space_a') b_vec = cfc.get('real_space_b') c_vec = cfc.get('real_space_c') self.unit_cell = cfc.get_unit_cell() self.ub_matrix = matrix.sqr(a_vec + b_vec + c_vec).inverse() # Get the minimum resolution in the integrate file d = [self.unit_cell.d(h) for h in self.integrate_handle.hkl] self.d_min = min(d) # extend the resolution shell by epsilon>0 # to account for rounding artifacts on 32-bit platforms self.d_min = self.d_min - 1e-15 # Get the number of frames from the max z value xcal, ycal, zcal = zip(*self.integrate_handle.xyzcal) self.scan.set_image_range((self.scan.get_image_range()[0], self.scan.get_image_range()[0] + int(ceil(max(zcal))))) # Print stuff # print self.beam # print self.gonio # print self.detector # print self.scan # Create the index generator self.generate_indices = IndexGenerator(self.unit_cell, self.space_group_type, self.d_min) s0 = self.beam.get_s0() m2 = self.gonio.get_rotation_axis() fixed_rotation = self.gonio.get_fixed_rotation() setting_rotation = self.gonio.get_setting_rotation() UB = self.ub_matrix dphi = self.scan.get_oscillation_range(deg=False) # Create the ray predictor self.predict_rays = ScanStaticRayPredictor(s0, m2, fixed_rotation, setting_rotation, dphi) # Predict the spot locations self.reflections = self.predict_rays( self.generate_indices.to_array(), UB)
def _index(self): """Actually do the autoindexing using the data prepared by the previous method.""" self._index_remove_masked_regions() if self._i_or_ii is None: self._i_or_ii = self.decide_i_or_ii() logger.debug("Selecting I or II, chose %s", self._i_or_ii) idxref = self.Idxref() for file in ["SPOT.XDS"]: idxref.set_input_data_file(file, self._indxr_payload[file]) # set the phi start etc correctly idxref.set_data_range(self._indxr_images[0][0], self._indxr_images[0][1]) idxref.set_background_range(self._indxr_images[0][0], self._indxr_images[0][1]) if self._i_or_ii == "i": blocks = self._index_select_images_i() for block in blocks[:1]: starting_frame = block[0] starting_angle = self.get_scan().get_angle_from_image_index( starting_frame) idxref.set_starting_frame(starting_frame) idxref.set_starting_angle(starting_angle) idxref.add_spot_range(block[0], block[1]) for block in blocks[1:]: idxref.add_spot_range(block[0], block[1]) else: for block in self._indxr_images[:1]: starting_frame = block[0] starting_angle = self.get_scan().get_angle_from_image_index( starting_frame) idxref.set_starting_frame(starting_frame) idxref.set_starting_angle(starting_angle) idxref.add_spot_range(block[0], block[1]) for block in self._indxr_images[1:]: idxref.add_spot_range(block[0], block[1]) # FIXME need to also be able to pass in the known unit # cell and lattice if already available e.g. from # the helper... indirectly if self._indxr_user_input_lattice: idxref.set_indexer_user_input_lattice(True) if self._indxr_input_lattice and self._indxr_input_cell: idxref.set_indexer_input_lattice(self._indxr_input_lattice) idxref.set_indexer_input_cell(self._indxr_input_cell) logger.debug("Set lattice: %s", self._indxr_input_lattice) logger.debug("Set cell: %f %f %f %f %f %f" % self._indxr_input_cell) original_cell = self._indxr_input_cell elif self._indxr_input_lattice: idxref.set_indexer_input_lattice(self._indxr_input_lattice) original_cell = None else: original_cell = None # FIXED need to set the beam centre here - this needs to come # from the input .xinfo object or header, and be converted # to the XDS frame... done. from dxtbx.serialize.xds import to_xds converter = to_xds(self.get_imageset()) xds_beam_centre = converter.detector_origin idxref.set_beam_centre(xds_beam_centre[0], xds_beam_centre[1]) # fixme need to check if the lattice, cell have been set already, # and if they have, pass these in as input to the indexing job. done = False while not done: try: done = idxref.run() # N.B. in here if the IDXREF step was being run in the first # pass done is FALSE however there should be a refined # P1 orientation matrix etc. available - so keep it! except XDSException as e: # inspect this - if we have complaints about not # enough reflections indexed, and we have a target # unit cell, and they are the same, well ignore it if "solution is inaccurate" in str(e): logger.debug( "XDS complains solution inaccurate - ignoring") done = idxref.continue_from_error() elif ("insufficient percentage (< 70%)" in str(e) or "insufficient percentage (< 50%)" in str(e)) and original_cell: done = idxref.continue_from_error() lattice, cell, mosaic = idxref.get_indexing_solution() # compare solutions check = PhilIndex.params.xia2.settings.xds_check_cell_deviation for j in range(3): # allow two percent variation in unit cell length if (math.fabs( (cell[j] - original_cell[j]) / original_cell[j]) > 0.02 and check): logger.debug("XDS unhappy and solution wrong") raise e # and two degree difference in angle if (math.fabs(cell[j + 3] - original_cell[j + 3]) > 2.0 and check): logger.debug("XDS unhappy and solution wrong") raise e logger.debug("XDS unhappy but solution ok") elif "insufficient percentage (< 70%)" in str( e) or "insufficient percentage (< 50%)" in str(e): logger.debug("XDS unhappy but solution probably ok") done = idxref.continue_from_error() else: raise e FileHandler.record_log_file( "%s INDEX" % self.get_indexer_full_name(), os.path.join(self.get_working_directory(), "IDXREF.LP"), ) for file in ["SPOT.XDS", "XPARM.XDS"]: self._indxr_payload[file] = idxref.get_output_data_file(file) # need to get the indexing solutions out somehow... self._indxr_other_lattice_cell = idxref.get_indexing_solutions() ( self._indxr_lattice, self._indxr_cell, self._indxr_mosaic, ) = idxref.get_indexing_solution() xparm_file = os.path.join(self.get_working_directory(), "XPARM.XDS") models = dxtbx.load(xparm_file) crystal_model = to_crystal(xparm_file) # this information gets lost when re-creating the models from the # XDS results - however is not refined so can simply copy from the # input - https://github.com/xia2/xia2/issues/372 models.get_detector()[0].set_thickness( converter.get_detector()[0].get_thickness()) experiment = Experiment( beam=models.get_beam(), detector=models.get_detector(), goniometer=models.get_goniometer(), scan=models.get_scan(), crystal=crystal_model, # imageset=self.get_imageset(), ) experiment_list = ExperimentList([experiment]) self.set_indexer_experiment_list(experiment_list) # I will want this later on to check that the lattice was ok self._idxref_subtree_problem = idxref.get_index_tree_problem()
def run_sim2smv(fileout): SIM = nanoBragg(detpixels_slowfast=(1000, 1000), pixel_size_mm=0.1, Ncells_abc=(5, 5, 5), verbose=9) import sys if len(sys.argv) > 2: SIM.seed = -int(sys.argv[2]) print "GOTHERE seed=", SIM.seed if len(sys.argv) > 1: if sys.argv[1] == "random": SIM.randomize_orientation() SIM.distance_mm = 100 #SIM = nanoBragg(detpixels_slowfast=(2527,2463),pixel_size_mm=0.172,Ncells_abc=(5,5,5),verbose=9) #SIM.distance_mm=200 # get same noise each time this test is run SIM.seed = 1 SIM.oversample = 1 SIM.wavelength_A = 1 SIM.polarization = 1 #SIM.unit_cell_tuple=(50,50,50,90,90,90) print "unit_cell_Adeg=", SIM.unit_cell_Adeg print "unit_cell_tuple=", SIM.unit_cell_tuple # this will become F000, marking the beam center SIM.default_F = 100 #SIM.missets_deg= (10,20,30) print "mosaic_seed=", SIM.mosaic_seed print "seed=", SIM.seed print "calib_seed=", SIM.calib_seed print "missets_deg =", SIM.missets_deg sfall = fcalc_from_pdb(resolution=1.6, algorithm="direct", wavelength=SIM.wavelength_A) # use crystal structure to initialize Fhkl array SIM.Fhkl = sfall # fastest option, least realistic SIM.xtal_shape = shapetype.Tophat # only really useful for long runs SIM.progress_meter = False # prints out value of one pixel only. will not render full image! #SIM.printout_pixel_fastslow=(500,500) #SIM.printout=True SIM.show_params() # flux is always in photons/s SIM.flux = 1e12 # assumes round beam SIM.beamsize_mm = 0.1 SIM.exposure_s = 0.1 temp = SIM.Ncells_abc print "Ncells_abc=", SIM.Ncells_abc SIM.Ncells_abc = temp print "Ncells_abc=", SIM.Ncells_abc print "xtal_size_mm=", SIM.xtal_size_mm print "unit_cell_Adeg=", SIM.unit_cell_Adeg print "unit_cell_tuple=", SIM.unit_cell_tuple print "missets_deg=", SIM.missets_deg print "Amatrix=", SIM.Amatrix print "beam_center_mm=", SIM.beam_center_mm print "XDS_ORGXY=", SIM.XDS_ORGXY print "detector_pivot=", SIM.detector_pivot print "xtal_shape=", SIM.xtal_shape print "beamcenter_convention=", SIM.beamcenter_convention print "fdet_vector=", SIM.fdet_vector print "sdet_vector=", SIM.sdet_vector print "odet_vector=", SIM.odet_vector print "beam_vector=", SIM.beam_vector print "polar_vector=", SIM.polar_vector print "spindle_axis=", SIM.spindle_axis print "twotheta_axis=", SIM.twotheta_axis print "distance_meters=", SIM.distance_meters print "distance_mm=", SIM.distance_mm print "close_distance_mm=", SIM.close_distance_mm print "detector_twotheta_deg=", SIM.detector_twotheta_deg print "detsize_fastslow_mm=", SIM.detsize_fastslow_mm print "detpixels_fastslow=", SIM.detpixels_fastslow print "detector_rot_deg=", SIM.detector_rot_deg print "curved_detector=", SIM.curved_detector print "pixel_size_mm=", SIM.pixel_size_mm print "point_pixel=", SIM.point_pixel print "polarization=", SIM.polarization print "nopolar=", SIM.nopolar print "oversample=", SIM.oversample print "region_of_interest=", SIM.region_of_interest print "wavelength_A=", SIM.wavelength_A print "energy_eV=", SIM.energy_eV print "fluence=", SIM.fluence print "flux=", SIM.flux print "exposure_s=", SIM.exposure_s print "beamsize_mm=", SIM.beamsize_mm print "dispersion_pct=", SIM.dispersion_pct print "dispsteps=", SIM.dispsteps print "divergence_hv_mrad=", SIM.divergence_hv_mrad print "divsteps_hv=", SIM.divsteps_hv print "divstep_hv_mrad=", SIM.divstep_hv_mrad print "round_div=", SIM.round_div print "phi_deg=", SIM.phi_deg print "osc_deg=", SIM.osc_deg print "phisteps=", SIM.phisteps print "phistep_deg=", SIM.phistep_deg print "detector_thick_mm=", SIM.detector_thick_mm print "detector_thicksteps=", SIM.detector_thicksteps print "detector_thickstep_mm=", SIM.detector_thickstep_mm print "mosaic_spread_deg=", SIM.mosaic_spread_deg print "mosaic_domains=", SIM.mosaic_domains print "indices=", SIM.indices print "amplitudes=", SIM.amplitudes print "Fhkl_tuple=", SIM.Fhkl_tuple print "default_F=", SIM.default_F print "interpolate=", SIM.interpolate print "integral_form=", SIM.integral_form # now actually burn up some CPU SIM.add_nanoBragg_spots() # simulated crystal is only 125 unit cells (25 nm wide) # amplify spot signal to simulate physical crystal of 4000x larger: 100 um (64e9 x the volume) SIM.raw_pixels *= 64e9 SIM.to_smv_format(fileout="intimage_001.img") # rough approximation to water: interpolation points for sin(theta/lambda) vs structure factor bg = flex.vec2_double([(0, 2.57), (0.0365, 2.58), (0.07, 2.8), (0.12, 5), (0.162, 8), (0.2, 6.75), (0.18, 7.32), (0.216, 6.75), (0.236, 6.5), (0.28, 4.5), (0.3, 4.3), (0.345, 4.36), (0.436, 3.77), (0.5, 3.17)]) SIM.Fbg_vs_stol = bg SIM.amorphous_sample_thick_mm = 0.1 SIM.amorphous_density_gcm3 = 1 SIM.amorphous_molecular_weight_Da = 18 SIM.flux = 1e12 SIM.beamsize_mm = 0.1 SIM.exposure_s = 0.1 SIM.add_background() SIM.to_smv_format(fileout="intimage_002.img") # rough approximation to air bg = flex.vec2_double([(0, 14.1), (0.045, 13.5), (0.174, 8.35), (0.35, 4.78), (0.5, 4.22)]) SIM.Fbg_vs_stol = bg SIM.amorphous_sample_thick_mm = 35 # between beamstop and collimator SIM.amorphous_density_gcm3 = 1.2e-3 SIM.amorphous_sample_molecular_weight_Da = 28 # nitrogen = N2 print "amorphous_sample_size_mm=", SIM.amorphous_sample_size_mm print "amorphous_sample_thick_mm=", SIM.amorphous_sample_thick_mm print "amorphous_density_gcm3=", SIM.amorphous_density_gcm3 print "amorphous_molecular_weight_Da=", SIM.amorphous_molecular_weight_Da SIM.add_background() # set this to 0 or -1 to trigger automatic radius. could be very slow with bright images SIM.detector_psf_kernel_radius_pixels = 5 SIM.detector_psf_fwhm_mm = 0.08 SIM.detector_psf_type = shapetype.Fiber #SIM.apply_psf() print SIM.raw_pixels[500000] SIM.to_smv_format(fileout="intimage_003.img") #SIM.detector_psf_fwhm_mm=0 print "quantum_gain=", SIM.quantum_gain print "adc_offset_adu=", SIM.adc_offset_adu print "detector_calibration_noise_pct=", SIM.detector_calibration_noise_pct print "flicker_noise_pct=", SIM.flicker_noise_pct print "readout_noise_adu=", SIM.readout_noise_adu print "detector_psf_type=", SIM.detector_psf_type print "detector_psf_fwhm_mm=", SIM.detector_psf_fwhm_mm print "detector_psf_kernel_radius_pixels=", SIM.detector_psf_kernel_radius_pixels SIM.add_noise() #fileout = "intimage_001.img" print "raw_pixels=", SIM.raw_pixels SIM.to_smv_format(fileout="noiseimage_001.img", intfile_scale=1) # try to write as CBF import dxtbx from dxtbx.format.FormatCBFMini import FormatCBFMini img = dxtbx.load("noiseimage_001.img") print img FormatCBFMini.as_file(detector=img.get_detector(), beam=img.get_beam(), gonio=img.get_goniometer(), scan=img.get_scan(), data=img.get_raw_data(), path=fileout) SIM.free_all()
to full reflection equivalents. Therefore it reports an absolute minimum number of images when the reality is almost certainly higher. """ # Set up dxtbx models, starting with a detector. Here we simulate # the gaps in a CSPAD by using a CSPAD CBF import dxtbx, libtbx.load_env, os img_root = libtbx.env.find_in_repositories("dials_regression") if img_root is not None: img_path = os.path.join(img_root, "spotfinding_test_data/idx-s00-20131106040304531.cbf") else: img_path = None if img_path is not None and os.path.exists(img_path): img = dxtbx.load(img_path) detector = img.get_detector() # Manually push the detector in to 100 mm h = detector.hierarchy() h.set_local_frame(h.get_fast_axis(), h.get_slow_axis(), (0, 0, -100)) else: # If dials_regression not present, use a simple detector with a single panel, similar to a CSPAD detector = detector_factory.simple("SENSOR_UNKNOWN", 100, (97.075, 97.075), "+x", "-y", (0.11, 0.11), (1765, 1765)) # Here's the MarCCD at XPP if desired. # detector=detector_factory.simple('SENSOR_UNKNOWN',150,(162.5,162.5),'+x','-y',(0.079346,0.079346),(4096,4096)) # Beam model wavelength = 1.32 # from Boutet 2012 beam = beam_factory.simple_directional((0, 0, 1), wavelength)
def run_sim2smv(prefix, crystal, spectra, rotation, rank, quick=False): local_data = data() smv_fileout = prefix + ".img" if quick is not True: if not write_safe(smv_fileout): print("File %s already exists, skipping in rank %d" % (smv_fileout, rank)) return direct_algo_res_limit = 1.7 wavlen, flux, wavelength_A = next( spectra) # list of lambdas, list of fluxes, average wavelength if quick: wavlen = flex.double([wavelength_A]) flux = flex.double([flex.sum(flux)]) print("Quick sim, lambda=%f, flux=%f" % (wavelength_A, flux[0])) GF = gen_fmodel(resolution=direct_algo_res_limit, pdb_text=local_data.get("pdb_lines"), algorithm="fft", wavelength=wavelength_A) GF.set_k_sol(0.435) GF.make_P1_primitive() sfall_main = GF.get_amplitudes() # use crystal structure to initialize Fhkl array sfall_main.show_summary(prefix="Amplitudes used ") N = crystal.number_of_cells(sfall_main.unit_cell()) #SIM = nanoBragg(detpixels_slowfast=(2000,2000),pixel_size_mm=0.11,Ncells_abc=(5,5,5),verbose=0) SIM = nanoBragg( detpixels_slowfast=(3000, 3000), pixel_size_mm=0.11, Ncells_abc=(N, N, N), # workaround for problem with wavelength array, specify it separately in constructor. wavelength_A=wavelength_A, verbose=0) SIM.adc_offset_adu = 0 # Do not offset by 40 SIM.adc_offset_adu = 10 # Do not offset by 40 import sys if len(sys.argv) > 2: SIM.seed = -int(sys.argv[2]) print("GOTHERE seed=", SIM.seed) if len(sys.argv) > 1: if sys.argv[1] == "random": SIM.randomize_orientation() SIM.mosaic_spread_deg = 0.05 # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = n_mosaic_domains # 77 seconds. With 100 energy points, 7700 seconds (2 hours) per image # 3000000 images would be 100000 hours on a 60-core machine (dials), or 11.4 years # using 2 nodes, 5.7 years. Do this at SLAC? NERSC? combination of all? # SLAC downtimes: Tues Dec 5 (24 hrs), Mon Dec 11 (72 hrs), Mon Dec 18 light use, 24 days # mosaic_domains setter must come after mosaic_spread_deg setter SIM.distance_mm = 141.7 UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister(seed=0) scitbx.random.set_random_seed(1234) rand_norm = scitbx.random.normal_distribution(mean=0, sigma=SIM.mosaic_spread_deg * math.pi / 180.) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(SIM.mosaic_domains) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) UMAT_nm.append(site.axis_and_angle_as_r3_rotation_matrix(m, deg=False)) SIM.set_mosaic_blocks(UMAT_nm) #SIM.detector_thick_mm = 0.5 # = 0 for Rayonix #SIM.detector_thicksteps = 1 # should default to 1 for Rayonix, but set to 5 for CSPAD #SIM.detector_attenuation_length_mm = default is silicon # get same noise each time this test is run SIM.seed = 1 SIM.oversample = 1 SIM.wavelength_A = wavelength_A SIM.polarization = 1 # this will become F000, marking the beam center SIM.default_F = 0 #SIM.missets_deg= (10,20,30) print("mosaic_seed=", SIM.mosaic_seed) print("seed=", SIM.seed) print("calib_seed=", SIM.calib_seed) print("missets_deg =", SIM.missets_deg) SIM.Fhkl = sfall_main print("Determinant", rotation.determinant()) Amatrix_rot = ( rotation * sqr(sfall_main.unit_cell().orthogonalization_matrix())).transpose() print("RAND_ORI", prefix, end=' ') for i in Amatrix_rot: print(i, end=' ') print() SIM.Amatrix_RUB = Amatrix_rot #workaround for failing init_cell, use custom written Amatrix setter print("unit_cell_Adeg=", SIM.unit_cell_Adeg) print("unit_cell_tuple=", SIM.unit_cell_tuple) Amat = sqr(SIM.Amatrix).transpose() # recovered Amatrix from SIM from cctbx import crystal_orientation Ori = crystal_orientation.crystal_orientation( Amat, crystal_orientation.basis_type.reciprocal) print("Python unit cell from SIM state", Ori.unit_cell()) # fastest option, least realistic #SIM.xtal_shape=shapetype.Tophat # RLP = hard sphere #SIM.xtal_shape=shapetype.Square # gives fringes SIM.xtal_shape = shapetype.Gauss # both crystal & RLP are Gaussian #SIM.xtal_shape=shapetype.Round # Crystal is a hard sphere # only really useful for long runs SIM.progress_meter = False # prints out value of one pixel only. will not render full image! #SIM.printout_pixel_fastslow=(500,500) #SIM.printout=True SIM.show_params() # flux is always in photons/s SIM.flux = 1e12 SIM.exposure_s = 1.0 # so total fluence is e12 # assumes round beam SIM.beamsize_mm = 0.003 #cannot make this 3 microns; spots are too intense temp = SIM.Ncells_abc print("Ncells_abc=", SIM.Ncells_abc) SIM.Ncells_abc = temp print("Ncells_abc=", SIM.Ncells_abc) print("xtal_size_mm=", SIM.xtal_size_mm) print("unit_cell_Adeg=", SIM.unit_cell_Adeg) print("unit_cell_tuple=", SIM.unit_cell_tuple) print("missets_deg=", SIM.missets_deg) print("Amatrix=", SIM.Amatrix) print("beam_center_mm=", SIM.beam_center_mm) print("XDS_ORGXY=", SIM.XDS_ORGXY) print("detector_pivot=", SIM.detector_pivot) print("xtal_shape=", SIM.xtal_shape) print("beamcenter_convention=", SIM.beamcenter_convention) print("fdet_vector=", SIM.fdet_vector) print("sdet_vector=", SIM.sdet_vector) print("odet_vector=", SIM.odet_vector) print("beam_vector=", SIM.beam_vector) print("polar_vector=", SIM.polar_vector) print("spindle_axis=", SIM.spindle_axis) print("twotheta_axis=", SIM.twotheta_axis) print("distance_meters=", SIM.distance_meters) print("distance_mm=", SIM.distance_mm) print("close_distance_mm=", SIM.close_distance_mm) print("detector_twotheta_deg=", SIM.detector_twotheta_deg) print("detsize_fastslow_mm=", SIM.detsize_fastslow_mm) print("detpixels_fastslow=", SIM.detpixels_fastslow) print("detector_rot_deg=", SIM.detector_rot_deg) print("curved_detector=", SIM.curved_detector) print("pixel_size_mm=", SIM.pixel_size_mm) print("point_pixel=", SIM.point_pixel) print("polarization=", SIM.polarization) print("nopolar=", SIM.nopolar) print("oversample=", SIM.oversample) print("region_of_interest=", SIM.region_of_interest) print("wavelength_A=", SIM.wavelength_A) print("energy_eV=", SIM.energy_eV) print("fluence=", SIM.fluence) print("flux=", SIM.flux) print("exposure_s=", SIM.exposure_s) print("beamsize_mm=", SIM.beamsize_mm) print("dispersion_pct=", SIM.dispersion_pct) print("dispsteps=", SIM.dispsteps) print("divergence_hv_mrad=", SIM.divergence_hv_mrad) print("divsteps_hv=", SIM.divsteps_hv) print("divstep_hv_mrad=", SIM.divstep_hv_mrad) print("round_div=", SIM.round_div) print("phi_deg=", SIM.phi_deg) print("osc_deg=", SIM.osc_deg) print("phisteps=", SIM.phisteps) print("phistep_deg=", SIM.phistep_deg) print("detector_thick_mm=", SIM.detector_thick_mm) print("detector_thicksteps=", SIM.detector_thicksteps) print("detector_thickstep_mm=", SIM.detector_thickstep_mm) print("***mosaic_spread_deg=", SIM.mosaic_spread_deg) print("***mosaic_domains=", SIM.mosaic_domains) print("indices=", SIM.indices) print("amplitudes=", SIM.amplitudes) print("Fhkl_tuple=", SIM.Fhkl_tuple) print("default_F=", SIM.default_F) print("interpolate=", SIM.interpolate) print("integral_form=", SIM.integral_form) from libtbx.development.timers import Profiler P = Profiler("nanoBragg") # now actually burn up some CPU #SIM.add_nanoBragg_spots() del P # simulated crystal is only 125 unit cells (25 nm wide) # amplify spot signal to simulate physical crystal of 4000x larger: 100 um (64e9 x the volume) print(crystal.domains_per_crystal) SIM.raw_pixels *= crystal.domains_per_crystal # must calculate the correct scale! # Use single wavelength for all energy channels for the purpose of Fcalc wavelength_hi_remote = wavlen[-1] GF.reset_wavelength(wavelength_hi_remote) GF.reset_specific_at_wavelength(label_has="FE1", tables=local_data.get("Fe_oxidized_model"), newvalue=wavelength_hi_remote) GF.reset_specific_at_wavelength(label_has="FE2", tables=local_data.get("Fe_reduced_model"), newvalue=wavelength_hi_remote) sfall_channel = GF.get_amplitudes() # sources channel_source_XYZ = flex.vec3_double(len(flux), SIM.xray_source_XYZ[0]) CP = channel_pixels( wavlen, flux, channel_source_XYZ) # class interface for multi-wavelength print("+++++++++++++++++++++++++++++++++++++++ Multiwavelength call") CH = CP(N=N, UMAT_nm=UMAT_nm, Amatrix_rot=Amatrix_rot, sfall_channel=sfall_channel) SIM.raw_pixels += CH.raw_pixels * crystal.domains_per_crystal CH.free_all() if quick: SIM.to_smv_format(fileout=prefix + "_intimage_001.img") # rough approximation to water: interpolation points for sin(theta/lambda) vs structure factor bg = flex.vec2_double([(0, 2.57), (0.0365, 2.58), (0.07, 2.8), (0.12, 5), (0.162, 8), (0.2, 6.75), (0.18, 7.32), (0.216, 6.75), (0.236, 6.5), (0.28, 4.5), (0.3, 4.3), (0.345, 4.36), (0.436, 3.77), (0.5, 3.17)]) SIM.Fbg_vs_stol = bg SIM.amorphous_sample_thick_mm = 0.1 SIM.amorphous_density_gcm3 = 1 SIM.amorphous_molecular_weight_Da = 18 SIM.flux = 1e12 SIM.beamsize_mm = 0.003 # square (not user specified) SIM.exposure_s = 1.0 # multiplies flux x exposure SIM.add_background() if quick: SIM.to_smv_format(fileout=prefix + "_intimage_002.img") # rough approximation to air bg = flex.vec2_double([(0, 14.1), (0.045, 13.5), (0.174, 8.35), (0.35, 4.78), (0.5, 4.22)]) SIM.Fbg_vs_stol = bg #SIM.amorphous_sample_thick_mm = 35 # between beamstop and collimator SIM.amorphous_sample_thick_mm = 10 # between beamstop and collimator SIM.amorphous_density_gcm3 = 1.2e-3 SIM.amorphous_sample_molecular_weight_Da = 28 # nitrogen = N2 print("amorphous_sample_size_mm=", SIM.amorphous_sample_size_mm) print("amorphous_sample_thick_mm=", SIM.amorphous_sample_thick_mm) print("amorphous_density_gcm3=", SIM.amorphous_density_gcm3) print("amorphous_molecular_weight_Da=", SIM.amorphous_molecular_weight_Da) SIM.add_background() #apply beamstop mask here # set this to 0 or -1 to trigger automatic radius. could be very slow with bright images # settings for CCD SIM.detector_psf_kernel_radius_pixels = 5 #SIM.detector_psf_fwhm_mm=0.08; #SIM.detector_psf_type=shapetype.Fiber # rayonix=Fiber, CSPAD=None (or small Gaussian) SIM.detector_psf_type = shapetype.Unknown # for CSPAD SIM.detector_psf_fwhm_mm = 0 #SIM.apply_psf() print("One pixel-->", SIM.raw_pixels[500000]) # at this point we scale the raw pixels so that the output array is on an scale from 0 to 50000. # that is the default behavior (intfile_scale<=0), otherwise it applies intfile_scale as a multiplier on an abs scale. if quick: SIM.to_smv_format(fileout=prefix + "_intimage_003.img") print("quantum_gain=", SIM.quantum_gain) #defaults to 1. converts photons to ADU print("adc_offset_adu=", SIM.adc_offset_adu) print("detector_calibration_noise_pct=", SIM.detector_calibration_noise_pct) print("flicker_noise_pct=", SIM.flicker_noise_pct) print("readout_noise_adu=", SIM.readout_noise_adu ) # gaussian random number to add to every pixel (0 for PAD) # apply Poissonion correction, then scale to ADU, then adc_offset. # should be 10 for most Rayonix, Pilatus should be 0, CSPAD should be 0. print("detector_psf_type=", SIM.detector_psf_type) print("detector_psf_fwhm_mm=", SIM.detector_psf_fwhm_mm) print("detector_psf_kernel_radius_pixels=", SIM.detector_psf_kernel_radius_pixels) SIM.add_noise() #converts phtons to ADU. print("raw_pixels=", SIM.raw_pixels) extra = "PREFIX=%s;\nRANK=%d;\n" % (prefix, rank) SIM.to_smv_format_py(fileout=smv_fileout, intfile_scale=1, rotmat=True, extra=extra, gz=True) # try to write as CBF if False: import dxtbx from dxtbx.format.FormatCBFMiniPilatus import FormatCBFMiniPilatus img = dxtbx.load(prefix + ".img") print(img) FormatCBFMiniPilatus.as_file(detector=img.get_detector(), beam=img.get_beam(), gonio=img.get_goniometer(), scan=img.get_scan(), data=img.get_raw_data(), path=prefix + ".cbf") SIM.free_all()
def run (args, image = None): from xfel import radial_average from scitbx.array_family import flex import os, sys import dxtbx # Parse input try: n = len(args) except Exception: params = args else: user_phil = [] for arg in args: if (not "=" in arg): try : user_phil.append(libtbx.phil.parse("""file_path=%s""" % arg)) except ValueError: raise Sorry("Unrecognized argument '%s'" % arg) else: try: user_phil.append(libtbx.phil.parse(arg)) except RuntimeError as e: raise Sorry("Unrecognized argument '%s' (error: %s)" % (arg, str(e))) params = master_phil.fetch(sources=user_phil).extract() if image is None: if params.file_path is None or len(params.file_path) == 0 or not all([os.path.isfile(f) for f in params.file_path]): master_phil.show() raise Usage("file_path must be defined (either file_path=XXX, or the path alone).") assert params.n_bins is not None assert params.verbose is not None assert params.output_bins is not None # Allow writing to a file instead of stdout if params.output_file is None: logger = sys.stdout else: logger = open(params.output_file, 'w') logger.write("%s "%params.output_file) if params.show_plots: from matplotlib import pyplot as plt import numpy as np colormap = plt.cm.gist_ncar plt.gca().set_color_cycle([colormap(i) for i in np.linspace(0, 0.9, len(params.file_path))]) if params.mask is not None: params.mask = easy_pickle.load(params.mask) if image is None: iterable = params.file_path load_func = lambda x: dxtbx.load(x) else: iterable = [image] load_func = lambda x: x # Iterate over each file provided for item in iterable: img = load_func(item) try: n_images = img.get_num_images() subiterable = xrange(n_images) except AttributeError: n_images = None subiterable = [0] for image_number in subiterable: if n_images is None: beam = img.get_beam() detector = img.get_detector() else: beam = img.get_beam(image_number) detector = img.get_detector(image_number) s0 = col(beam.get_s0()) # Search the detector for the panel farthest from the beam. The number of bins in the radial average will be # equal to the farthest point from the beam on the detector, in pixels, unless overridden at the command line panel_res = [p.get_max_resolution_at_corners(s0) for p in detector] farthest_panel = detector[panel_res.index(min(panel_res))] size2, size1 = farthest_panel.get_image_size() corners = [(0,0), (size1-1,0), (0,size2-1), (size1-1,size2-1)] corners_lab = [col(farthest_panel.get_pixel_lab_coord(c)) for c in corners] corner_two_thetas = [farthest_panel.get_two_theta_at_pixel(s0, c) for c in corners] extent_two_theta = max(corner_two_thetas) max_corner = corners_lab[corner_two_thetas.index(extent_two_theta)] extent = int(math.ceil(max_corner.length()*math.sin(extent_two_theta)/max(farthest_panel.get_pixel_size()))) extent_two_theta *= 180/math.pi if params.n_bins < extent: params.n_bins = extent # These arrays will store the radial average info sums = flex.double(params.n_bins) * 0 sums_sq = flex.double(params.n_bins) * 0 counts = flex.int(params.n_bins) * 0 if n_images is None: all_data = img.get_raw_data() else: all_data = img.get_raw_data(image_number) if not isinstance(all_data, tuple): all_data = (all_data,) for tile, (panel, data) in enumerate(zip(detector, all_data)): if params.mask is None: mask = flex.bool(flex.grid(data.focus()), True) else: mask = params.mask[tile] if hasattr(data,"as_double"): data = data.as_double() logger.flush() if params.verbose: logger.write("Average intensity tile %d: %9.3f\n"%(tile, flex.mean(data))) logger.write("N bins: %d\n"%params.n_bins) logger.flush() x1,y1,x2,y2 = 0,0,panel.get_image_size()[1],panel.get_image_size()[0] bc = panel.get_beam_centre_px(beam.get_s0()) bc = int(round(bc[1])), int(round(bc[0])) # compute the average radial_average(data,mask,bc,sums,sums_sq,counts,panel.get_pixel_size()[0],panel.get_distance(), (x1,y1),(x2,y2)) # average the results, avoiding division by zero results = sums.set_selected(counts <= 0, 0) results /= counts.set_selected(counts <= 0, 1).as_double() if params.median_filter_size is not None: logger.write("WARNING, the median filter is not fully propogated to the variances\n") from scipy.ndimage.filters import median_filter results = flex.double(median_filter(results.as_numpy_array(), size = params.median_filter_size)) # calculate standard devations stddev_sel = ((sums_sq-sums*results) >= 0) & (counts > 0) std_devs = flex.double(len(sums), 0) std_devs.set_selected(stddev_sel, (sums_sq.select(stddev_sel)-sums.select(stddev_sel)* \ results.select(stddev_sel))/counts.select(stddev_sel).as_double()) std_devs = flex.sqrt(std_devs) twotheta = flex.double(xrange(len(results)))*extent_two_theta/params.n_bins q_vals = 4*math.pi*flex.sin(math.pi*twotheta/360)/beam.get_wavelength() if params.low_max_two_theta_limit is None: subset = results else: subset = results.select(twotheta >= params.low_max_two_theta_limit) max_result = flex.max(subset) if params.x_axis == 'two_theta': xvals = twotheta max_x = twotheta[flex.first_index(results, max_result)] elif params.x_axis == 'q': xvals = q_vals max_x = q_vals[flex.first_index(results, max_result)] for i in xrange(len(results)): val = xvals[i] if params.output_bins and "%.3f"%results[i] != "nan": #logger.write("%9.3f %9.3f\n"% (val,results[i])) #.xy format for Rex.cell. logger.write("%9.3f %9.3f %9.3f\n"%(val,results[i],std_devs[i])) #.xye format for GSASII #logger.write("%.3f %.3f %.3f\n"%(val,results[i],ds[i])) # include calculated d spacings logger.write("Maximum %s: %f, value: %f\n"%(params.x_axis, max_x, max_result)) if params.show_plots: if params.plot_x_max is not None: results = results.select(xvals <= params.plot_x_max) xvals = xvals.select(xvals <= params.plot_x_max) if params.normalize: plt.plot(xvals.as_numpy_array(),(results/flex.max(results)).as_numpy_array(),'-') else: plt.plot(xvals.as_numpy_array(),results.as_numpy_array(),'-') if params.x_axis == 'two_theta': plt.xlabel("2 theta") elif params.x_axis == 'q': plt.xlabel("q") plt.ylabel("Avg ADUs") if params.plot_y_max is not None: plt.ylim(0, params.plot_y_max) if params.show_plots: #plt.legend([os.path.basename(os.path.splitext(f)[0]) for f in params.file_path], ncol=2) plt.show() return xvals, results
from cxid9114 import utils MIN_SPOT_PER_HIT = 30 output_dir = "." pickle_fname = sys.argv[1] image_fname = sys.argv[2] output_tag = sys.argv[3] print('Loading reflections') with open(pickle_fname, 'r') as f: found_refl = cPickle.load(f) refl_select = count_spots.ReflectionSelect(found_refl) print('Loading format') loader = dxtbx.load(image_fname) imgset = loader.get_imageset(loader.get_image_file()) print('Counting spots') idx, Nspot_at_idx = count_spots.count_spots(pickle_fname) where_hits = np.where(Nspot_at_idx > MIN_SPOT_PER_HIT)[0] Nhits = where_hits.shape[0] # ============ output_h5_name = os.path.join( output_dir, "run%d_hits_%s.h5" % (loader.run_number, output_tag)) with h5py.File(output_h5_name, "w") as out_h5: out_h5.create_dataset("panel_masks", data=loader.cspad_mask, dtype=np.bool) out_h5.create_dataset("panel_gainmasks", data=loader.gain)