def create_trial(self, d_min = 1.5, n_bins = 10, **kwargs): # d_min and n_bins only used if isoforms are in this trial trial = Trial(self, d_min = d_min, **kwargs) if trial.target_phil_str is not None: from iotbx.phil import parse dispatcher = self.params.dispatcher if dispatcher == 'cxi.xtc_process': from spotfinder.applications.xfel import cxi_phil trial_params = cxi_phil.cxi_versioned_extract().persist.phil_scope.fetch(parse(trial.target_phil_str)).extract() isoforms = trial_params.isoforms else: from xfel.ui import load_phil_scope_from_dispatcher phil_scope = load_phil_scope_from_dispatcher(self.params.dispatcher) trial_params = phil_scope.fetch(parse(trial.target_phil_str)).extract() isoforms = trial_params.indexing.stills.isoforms if len(isoforms) > 0: for isoform in isoforms: print("Creating isoform", isoform.name) db_isoform = Isoform(self, name = isoform.name, trial_id = trial.id) a, b, c, alpha, beta, gamma = isoform.cell.parameters() cell = self.create_cell(cell_a = a, cell_b = b, cell_c = c, cell_alpha = alpha, cell_beta = beta, cell_gamma = gamma, lookup_symbol = isoform.lookup_symbol, isoform_id = db_isoform.id) from cctbx.crystal import symmetry cs = symmetry(unit_cell = isoform.cell,space_group_symbol=str(isoform.lookup_symbol)) mset = cs.build_miller_set(anomalous_flag=False, d_min=d_min) binner = mset.setup_binner(n_bins=n_bins) for i in binner.range_used(): d_max, d_min = binner.bin_d_range(i) Bin(self, number = i, d_min = d_min, d_max = d_max, total_hkl = binner.counts_complete()[i], cell_id = cell.id) elif dispatcher == 'cxi.xtc_process': pass # TODO: labelit target else: if trial_params.indexing.known_symmetry.unit_cell is not None and \ trial_params.indexing.known_symmetry.space_group is not None: print("Creating target cell") unit_cell = trial_params.indexing.known_symmetry.unit_cell symbol = str(trial_params.indexing.known_symmetry.space_group) a, b, c, alpha, beta, gamma = unit_cell.parameters() cell = self.create_cell(cell_a = a, cell_b = b, cell_c = c, cell_alpha = alpha, cell_beta = beta, cell_gamma = gamma, lookup_symbol = symbol, trial_id = trial.id) from cctbx.crystal import symmetry cs = symmetry(unit_cell = unit_cell, space_group_symbol = symbol) mset = cs.build_miller_set(anomalous_flag=False, d_min=d_min) binner = mset.setup_binner(n_bins=n_bins) for i in binner.range_used(): d_max, d_min = binner.bin_d_range(i) Bin(self, number = i, d_min = d_min, d_max = d_max, total_hkl = binner.counts_complete()[i], cell_id = cell.id) return trial
def get_phil_scope(app, task_type): assert task_type in task_types if task_type == "indexing": dispatcher = app.params.dispatcher if dispatcher == 'cxi.xtc_process': #LABELIT from spotfinder.applications.xfel import cxi_phil return cxi_phil.cxi_versioned_extract().persist.phil_scope else: dispatcher = task_dispatchers[task_types.index(task_type)] return dispatcher, load_phil_scope_from_dispatcher(dispatcher)
def submit(self, previous_job = None): import libtbx.load_env configs_dir = os.path.join(settings_dir, "cfgs") if not os.path.exists(configs_dir): os.makedirs(configs_dir) identifier_string = self.get_identifier_string() target_phil_path = os.path.join(configs_dir, identifier_string + "_params.phil") dispatcher = self.app.params.dispatcher phil_str = self.trial.target_phil_str if phil_str is None: phil_str = "" if self.rungroup.extra_phil_str is not None: phil_str += "\n" + self.rungroup.extra_phil_str from xfel.ui import load_phil_scope_from_dispatcher if dispatcher == "cxi.xtc_process": image_format = 'pickle' else: orig_phil_scope = load_phil_scope_from_dispatcher(dispatcher) if os.path.isfile(dispatcher): dispatcher = 'libtbx.python ' + dispatcher from iotbx.phil import parse if self.rungroup.two_theta_low is not None or self.rungroup.two_theta_high is not None: override_str = """ radial_average { enable = True show_plots = False verbose = False output_bins = False mask = %s } """%(self.rungroup.untrusted_pixel_mask_path) phil_scope = orig_phil_scope.fetch(parse(override_str)) else: phil_scope = orig_phil_scope trial_params = phil_scope.fetch(parse(phil_str)).extract() image_format = self.rungroup.format mode = "other" if self.app.params.facility.name == 'lcls': if "rayonix" in self.rungroup.detector_address.lower(): mode = "rayonix" elif "cspad" in self.rungroup.detector_address.lower(): mode = "cspad" elif "jungfrau" in self.rungroup.detector_address.lower(): mode = "jungfrau" if hasattr(trial_params, 'format'): trial_params.format.file_format = image_format trial_params.format.cbf.mode = mode if self.rungroup.calib_dir is not None or self.rungroup.config_str is not None or dispatcher == 'cxi.xtc_process' or image_format == 'pickle': config_path = os.path.join(configs_dir, identifier_string + ".cfg") else: config_path = None if hasattr(trial_params.dispatch, 'process_percent'): trial_params.dispatch.process_percent = self.trial.process_percent # Dictionary for formating the submit phil and, if used, the labelit cfg file d = dict( # Generally for the LABELIT backend or image pickles address = self.rungroup.detector_address, default_calib_dir = libtbx.env.find_in_repositories("xfel/metrology/CSPad/run4/CxiDs1.0_Cspad.0"), dark_avg_path = self.rungroup.dark_avg_path, dark_stddev_path = self.rungroup.dark_stddev_path, untrusted_pixel_mask_path = self.rungroup.untrusted_pixel_mask_path, detz_parameter = self.rungroup.detz_parameter, gain_map_path = self.rungroup.gain_map_path, gain_mask_level = self.rungroup.gain_mask_level, beamx = self.rungroup.beamx, beamy = self.rungroup.beamy, energy = self.rungroup.energy, binning = self.rungroup.binning, two_theta_low = self.rungroup.two_theta_low, two_theta_high = self.rungroup.two_theta_high, # Generally for job submission dry_run = self.app.params.dry_run, dispatcher = dispatcher, cfg = config_path, experiment = self.app.params.facility.lcls.experiment, # LCLS specific parameter run_num = self.run.run, output_dir = self.app.params.output_folder, use_ffb = self.app.params.facility.lcls.use_ffb, # LCLS specific parameter # Generally for both trial = self.trial.trial, rungroup = self.rungroup.rungroup_id, experiment_tag = self.app.params.experiment_tag, calib_dir = self.rungroup.calib_dir, nproc = self.app.params.mp.nproc, nnodes = self.app.params.mp.nnodes_index or self.app.params.mp.nnodes, nproc_per_node = self.app.params.mp.nproc_per_node, queue = self.app.params.mp.queue or None, env_script = self.app.params.mp.env_script[0] if self.app.params.mp.env_script is not None and len(self.app.params.mp.env_script) > 0 and len(self.app.params.mp.env_script[0]) > 0 else None, phenix_script = self.app.params.mp.phenix_script[0] if self.app.params.mp.phenix_script is not None and len(self.app.params.mp.phenix_script) > 0 and len(self.app.params.mp.phenix_script[0]) > 0 else None, method = self.app.params.mp.method, wall_time = self.app.params.mp.wall_time, htcondor_executable_path = self.app.params.mp.htcondor.executable_path, nersc_shifter_image = self.app.params.mp.shifter.shifter_image, sbatch_script_template = self.app.params.mp.shifter.sbatch_script_template, srun_script_template = self.app.params.mp.shifter.srun_script_template, nersc_partition = self.app.params.mp.shifter.partition, nersc_jobname = self.app.params.mp.shifter.jobname, nersc_project = self.app.params.mp.shifter.project, nersc_constraint = self.app.params.mp.shifter.constraint, nersc_reservation = self.app.params.mp.shifter.reservation, nersc_staging = self.app.params.mp.shifter.staging, target = target_phil_path, host = self.app.params.db.host, dbname = self.app.params.db.name, user = self.app.params.db.user, port = self.app.params.db.port, # always use mpi for 'lcls' use_mpi = self.app.params.mp.method != 'local' or (self.app.params.mp.method == 'local' and self.app.params.facility.name == 'lcls'), mpi_command = self.app.params.mp.mpi_command, extra_options = "\n".join(["extra_options = %s"%opt for opt in self.app.params.mp.extra_options]), ) if self.app.params.mp.method == 'sge': d['use_mpi'] = False if self.app.params.db.password is not None and len(self.app.params.db.password) == 0: d['password'] = None else: d['password'] = self.app.params.db.password phil = open(target_phil_path, "w") if dispatcher == 'cxi.xtc_process': phil.write(phil_str) else: extra_scope = None if hasattr(trial_params, 'format'): if image_format == "cbf": trial_params.input.address = self.rungroup.detector_address trial_params.format.cbf.detz_offset = self.rungroup.detz_parameter trial_params.format.cbf.override_energy = self.rungroup.energy trial_params.format.cbf.invalid_pixel_mask = self.rungroup.untrusted_pixel_mask_path if mode == 'cspad': trial_params.format.cbf.cspad.gain_mask_value = self.rungroup.gain_mask_level elif mode == 'rayonix': trial_params.format.cbf.rayonix.bin_size = self.rungroup.binning trial_params.format.cbf.rayonix.override_beam_x = self.rungroup.beamx trial_params.format.cbf.rayonix.override_beam_y = self.rungroup.beamy if trial_params.input.known_orientations_folder is not None: trial_params.input.known_orientations_folder = trial_params.input.known_orientations_folder.format(run=self.run.run) else: if trial_params.spotfinder.lookup.mask is None: trial_params.spotfinder.lookup.mask = self.rungroup.untrusted_pixel_mask_path if trial_params.integration.lookup.mask is None: trial_params.integration.lookup.mask = self.rungroup.untrusted_pixel_mask_path if self.app.params.facility.name == 'lcls': locator_path = os.path.join(configs_dir, identifier_string + ".loc") locator = open(locator_path, 'w') locator.write("experiment=%s\n"%self.app.params.facility.lcls.experiment) # LCLS specific parameter locator.write("run=%s\n"%self.run.run) locator.write("detector_address=%s\n"%self.rungroup.detector_address) if self.rungroup.wavelength_offset: locator.write("wavelength_offset=%s\n"%self.rungroup.wavelength_offset) if self.rungroup.spectrum_eV_per_pixel: locator.write("spectrum_eV_per_pixel=%s\n"%self.rungroup.spectrum_eV_per_pixel) if self.rungroup.spectrum_eV_offset: locator.write("spectrum_eV_offset=%s\n"%self.rungroup.spectrum_eV_offset) if self.app.params.facility.lcls.use_ffb: locator.write("use_ffb=True\n") if mode == 'rayonix': from xfel.cxi.cspad_ana import rayonix_tbx pixel_size = rayonix_tbx.get_rayonix_pixel_size(self.rungroup.binning) extra_scope = parse("geometry { detector { panel { origin = (%f, %f, %f) } } }"%(-self.rungroup.beamx * pixel_size, self.rungroup.beamy * pixel_size, -self.rungroup.detz_parameter)) locator.write("rayonix.bin_size=%s\n"%self.rungroup.binning) elif mode == 'cspad': locator.write("cspad.detz_offset=%s\n"%self.rungroup.detz_parameter) locator.close() d['locator'] = locator_path else: d['locator'] = None if self.rungroup.two_theta_low is not None or self.rungroup.two_theta_high is not None: try: trial_params.radial_average.two_theta_low = self.rungroup.two_theta_low trial_params.radial_average.two_theta_high = self.rungroup.two_theta_high except AttributeError: pass # not all dispatchers support radial averaging working_phil = phil_scope.format(python_object=trial_params) if extra_scope: working_phil = working_phil.fetch(extra_scope) diff_phil = orig_phil_scope.fetch_diff(source=working_phil) phil.write(diff_phil.as_str()) phil.close() if config_path is not None: if dispatcher != 'cxi.xtc_process': d['untrusted_pixel_mask_path'] = None # Don't pass a pixel mask to mod_image_dict as it will # will be used during dials processing directly config_str = "[psana]\n" if self.rungroup.calib_dir is not None: config_str += "calib-dir=%s\n"%self.rungroup.calib_dir modules = [] if self.rungroup.config_str is not None: for line in self.rungroup.config_str.split("\n"): if line.startswith('['): modules.append(line.lstrip('[').rstrip(']')) if dispatcher == 'cxi.xtc_process': modules.insert(0, 'my_ana_pkg.mod_radial_average') modules.extend(['my_ana_pkg.mod_hitfind:index','my_ana_pkg.mod_dump:index']) elif image_format == 'pickle': modules.insert(0, 'my_ana_pkg.mod_radial_average') modules.extend(['my_ana_pkg.mod_image_dict']) if self.app.params.facility.lcls.dump_shots: modules.insert(0, 'my_ana_pkg.mod_dump:shot') if len(modules) > 0: config_str += "modules = %s\n"%(" ".join(modules)) if self.rungroup.config_str is not None: config_str += self.rungroup.config_str + "\n" if dispatcher == 'cxi.xtc_process' or image_format == 'pickle': d['address'] = d['address'].replace('.','-').replace(':','|') # old style address if dispatcher == 'cxi.xtc_process': template = open(os.path.join(libtbx.env.find_in_repositories("xfel/ui/db/cfgs"), "index_all.cfg")) elif image_format == 'pickle': template = open(os.path.join(libtbx.env.find_in_repositories("xfel/ui/db/cfgs"), "image_dict.cfg")) for line in template.readlines(): config_str += line.format(**d) template.close() d['address'] = self.rungroup.detector_address cfg = open(config_path, 'w') cfg.write(config_str) cfg.close() if dispatcher != 'cxi.xtc_process': d['untrusted_pixel_mask_path'] = self.rungroup.untrusted_pixel_mask_path submit_phil_path = os.path.join(configs_dir, identifier_string + "_submit.phil") submit_root = libtbx.env.find_in_repositories("xfel/ui/db/cfgs") if dispatcher in ['cxi.xtc_process', 'cctbx.xfel.xtc_process']: template = open(os.path.join(submit_root, "submit_xtc_process.phil")) else: test_root = os.path.join(submit_root, "submit_" + dispatcher + ".phil") if os.path.exists(test_root): template = open(test_root) else: if hasattr(trial_params, 'format'): template = open(os.path.join(submit_root, "submit_xtc_process.phil")) else: template = open(os.path.join(submit_root, "submit_xfel_process.phil")) phil = open(submit_phil_path, "w") if dispatcher == 'cxi.xtc_process': d['target'] = None # any target phil will be in mod_hitfind for line in template.readlines(): phil.write(line.format(**d)) d['target'] = target_phil_path template.close() phil.close() from xfel.command_line.cxi_mpi_submit import Script as submit_script args = [submit_phil_path] if self.app.params.facility.name not in ['lcls']: args.append(self.run.path) return submit_script().run(args)