def run_full_proc(self):
''' Run IOTA in full-processing mode (i.e. process image from import to
integration; allows real-time tracking of output '''
# Process images
self.stage = 'all'
self.run_all()
# Analysis of integration results
final_objects = [i for i in self.img_objects if i.fail == None]
if len(final_objects) > 0:
self.run_analysis()
else:
print 'No images successfully integrated!'
# Exit IOTA
misc.iota_exit()
def run(self):
''' Run IOTA '''
# Import Images
self.stage = 'import'
self.run_import()
# Remove rejected images from image object list
acc_img_objects = [i.fail for i in self.img_objects if i.fail == None]
cmd.Command.end("Accepted {} of {} images -- DONE " \
"".format(len(acc_img_objects), len(self.img_objects)))
# Exit if none of the images have diffraction
if str(self.init.params.image_triage.type).lower() != 'none':
if len(acc_img_objects) == 0:
misc.main_log(self.init.logfile, 'No images have diffraction!', True)
misc.iota_exit()
else:
misc.main_log(self.init.logfile,
"{} out of {} images have diffraction "
"(at least {} Bragg peaks)"
"".format(len(acc_img_objects),
len(self.img_objects),
self.init.params.image_triage.min_Bragg_peaks))
# Check for -c option and exit if true
if self.init.params.image_conversion.convert_only:
misc.iota_exit()
# Process Images
self.stage = 'process'
self.run_process()
# Analysis of integration results
final_objects = [i for i in self.img_objects if i.fail == None]
if len(final_objects) > 0:
self.run_analysis()
else:
print 'No images successfully integrated!'
# Exit IOTA
misc.iota_exit()
def run(self):
self.args, self.phil_args = parse_command_args(
self.iver, self.help_message).parse_known_args()
# Check for type of input
if len(self.args.path) == 0 or self.args.path is None: # No input
parse_command_args(self.iver, self.help_message).print_help()
if self.args.default: # Write out default params and exit
help_out, txt_out = inp.print_params()
print '\n{:-^70}\n'.format('IOTA Parameters')
print help_out
inp.write_defaults(os.path.abspath(os.path.curdir), txt_out)
misc.iota_exit()
elif len(self.args.path) > 1: # If multiple paths / wildcards
file_list = ginp.make_input_list(self.args.path)
list_file = os.path.join(os.path.abspath(os.path.curdir),
'input.lst')
with open(list_file, 'w') as lf:
lf.write('\n'.join(file_list))
msg = "\nIOTA will run in AUTO mode using wildcard datapath:\n" \
"{} files found, compiled in {}\n".format(len(file_list), list_file)
self.params, self.txt_out = inp.process_input(
self.args, self.phil_args, list_file, 'auto', self.now)
else: # If single path, check type
carg = os.path.abspath(self.args.path[0])
if os.path.exists(carg):
# If user provided a parameter file
if os.path.isfile(carg) and os.path.basename(carg).endswith(
'.param'):
msg = ''
self.params, self.txt_out = inp.process_input(
self.args, self.phil_args, carg, 'file')
# If user provided a list of input files
elif os.path.isfile(carg) and os.path.basename(carg).endswith(
'.lst'):
msg = "\nIOTA will run in AUTO mode using {}:\n".format(
carg)
self.params, self.txt_out = inp.process_input(
self.args, self.phil_args, carg, 'auto', self.now)
# If user provided a single filepath
elif os.path.isfile(
carg) and not os.path.basename(carg).endswith('.lst'):
msg = "\nIOTA will run in SINGLE-FILE mode using {}:\n".format(
carg)
self.params, self.txt_out = inp.process_input(
self.args, self.phil_args, carg, 'auto', self.now)
# If user provided a data folder
elif os.path.isdir(carg):
msg = "\nIOTA will run in AUTO mode using {}:\n".format(
carg)
self.params, self.txt_out = inp.process_input(
self.args, self.phil_args, carg, 'auto', self.now)
# If user provided gibberish
else:
print self.logo
print "ERROR: Invalid input! Need parameter filename or data folder."
misc.iota_exit()
# Identify indexing / integration program
if self.params.advanced.integrate_with == 'cctbx':
prg = " with CCTBX.XFEL\n"
elif self.params.advanced.integrate_with == 'dials':
prg = " with DIALS\n"
self.logo += prg
print self.logo
print '\n{}\n'.format(self.now)
if msg != '':
print msg
if self.args.analyze != None:
print 'ANALYSIS ONLY will be performed (analyzing run #{})'.format(
self.args.analyze)
self.analyze_prior_results('{:003d}'.format(int(
self.args.analyze)))
misc.iota_exit()
if self.params.mp_method == 'mpi':
rank, size = misc.get_mpi_rank_and_size()
self.master_process = rank == 0
else:
self.master_process = True
# Call function to read input folder structure (or input file) and
# generate list of image file paths
if self.params.cctbx.selection.select_only.flag_on:
self.gs_img_objects = self.make_int_object_list()
self.input_list = [i.conv_img for i in self.gs_img_objects]
else:
self.input_list = self.make_input_list()
# Check for -l option, output list of input files and exit
if self.args.list:
list_file = os.path.abspath("{}/input.lst".format(os.curdir))
# Check if other files of this name exist under the current folder
list_folder = os.path.dirname(list_file)
list_files = [
i for i in os.listdir(list_folder) if i.endswith(".lst")
]
if len(list_files) > 0:
list_file = os.path.join(
list_folder, "input_{}.lst".format(len(list_files)))
print '\nINPUT LIST ONLY option selected'
print 'Input list in {} \n\n'.format(list_file)
with open(list_file, "w") as lf:
for i, input_file in enumerate(self.input_list, 1):
lf.write('{}\n'.format(input_file))
print "{}: {}".format(i, input_file)
lf.write('{}\n'.format(input_file))
print '\nExiting...\n\n'
misc.iota_exit()
# If fewer images than requested processors are supplied, set the number of
# processors to the number of images
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')
self.tmp_base = os.path.join(
'/tmp', '{}_{}'.format(os.getlogin(), time.time()))
# Generate base folders
os.makedirs(self.int_base)
os.makedirs(self.obj_base)
os.makedirs(self.fin_base)
os.makedirs(self.log_base)
os.makedirs(self.tmp_base)
# Determine input base
self.input_base = os.path.abspath(
os.path.dirname(os.path.commonprefix(self.input_list)))
# Initialize main log
self.logfile = os.path.abspath(os.path.join(self.int_base, 'iota.log'))
# 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)
if self.params.advanced.integrate_with == 'cctbx':
target_file = self.params.cctbx.target
elif self.params.advanced.integrate_with == 'dials':
target_file = self.params.dials.target
misc.main_log(
self.logfile, '{:-^80} \n\n'
''.format(' TARGET FILE ({}) CONTENTS '
''.format(target_file)))
with open(target_file, 'r') as phil_file:
phil_file_contents = phil_file.read()
misc.main_log(self.logfile, phil_file_contents)
# Write target file and record its location in params
local_target_file = os.path.join(self.int_base, 'target.phil')
with open(local_target_file, 'w') as tf:
tf.write(phil_file_contents)
def run(self):
self.args, self.phil_args = parse_command_args(self.iver,
self.help_message).parse_known_args()
# Check for type of input
if self.args.path == None: # No input
parse_command_args(self.iver, self.help_message).print_help()
if self.args.default: # Write out default params and exit
help_out, txt_out = inp.print_params()
print '\n{:-^70}\n'.format('IOTA Parameters')
print help_out
inp.write_defaults(os.path.abspath(os.path.curdir), txt_out)
misc.iota_exit()
else: # If input exists, check type
carg = os.path.abspath(self.args.path)
if os.path.exists(carg):
# If user provided a parameter file
if os.path.isfile(carg) and os.path.basename(carg).endswith('.param'):
msg = ''
self.params, self.txt_out = inp.process_input(self.args,
self.phil_args,
carg, 'file')
# If user provided a list of input files
elif os.path.isfile(carg) and os.path.basename(carg).endswith('.lst'):
msg = "\nIOTA will run in AUTO mode using {}:\n".format(carg)
self.params, self.txt_out = inp.process_input(self.args,
self.phil_args,
carg, 'auto', self.now)
# If user provided a single filepath
elif os.path.isfile(carg) and not os.path.basename(carg).endswith('.lst'):
msg = "\nIOTA will run in SINGLE-FILE mode using {}:\n".format(carg)
self.params, self.txt_out = inp.process_input(self.args,
self.phil_args,
carg, 'auto', self.now)
# If user provided a data folder
elif os.path.isdir(carg):
msg = "\nIOTA will run in AUTO mode using {}:\n".format(carg)
self.params, self.txt_out = inp.process_input(self.args,
self.phil_args,
carg, 'auto', self.now)
# If user provided gibberish
else:
print self.logo
print "ERROR: Invalid input! Need parameter filename or data folder."
misc.iota_exit()
# Identify indexing / integration program
if self.params.advanced.integrate_with == 'cctbx':
prg = " with CCTBX.XFEL\n"
elif self.params.advanced.integrate_with == 'dials':
prg = " with DIALS\n"
self.logo += prg
print self.logo
print '\n{}\n'.format(self.now)
if msg != '':
print msg
if self.args.analyze != None:
self.analyze_prior_results('{:003d}'.format(int(self.args.analyze)))
misc.iota_exit()
if self.params.mp_method == 'mpi':
rank, size = misc.get_mpi_rank_and_size()
self.master_process = rank == 0
else:
self.master_process = True
# Call function to read input folder structure (or input file) and
# generate list of image file paths
if self.params.cctbx.selection.select_only.flag_on:
self.gs_img_objects = self.make_int_object_list()
self.input_list = [i.conv_img for i in self.gs_img_objects]
else:
self.input_list = self.make_input_list()
# Check for -l option, output list of input files and exit
if self.args.list:
if list_file == None:
list_file = os.path.abspath("{}/input.lst".format(os.curdir))
print '\nINPUT LIST ONLY option selected'
print 'Input list in {} \n\n'.format(list_file)
with open(list_file, "w") as lf:
for i, input_file in enumerate(self.input_list, 1):
lf.write('{}\n'.format(input_file))
print "{}: {}".format(i, input_file)
lf.write('{}\n'.format(input_file))
print '\nExiting...\n\n'
misc.iota_exit()
# If fewer images than requested processors are supplied, set the number of
# processors to the number of images
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.tmp_base = os.path.join(self.int_base, 'tmp')
self.viz_base = os.path.join(self.int_base, 'visualization')
# Generate base folders
os.makedirs(self.int_base)
os.makedirs(self.obj_base)
os.makedirs(self.fin_base)
os.makedirs(self.tmp_base)
# Determine input base
self.input_base = os.path.abspath(os.path.dirname(os.path.commonprefix(self.input_list)))
# Initialize main log
self.logfile = os.path.abspath(os.path.join(self.int_base, 'iota.log'))
# 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)
if self.params.advanced.integrate_with == 'cctbx':
target_file = self.params.cctbx.target
elif self.params.advanced.integrate_with == 'dials':
target_file = self.params.dials.target
misc.main_log(self.logfile, '{:-^80} \n\n'
''.format(' TARGET FILE ({}) CONTENTS '
''.format(target_file)))
with open(target_file, 'r') as phil_file:
phil_file_contents = phil_file.read()
misc.main_log(self.logfile, phil_file_contents)
# Import image
single_image = img.SingleImage(image, init, verbose=True)
img_object = single_image.import_image()
# Exit if the image does not have diffraction
if img_object.fail == 'failed triage':
return img_object
# Process image
img_object.process(single_image=True)
return img_object
# ============================================================================ #
if __name__ == "__main__":
# Initialize IOTA parameters and log
init = InitAll(help_message)
init.run()
# Run single image
image = [1, 1, init.input_list[0]]
cmd.Command.start("Processing single image")
img_object = run_one_image(image, init)
cmd.Command.end("Processing single image -- DONE")
misc.iota_exit(iota_version)
def run_one_image(image, init):
# Import image
single_image = img.SingleImage(image, init, verbose=True)
img_object = single_image.import_image()
# Exit if the image does not have diffraction
if img_object.fail == 'failed triage':
return img_object
# Process image
img_object.process(single_image=True)
return img_object
# ============================================================================ #
if __name__ == "__main__":
# Initialize IOTA parameters and log
init = InitAll(help_message)
init.run()
# Run single image
image = [1, 1, init.input_list[0]]
cmd.Command.start("Processing single image")
img_object = run_one_image(image, init)
cmd.Command.end("Processing single image -- DONE")
misc.iota_exit(iota_version)