def make_phil(phil_file=None, show_phil=False):
if phil_file:
with open(phil_file, "r") as pf:
spf_phil = ip.parse(pf.read())
else:
spf_phil = ip.parse(spf_params_string)
new_phil = spf_scope.fetch(source=spf_phil)
spf_params = new_phil.extract()
if show_phil:
diff_phil = spf_scope.fetch_diff(source=spf_phil)
diff_phil.show()
return spf_params
def work(filename, cl=None):
if cl is None:
cl = []
import libtbx.phil
phil_scope = libtbx.phil.parse('''\
index = False
.type = bool
integrate = False
.type = bool
indexing_min_spots = 10
.type = int(value_min=1)
''')
if not os.access(filename, os.R_OK):
raise RuntimeError("Server does not have read access to file %s" %filename)
interp = phil_scope.command_line_argument_interpreter()
params, unhandled = interp.process_and_fetch(
cl, custom_processor='collect_remaining')
index = params.extract().index
integrate = params.extract().integrate
indexing_min_spots = params.extract().indexing_min_spots
from dials.command_line.find_spots import phil_scope as find_spots_phil_scope
from dxtbx.datablock import DataBlockFactory
from dials.array_family import flex
interp = find_spots_phil_scope.command_line_argument_interpreter()
phil_scope, unhandled = interp.process_and_fetch(
unhandled, custom_processor='collect_remaining')
logger.info('The following spotfinding parameters have been modified:')
logger.info(find_spots_phil_scope.fetch_diff(source=phil_scope).as_str())
params = phil_scope.extract()
# no need to write the hot mask in the server/client
params.spotfinder.write_hot_mask = False
datablock = DataBlockFactory.from_filenames([filename])[0]
t0 = time.time()
reflections = flex.reflection_table.from_observations(datablock, params)
t1 = time.time()
logger.info('Spotfinding took %.2f seconds' %(t1-t0))
from dials.algorithms.spot_finding import per_image_analysis
imageset = datablock.extract_imagesets()[0]
scan = imageset.get_scan()
if scan is not None:
i = scan.get_array_range()[0]
else:
i = 0
stats = per_image_analysis.stats_single_image(
imageset, reflections, i=i, plot=False)
stats = stats.__dict__
t2 = time.time()
logger.info('Resolution analysis took %.2f seconds' %(t2-t1))
if index and stats['n_spots_no_ice'] > indexing_min_spots:
import logging
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
from dials.algorithms.indexing import indexer
interp = indexer.master_phil_scope.command_line_argument_interpreter()
phil_scope, unhandled = interp.process_and_fetch(
unhandled, custom_processor='collect_remaining')
imagesets = [imageset]
logger.info('The following indexing parameters have been modified:')
indexer.master_phil_scope.fetch_diff(source=phil_scope).show()
params = phil_scope.extract()
params.indexing.scan_range=[]
if (imageset.get_goniometer() is not None and
imageset.get_scan() is not None and
imageset.get_scan().get_oscillation()[1] == 0):
imageset.set_goniometer(None)
imageset.set_scan(None)
try:
idxr = indexer.indexer_base.from_parameters(
reflections, imagesets, params=params)
indexing_results = []
idxr.index()
indexed_sel = idxr.refined_reflections.get_flags(
idxr.refined_reflections.flags.indexed)
indexed_sel &= ~(idxr.refined_reflections.get_flags(
idxr.refined_reflections.flags.centroid_outlier))
for i_expt, expt in enumerate(idxr.refined_experiments):
sel = idxr.refined_reflections['id'] == i_expt
sel &= indexed_sel
indexing_results.append({
'crystal': expt.crystal.to_dict(),
'n_indexed': sel.count(True),
'fraction_indexed': sel.count(True)/sel.size()})
stats['lattices'] = indexing_results
stats['n_indexed'] = indexed_sel.count(True)
stats['fraction_indexed'] = indexed_sel.count(True)/len(reflections)
except Exception, e:
logger.error(e)
stats['error'] = str(e)
#stats.crystal = None
#stats.n_indexed = None
#stats.fraction_indexed = None
finally:
def work(filename, cl=None):
if cl is None:
cl = []
import libtbx.phil
phil_scope = libtbx.phil.parse('''\
ice_rings {
filter = True
.type = bool
width = 0.004
.type = float(value_min=0.0)
}
index = False
.type = bool
integrate = False
.type = bool
indexing_min_spots = 10
.type = int(value_min=1)
''')
if not os.access(filename, os.R_OK):
raise RuntimeError("Server does not have read access to file %s" %
filename)
interp = phil_scope.command_line_argument_interpreter()
params, unhandled = interp.process_and_fetch(
cl, custom_processor='collect_remaining')
filter_ice = params.extract().ice_rings.filter
ice_rings_width = params.extract().ice_rings.width
index = params.extract().index
integrate = params.extract().integrate
indexing_min_spots = params.extract().indexing_min_spots
from dials.command_line.find_spots import phil_scope as find_spots_phil_scope
from dxtbx.datablock import DataBlockFactory
from dials.array_family import flex
interp = find_spots_phil_scope.command_line_argument_interpreter()
phil_scope, unhandled = interp.process_and_fetch(
unhandled, custom_processor='collect_remaining')
logger.info('The following spotfinding parameters have been modified:')
logger.info(find_spots_phil_scope.fetch_diff(source=phil_scope).as_str())
params = phil_scope.extract()
# no need to write the hot mask in the server/client
params.spotfinder.write_hot_mask = False
datablock = DataBlockFactory.from_filenames([filename])[0]
t0 = time.time()
reflections = flex.reflection_table.from_observations(datablock, params)
t1 = time.time()
logger.info('Spotfinding took %.2f seconds' % (t1 - t0))
from dials.algorithms.spot_finding import per_image_analysis
imageset = datablock.extract_imagesets()[0]
scan = imageset.get_scan()
if scan is not None:
i = scan.get_array_range()[0]
else:
i = 0
stats = per_image_analysis.stats_single_image(
imageset,
reflections,
i=i,
plot=False,
filter_ice=filter_ice,
ice_rings_width=ice_rings_width)
stats = stats.__dict__
t2 = time.time()
logger.info('Resolution analysis took %.2f seconds' % (t2 - t1))
if index and stats['n_spots_no_ice'] > indexing_min_spots:
import logging
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
from dials.algorithms.indexing import indexer
interp = indexer.master_phil_scope.command_line_argument_interpreter()
phil_scope, unhandled = interp.process_and_fetch(
unhandled, custom_processor='collect_remaining')
imagesets = [imageset]
logger.info('The following indexing parameters have been modified:')
indexer.master_phil_scope.fetch_diff(source=phil_scope).show()
params = phil_scope.extract()
params.indexing.scan_range = []
if (imageset.get_goniometer() is not None
and imageset.get_scan() is not None
and imageset.get_scan().get_oscillation()[1] == 0):
imageset.set_goniometer(None)
imageset.set_scan(None)
try:
idxr = indexer.indexer_base.from_parameters(reflections,
imagesets,
params=params)
indexing_results = []
idxr.index()
indexed_sel = idxr.refined_reflections.get_flags(
idxr.refined_reflections.flags.indexed)
indexed_sel &= ~(idxr.refined_reflections.get_flags(
idxr.refined_reflections.flags.centroid_outlier))
for i_expt, expt in enumerate(idxr.refined_experiments):
sel = idxr.refined_reflections['id'] == i_expt
sel &= indexed_sel
indexing_results.append({
'crystal':
expt.crystal.to_dict(),
'n_indexed':
sel.count(True),
'fraction_indexed':
sel.count(True) / sel.size()
})
stats['lattices'] = indexing_results
stats['n_indexed'] = indexed_sel.count(True)
stats['fraction_indexed'] = indexed_sel.count(True) / len(
reflections)
except Exception as e:
logger.error(e)
stats['error'] = str(e)
#stats.crystal = None
#stats.n_indexed = None
#stats.fraction_indexed = None
finally:
t3 = time.time()
logger.info('Indexing took %.2f seconds' % (t3 - t2))
if integrate and 'lattices' in stats:
from dials.algorithms.profile_model.factory import ProfileModelFactory
from dials.algorithms.integration.integrator import IntegratorFactory
from dials.command_line.integrate import phil_scope as integrate_phil_scope
interp = integrate_phil_scope.command_line_argument_interpreter()
phil_scope, unhandled = interp.process_and_fetch(
unhandled, custom_processor='collect_remaining')
imagesets = [imageset]
logger.error(
'The following integration parameters have been modified:')
integrate_phil_scope.fetch_diff(source=phil_scope).show()
params = phil_scope.extract()
try:
params.profile.gaussian_rs.min_spots = 0
experiments = idxr.refined_experiments
reference = idxr.refined_reflections
predicted = flex.reflection_table.from_predictions_multi(
experiments,
dmin=params.prediction.d_min,
dmax=params.prediction.d_max,
margin=params.prediction.margin,
force_static=params.prediction.force_static)
matched, reference, unmatched = predicted.match_with_reference(
reference)
assert (len(matched) == len(predicted))
assert (matched.count(True) <= len(reference))
if matched.count(True) == 0:
raise Sorry('''
Invalid input for reference reflections.
Zero reference spots were matched to predictions
''')
elif matched.count(True) != len(reference):
logger.info('')
logger.info('*' * 80)
logger.info(
'Warning: %d reference spots were not matched to predictions'
% (len(reference) - matched.count(True)))
logger.info('*' * 80)
logger.info('')
# Compute the profile model
experiments = ProfileModelFactory.create(
params, experiments, reference)
# Compute the bounding box
predicted.compute_bbox(experiments)
# Create the integrator
integrator = IntegratorFactory.create(params, experiments,
predicted)
# Integrate the reflections
reflections = integrator.integrate()
#print len(reflections)
stats['integrated_intensity'] = flex.sum(
reflections['intensity.sum.value'])
except Exception as e:
logger.error(e)
stats['error'] = str(e)
finally:
t4 = time.time()
logger.info('Integration took %.2f seconds' % (t4 - t3))
return stats
def work(filename, cl=None):
if cl is None:
cl = []
phil_scope = libtbx.phil.parse("""\
ice_rings {
filter = True
.type = bool
width = 0.004
.type = float(value_min=0.0)
}
index = False
.type = bool
integrate = False
.type = bool
indexing_min_spots = 10
.type = int(value_min=1)
""")
interp = phil_scope.command_line_argument_interpreter()
params, unhandled = interp.process_and_fetch(
cl, custom_processor="collect_remaining")
filter_ice = params.extract().ice_rings.filter
ice_rings_width = params.extract().ice_rings.width
index = params.extract().index
integrate = params.extract().integrate
indexing_min_spots = params.extract().indexing_min_spots
from dials.command_line.find_spots import phil_scope as find_spots_phil_scope
from dxtbx.model.experiment_list import ExperimentListFactory
from dials.array_family import flex
interp = find_spots_phil_scope.command_line_argument_interpreter()
phil_scope, unhandled = interp.process_and_fetch(
unhandled, custom_processor="collect_remaining")
logger.info("The following spotfinding parameters have been modified:")
logger.info(find_spots_phil_scope.fetch_diff(source=phil_scope).as_str())
params = phil_scope.extract()
# no need to write the hot mask in the server/client
params.spotfinder.write_hot_mask = False
experiments = ExperimentListFactory.from_filenames([filename])
t0 = time.time()
reflections = flex.reflection_table.from_observations(experiments, params)
t1 = time.time()
logger.info("Spotfinding took %.2f seconds" % (t1 - t0))
from dials.algorithms.spot_finding import per_image_analysis
imageset = experiments.imagesets()[0]
reflections.centroid_px_to_mm(experiments)
reflections.map_centroids_to_reciprocal_space(experiments)
stats = per_image_analysis.stats_for_reflection_table(
reflections, filter_ice=filter_ice,
ice_rings_width=ice_rings_width)._asdict()
t2 = time.time()
logger.info("Resolution analysis took %.2f seconds" % (t2 - t1))
if index and stats["n_spots_no_ice"] > indexing_min_spots:
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
from dials.algorithms.indexing import indexer
from dials.command_line.index import phil_scope as index_phil_scope
interp = index_phil_scope.command_line_argument_interpreter()
phil_scope, unhandled = interp.process_and_fetch(
unhandled, custom_processor="collect_remaining")
logger.info("The following indexing parameters have been modified:")
index_phil_scope.fetch_diff(source=phil_scope).show()
params = phil_scope.extract()
if (imageset.get_goniometer() is not None
and imageset.get_scan() is not None
and imageset.get_scan().is_still()):
imageset.set_goniometer(None)
imageset.set_scan(None)
try:
idxr = indexer.Indexer.from_parameters(reflections,
experiments,
params=params)
indexing_results = []
idxr.index()
indexed_sel = idxr.refined_reflections.get_flags(
idxr.refined_reflections.flags.indexed)
indexed_sel &= ~(idxr.refined_reflections.get_flags(
idxr.refined_reflections.flags.centroid_outlier))
for i_expt, expt in enumerate(idxr.refined_experiments):
sel = idxr.refined_reflections["id"] == i_expt
sel &= indexed_sel
indexing_results.append({
"crystal":
expt.crystal.to_dict(),
"n_indexed":
sel.count(True),
"fraction_indexed":
sel.count(True) / sel.size(),
})
stats["lattices"] = indexing_results
stats["n_indexed"] = indexed_sel.count(True)
stats["fraction_indexed"] = indexed_sel.count(True) / len(
reflections)
except Exception as e:
logger.error(e)
stats["error"] = str(e)
finally:
t3 = time.time()
logger.info("Indexing took %.2f seconds" % (t3 - t2))
if integrate and "lattices" in stats:
from dials.algorithms.profile_model.factory import ProfileModelFactory
from dials.algorithms.integration.integrator import IntegratorFactory
from dials.command_line.integrate import phil_scope as integrate_phil_scope
interp = integrate_phil_scope.command_line_argument_interpreter()
phil_scope, unhandled = interp.process_and_fetch(
unhandled, custom_processor="collect_remaining")
logger.error(
"The following integration parameters have been modified:")
integrate_phil_scope.fetch_diff(source=phil_scope).show()
params = phil_scope.extract()
try:
params.profile.gaussian_rs.min_spots = 0
experiments = idxr.refined_experiments
reference = idxr.refined_reflections
predicted = flex.reflection_table.from_predictions_multi(
experiments,
dmin=params.prediction.d_min,
dmax=params.prediction.d_max,
margin=params.prediction.margin,
force_static=params.prediction.force_static,
)
matched, reference, unmatched = predicted.match_with_reference(
reference)
assert len(matched) == len(predicted)
assert matched.count(True) <= len(reference)
if matched.count(True) == 0:
raise Sorry("""
Invalid input for reference reflections.
Zero reference spots were matched to predictions
""")
elif matched.count(True) != len(reference):
logger.info("")
logger.info("*" * 80)
logger.info(
"Warning: %d reference spots were not matched to predictions"
% (len(reference) - matched.count(True)))
logger.info("*" * 80)
logger.info("")
# Compute the profile model
experiments = ProfileModelFactory.create(
params, experiments, reference)
# Compute the bounding box
predicted.compute_bbox(experiments)
# Create the integrator
integrator = IntegratorFactory.create(params, experiments,
predicted)
# Integrate the reflections
reflections = integrator.integrate()
# print len(reflections)
stats["integrated_intensity"] = flex.sum(
reflections["intensity.sum.value"])
except Exception as e:
logger.error(e)
stats["error"] = str(e)
finally:
t4 = time.time()
logger.info("Integration took %.2f seconds" % (t4 - t3))
return stats
def work(filename, cl=None):
if cl is None:
cl = []
import libtbx.phil
phil_scope = libtbx.phil.parse('''\
index = False
.type = bool
integrate = False
.type = bool
indexing_min_spots = 10
.type = int(value_min=1)
''')
if not os.access(filename, os.R_OK):
raise RuntimeError("Server does not have read access to file %s" %filename)
interp = phil_scope.command_line_argument_interpreter()
params, unhandled = interp.process_and_fetch(
cl, custom_processor='collect_remaining')
index = params.extract().index
integrate = params.extract().integrate
indexing_min_spots = params.extract().indexing_min_spots
from dials.command_line.find_spots import phil_scope as find_spots_phil_scope
from dxtbx.datablock import DataBlockFactory
from dials.array_family import flex
interp = find_spots_phil_scope.command_line_argument_interpreter()
phil_scope, unhandled = interp.process_and_fetch(
unhandled, custom_processor='collect_remaining')
logger.info('The following spotfinding parameters have been modified:')
logger.info(find_spots_phil_scope.fetch_diff(source=phil_scope).as_str())
params = phil_scope.extract()
# no need to write the hot mask in the server/client
params.spotfinder.write_hot_mask = False
datablock = DataBlockFactory.from_filenames([filename])[0]
t0 = time.time()
reflections = flex.reflection_table.from_observations(datablock, params)
t1 = time.time()
logger.info('Spotfinding took %.2f seconds' %(t1-t0))
from dials.algorithms.spot_finding import per_image_analysis
imageset = datablock.extract_imagesets()[0]
scan = imageset.get_scan()
if scan is not None:
i = scan.get_array_range()[0]
else:
i = 0
stats = per_image_analysis.stats_single_image(
imageset, reflections, i=i, plot=False)
stats = stats.__dict__
t2 = time.time()
logger.info('Resolution analysis took %.2f seconds' %(t2-t1))
if index and stats['n_spots_no_ice'] > indexing_min_spots:
import logging
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
from dials.algorithms.indexing import indexer
from dxtbx.serialize.crystal import to_dict
interp = indexer.master_phil_scope.command_line_argument_interpreter()
phil_scope, unhandled = interp.process_and_fetch(
unhandled, custom_processor='collect_remaining')
imagesets = [imageset]
logger.info('The following indexing parameters have been modified:')
indexer.master_phil_scope.fetch_diff(source=phil_scope).show()
params = phil_scope.extract()
params.indexing.scan_range=[]
if (imageset.get_goniometer() is not None and
imageset.get_scan() is not None and
imageset.get_scan().get_oscillation()[1] == 0):
imageset.set_goniometer(None)
imageset.set_scan(None)
try:
idxr = indexer.indexer_base.from_parameters(
reflections, imagesets, params=params)
indexing_results = []
indexed_sel = idxr.refined_reflections.get_flags(
idxr.refined_reflections.flags.indexed)
indexed_sel &= ~(idxr.refined_reflections.get_flags(
idxr.refined_reflections.flags.centroid_outlier))
for i_expt, expt in enumerate(idxr.refined_experiments):
sel = idxr.refined_reflections['id'] == i_expt
sel &= indexed_sel
indexing_results.append({
'crystal': to_dict(expt.crystal),
'n_indexed': sel.count(True),
'fraction_indexed': sel.count(True)/sel.size()})
stats['lattices'] = indexing_results
stats['n_indexed'] = indexed_sel.count(True)
stats['fraction_indexed'] = indexed_sel.count(True)/len(reflections)
except Exception, e:
logger.error(e)
stats['error'] = str(e)
#stats.crystal = None
#stats.n_indexed = None
#stats.fraction_indexed = None
finally: