def onRun(self, e):
# Run full processing
self.init_settings()
if self.sanity_check():
prime_phil = master_phil.format(python_object=self.pparams)
with misc.Capturing() as output:
prime_phil.show()
txt_out = ''
for one_output in output:
txt_out += one_output + '\n'
source_dir = os.path.dirname(self.out_dir)
prime_file = os.path.join(source_dir, self.prime_filename)
out_file = os.path.join(self.out_dir, 'stdout.log')
with open(prime_file, 'w') as pf:
pf.write(txt_out)
self.prime_run_window = frm.PRIMERunWindow(self, -1,
title='PRIME Output',
params=self.pparams,
prime_file=prime_file)
self.prime_run_window.prev_pids = easy_run.fully_buffered('pgrep -u {} {}'
''.format(user, python)).stdout_lines
self.prime_run_window.Show(True)
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 __init__(self,
source_image,
object_folder,
final_folder,
final_filename,
final,
logfile,
gain=0.32,
params=None):
'''Initialise the script.'''
from dxtbx.datablock import DataBlockFactory
self.params = params
# Read settings from the DIALS target (.phil) file
# If none is provided, use default settings (and may God have mercy)
if self.params.dials.target != None:
with open(self.params.dials.target, 'r') as settings_file:
settings_file_contents = settings_file.read()
settings = parse(settings_file_contents)
current_phil = phil_scope.fetch(sources=[settings])
self.phil = current_phil.extract()
else:
self.phil = phil_scope.extract()
# Set general file-handling settings
file_basename = os.path.basename(source_image).split('.')[0]
self.phil.output.datablock_filename = "{}/{}.json".format(
object_folder, file_basename)
self.phil.output.indexed_filename = "{}/{}_indexed.pickle".format(
object_folder, file_basename)
self.phil.output.strong_filename = "{}/{}_strong.pickle".format(
object_folder, file_basename)
self.phil.output.refined_experiments_filename = "{}/{}_refined_experiments.json".format(
object_folder, file_basename)
self.phil.output.integrated_filename = "{}/{}_integrated.pickle".format(
object_folder, file_basename)
self.phil.output.profile_filename = "{}/{}_profile.phil".format(
object_folder, file_basename)
self.phil.output.integration_pickle = final_filename
self.int_log = logfile #"{}/int_{}.log".format(final_folder, file_basename)
self.img = [source_image]
self.obj_base = object_folder
self.gain = gain
self.fail = None
self.frame = None
self.final = final
self.final['final'] = final_filename
with misc.Capturing() as junk_output:
self.datablock = DataBlockFactory.from_filenames(self.img)[0]
self.obj_filename = "int_{}".format(os.path.basename(self.img[0]))
def regenerate_params(self, phil=None):
if phil is not None:
current_phil = master_phil.format(python_object=phil)
else:
current_phil = master_phil
# Generate Python object and text of parameters
self.pparams = current_phil.extract()
with misc.Capturing() as txt_output:
current_phil.show()
self.phil_string = ''
for one_output in txt_output:
self.phil_string += one_output + '\n'
def reset_settings(self):
self.pparams = master_phil.extract()
self.input_window.inp_box.delete_all()
self.input_window.out_box.reset_default()
self.input_window.project_title.reset_default()
self.input_window.opt_chk_useref.SetValue(False)
self.input_window.opt_spc_nproc.reset_default()
self.input_window.opt_spc_nres.reset_default()
# Generate Python object and text of parameters
with misc.Capturing() as txt_output:
master_phil.show()
self.phil_string = ''
for one_output in txt_output:
self.phil_string += one_output + '\n'
def onOutputScript(self, e):
# Determine param filepath
save_dlg = wx.FileDialog(self,
message="Save IOTA Script",
defaultDir=os.curdir,
defaultFile="*.param",
wildcard="*",
style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
if save_dlg.ShowModal() == wx.ID_OK:
script_filepath = save_dlg.GetPath()
# Finalize settings
self.init_settings()
self.gparams = self.iota_phil.extract()
# Save target PHIL file, if a PHIL script exists
if self.target_phil is not None:
if self.gparams.advanced.integrate_with == 'cctbx':
phil_filepath = os.path.join(
os.path.dirname(script_filepath), 'cctbx.phil')
self.gparams.cctbx.target = phil_filepath
if self.gparams.advanced.integrate_with == 'dials':
phil_filepath = os.path.join(
os.path.dirname(script_filepath), 'dials.phil')
self.gparams.dials.target = phil_filepath
# Generate text of params
final_phil = self.iota_phil.format(python_object=self.gparams)
test_params = final_phil.extract()
with misc.Capturing() as txt_output:
final_phil.show()
txt_out = ''
for one_output in txt_output:
txt_out += one_output + '\n'
# Save files
with open(script_filepath, 'w') as param_file:
param_file.write(txt_out)
if self.target_phil is not None:
with open(phil_filepath, 'w') as phil_file:
phil_file.write(self.target_phil)
def run_distl(self, params):
""" Performs a quick DISTL spotfinding and returns Bragg spots information.
"""
from spotfinder.applications import signal_strength
# run DISTL spotfinder
with misc.Capturing() as distl_output:
Org = signal_strength.run_signal_strength(params)
# Extract relevant spotfinding info
for frame in Org.S.images.keys():
saturation = Org.Files.imageindex(frame).saturation
Bragg_spots = [
flex.sum(spot.wts)
for spot in Org.S.images[frame]['inlier_spots']
]
return Bragg_spots
def __init__(self, img, gain, params, center_intensity=0):
""" Initialization and data read-in
"""
self.gain = gain
self.params = params
# Read settings from the DIALS target (.phil) file
# If none is provided, use default settings (and may God have mercy)
if self.params.dials.target != None:
with open(self.params.dials.target, 'r') as settings_file:
settings_file_contents = settings_file.read()
settings = parse(settings_file_contents)
current_phil = phil_scope.fetch(sources=[settings])
self.phil = current_phil.extract()
else:
self.phil = phil_scope.extract()
# Modify settings
self.phil.output.strong_filename = None
self.processor = IOTADialsProcessor(params=self.phil)
# Set customized parameters
beamX = self.params.image_conversion.beam_center.x
beamY = self.params.image_conversion.beam_center.y
if beamX != 0 or beamY != 0:
self.phil.geometry.detector.slow_fast_beam_centre = '{} {}'.format(
beamY, beamX)
if self.params.image_conversion.distance != 0:
self.phil.geometry.detector.distance = self.params.image_conversion.distance
if self.params.advanced.estimate_gain:
self.phil.spotfinder.threshold.dispersion.gain = gain
if self.params.image_conversion.mask is not None:
self.phil.spotfinder.lookup.mask = self.params.image_conversion.mask
self.phil.integration.lookup.mask = self.params.image_conversion.mask
if self.params.dials.auto_threshold:
threshold = int(center_intensity)
self.phil.spotfinder.threshold.dispersion.global_threshold = threshold
# Convert raw image into single-image datablock
with misc.Capturing() as junk_output:
self.datablock = DataBlockFactory.from_filenames([img])[0]
def cluster_unit_cells(self):
input = []
for item in self.spotfinding_info:
if item[4] is not None:
try:
info_line = [float(i) for i in item[4]]
info_line.append(item[3])
input.append(info_line)
except ValueError:
pass
with misc.Capturing() as junk_output:
try:
ucs = Cluster.from_iterable(iterable=input)
clusters, _ = ucs.ab_cluster(5000,
log=False,
write_file_lists=False,
schnell=True,
doplot=False)
except Exception, e:
clusters = []
def run(self):
log_entry = ['\n']
with misc.Capturing() as output:
e = None
try:
print "{:-^100}\n".format(" SPOTFINDING: ")
self.find_spots()
print "{:-^100}\n\n".format(" FOUND {} SPOTS: ".format(
len(self.observed)))
except Exception, e:
if hasattr(e, "classname"):
print e.classname, "for %s:" % self.img[0],
error_message = "{}: {}".format(
e.classname, e[0].replace('\n', ' ')[:50])
else:
print "Spotfinding error for %s:" % self.img[0],
error_message = "{}".format(str(e).replace('\n', ' ')[:50])
print e
self.fail = 'failed spotfinding'
if self.fail == None:
try:
print "{:-^100}\n".format(" INDEXING: ")
self.index()
print "{:-^100}\n\n".format(
" USED {} INDEXED REFLECTIONS: ".format(
len(self.indexed)))
except Exception, e:
if hasattr(e, "classname"):
print e.classname, "for %s:" % self.img[0],
error_message = "{}: {}".format(
e.classname, e[0].replace('\n', ' ')[:50])
else:
print "Indexing error for %s:" % self.img[0],
error_message = "{}".format(
str(e).replace('\n', ' ')[:50])
print e
self.fail = 'failed indexing'
def __init__(self, img, gain, params):
""" Initialization and data read-in
"""
from dxtbx.datablock import DataBlockFactory
self.gain = gain
self.params = params
# Read settings from the DIALS target (.phil) file
# If none is provided, use default settings (and may God have mercy)
if self.params.dials.target != None:
with open(self.params.dials.target, 'r') as settings_file:
settings_file_contents = settings_file.read()
settings = parse(settings_file_contents)
current_phil = phil_scope.fetch(sources=[settings])
self.phil = current_phil.extract()
else:
self.phil = phil_scope.extract()
# Convert raw image into single-image datablock
with misc.Capturing() as junk_output:
self.datablock = DataBlockFactory.from_filenames([img])[0]
def onSaveScript(self, e):
self.init_settings()
# Generate text of params
final_phil = master_phil.format(python_object=self.pparams)
with misc.Capturing() as txt_output:
final_phil.show()
txt_out = ''
for one_output in txt_output:
txt_out += one_output + '\n'
# Save param file
save_dlg = wx.FileDialog(self,
message="Save PRIME Script",
defaultDir=os.curdir,
defaultFile="*.phil",
wildcard="*.phil",
style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
if save_dlg.ShowModal() == wx.ID_OK:
with open(save_dlg.GetPath(), 'w') as savefile:
savefile.write(txt_out)
save_dlg.Destroy()
class SingleImage(object):
def __init__(self, img, init, verbose=True, imported_grid=None):
""" Constructor for the SingleImage object using a raw image file or pickle
"""
# Initialize parameters
self.params = init.params
self.args = init.args
self.user_id = init.user_id
self.raw_img = img[2]
self.conv_img = img[2]
self.img_index = img[0]
self.center_int = 0
self.status = None
self.fail = None
self.final = None
self.log_info = []
self.gs_results = []
self.main_log = init.logfile
self.verbose = verbose
self.hmed = self.params.cctbx.grid_search.height_median
self.amed = self.params.cctbx.grid_search.area_median
self.input_base = init.input_base
self.conv_base = init.conv_base
self.int_base = init.int_base
self.obj_base = init.obj_base
self.fin_base = init.fin_base
self.viz_base = init.viz_base
self.log_base = init.log_base
self.tmp_base = init.tmp_base
self.abort_file = os.path.join(self.int_base, '.abort.tmp')
self.obj_path = None
self.obj_file = None
self.fin_path = None
self.fin_file = None
self.viz_path = None
# ============================== SELECTION-ONLY FUNCTIONS ============================== #
def import_int_file(self, init):
""" Replaces path settings in imported image object with new settings
NEED TO RE-DO LATER """
if os.path.isfile(self.abort_file):
self.fail = 'aborted'
return self
# Generate paths to output files
self.params = init.params
self.main_log = init.logfile
self.input_base = init.input_base
self.conv_base = init.conv_base
self.int_base = init.int_base
self.obj_base = init.obj_base
self.fin_base = init.fin_base
self.log_base = init.log_base
self.viz_base = init.viz_base
self.obj_path = misc.make_image_path(self.conv_img, self.input_base,
self.obj_base)
self.obj_file = os.path.abspath(
os.path.join(
self.obj_path,
os.path.basename(self.conv_img).split('.')[0] + ".int"))
self.fin_path = misc.make_image_path(self.conv_img, self.input_base,
self.fin_base)
self.log_path = misc.make_image_path(self.conv_img, self.input_base,
self.log_base)
self.fin_file = os.path.abspath(
os.path.join(
self.fin_path,
os.path.basename(self.conv_img).split('.')[0] + "_int.pickle"))
self.final['final'] = self.fin_file
self.final['img'] = self.conv_img
self.viz_path = misc.make_image_path(self.conv_img, self.input_base,
self.viz_base)
self.viz_file = os.path.join(
self.viz_path,
os.path.basename(self.conv_img).split('.')[0] + "_int.png")
# Create actual folders (if necessary)
try:
if not os.path.isdir(self.obj_path):
os.makedirs(self.obj_path)
if not os.path.isdir(self.fin_path):
os.makedirs(self.fin_path)
if not os.path.isdir(self.viz_path):
os.makedirs(self.viz_path)
except OSError:
pass
# Grid search / integration log file
self.int_log = os.path.join(
self.log_path,
os.path.basename(self.conv_img).split('.')[0] + '.tmp')
# Reset status to 'grid search' to pick up at selection (if no fail)
if self.fail == None:
self.status = 'bypass grid search'
return self
def determine_gs_result_file(self):
""" For 'selection-only' cctbx.xfel runs, determine where the image objects are """
if self.params.cctbx.selection.select_only.grid_search_path != None:
obj_path = os.path.abspath(
self.params.cctbx.selection.select_only.grid_search_path)
else:
run_number = int(os.path.basename(self.int_base)) - 1
obj_path = "{}/integration/{:03d}/image_objects"\
"".format(os.path.abspath(os.curdir), run_number)
gs_result_file = os.path.join(obj_path,
os.path.basename(self.obj_file))
return gs_result_file
# =============================== IMAGE IMPORT FUNCTIONS =============================== #
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 Exception, e:
print 'IOTA IMPORT ERROR:', e
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
img_type = 'pickle'
else:
img_type = 'raw'
msec, sec = math.modf(scan.get_epochs()[0])
timestamp = evt_timestamp((sec, msec))
# 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)
if scan is not None:
osc_start, osc_range = scan.get_oscillation()
if osc_start != osc_range:
data['OSC_START'] = 0 #osc_start
data['OSC_RANGE'] = 0 #osc_start
data['TIME'] = scan.get_exposure_times()[0]
else:
data = None
img_type = 'not imported'
# 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:
from dxtbx.datablock import DataBlockFactory
from dials.command_line.estimate_gain import estimate_gain
with misc.Capturing() as junk_output:
try:
datablock = DataBlockFactory.from_filenames([self.raw_img
])[0]
imageset = datablock.extract_imagesets()[0]
self.gain = estimate_gain(imageset)
except Exception, e:
self.gain = 1.0
def generate_phil_string(self, current_phil):
with misc.Capturing() as txt_output:
current_phil.show()
self.phil_string = ''
for one_output in txt_output:
self.phil_string += one_output + '\n'
def run(self, gparams, target_phil=None, list_file=None):
''' Run initialization for IOTA GUI
gparams = IOTA parameters from the GUI elements in PHIL format
gtxt = text version of gparams
list_file = if "Write Input List" button pressed, specifies name
of list file
'''
self.params = gparams
self.target_phil = target_phil
# If input list for some reason isn't transmitted from main window, make it
if self.input_list is None:
self.input_list = self.make_input_list()
# Select range of images if turned on
if self.params.advanced.image_range.flag_on:
self.input_list = self.select_image_range(self.input_list)
# Select a random subset of images if turned on
if self.params.advanced.random_sample.flag_on and \
self.params.advanced.random_sample.number < len(self.input_list):
self.input_list = self.select_random_subset(self.input_list)
# Check for data not found
if len(self.input_list) == 0:
wx.MessageBox('ERROR: Data Not Found!', 'ERROR',
wx.OK | wx.ICON_ERROR)
return False
# If list-only option selected, output list only
if list_file != None:
with open(list_file, "w") as lf:
for i, input_file in enumerate(self.input_list, 1):
lf.write('{}\n'.format(input_file))
return True
# Run the sanity check procedure
if not self.sanity_check():
return False
# If fewer images than requested processors are supplied, set the number of
# processors to the number of images
if self.params.mp_method == 'multiprocessing':
if self.params.n_processors > len(self.input_list):
self.params.n_processors = len(self.input_list)
# Generate base folder paths
self.conv_base = misc.set_base_dir('converted_pickles',
out_dir=self.params.output)
self.int_base = misc.set_base_dir('integration',
out_dir=self.params.output)
self.obj_base = os.path.join(self.int_base, 'image_objects')
self.fin_base = os.path.join(self.int_base, 'final')
self.log_base = os.path.join(self.int_base, 'logs')
self.viz_base = os.path.join(self.int_base, 'visualization')
if str(self.params.advanced.temporary_output_folder).lower() in (
'none', ''):
self.tmp_base = os.path.join(self.int_base, 'tmp')
else:
self.tmp_base = os.path.join(
self.params.advanced.temporary_output_folder)
# Generate base folders
os.makedirs(self.int_base)
os.makedirs(self.obj_base)
os.makedirs(self.fin_base)
os.makedirs(self.log_base)
try:
if not os.path.isdir(self.tmp_base):
os.makedirs(self.tmp_base)
except OSError:
pass
# Determine input base
common_pfx = os.path.abspath(
os.path.dirname(os.path.commonprefix(self.input_list)))
if len(self.params.input) == 1:
self.input_base = os.path.commonprefix(
[self.params.input[0], common_pfx])
else:
self.input_base = common_pfx
# Initialize main log
self.logfile = os.path.abspath(os.path.join(self.int_base, 'iota.log'))
# Write target file and record its location in params
local_target_file = os.path.join(self.int_base, 'target.phil')
if type(self.target_phil) == list:
self.target_phil = '\n'.join(self.target_phil)
with open(local_target_file, 'w') as tf:
tf.write(self.target_phil)
if self.params.advanced.integrate_with == 'cctbx':
self.params.cctbx.target = local_target_file
elif self.params.advanced.integrate_with == 'dials':
self.params.dials.target = local_target_file
# Collect final params and convert to PHIL object
final_phil = inp.master_phil.format(python_object=self.params)
# Generate text of params
with misc.Capturing() as txt_output:
final_phil.show()
self.txt_out = ''
for one_output in txt_output:
self.txt_out += one_output + '\n'
# Log starting info
misc.main_log(self.logfile, '{:=^80} \n'.format(' IOTA MAIN LOG '))
misc.main_log(self.logfile,
'{:-^80} \n'.format(' SETTINGS FOR THIS RUN '))
misc.main_log(self.logfile, self.txt_out)
# Log cctbx.xfel / DIALS settings
misc.main_log(
self.logfile, '{:-^80} \n\n'
''.format(' TARGET FILE ({}) CONTENTS '
''.format(local_target_file)))
misc.main_log(self.logfile, self.target_phil)
return True
def integrate(self, grid_point):
""" Runs the integration module in cctbx.xfel; used by either grid-search or
final integration function. """
self.s = grid_point['sih']
self.h = grid_point['sph']
self.a = grid_point['spa']
args = self.args
# Generate advanced arguments (and PDF subfolder)
if self.charts and self.tag == 'grid search':
filename = os.path.basename(self.img).split('.')[0]
pdf_folder = os.path.join(self.viz, 'pdf_{}/s{}_h{}_a{}'\
''.format(filename, self.s, self.h, self.a))
if not os.path.exists(pdf_folder):
os.makedirs(pdf_folder)
self.args.extend([
"integration.enable_residual_map=True",
"integration.enable_residual_scatter=True",
"integration.mosaic.enable_AD14F7B=True",
"integration.graphics_backend=pdf",
"integration.pdf_output_dir={}".format(pdf_folder)
])
if self.tag == 'integrate':
args.append("indexing.completeness_pickle={}".format(self.out_img))
#Actually run integration using iota.bulletproof
error_message = ''
with misc.Capturing() as index_log:
arguments = [
"distl.minimum_signal_height={}".format(
str(self.s)), "distl.minimum_spot_height={}".format(
str(self.h)), "distl.minimum_spot_area={}".format(
str(self.a)), "indexing.open_wx_viewer=False"
] + list(args[1:])
tmppath = os.path.join(self.tmp_base,
str(uuid.uuid4()) + ".pickle")
assert not os.path.exists(tmppath)
# invoke the indexer in a way that will protect iota from any crashes
command = "iota.bulletproof {} {} {}" \
"".format(tmppath, self.target, " ".join(arguments))
try:
easy_run.fully_buffered(command,
join_stdout_stderr=True).show_stdout()
if not os.path.exists(tmppath):
print tmppath
print command
raise Exception("Indexing failed for an unknown reason")
# iota.bulletproof saves the needed results from indexing in a tmp file
result = easy_pickle.load(tmppath)
os.remove(tmppath)
if isinstance(result, str):
raise Exception(result)
else:
int_final = result
except Exception, e:
int_final = None
if hasattr(e, "classname"):
print e.classname, "for %s:" % self.img,
error_message = "{}: {}".format(
e.classname, e[0].replace('\n', ' ')[:50])
else:
print "Integration error for %s:" % self.img,
error_message = "{}".format(str(e).replace('\n', ' ')[:50])
print e
def run(self):
self.processor = IOTADialsProcessor(params=self.phil)
log_entry = ['\n']
with misc.Capturing() as output:
e = None
try:
print "{:-^100}\n".format(" SPOTFINDING: ")
self.find_spots()
print "{:-^100}\n\n".format(" FOUND {} SPOTS: ".format(
len(self.observed)))
except Exception as e:
if hasattr(e, "classname"):
print e.classname, "for %s:" % self.img[0],
error_message = "{}: {}".format(
e.classname, e[0].replace('\n', ' ')[:50])
else:
print "Spotfinding error for %s:" % self.img[0],
error_message = "{}".format(str(e).replace('\n', ' ')[:50])
print error_message
self.fail = 'failed spotfinding'
if self.fail == None:
try:
print "{:-^100}\n".format(" INDEXING: ")
self.index()
if self.indexed is not None:
print "{:-^100}\n\n".format(
" USED {} INDEXED REFLECTIONS: "
"".format(len(self.indexed)))
except Exception as e:
if hasattr(e, "classname"):
error_message = "{}: {}".format(
e.classname, e[0].replace('\n', ' ')[:50])
else:
print "Indexing error for %s:" % self.img[0],
error_message = "{}".format(
str(e).replace('\n', ' ')[:50])
print error_message
self.fail = 'failed indexing'
if (self.fail is None
and self.phil.indexing.known_symmetry.space_group is None
and self.params.dials.determine_sg_and_reindex):
try:
print "{:-^100}\n".format(" DETERMINING SPACE GROUP : ")
self.refine_bravais_settings_and_reindex()
lat = self.experiments[0].crystal.get_space_group().info()
sg = str(lat).replace(' ', '')
if sg != 'P1':
print "{:-^100}\n".format(
" REINDEXED TO SPACE GROUP {} ".format(sg))
else:
print "{:-^100}\n".format(
" RETAINED TRICLINIC (P1) SYMMETRY ")
except Exception as e:
print "Bravais / Reindexing Error: ", e
if self.fail == None:
try:
self.refine()
print "{:-^100}\n".format(" INTEGRATING: ")
self.integrate()
print "{:-^100}\n\n".format(
" FINAL {} INTEGRATED REFLECTIONS "
"".format(len(self.integrated)))
except Exception as e:
if hasattr(e, "classname"):
print e.classname, "for %s:" % self.img[0],
error_message = "{}: {}".format(
e.classname, e[0].replace('\n', ' ')[:50])
else:
print "Integration error for %s:" % self.img[0],
error_message = "{}".format(
str(e).replace('\n', ' ')[:50])
print error_message
self.fail = 'failed integration'
if self.fail == None and self.params.dials.filter.flag_on:
selector = Selector(
frame=self.frame,
uc_tol=self.params.dials.filter.target_uc_tolerance,
pg=self.params.dials.filter.target_pointgroup,
uc=self.params.dials.filter.target_unit_cell,
min_ref=self.params.dials.filter.min_reflections,
min_res=self.params.dials.filter.min_resolution)
self.fail = selector.filter()
with open(self.int_log, 'w') as tf:
for i in output:
if 'cxi_version' not in i:
tf.write('\n{}'.format(i))
if self.fail == None:
# Collect information
obs = self.frame['observations'][0]
Bravais_lattice = self.frame['pointgroup']
cell = obs.unit_cell().parameters()
lres, hres = obs.d_max_min()
# Calculate number of spots w/ high I / sigmaI
Is = obs.data()
sigmas = obs.sigmas()
I_over_sigI = Is / sigmas
spots = len(Is)
strong_spots = len([
i for i in I_over_sigI
if i >= self.params.cctbx.selection.min_sigma
])
# Mosaicity parameters
mosaicity = round(
(self.frame.get('ML_half_mosaicity_deg', [0])[0]), 6)
dom_size = self.frame.get('ML_domain_size_ang', [0])[0]
ewald_proximal_volume = self.frame.get('ewald_proximal_volume',
[0])[0]
# Assemble output for log file and/or integration result file
p_cell = "{:>6.2f}, {:>6.2f}, {:>6.2f}, {:>6.2f}, {:>6.2f}, {:>6.2f}"\
"".format(cell[0], cell[1], cell[2], cell[3], cell[4], cell[5])
int_status = 'RES: {:<4.2f} NSREF: {:<4} SG: {:<5} CELL: {}'\
''.format(hres, strong_spots, Bravais_lattice, p_cell)
int_results = {
'sg': Bravais_lattice,
'a': cell[0],
'b': cell[1],
'c': cell[2],
'alpha': cell[3],
'beta': cell[4],
'gamma': cell[5],
'wavelength': self.frame['wavelength'],
'distance': self.frame['distance'],
'beamX': self.frame['xbeam'],
'beamY': self.frame['ybeam'],
'strong': strong_spots,
'res': hres,
'lres': lres,
'mos': mosaicity,
'epv': ewald_proximal_volume,
'info': int_status,
'ok': True
}
# Update final entry with integration results
self.final.update(int_results)
# Generate log summary of integration results
img_filename = os.path.basename(self.img[0])
log_entry.append('DIALS integration:')
log_entry.append('{:<{width}} ---> {}'.format(
img_filename, int_status, width=len(img_filename) + 2))
else:
# Generate log summary of integration results
if 'spotfinding' in self.fail:
step_id = 'SPOTFINDING'
elif 'indexing' in self.fail:
step_id = 'INDEXING'
elif 'integration' in self.fail:
step_id = 'INTEGRATION'
elif 'filter' in self.fail:
step_id = 'FILTER'
log_entry.append('\n {} FAILED - {}'.format(step_id, e))
int_status = 'not integrated -- {}'.format(e)
int_results = {'info': int_status}
self.final['final'] = None
log_entry = "\n".join(log_entry)
return self.fail, self.final, log_entry
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 Exception as e:
print 'IOTA IMPORT ERROR:', e
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
img_type = 'pickle'
else:
img_type = 'raw'
msec, sec = math.modf(scan.get_epochs()[0])
timestamp = evt_timestamp((sec,msec))
# 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
)
if scan is not None:
osc_start, osc_range = scan.get_oscillation()
if osc_start != osc_range:
data['OSC_START'] = 0 #osc_start
data['OSC_RANGE'] = 0 #osc_start
data['TIME'] = scan.get_exposure_times()[0]
else:
data = None
img_type = 'not imported'
# 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:
from dxtbx.datablock import DataBlockFactory
from dials.command_line.estimate_gain import estimate_gain
with misc.Capturing() as junk_output:
try:
datablock = DataBlockFactory.from_filenames([self.raw_img])[0]
imageset = datablock.extract_imagesets()[0]
self.gain = estimate_gain(imageset)
except Exception as e:
self.gain = 1.0
else:
self.gain = 1.0
return data, img_type
