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 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 get_CSPAD_active_areas(image, version_phil):
from libtbx.phil import parse
from iotbx.detectors.npy import NpyImage
from spotfinder.applications.xfel.cxi_phil import cxi_basic_start
data = pickle.load(open(image, "rb"))
scope = parse(file_name=version_phil)
basic_scope = cxi_basic_start()
new_scope = basic_scope.phil_scope.fetch(source=scope)
phil = new_scope.extract()
img = NpyImage("dummy", source_data=data)
img.readHeader(phil)
tm = img.get_tile_manager(phil)
return list(tm.effective_tiling_as_flex_int())
def tiling_from_image(self):
if self.tm is not None:
return self.tm
labelit_regression = libtbx.env.find_in_repositories(
relative_path="labelit_regression", test=os.path.isdir)
if detector_phil is None:
detector_phil = os.path.join(labelit_regression, "xfel",
"cxi-10.1.phil")
detector_scope = parse(file_name=detector_phil)
basic_scope = cxi_basic_start()
new_scope = basic_scope.phil_scope.fetch(source=detector_scope)
tiling_phil = new_scope.extract()
img = NpyImage("dummy", source_data=img_data)
img.readHeader(tiling_phil)
self.tm = img.get_tile_manager(phil)
return self.tm
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 ImageFactory(filename):
global parameters
if type(filename)==type("") and os.path.isfile(filename):
from dxtbx.format.FormatPYunspecified import FormatPYunspecified
assert FormatPYunspecified.understand(filename)
I = FormatPYunspecified(filename).get_detectorbase()
else:
print "This is not a file; assume the data are in the defined dictionary format"
I = NpyImage(filename, source_data=parameters.horizons_phil.indexing.data)
I.readHeader(parameters.horizons_phil)
I.translate_tiles(parameters.horizons_phil)
#from xfel.cxi.display_powder_arcs import apply_gaussian_noise
#apply_gaussian_noise(I,parameters.horizons_phil)
if (parameters.horizons_phil.viewer.powder_arcs.show):
from xfel.cxi.display_powder_arcs import superimpose_powder_arcs
superimpose_powder_arcs(I,parameters.horizons_phil)
return I
def ImageFactory(path):
if os.path.isfile(path):
I = NpyImage(path)
I.readHeader()
return (I)
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))
evt = fake_evt(data3d)
beam_center, active_areas = cbcaa(fake_config(), sections)
data = flex.int(
CsPadDetector(address, evt, env, sections).astype(numpy.float64))
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
def ImageFactory(path):
if os.path.isfile(path):
I = NpyImage(path)
I.readHeader()
return (I)
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
evt = fake_evt(data3d)
beam_center, active_areas = cbcaa(fake_config(),sections)
data = flex.int(CsPadDetector(address, evt, env, sections).astype(numpy.float64))
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 params.resolution is not None:
def ImageFactory(filename):
if os.path.isfile(filename):
I = NpyImage(filename)
I.readHeader()
return I
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" %
def ImageFactory(filename):
if os.path.isfile(filename):
I = NpyImage(filename)
I.readHeader()
return I
