def start_helper(self, version_token):
from spotfinder.applications.xfel import cxi_phil
from iotbx.detectors.npy import NpyImage
import os, copy
is_file = isinstance(self._image_file, basestring) and os.path.isfile(
self._image_file)
if is_file:
file_name = self._image_file
else:
file_name = "inmem"
args = [
file_name,
version_token,
"viewer.powder_arcs.show=False",
"viewer.powder_arcs.code=3n9c",
]
params = cxi_phil.cxi_versioned_extract(args)
horizons_phil = params.persist.commands
if is_file:
I = NpyImage(file_name)
else:
print "This is not a file; assume the data are in the defined dictionary format"
I = NpyImage(file_name, source_data=self._image_file)
I.readHeader(horizons_phil)
I.translate_tiles(horizons_phil)
# necessary to keep the phil parameters for subsequent calls to get_tile_manager()
I.horizons_phil_cache = copy.deepcopy(horizons_phil)
self.detectorbase = I
def start_helper(self, version_token):
from spotfinder.applications.xfel import cxi_phil
from iotbx.detectors.npy import NpyImage
import os,copy
is_file = isinstance(self._image_file, basestring) and os.path.isfile(self._image_file)
if is_file:
file_name = self._image_file
else:
file_name = "inmem"
args = [file_name,
version_token,
"viewer.powder_arcs.show=False",
"viewer.powder_arcs.code=3n9c",
]
params = cxi_phil.cxi_versioned_extract(args)
horizons_phil = params.persist.commands
if is_file:
I = NpyImage(file_name)
else:
print "This is not a file; assume the data are in the defined dictionary format"
I = NpyImage(file_name, source_data=self._image_file)
I.readHeader(horizons_phil)
I.translate_tiles(horizons_phil)
# necessary to keep the phil parameters for subsequent calls to get_tile_manager()
I.horizons_phil_cache = copy.deepcopy(horizons_phil)
self.detectorbase = I
def view_raw_image(path, *command_line, **kwargs):
args = [path,
"viewer.powder_arcs.show=False",
"viewer.powder_arcs.code=3n9c",
]
horizons_phil = cxi_phil.cxi_versioned_extract(
copy.deepcopy(args),list(command_line))
global parameters
parameters.horizons_phil = horizons_phil
if horizons_phil.viewer.calibrate_pdb.code is not None:
from rstbx.viewer.calibration import pdb_code_wrapper
pdb_code_wrapper(horizons_phil).display(path)
return
elif horizons_phil.viewer.calibrate_unitcell.unitcell is not None:
from rstbx.viewer.calibration import unit_cell_wrapper
unit_cell_wrapper(horizons_phil).display(path)
return
elif horizons_phil.viewer.calibrate_silver==True:
from rstbx.viewer.calibration import sb_wrapper
sb_wrapper(horizons_phil).display(path)
return
wrapper_of_callback().display(path)
def view_raw_image(path, *command_line, **kwargs):
args = [path,
"viewer.powder_arcs.show=False",
"viewer.powder_arcs.code=3n9c",
]
horizons_phil = cxi_phil.cxi_versioned_extract(
copy.deepcopy(args),list(command_line))
global parameters
parameters.horizons_phil = horizons_phil
if horizons_phil.viewer.calibrate_pdb.code is not None:
from rstbx.viewer.calibration import pdb_code_wrapper
pdb_code_wrapper(horizons_phil).display(path)
return
elif horizons_phil.viewer.calibrate_unitcell.unitcell is not None:
from rstbx.viewer.calibration import unit_cell_wrapper
unit_cell_wrapper(horizons_phil).display(path)
return
elif horizons_phil.viewer.calibrate_silver==True:
from rstbx.viewer.calibration import sb_wrapper
sb_wrapper(horizons_phil).display(path)
return
wrapper_of_callback().display(path)
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
backend = ['labelit', 'dials'][['cxi.xtc_process', 'cctbx.xfel.xtc_process'].index(self.params.dispatcher)]
if backend == 'labelit':
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
elif backend == 'dials':
from xfel.command_line.xtc_process import phil_scope
trial_params = phil_scope.fetch(parse(trial.target_phil_str)).extract()
isoforms = trial_params.indexing.stills.isoforms
else:
assert False
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 backend == 'labelit':
pass # TODO: labelit target
elif backend == 'dials':
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 start_helper(self, version_token):
is_file = isinstance(self._image_file,
six.string_types) and os.path.isfile(
self._image_file)
if is_file:
file_name = self._image_file
else:
file_name = "inmem"
args = [
file_name,
version_token,
"viewer.powder_arcs.show=False",
"viewer.powder_arcs.code=3n9c",
]
params = cxi_phil.cxi_versioned_extract(args)
horizons_phil = params.persist.commands
if is_file:
image = NpyImage(file_name)
else:
print(
"This is not a file; assume the data are in the defined dictionary format"
)
image = NpyImage(file_name, source_data=self._image_file)
image.readHeader(horizons_phil)
image.translate_tiles(horizons_phil)
# necessary to keep the phil parameters for subsequent calls to get_tile_manager()
image.horizons_phil_cache = copy.deepcopy(horizons_phil)
self.detectorbase = image
def print_unit_translations(data, params, optional):
from scitbx.array_family import flex
def pretty_format(data):
out = """"""
for quad in [0,1,2,3]:
for blockof2 in [0,1,2,3]:
format = "%3.0f,"*8
if quad==3 and blockof2==3:
format = format[0:-1]
format = " %s"%format
out+=format+"""
"""
if quad<3: out += """
"""
# reality check here in case the PAD is not 64-tiles
Nparam = len(data)
decoration = out.split("%3.0f,")
if len(decoration)>Nparam+1:
decoration = decoration[len(decoration)-Nparam:]
return "%3.0f,".join(decoration)
return out
from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract
if params.detector_format_version is not None:
base_arguments = ["distl.detector_format_version=%s"%params.detector_format_version]
if optional is not None:
if optional.distl.quad_translations is not None:
base_arguments.append("distl.quad_translations="+",".join([str(s) for s in optional.distl.quad_translations]))
if optional.distl.tile_translations is not None:
base_arguments.append("distl.tile_translations="+",".join([str(s) for s in optional.distl.tile_translations]))
stuff = cxi_versioned_extract(base_arguments)
old = flex.double(stuff.distl.tile_translations)
print "cctbx already defines unit pixel translations for detector format version %s:"%params.detector_format_version
print pretty_format(old)%tuple(old)
print "new unit pixel increments will be SUBTRACTED off these to get final translations"
print
else:
print "no pre-existing translations were input"
print
old = flex.double(128)
print "Unit translations to be pasted into spotfinder/applications/xfel/cxi_phil.py:"
new = old - flex.double(data)
#overall_format = """ working_extract.distl.tile_translations = [
overall_format = '''distl {\n tile_translations = """
'''+pretty_format(new)+''' """}'''
print overall_format%tuple(new)
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 integrate_one_image(data):
from .display_spots import run_one_index_core
from labelit.dptbx.error import NoAutoIndex
from libtbx.utils import Sorry
path = "strong/" + data[
'TIMESTAMP'] + "_" + "%05d" % data['SEQUENCE_NUMBER'] + ".pickle"
args = [
"indexing.data=dummy",
"distl.detector_format_version=CXI 3.2",
"force_method2_resolution_limit=2.2",
"distl_highres_limit=2.2",
"distl.res.outer=2.0",
"beam_search_scope=0.5",
"target_cell=38,78,78,90,90,90",
"lepage_max_delta = 3.0",
"spots_pickle = None",
"subgroups_pickle = None",
"refinements_pickle = None",
"rmsd_tolerance = 5.0",
"mosflm_rmsd_tolerance = 5.0",
"known_setting = 9",
"mosaicity_limit=1.0",
"indexing.completeness_pickle=%s" % path,
"difflimit_sigma_cutoff=2.0",
"indexing.verbose_cv=True",
#"indexing.open_wx_viewer=True"
]
from spotfinder.applications.xfel import cxi_phil
horizons_phil = cxi_phil.cxi_versioned_extract(args)
horizons_phil.indexing.data = data
try:
run_one_index_core(horizons_phil)
except NoAutoIndex as e:
print "NoAutoIndex"
print e
except Sorry as e:
print e
except ZeroDivisionError as e:
print "ZeroDivisionError"
print e
except Exception as e:
print "ANOTHER exception"
print e
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, **kwargs)
if trial.target_phil_str is not None:
from iotbx.phil import parse
backend = ['labelit', 'dials'][['cxi.xtc_process', 'cctbx.xfel.xtc_process'].index(self.params.dispatcher)]
if backend == 'labelit':
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
elif backend == 'dials':
from xfel.command_line.xtc_process import phil_scope
trial_params = phil_scope.fetch(parse(trial.target_phil_str)).extract()
isoforms = trial_params.indexing.stills.isoforms
else:
assert False
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)
return trial
def run_one(path, *command_line, **kwargs):
args = ["distl.image=%s"%path,
"distl.res.outer=2.1",
"distl.detector_format_version=CXI 5.1",
]
horizons_phil = cxi_phil.cxi_versioned_extract(
copy.deepcopy(args),list(command_line))
global parameters
parameters.horizons_phil = horizons_phil
from spotfinder.applications import signal_strength
info = signal_strength.run_signal_strength(horizons_phil)
if kwargs.get("display",False):
work = wrapper_of_callback(info)
work.display_with_callback(path)
def run_one(path, *command_line, **kwargs):
args = ["distl.image=%s"%path,
"distl.res.outer=2.1",
"distl.detector_format_version=CXI 5.1",
]
horizons_phil = cxi_phil.cxi_versioned_extract(
copy.deepcopy(args),list(command_line))
global parameters
parameters.horizons_phil = horizons_phil
from spotfinder.applications import signal_strength
info = signal_strength.run_signal_strength(horizons_phil)
if kwargs.get("display",False):
work = wrapper_of_callback(info)
work.display_with_callback(path)
def integrate_one_image(data):
from display_spots import run_one_index_core
from labelit.dptbx.error import NoAutoIndex
from libtbx.utils import Sorry
path = "strong/" + data['TIMESTAMP'] + "_" + "%05d" % data['SEQUENCE_NUMBER'] + ".pickle"
args = ["indexing.data=dummy",
"distl.detector_format_version=CXI 3.2",
"force_method2_resolution_limit=2.2",
"distl_highres_limit=2.2",
"distl.res.outer=2.0",
"beam_search_scope=0.5",
"target_cell=38,78,78,90,90,90",
"lepage_max_delta = 3.0",
"spots_pickle = None",
"subgroups_pickle = None",
"refinements_pickle = None",
"rmsd_tolerance = 5.0",
"mosflm_rmsd_tolerance = 5.0",
"known_setting = 9",
"mosaicity_limit=1.0",
"indexing.completeness_pickle=%s"%path,
"difflimit_sigma_cutoff=2.0",
"indexing.verbose_cv=True",
#"indexing.open_wx_viewer=True"
]
from spotfinder.applications.xfel import cxi_phil
horizons_phil = cxi_phil.cxi_versioned_extract(args)
horizons_phil.indexing.data = data
try:
run_one_index_core(horizons_phil)
except NoAutoIndex,e:
print "NoAutoIndex"
print e
arg=arg
)
horizons_phil = horizons_phil.fetch(sources=[command_line_params,])
consume.append(arg)
except Sorry,e:
pass
for item in consume:
args.remove(item)
if len(args) > 0:
raise Sorry("Not all arguments processed")
params = horizons_phil.extract()
if params.distl.tile_translations is not None and params.distl.quad_translations is not None:
return params
from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract
args = ["distl.detector_format_version=%s"%params.distl.detector_format_version]
versioned_extract = cxi_versioned_extract(args).persist.commands
if params.distl.quad_translations is None:
params.distl.quad_translations = versioned_extract.distl.quad_translations
if params.distl.tile_translations is None:
params.distl.tile_translations = versioned_extract.distl.tile_translations
return params
if _detector_format_version_dict[version]['start_time'] is None:
print "None"
else:
print evt_timestamp((_detector_format_version_dict[version]['end_time'], 0))
if __name__=='__main__':
if len(sys.argv) <= 1:
print "Listing of all known detector formats. Use cxi.detector_format_versions <version> to show the quadrant and unit pixel translations for a given format version"
print
print "Format version Det. address Start time End time"
for key in sorted(_detector_format_version_dict):
print_version(key)
else:
from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract
for version in sys.argv[1:]:
if version not in _detector_format_version_dict:
print "Version %s not found. Did you use quotes?"%version
continue
print "Showing info for %s detector format version"%version
print
print "Format version Det. address Start time End time"
print_version(version)
print
phil = cxi_versioned_extract(["distl.detector_format_version=%s"%version])
print "Quad translations:", phil.distl.quad_translations
print "Tile translations:", phil.distl.tile_translations
# legacy format; try to guess the address
LCLS_detector_address = 'CxiDs1-0|Cspad-0'
if "DISTANCE" in source_data and source_data["DISTANCE"] > 1000:
# downstream CS-PAD detector station of CXI instrument
LCLS_detector_address = 'CxiDsd-0|Cspad-0'
else:
LCLS_detector_address = source_data["DETECTOR_ADDRESS"]
timesec = reverse_timestamp(source_data["TIMESTAMP"])[0]
version_lookup = detector_format_function(LCLS_detector_address, timesec)
args = [
"distl.detector_format_version=%s" % version_lookup,
"viewer.powder_arcs.show=False",
"viewer.powder_arcs.code=3n9c",
]
horizons_phil = cxi_phil.cxi_versioned_extract(args).persist.commands
img = NpyImage(params.file_path, source_data)
img.readHeader(horizons_phil)
img.translate_tiles(horizons_phil)
if params.verbose:
img.show_header()
the_tiles = img.get_tile_manager(
horizons_phil).effective_tiling_as_flex_int(
reapply_peripheral_margin=False, encode_inactive_as_zeroes=True)
if params.beam_x is None:
params.beam_x = img.beamx / img.pixel_size
if params.beam_y is None:
params.beam_y = img.beamy / img.pixel_size
# legacy format; try to guess the address
LCLS_detector_address = 'CxiDs1-0|Cspad-0'
if "DISTANCE" in source_data and source_data["DISTANCE"] > 1000:
# downstream CS-PAD detector station of CXI instrument
LCLS_detector_address = 'CxiDsd-0|Cspad-0'
else:
LCLS_detector_address = source_data["DETECTOR_ADDRESS"]
timesec = reverse_timestamp( source_data["TIMESTAMP"] )[0]
version_lookup = detector_format_function(LCLS_detector_address,timesec)
args = [
"distl.detector_format_version=%s"%version_lookup,
"viewer.powder_arcs.show=False",
"viewer.powder_arcs.code=3n9c",
]
horizons_phil = cxi_phil.cxi_versioned_extract(args).persist.commands
img = NpyImage(params.file_path, source_data)
img.readHeader(horizons_phil)
img.translate_tiles(horizons_phil)
if params.verbose:
img.show_header()
the_tiles = img.get_tile_manager(horizons_phil).effective_tiling_as_flex_int(
reapply_peripheral_margin=False,encode_inactive_as_zeroes=True)
if params.beam_x is None:
params.beam_x = img.beamx / img.pixel_size
if params.beam_y is None:
params.beam_y = img.beamy / img.pixel_size
if params.verbose:
def load_cxi_phil(path, args=[]):
import os
from labelit.phil_preferences import iotbx_defs, libtbx_defs
from iotbx import phil
from libtbx.phil.command_line import argument_interpreter
from libtbx.utils import Sorry
exts = ["", ".params", ".phil"]
foundIt = False
for ext in exts:
if os.path.exists(path + ext):
foundIt = True
path += ext
break
if not foundIt:
raise Sorry("Target not found: " + path)
master_phil = phil.parse(input_string=iotbx_defs + libtbx_defs,
process_includes=True)
horizons_phil = master_phil.fetch(
sources=[phil.parse(file_name=path, process_includes=True)])
argument_interpreter = argument_interpreter(master_phil=master_phil)
consume = []
for arg in args:
try:
command_line_params = argument_interpreter.process(arg=arg)
horizons_phil = horizons_phil.fetch(sources=[
command_line_params,
])
consume.append(arg)
except Sorry as e:
pass
for item in consume:
args.remove(item)
if len(args) > 0:
raise Sorry("Not all arguments processed")
params = horizons_phil.extract()
if params.distl.tile_translations is not None and params.distl.quad_translations is not None:
return params
from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract
args = [
"distl.detector_format_version=%s" %
params.distl.detector_format_version
]
versioned_extract = cxi_versioned_extract(args).persist.commands
if params.distl.quad_translations is None:
params.distl.quad_translations = versioned_extract.distl.quad_translations
if params.distl.tile_translations is None:
params.distl.tile_translations = versioned_extract.distl.tile_translations
return params
consume.append(arg)
except Sorry, e:
pass
for item in consume:
args.remove(item)
if len(args) > 0:
raise Sorry("Not all arguments processed")
params = horizons_phil.extract()
if params.distl.tile_translations is not None and params.distl.quad_translations is not None:
return params
from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract
args = [
"distl.detector_format_version=%s" %
params.distl.detector_format_version
]
versioned_extract = cxi_versioned_extract(args).persist.commands
if params.distl.quad_translations is None:
params.distl.quad_translations = versioned_extract.distl.quad_translations
if params.distl.tile_translations is None:
params.distl.tile_translations = versioned_extract.distl.tile_translations
return params
img_dict = dpack(active_areas=active_areas,
address=address,
beam_center_x=beam_center[0] * pixel_size,
beam_center_y=beam_center[1] * pixel_size,
data=data,
distance=params.distance,
pixel_size=pixel_size,
timestamp=timestamp,
wavelength=params.wavelength)
img = NpyImage("", source_data=img_dict)
args = [
"distl.detector_format_version=%s" % params.detector_format_version
]
horizons_phil = cxi_phil.cxi_versioned_extract(args)
img.readHeader(horizons_phil)
img.translate_tiles(horizons_phil)
tm = img.get_tile_manager(horizons_phil)
effective_active_areas = tm.effective_tiling_as_flex_int()
if annulus:
inner = params.distance * math.tan(
2 * math.sinh(params.wavelength /
(2 * params.annulus_inner))) / pixel_size
outer = params.distance * math.tan(
2 * math.sinh(params.wavelength /
(2 * params.annulus_outer))) / pixel_size
print "Pixel inner:", inner
print "Pixel outer:", outer
if (residx == -1) and ((latxdim == -1) or (latydim == -1) or (latzdim == -1)):
raise Exception,"Must provide either diffuse.lattice.resolution or latxdim, latydim, and latzdim."
import os
# read input file with list of diffraction images and scale factors
f = open(ifname,"r")
lines = []
for line in f:
if ((line.strip()!="") and (line[0] != '.')):
lines.append(line)
f.close()
from spotfinder.applications.xfel import cxi_phil
horizons_phil = cxi_phil.cxi_versioned_extract(args)
print "indexing..."
t0 = clock()
# indexing can be slow. would be good to save indexing info and read it back in
results = run_one_index_core(horizons_phil)
tel = clock()-t0
print "done indexing (",tel," sec)"
latsize = latxdim*latydim*latzdim
lat = np.zeros(latsize, dtype=np.float32)
ct = np.zeros(latsize, dtype=np.float32)
#name_of_interest = results.organizer.Files.filenames.FN[0]
AI = results.indexing_ai
i0=latxdim/2-1
def run(args, source_data=None):
from xfel import radial_average
from scitbx.array_family import flex
from iotbx.detectors.cspad_detector_formats import reverse_timestamp
from iotbx.detectors.cspad_detector_formats import detector_format_version as detector_format_function
from spotfinder.applications.xfel import cxi_phil
from iotbx.detectors.npy import NpyImage
import os, sys
from iotbx.detectors.npy import NpyImage
user_phil = []
# TODO: replace this stuff with iotbx.phil.process_command_line_with_files
# as soon as I can safely modify it
for arg in args:
if (not "=" in arg):
try:
user_phil.append(libtbx.phil.parse("""file_path=%s""" % arg))
except ValueError as e:
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 params.file_path is None or not os.path.isfile(
params.file_path) and source_data is None:
master_phil.show()
raise Usage(
"file_path must be defined (either file_path=XXX, or the path alone)."
)
assert params.handedness is not None
assert params.n_bins is not None
assert params.verbose is not None
assert params.output_bins is not None
if source_data is None:
from libtbx import easy_pickle
source_data = easy_pickle.load(params.file_path)
if params.output_file is None:
logger = sys.stdout
else:
logger = open(params.output_file, 'w')
logger.write("%s " % params.output_file)
if not "DETECTOR_ADDRESS" in source_data:
# legacy format; try to guess the address
LCLS_detector_address = 'CxiDs1-0|Cspad-0'
if "DISTANCE" in source_data and source_data["DISTANCE"] > 1000:
# downstream CS-PAD detector station of CXI instrument
LCLS_detector_address = 'CxiDsd-0|Cspad-0'
else:
LCLS_detector_address = source_data["DETECTOR_ADDRESS"]
timesec = reverse_timestamp(source_data["TIMESTAMP"])[0]
version_lookup = detector_format_function(LCLS_detector_address, timesec)
args = [
"distl.detector_format_version=%s" % version_lookup,
"viewer.powder_arcs.show=False",
"viewer.powder_arcs.code=3n9c",
]
horizons_phil = cxi_phil.cxi_versioned_extract(args).persist.commands
img = NpyImage(params.file_path, source_data)
img.readHeader(horizons_phil)
img.translate_tiles(horizons_phil)
if params.verbose:
img.show_header()
the_tiles = img.get_tile_manager(
horizons_phil).effective_tiling_as_flex_int(
reapply_peripheral_margin=False, encode_inactive_as_zeroes=True)
if params.beam_x is None:
params.beam_x = img.beamx / img.pixel_size
if params.beam_y is None:
params.beam_y = img.beamy / img.pixel_size
if params.verbose:
logger.write("I think the beam center is (%s,%s)\n" %
(params.beam_x, params.beam_y))
bc = (int(params.beam_x), int(params.beam_y))
extent = int(
math.ceil(
max(distance((0, 0), bc), distance((img.size1, 0), bc),
distance((0, img.size2), bc),
distance((img.size1, img.size2), bc))))
if params.n_bins < extent:
params.n_bins = extent
extent_in_mm = extent * img.pixel_size
extent_two_theta = math.atan(extent_in_mm / img.distance) * 180 / math.pi
sums = flex.double(params.n_bins) * 0
sums_sq = flex.double(params.n_bins) * 0
counts = flex.int(params.n_bins) * 0
data = img.get_raw_data()
if hasattr(data, "as_double"):
data = data.as_double()
logger.write("Average intensity: %9.3f\n" % flex.mean(data))
if params.verbose:
logger.write("Generating average...tile:")
logger.flush()
for tile in xrange(len(the_tiles) // 4):
if params.verbose:
logger.write(" %d" % tile)
logger.flush()
x1, y1, x2, y2 = get_tile_coords(the_tiles, tile)
radial_average(data, bc, sums, sums_sq, counts, img.pixel_size,
img.distance, (x1, y1), (x2, y2))
if params.verbose:
logger.write(" Finishing...\n")
# average, avoiding division by zero
results = sums.set_selected(counts <= 0, 0)
results /= counts.set_selected(counts <= 0, 1).as_double()
# calculte standard devations
std_devs = [
math.sqrt((sums_sq[i] - sums[i] * results[i]) /
counts[i]) if counts[i] > 0 else 0 for i in xrange(len(sums))
]
xvals = flex.double(len(results))
max_twotheta = float('-inf')
max_result = float('-inf')
for i in xrange(len(results)):
twotheta = i * extent_two_theta / params.n_bins
xvals[i] = twotheta
if params.output_bins and "%.3f" % results[i] != "nan":
#logger.write("%9.3f %9.3f\n"% (twotheta,results[i])) #.xy format for Rex.cell.
logger.write(
"%9.3f %9.3f %9.3f\n" %
(twotheta, results[i], std_devs[i])) #.xye format for GSASII
#logger.write("%.3f %.3f %.3f\n"%(twotheta,results[i],ds[i])) # include calculated d spacings
if results[i] > max_result:
max_twotheta = twotheta
max_result = results[i]
logger.write(
"Maximum 2theta for %s, TS %s: %f, value: %f\n" %
(params.file_path, source_data['TIMESTAMP'], max_twotheta, max_result))
if params.verbose:
from pylab import scatter, show, xlabel, ylabel, ylim
scatter(xvals, results)
xlabel("2 theta")
ylabel("Avg ADUs")
if params.plot_y_max is not None:
ylim(0, params.plot_y_max)
show()
return xvals, results
if len(sys.argv) <= 1:
print(
"Listing of all known detector formats. Use cxi.detector_format_versions <version> to show the quadrant and unit pixel translations for a given format version"
)
print()
print(
"Format version Det. address Start time End time"
)
for key in sorted(_detector_format_version_dict):
print_version(key)
else:
from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract
for version in sys.argv[1:]:
if version not in _detector_format_version_dict:
print("Version %s not found. Did you use quotes?" % version)
continue
print("Showing info for %s detector format version" % version)
print()
print(
"Format version Det. address Start time End time"
)
print_version(version)
print()
phil = cxi_versioned_extract(
["distl.detector_format_version=%s" % version])
print("Quad translations:", phil.distl.quad_translations)
print("Tile translations:", phil.distl.tile_translations)
def __init__(self, **kwargs):
"""The _Format constructor builds a dxtbx Format instance from the
supplied keyworded arguments. It should be equivalent to the
FormatPYunspecified constructor.
"""
from copy import deepcopy
from dxtbx.model.beam import Beam, beam_factory
from dxtbx.model.detector import Detector, detector_factory
from dxtbx.model.goniometer import Goniometer, goniometer_factory
from dxtbx.model.scan import Scan, scan_factory
from spotfinder.applications.xfel import cxi_phil
from iotbx.detectors.cspad_detector_formats import detector_format_version
# From Format.__init__().
self._goniometer_factory = goniometer_factory
self._detector_factory = detector_factory
self._beam_factory = beam_factory
self._scan_factory = scan_factory
# From FormatPYunspecified._start(). Split the keyworded
# arguments into a parameter dictionary suitable for
# iotbx.detectors.npy.NpyImage and a separate image data object.
parameters = dict(
BEAM_CENTER_X=kwargs['PIXEL_SIZE'] * kwargs['BEAM_CENTER'][0],
BEAM_CENTER_Y=kwargs['PIXEL_SIZE'] * kwargs['BEAM_CENTER'][1],
CCD_IMAGE_SATURATION=kwargs['SATURATED_VALUE'],
DISTANCE=kwargs['DISTANCE'],
OSC_RANGE=0,
OSC_START=0,
PIXEL_SIZE=kwargs['PIXEL_SIZE'],
SATURATED_VALUE=kwargs['SATURATED_VALUE'],
SIZE1=kwargs['DATA'].focus()[0],
SIZE2=kwargs['DATA'].focus()[1],
WAVELENGTH=kwargs['WAVELENGTH'])
self.detectorbase = _ImgDict(kwargs['DATA'], parameters)
# Attempt to apply tile translations only for detectors that
# support it.
version_lookup = detector_format_version(kwargs['DETECTOR_ADDRESS'],
kwargs['TIME_TUPLE'][0])
if version_lookup is not None:
params = cxi_phil.cxi_versioned_extract(
"distl.detector_format_version=" + version_lookup)
# Necessary to keep the phil parameters for subsequent calls to
# get_tile_manager().
horizons_phil = params.persist.commands
self.detectorbase.translate_tiles(horizons_phil)
self.detectorbase.horizons_phil_cache = deepcopy(horizons_phil)
# From Format.setup().
goniometer_instance = self._goniometer()
assert (isinstance(goniometer_instance, Goniometer))
self._goniometer_instance = goniometer_instance
detector_instance = self._detector()
assert (isinstance(detector_instance, Detector))
self._detector_instance = detector_instance
beam_instance = self._beam()
assert (isinstance(beam_instance, Beam))
self._beam_instance = beam_instance
scan_instance = self._scan()
assert (isinstance(scan_instance, Scan))
self._scan_instance = scan_instance
def __init__(self, **kwargs):
"""The _Format constructor builds a dxtbx Format instance from the
supplied keyworded arguments. It should be equivalent to the
FormatPYunspecified constructor.
"""
from copy import deepcopy
from dxtbx.model.beam import Beam, beam_factory
from dxtbx.model.detector import Detector, detector_factory
from dxtbx.model.goniometer import Goniometer, goniometer_factory
from dxtbx.model.scan import Scan, scan_factory
from spotfinder.applications.xfel import cxi_phil
from xfel.detector_formats import detector_format_version
# From Format.__init__().
self._goniometer_factory = goniometer_factory
self._detector_factory = detector_factory
self._beam_factory = beam_factory
self._scan_factory = scan_factory
# From FormatPYunspecified._start(). Split the keyworded
# arguments into a parameter dictionary suitable for
# iotbx.detectors.npy.NpyImage and a separate image data object.
parameters = dict(
BEAM_CENTER_X=kwargs['PIXEL_SIZE'] * kwargs['BEAM_CENTER'][0],
BEAM_CENTER_Y=kwargs['PIXEL_SIZE'] * kwargs['BEAM_CENTER'][1],
CCD_IMAGE_SATURATION=kwargs['SATURATED_VALUE'],
DISTANCE=kwargs['DISTANCE'],
OSC_RANGE=0,
OSC_START=0,
PIXEL_SIZE=kwargs['PIXEL_SIZE'],
SATURATED_VALUE=kwargs['SATURATED_VALUE'],
SIZE1=kwargs['DATA'].focus()[0],
SIZE2=kwargs['DATA'].focus()[1],
WAVELENGTH=kwargs['WAVELENGTH'])
self.detectorbase = _ImgDict(kwargs['DATA'], parameters)
# Attempt to apply tile translations only for detectors that
# support it.
version_lookup = detector_format_version(
kwargs['DETECTOR_ADDRESS'],
kwargs['TIME_TUPLE'][0])
if version_lookup is not None:
params = cxi_phil.cxi_versioned_extract(
"distl.detector_format_version=" + version_lookup)
# Necessary to keep the phil parameters for subsequent calls to
# get_tile_manager().
horizons_phil = params.persist.commands
self.detectorbase.translate_tiles(horizons_phil)
self.detectorbase.horizons_phil_cache = deepcopy(horizons_phil)
# From Format.setup().
goniometer_instance = self._goniometer()
assert(isinstance(goniometer_instance, Goniometer))
self._goniometer_instance = goniometer_instance
detector_instance = self._detector()
assert(isinstance(detector_instance, Detector))
self._detector_instance = detector_instance
beam_instance = self._beam()
assert(isinstance(beam_instance, Beam))
self._beam_instance = beam_instance
scan_instance = self._scan()
assert(isinstance(scan_instance, Scan))
self._scan_instance = scan_instance
