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)
