def run(show_plots,args):
from xfel.command_line.cxi_merge import master_phil
phil = iotbx.phil.process_command_line(args=args, master_string=master_phil).show()
work_params = phil.work.extract()
from xfel.merging.phil_validation import application,samosa
application(work_params)
samosa(work_params)
if ("--help" in args) :
libtbx.phil.parse(master_phil.show())
return
datadir = "."
written_files = []
if work_params.levmar.compute_cc_half:
for half_data_flag in [1,2,0]:
case = execute_case(datadir, work_params, plot=show_plots, half_data_flag=half_data_flag)
assert len(case.Fit_I)==len(case.ordered_intensities.indices())==len(case.reference_millers.indices())
model_subset = case.reference_millers[0:len(case.Fit_I)]
fitted_miller_array = miller.array (miller_set = model_subset,
data = case.Fit_I, sigmas = case.Fit_I_stddev)
fitted_miller_array.set_observation_type_xray_intensity()
output_result = fitted_miller_array.select(case.I_visited==1)
outfile = "%s_s%1d_levmar.mtz"%(work_params.output.prefix,half_data_flag)
output_result.show_summary(prefix="%s: "%outfile)
mtz_out = output_result.as_mtz_dataset(column_root_label="Iobs",title=outfile,wavelength=None)
mtz_obj = mtz_out.mtz_object()
mtz_obj.write(outfile)
written_files.append(outfile)
print "OK s%1d"%half_data_flag
#raw_input("OK?")
"""Guest code to retrieve the modified orientations after rotational fitting is done"""
if "Rxy" in work_params.levmar.parameter_flags:
all_A = [e.crystal.get_A() for e in case.experiments.get_experiments()]
all_files = case.experiments.get_files()
all_x = case.Fit["Ax"]
all_y = case.Fit["Ay"]
from scitbx import matrix
x_axis = matrix.col((1.,0.,0.))
y_axis = matrix.col((0.,1.,0.))
out = open("aaaaa","w")
for x in xrange(len(all_A)):
Rx = x_axis.axis_and_angle_as_r3_rotation_matrix(angle=all_x[x], deg=True)
Ry = y_axis.axis_and_angle_as_r3_rotation_matrix(angle=all_y[x], deg=True)
modified_A = Rx * Ry * all_A[x]
filename = all_files[x]
print >>out, filename, " ".join([str(a) for a in modified_A.elems])
work_params.scaling.algorithm="levmar"
from xfel.cxi.cxi_cc import run_cc
run_cc(work_params,work_params.model_reindex_op,sys.stdout)
else:
execute_case(datadir, work_params, plot=show_plots)
def run(show_plots,args):
from xfel.command_line.cxi_merge import master_phil
phil = iotbx.phil.process_command_line(args=args, master_string=master_phil).show()
work_params = phil.work.extract()
from xfel.merging.phil_validation import application,samosa
application(work_params)
samosa(work_params)
if ("--help" in args) :
libtbx.phil.parse(master_phil.show())
return
datadir = "."
written_files = []
if work_params.levmar.compute_cc_half:
for half_data_flag in [1,2,0]:
case = execute_case(datadir, work_params, plot=show_plots, half_data_flag=half_data_flag)
assert len(case.Fit_I)==len(case.ordered_intensities.indices())==len(case.reference_millers.indices())
model_subset = case.reference_millers[0:len(case.Fit_I)]
fitted_miller_array = miller.array (miller_set = model_subset,
data = case.Fit_I, sigmas = case.Fit_I_stddev)
fitted_miller_array.set_observation_type_xray_intensity()
output_result = fitted_miller_array.select(case.I_visited==1)
outfile = "%s_s%1d_levmar.mtz"%(work_params.output.prefix,half_data_flag)
output_result.show_summary(prefix="%s: "%outfile)
mtz_out = output_result.as_mtz_dataset(column_root_label="Iobs",title=outfile,wavelength=None)
mtz_obj = mtz_out.mtz_object()
mtz_obj.write(outfile)
written_files.append(outfile)
print "OK s%1d"%half_data_flag
#raw_input("OK?")
"""Guest code to retrieve the modified orientations after rotational fitting is done"""
if "Rxy" in work_params.levmar.parameter_flags:
all_A = [e.crystal.get_A() for e in case.experiments.get_experiments()]
all_files = case.experiments.get_files()
all_x = case.Fit["Ax"]
all_y = case.Fit["Ay"]
from scitbx import matrix
x_axis = matrix.col((1.,0.,0.))
y_axis = matrix.col((0.,1.,0.))
out = open("aaaaa","w")
for x in xrange(len(all_A)):
Rx = x_axis.axis_and_angle_as_r3_rotation_matrix(angle=all_x[x], deg=True)
Ry = y_axis.axis_and_angle_as_r3_rotation_matrix(angle=all_y[x], deg=True)
modified_A = Rx * Ry * all_A[x]
filename = all_files[x]
print >>out, filename, " ".join([str(a) for a in modified_A.elems])
work_params.scaling.algorithm="levmar"
from xfel.cxi.cxi_cc import run_cc
run_cc(work_params,work_params.model_reindex_op,sys.stdout)
table_data.append([""] * len(table_data[0]))
table_data.append(["All", "", '%8d' % n_frames])
print >> out
print >> out, table_utils.format(
table_data, has_header=1, justify='center', delim=' ')
reindexing_ops = {"h,k,l":0} # get a list of all reindexing ops for this dataset
if work_params.merging.reverse_lookup is not None:
for key in scaler.reverse_lookup:
if reindexing_ops.get(scaler.reverse_lookup[key], None) is None:
reindexing_ops[scaler.reverse_lookup[key]]=0
reindexing_ops[scaler.reverse_lookup[key]]+=1
from xfel.cxi.cxi_cc import run_cc
for key in reindexing_ops.keys():
run_cc(work_params,reindexing_op=key,output=out)
return result
if (__name__ == "__main__"):
show_plots = False
if ("--plots" in sys.argv) :
sys.argv.remove("--plots")
show_plots = True
result = run(args=sys.argv[1:])
if result is None:
sys.exit(1)
if (show_plots) :
try :
result.plots.show_all_pyplot()
from wxtbx.command_line import loggraph
has_header=1,
justify='center',
delim=' ')
reindexing_ops = {
"h,k,l": 0
} # get a list of all reindexing ops for this dataset
if work_params.merging.reverse_lookup is not None:
for key in scaler.reverse_lookup:
if reindexing_ops.get(scaler.reverse_lookup[key], None) is None:
reindexing_ops[scaler.reverse_lookup[key]] = 0
reindexing_ops[scaler.reverse_lookup[key]] += 1
from xfel.cxi.cxi_cc import run_cc
for key in reindexing_ops.keys():
run_cc(work_params, reindexing_op=key, output=out)
return result
if (__name__ == "__main__"):
show_plots = False
if ("--plots" in sys.argv):
sys.argv.remove("--plots")
show_plots = True
result = run(args=sys.argv[1:])
if result is None:
sys.exit(1)
if (show_plots):
try:
result.plots.show_all_pyplot()
from wxtbx.command_line import loggraph
def run(args):
phil = iotbx.phil.process_command_line(args=args,
master_string=master_phil).show()
work_params = phil.work.extract()
from xfel.merging.phil_validation import application
application(work_params)
if ("--help" in args):
libtbx.phil.parse(master_phil.show())
return
if ((work_params.d_min is None) or (work_params.data is None)
or ((work_params.model is None)
and work_params.scaling.algorithm != "mark1")):
raise Usage("cxi.merge "
"d_min=4.0 "
"data=~/scratch/r0220/006/strong/ "
"model=3bz1_3bz2_core.pdb")
if ((work_params.rescale_with_average_cell)
and (not work_params.set_average_unit_cell)):
raise Usage(
"If rescale_with_average_cell=True, you must also specify " +
"set_average_unit_cell=True.")
if work_params.raw_data.sdfac_auto and work_params.raw_data.sdfac_refine:
raise Usage("Cannot specify both sdfac_auto and sdfac_refine")
if not work_params.include_negatives_fix_27May2018:
work_params.include_negatives = False # use old behavior
log = open(
"%s_%s.log" %
(work_params.output.prefix, work_params.scaling.algorithm), "w")
out = multi_out()
out.register("log", log, atexit_send_to=None)
out.register("stdout", sys.stdout)
# Verify that the externally supplied isomorphous reference, if
# present, defines a suitable column of intensities, and exit with
# error if it does not. Then warn if it is necessary to generate
# Bijvoet mates. Failure to catch these issues here would lead to
# possibly obscure problems in cxi/cxi_cc.py later on.
try:
data_SR = mtz.object(work_params.scaling.mtz_file)
except RuntimeError:
pass
else:
array_SR = None
obs_labels = []
for array in data_SR.as_miller_arrays():
this_label = array.info().label_string().lower()
if array.observation_type() is not None:
obs_labels.append(this_label.split(',')[0])
if this_label.find('fobs') >= 0:
array_SR = array.as_intensity_array()
break
if this_label.find('imean') >= 0:
array_SR = array.as_intensity_array()
break
if this_label.find(work_params.scaling.mtz_column_F) == 0:
array_SR = array.as_intensity_array()
break
if array_SR is None:
known_labels = ['fobs', 'imean', work_params.scaling.mtz_column_F]
raise Usage(work_params.scaling.mtz_file +
" does not contain any observations labelled [" +
", ".join(known_labels) +
"]. Please set scaling.mtz_column_F to one of [" +
",".join(obs_labels) + "].")
elif not work_params.merge_anomalous and not array_SR.anomalous_flag():
print("Warning: Preserving anomalous contributors, but %s " \
"has anomalous contributors merged. Generating identical Bijvoet " \
"mates." % work_params.scaling.mtz_file, file=out)
# Read Nat's reference model from an MTZ file. XXX The observation
# type is given as F, not I--should they be squared? Check with Nat!
print("I model", file=out)
if work_params.model is not None:
from xfel.merging.general_fcalc import run
i_model = run(work_params)
work_params.target_unit_cell = i_model.unit_cell()
work_params.target_space_group = i_model.space_group_info()
i_model.show_summary()
else:
i_model = None
print("Target unit cell and space group:", file=out)
print(" ", work_params.target_unit_cell, file=out)
print(" ", work_params.target_space_group, file=out)
miller_set, i_model = consistent_set_and_model(work_params, i_model)
# ---- Augment this code with any special procedures for x scaling
scaler = xscaling_manager(miller_set=miller_set,
i_model=i_model,
params=work_params,
log=out)
scaler.scale_all()
if scaler.n_accepted == 0:
return None
# --- End of x scaling
scaler.uc_values = unit_cell_distribution()
for icell in range(len(scaler.frames["unit_cell"])):
if scaler.params.model is None:
scaler.uc_values.add_cell(
unit_cell=scaler.frames["unit_cell"][icell])
else:
scaler.uc_values.add_cell(
unit_cell=scaler.frames["unit_cell"][icell],
rejected=(scaler.frames["cc"][icell] < scaler.params.min_corr))
scaler.show_unit_cell_histograms()
if (work_params.rescale_with_average_cell):
average_cell_abc = scaler.uc_values.get_average_cell_dimensions()
average_cell = uctbx.unit_cell(
list(average_cell_abc) +
list(work_params.target_unit_cell.parameters()[3:]))
work_params.target_unit_cell = average_cell
print("", file=out)
print("#" * 80, file=out)
print("RESCALING WITH NEW TARGET CELL", file=out)
print(" average cell: %g %g %g %g %g %g" % \
work_params.target_unit_cell.parameters(), file=out)
print("", file=out)
scaler.reset()
scaler = xscaling_manager(miller_set=miller_set,
i_model=i_model,
params=work_params,
log=out)
scaler.scale_all()
scaler.uc_values = unit_cell_distribution()
for icell in range(len(scaler.frames["unit_cell"])):
if scaler.params.model is None:
scaler.uc_values.add_cell(
unit_cell=scaler.frames["unit_cell"][icell])
else:
scaler.uc_values.add_cell(
unit_cell=scaler.frames["unit_cell"][icell],
rejected=(scaler.frames["cc"][icell] <
scaler.params.min_corr))
scaler.show_unit_cell_histograms()
if False: #(work_params.output.show_plots) :
try:
plot_overall_completeness(completeness)
except Exception as e:
print("ERROR: can't show plots")
print(" %s" % str(e))
print("\n", file=out)
reserve_prefix = work_params.output.prefix
for data_subset in [1, 2, 0]:
work_params.data_subset = data_subset
work_params.output.prefix = "%s_s%1d_%s" % (
reserve_prefix, data_subset, work_params.scaling.algorithm)
if work_params.data_subset == 0:
scaler.frames["data_subset"] = flex.bool(
scaler.frames["frame_id"].size(), True)
elif work_params.data_subset == 1:
scaler.frames["data_subset"] = scaler.frames["odd_numbered"]
elif work_params.data_subset == 2:
scaler.frames["data_subset"] = scaler.frames[
"odd_numbered"] == False
# --------- New code ------------------
#sanity check
for mod, obs in zip(miller_set.indices(),
scaler.millers["merged_asu_hkl"]):
if mod != obs:
raise Exception(
"miller index lists inconsistent--check d_min are equal for merge and xmerge scripts"
)
assert mod == obs
"""Sum the observations of I and I/sig(I) for each reflection.
sum_I = flex.double(i_model.size(), 0.)
sum_I_SIGI = flex.double(i_model.size(), 0.)
scaler.completeness = flex.int(i_model.size(), 0)
scaler.summed_N = flex.int(i_model.size(), 0)
scaler.summed_wt_I = flex.double(i_model.size(), 0.)
scaler.summed_weight = flex.double(i_model.size(), 0.)
scaler.n_rejected = flex.double(scaler.frames["frame_id"].size(), 0.)
scaler.n_obs = flex.double(scaler.frames["frame_id"].size(), 0.)
scaler.d_min_values = flex.double(scaler.frames["frame_id"].size(), 0.)
scaler.ISIGI = {}"""
from xfel import scaling_results, get_scaling_results, get_isigi_dict
results = scaling_results(scaler._observations, scaler._frames,
scaler.millers["merged_asu_hkl"],
scaler.frames["data_subset"],
work_params.include_negatives)
results.__getattribute__(work_params.scaling.algorithm)(
scaler.params.min_corr, scaler.params.target_unit_cell)
sum_I, sum_I_SIGI, \
scaler.completeness, scaler.summed_N, \
scaler.summed_wt_I, scaler.summed_weight, scaler.n_rejected, scaler.n_obs, \
scaler.d_min_values, hkl_ids, i_sigi_list = get_scaling_results(results)
scaler.ISIGI = get_isigi_dict(results)
if work_params.merging.refine_G_Imodel:
from xfel.cxi.merging.refine import find_scale
my_find_scale = find_scale(scaler, work_params)
sum_I, sum_I_SIGI, \
scaler.completeness, scaler.summed_N, \
scaler.summed_wt_I, scaler.summed_weight, scaler.n_rejected, \
scaler.n_obs, scaler.d_min_values, hkl_ids, i_sigi_list \
= my_find_scale.get_scaling_results(results, scaler)
scaler.ISIGI = get_isigi_dict(results)
scaler.wavelength = scaler.frames["wavelength"]
scaler.corr_values = scaler.frames["cc"]
scaler.rejected_fractions = flex.double(
scaler.frames["frame_id"].size(), 0.)
for irej in range(len(scaler.rejected_fractions)):
if scaler.n_obs[irej] > 0:
scaler.rejected_fractions = scaler.n_rejected[
irej] / scaler.n_obs[irej]
# ---------- End of new code ----------------
if work_params.raw_data.sdfac_refine or work_params.raw_data.errors_from_sample_residuals:
if work_params.raw_data.sdfac_refine:
if work_params.raw_data.error_models.sdfac_refine.minimizer == 'simplex':
from xfel.merging.algorithms.error_model.sdfac_refine import sdfac_refine as error_modeler
elif work_params.raw_data.error_models.sdfac_refine.minimizer == 'lbfgs':
from xfel.merging.algorithms.error_model.sdfac_refine_lbfgs import sdfac_refine_refltable_lbfgs as error_modeler
elif self.params.raw_data.error_models.sdfac_refine.minimizer == 'LevMar':
from xfel.merging.algorithms.error_model.sdfac_refine_levmar import sdfac_refine_refltable_levmar as error_modeler
if work_params.raw_data.errors_from_sample_residuals:
from xfel.merging.algorithms.error_model.errors_from_residuals import errors_from_residuals as error_modeler
error_modeler(scaler).adjust_errors()
if work_params.raw_data.reduced_chi_squared_correction:
from xfel.merging.algorithms.error_model.reduced_chi_squared import reduced_chi_squared
reduced_chi_squared(scaler).compute()
miller_set_avg = miller_set.customized_copy(
unit_cell=work_params.target_unit_cell)
table1 = show_overall_observations(
obs=miller_set_avg,
redundancy=scaler.completeness,
redundancy_to_edge=None,
summed_wt_I=scaler.summed_wt_I,
summed_weight=scaler.summed_weight,
ISIGI=scaler.ISIGI,
n_bins=work_params.output.n_bins,
title="Statistics for all reflections",
out=out,
work_params=work_params)
if table1 is None:
raise Exception("table could not be constructed")
print("", file=out)
if work_params.scaling.algorithm == 'mark0':
n_refl, corr = scaler.get_overall_correlation(sum_I)
else:
n_refl, corr = ((scaler.completeness > 0).count(True), 0)
print("\n", file=out)
table2 = show_overall_observations(
obs=miller_set_avg,
redundancy=scaler.summed_N,
redundancy_to_edge=None,
summed_wt_I=scaler.summed_wt_I,
summed_weight=scaler.summed_weight,
ISIGI=scaler.ISIGI,
n_bins=work_params.output.n_bins,
title="Statistics for reflections where I > 0",
out=out,
work_params=work_params)
if table2 is None:
raise Exception("table could not be constructed")
print("", file=out)
mtz_file, miller_array = scaler.finalize_and_save_data()
loggraph_file = os.path.abspath("%s_graphs.log" %
work_params.output.prefix)
f = open(loggraph_file, "w")
f.write(table1.format_loggraph())
f.write("\n")
f.write(table2.format_loggraph())
f.close()
result = scaling_result(miller_array=miller_array,
plots=scaler.get_plot_statistics(),
mtz_file=mtz_file,
loggraph_file=loggraph_file,
obs_table=table1,
all_obs_table=table2,
n_reflections=n_refl,
overall_correlation=corr)
easy_pickle.dump("%s.pkl" % work_params.output.prefix, result)
work_params.output.prefix = reserve_prefix
# Output table with number of images contribution reflections per
# resolution bin.
from libtbx import table_utils
miller_set_avg.setup_binner(d_max=100000,
d_min=work_params.d_min,
n_bins=work_params.output.n_bins)
table_data = [["Bin", "Resolution Range", "# images", "%accept"]]
if work_params.model is None:
appropriate_min_corr = -1.1 # lowest possible c.c.
else:
appropriate_min_corr = work_params.min_corr
n_frames = (scaler.frames['cc'] > appropriate_min_corr).count(True)
iselect = 1
while iselect < work_params.output.n_bins:
col_count1 = results.count_frames(
appropriate_min_corr,
miller_set_avg.binner().selection(iselect))
print("colcount1", col_count1)
if col_count1 > 0: break
iselect += 1
if col_count1 == 0: raise Exception("no reflections in any bins")
for i_bin in miller_set_avg.binner().range_used():
col_count = '%8d' % results.count_frames(
appropriate_min_corr,
miller_set_avg.binner().selection(i_bin))
col_legend = '%-13s' % miller_set_avg.binner().bin_legend(
i_bin=i_bin,
show_bin_number=False,
show_bin_range=False,
show_d_range=True,
show_counts=False)
xpercent = results.count_frames(
appropriate_min_corr,
miller_set_avg.binner().selection(i_bin)) / float(n_frames)
percent = '%5.2f' % (100. * xpercent)
table_data.append(['%3d' % i_bin, col_legend, col_count, percent])
table_data.append([""] * len(table_data[0]))
table_data.append(["All", "", '%8d' % n_frames])
print(file=out)
print(table_utils.format(table_data,
has_header=1,
justify='center',
delim=' '),
file=out)
reindexing_ops = {
"h,k,l": 0
} # get a list of all reindexing ops for this dataset
if work_params.merging.reverse_lookup is not None:
for key in scaler.reverse_lookup:
if reindexing_ops.get(scaler.reverse_lookup[key], None) is None:
reindexing_ops[scaler.reverse_lookup[key]] = 0
reindexing_ops[scaler.reverse_lookup[key]] += 1
from xfel.cxi.cxi_cc import run_cc
for key in reindexing_ops.keys():
run_cc(work_params, reindexing_op=key, output=out)
if isinstance(scaler.ISIGI, dict):
from xfel.merging import isigi_dict_to_reflection_table
refls = isigi_dict_to_reflection_table(scaler.miller_set.indices(),
scaler.ISIGI)
else:
refls = scaler.ISIGI
easy_pickle.dump("%s.refl" % work_params.output.prefix, refls)
return result
outfile = "%s_s%1d_levmar.mtz" % (tag, half_data_flag)
output_result.show_summary(prefix="%s: " % outfile)
mtz_out = output_result.as_mtz_dataset(
column_root_label="Iobs", title=outfile, wavelength=None)
mtz_obj = mtz_out.mtz_object()
mtz_obj.write(outfile)
written_files.append(outfile)
print "OK"
#raw_input("OK")
sys.stdout.flush()
from xfel.command_line.cxi_merge import master_phil
import iotbx.phil
args = [
"output.prefix=%s" % tag, "scaling.algorithm=levmar",
"d_min=%f" % (case.d_min),
"output.n_bins=%d" % (case.n_bins),
"model=%s" % (os.path.join(datadir, "not_used.pdb")),
"mtz_file=%s" % ("rigged_filename.mtz"), "mtz_column_F=iobs",
"merge_anomalous=True", "scaling.show_plots=False",
"log_cutoff=-20"
]
phil = iotbx.phil.process_command_line(
args=args, master_string=master_phil) # .show()
work_params = phil.work.extract()
from xfel.merging.phil_validation import application
application(work_params)
get_model_intensities(work_params, case.ordered_intensities)
from xfel.cxi.cxi_cc import run_cc
run_cc(work_params, "h,k,l", sys.stdout)
plot=plot_flag, esd_plot = esd_plot_flag,half_data_flag = half_data_flag)
model_subset = case.ordered_intensities[0:len(case.Fit_I)]
from cctbx.xray import observation_types
fitted_miller_array = model_subset.customized_copy(data = case.Fit_I, sigmas = case.Fit_I_stddev,
observation_type=observation_types.intensity())
output_result = fitted_miller_array.select(case.I_visited==1)
outfile = "%s_s%1d_levmar.mtz"%(tag,half_data_flag)
output_result.show_summary(prefix="%s: "%outfile)
mtz_out = output_result.as_mtz_dataset(column_root_label="Iobs",title=outfile,wavelength=None)
mtz_obj = mtz_out.mtz_object()
mtz_obj.write(outfile)
written_files.append(outfile)
print "OK"
#raw_input("OK")
sys.stdout.flush()
from xfel.command_line.cxi_merge import master_phil
import iotbx.phil
args = ["output.prefix=%s"%tag,"scaling.algorithm=levmar",
"d_min=%f"%(case.d_min),"output.n_bins=%d"%(case.n_bins),"model=%s"%(os.path.join(datadir,"not_used.pdb")),
"mtz_file=%s"%("rigged_filename.mtz"),
"mtz_column_F=iobs",
"merge_anomalous=True","scaling.show_plots=False","log_cutoff=-20"]
phil = iotbx.phil.process_command_line(args=args, master_string=master_phil)# .show()
work_params = phil.work.extract()
from xfel.merging.phil_validation import application
application(work_params)
get_model_intensities(work_params,case.ordered_intensities)
from xfel.cxi.cxi_cc import run_cc
run_cc(work_params,"h,k,l",sys.stdout)
