def __init__(
self,
intensities,
anomalous=False,
n_resolution_bins=20,
xtriage_analyses=None,
run_xtriage_analysis=True,
):
self.n_bins = n_resolution_bins
self._xanalysis = xtriage_analyses
if anomalous:
intensities = intensities.as_anomalous_array()
intensities.setup_binner(n_bins=self.n_bins)
merged = intensities.merge_equivalents()
self.binner = intensities.binner()
self.merged_intensities = merged.array()
self.multiplicities = merged.redundancies().complete_array(
new_data_value=0)
if not self._xanalysis and run_xtriage_analysis:
# imports needed here or won't work, unsure why.
from mmtbx.scaling.xtriage import xtriage_analyses
from mmtbx.scaling.xtriage import master_params as xtriage_master_params
xtriage_params = xtriage_master_params.fetch(sources=[]).extract()
xtriage_params.scaling.input.xray_data.skip_sanity_checks = True
xanalysis = xtriage_analyses(
miller_obs=self.merged_intensities,
unmerged_obs=intensities,
text_out="silent",
params=xtriage_params,
)
self._xanalysis = xanalysis
def xtriage_report(self):
xtriage_success = []
xtriage_warnings = []
xtriage_danger = []
s = StringIO()
pout = printed_output(out=s)
from mmtbx.scaling.xtriage import xtriage_analyses
from mmtbx.scaling.xtriage import master_params as xtriage_master_params
xtriage_params = xtriage_master_params.fetch(sources=[]).extract()
xtriage_params.scaling.input.xray_data.skip_sanity_checks = True
xanalysis = xtriage_analyses(
miller_obs=self.merged_intensities,
unmerged_obs=self.intensities,
text_out=pout,
params=xtriage_params,
)
if self.report_dir is not None:
with open(os.path.join(self.report_dir, "xtriage.log"), "wb") as f:
f.write(s.getvalue())
xia2.Handlers.Files.FileHandler.record_log_file(
"Xtriage", os.path.join(self.report_dir, "xtriage.log"))
xs = StringIO()
xout = xtriage_output(xs)
xanalysis.show(out=xout)
xout.flush()
sub_header_to_out = xout._sub_header_to_out
issues = xanalysis.summarize_issues()
# issues.show()
for level, text, sub_header in issues._issues:
summary = sub_header_to_out.get(sub_header, StringIO()).getvalue()
d = {
"level": level,
"text": text,
"summary": summary,
"header": sub_header
}
if level == 0:
xtriage_success.append(d)
elif level == 1:
xtriage_warnings.append(d)
elif level == 2:
xtriage_danger.append(d)
self._xanalysis = xanalysis
return xtriage_success, xtriage_warnings, xtriage_danger
def xtriage_report(self):
xtriage_success = []
xtriage_warnings = []
xtriage_danger = []
s = StringIO()
pout = printed_output(out=s)
from mmtbx.scaling.xtriage import xtriage_analyses
from mmtbx.scaling.xtriage import master_params as xtriage_master_params
xtriage_params = xtriage_master_params.fetch(sources=[]).extract()
xtriage_params.scaling.input.xray_data.skip_sanity_checks = True
xanalysis = xtriage_analyses(
miller_obs=self.merged_intensities,
unmerged_obs=self.intensities,
text_out=pout,
params=xtriage_params,
)
with open(os.path.join(self.report_dir, 'xtriage.log'), 'wb') as f:
f.write(s.getvalue())
xia2.Handlers.Files.FileHandler.record_log_file(
'Xtriage', os.path.join(self.report_dir, 'xtriage.log'))
xs = StringIO()
xout = xtriage_output(xs)
xanalysis.show(out=xout)
xout.flush()
sub_header_to_out = xout._sub_header_to_out
issues = xanalysis.summarize_issues()
#issues.show()
for level, text, sub_header in issues._issues:
summary = sub_header_to_out.get(sub_header, StringIO()).getvalue()
summary = summary.replace('<', '<').replace('>', '>')
d = {
'level': level,
'text': text,
'summary': summary,
'header': sub_header,
}
if level == 0: xtriage_success.append(d)
elif level == 1: xtriage_warnings.append(d)
elif level == 2: xtriage_danger.append(d)
self._xanalysis = xanalysis
return xtriage_success, xtriage_warnings, xtriage_danger
def __init__(
self,
intensities,
anomalous=False,
n_resolution_bins=20,
xtriage_analyses=None,
run_xtriage_analysis=True,
):
self.n_bins = n_resolution_bins
self._xanalysis = xtriage_analyses
if anomalous:
intensities = intensities.as_anomalous_array()
intensities.setup_binner(n_bins=self.n_bins)
merged = intensities.merge_equivalents()
self.binner = intensities.binner()
self.merged_intensities = merged.array()
self.multiplicities = merged.redundancies().complete_array(
new_data_value=0)
intensities.setup_binner_d_star_sq_step(auto_binning=True)
self.wilson_plot_result = intensities.wilson_plot(use_binning=True)
mr = matthews_rupp(intensities.crystal_symmetry(), out=StringIO())
self.n_residues = mr.n_residues
if not self._xanalysis and run_xtriage_analysis:
# imports needed here or won't work, unsure why.
from mmtbx.scaling.xtriage import master_params as xtriage_master_params
from mmtbx.scaling.xtriage import xtriage_analyses
xtriage_params = xtriage_master_params.fetch(sources=[]).extract()
xtriage_params.scaling.input.xray_data.skip_sanity_checks = True
try:
self._xanalysis = xtriage_analyses(
miller_obs=self.merged_intensities,
unmerged_obs=intensities,
text_out="silent",
params=xtriage_params,
)
except RuntimeError:
logger.warning("Xtriage analysis failed.", exc_info=True)
self._xanalysis = None
def exercise_2 () :
hkl_file = libtbx.env.find_in_repositories(
relative_path="phenix_regression/wizards/p9_se_w2.sca",
test=os.path.isfile)
if (hkl_file is None) :
warnings.warn("phenix_regression not available, skipping test")
return
hkl_in = file_reader.any_file(hkl_file).assert_file_type("hkl")
i_obs_raw = hkl_in.file_object.as_miller_arrays(
merge_equivalents=False,
crystal_symmetry=crystal.symmetry(
space_group_symbol="I4",
unit_cell=(113.949,113.949,32.474,90,90,90)))[0]
i_obs = i_obs_raw.merge_equivalents().array()
# completeness and data strength
cstats = ds.i_sigi_completeness_stats(i_obs)
d_min_cut = cstats.resolution_cut
assert approx_equal(d_min_cut, 2.150815)
ws = ds.wilson_scaling(
miller_array=i_obs,
n_residues=120)
# outliers - this shouldn't actually work, since it requires additional
# processing steps on the input data
try :
outliers = ds.possible_outliers(i_obs)
except AssertionError :
pass
else :
raise Exception_expected
######################################################################
# OVERALL ANALYSIS
pdb_file = libtbx.env.find_in_repositories(
relative_path="phenix_examples/p9-build/p9.pdb",
test=os.path.isfile)
f_calc = None
if (pdb_file is not None) :
pdb_in = file_reader.any_file(pdb_file).assert_file_type("pdb")
hierarchy = pdb_in.file_object.hierarchy
xrs = pdb_in.file_object.xray_structure_simple(
crystal_symmetry=i_obs)
f_calc = xrs.structure_factors(d_min=i_obs.d_min()).f_calc()
f_calc = abs(f_calc).generate_bijvoet_mates()
f_calc = f_calc.set_observation_type_xray_amplitude()
i_obs, f_calc = i_obs.common_sets(other=f_calc)
open("tmp_xtriage.pdb", "w").write(hierarchy.as_pdb_string(
crystal_symmetry=i_obs))
pdb_file = "tmp_xtriage.pdb"
params = xtriage.master_params.extract()
params.scaling.input.asu_contents.n_residues = 141
result = xtriage.xtriage_analyses(
miller_obs=i_obs,
miller_calc=f_calc,
params=params,
unmerged_obs=i_obs_raw,
text_out=open("logfile3.log", "w"))#sys.stdout)
# XXX there appears to be some system-dependence here, hence sloppy limits
assert (15.5 < result.aniso_b_min < 15.9)
assert (10 < result.aniso_range_of_b < 11)
# check relative Wilson
if (pdb_file is not None) :
assert (result.relative_wilson is not None)
# FIXME
#assert (result.relative_wilson.n_outliers() == 34)
#show_pickled_object_sizes(result)
test_pickle_consistency_and_size(result)
# XXX PDB validation server
assert approx_equal(result.iso_b_wilson, 18.33, eps=0.1)
assert approx_equal(result.aniso_b_ratio, 0.546, eps=0.1)
assert (result.number_of_wilson_outliers == 0)
assert approx_equal(result.l_test_mean_l, 0.493, eps=0.1)
assert approx_equal(result.l_test_mean_l_squared, 0.326, eps=0.1)
assert approx_equal(result.i_over_sigma_outer_shell, 3.25, eps=0.1)
assert ("No significant pseudotranslation is detected" in
result.patterson_verdict)
# test consistency of output after pickling and unpickling
try :
from phenix_dev.phenix_cloud import xtriage_json
except ImportError :
pass
else :
json_out = xtriage_json.json_output("p9.sca")
result.show(out=json_out)
open("xtriage.json", "w").write(json_out.export())
# unmerged data
assert result.merging_stats is not None
out = StringIO()
result.merging_stats.show(out=out)
assert ("R-merge: 0.073" in out.getvalue())
assert approx_equal(result.estimate_d_min(min_i_over_sigma=10), 1.9645,
eps=0.001)
# FIXME PDB doesn't actually have unit cell!
# test detection of symmetry in reference file
if (pdb_file is not None) :
args = [hkl_file, pdb_file]
result = xtriage.run(args=args, out=null_out())
def exercise_2():
hkl_file = libtbx.env.find_in_repositories(
relative_path="phenix_regression/wizards/data/p9_se_w2.sca",
test=os.path.isfile)
if (hkl_file is None):
warnings.warn("phenix_regression not available, skipping test")
return
hkl_in = file_reader.any_file(hkl_file).assert_file_type("hkl")
i_obs_raw = hkl_in.file_object.as_miller_arrays(
merge_equivalents=False,
crystal_symmetry=crystal.symmetry(space_group_symbol="I4",
unit_cell=(113.949, 113.949, 32.474,
90, 90, 90)))[0]
i_obs = i_obs_raw.merge_equivalents().array()
# completeness and data strength
cstats = ds.i_sigi_completeness_stats(i_obs)
d_min_cut = cstats.resolution_cut
assert approx_equal(d_min_cut, 2.150815)
ws = ds.wilson_scaling(miller_array=i_obs, n_residues=120)
# outliers - this shouldn't actually work, since it requires additional
# processing steps on the input data
try:
outliers = ds.possible_outliers(i_obs)
except AssertionError:
pass
else:
raise Exception_expected
######################################################################
# OVERALL ANALYSIS
pdb_file = libtbx.env.find_in_repositories(
relative_path="phenix_examples/p9-build/p9.pdb", test=os.path.isfile)
f_calc = None
if (pdb_file is not None):
pdb_in = file_reader.any_file(pdb_file).assert_file_type("pdb")
hierarchy = pdb_in.file_object.hierarchy
xrs = pdb_in.file_object.xray_structure_simple(crystal_symmetry=i_obs)
f_calc = xrs.structure_factors(d_min=i_obs.d_min()).f_calc()
f_calc = abs(f_calc).generate_bijvoet_mates()
f_calc = f_calc.set_observation_type_xray_amplitude()
i_obs, f_calc = i_obs.common_sets(other=f_calc)
open("tmp_xtriage.pdb",
"w").write(hierarchy.as_pdb_string(crystal_symmetry=i_obs))
pdb_file = "tmp_xtriage.pdb"
params = xtriage.master_params.extract()
params.scaling.input.asu_contents.n_residues = 141
result = xtriage.xtriage_analyses(miller_obs=i_obs,
miller_calc=f_calc,
params=params,
unmerged_obs=i_obs_raw,
text_out=open("logfile3.log",
"w")) #sys.stdout)
# XXX there appears to be some system-dependence here, hence sloppy limits
assert (15.5 < result.aniso_b_min < 15.9)
assert (10 < result.aniso_range_of_b < 11)
# check relative Wilson
if (pdb_file is not None):
assert (result.relative_wilson is not None)
# FIXME
#assert (result.relative_wilson.n_outliers() == 34)
#show_pickled_object_sizes(result)
test_pickle_consistency_and_size(result)
# XXX PDB validation server
assert approx_equal(result.iso_b_wilson, 18.33, eps=0.1)
assert approx_equal(result.aniso_b_ratio, 0.546, eps=0.1)
assert (result.number_of_wilson_outliers == 0)
assert approx_equal(result.l_test_mean_l, 0.493, eps=0.1)
assert approx_equal(result.l_test_mean_l_squared, 0.326, eps=0.1)
assert approx_equal(result.i_over_sigma_outer_shell, 3.25, eps=0.1)
assert approx_equal(result.overall_i_sig_i, 10.34, eps=0.1)
assert approx_equal(
result.anomalous_info.plan_sad_experiment_stats.get_overall(
item="i_over_sigma_dict"),
10.61,
eps=0.1)
assert approx_equal(
result.anomalous_info.plan_sad_experiment_stats.get_overall(
item="anom_signal_dict"),
15.35,
eps=0.1)
assert ("No significant pseudotranslation is detected"
in result.patterson_verdict)
# test consistency of output after pickling and unpickling
try:
from phenix_dev.phenix_cloud import xtriage_json
except ImportError:
pass
else:
json_out = xtriage_json.json_output("p9.sca")
result.show(out=json_out)
open("xtriage.json", "w").write(json_out.export())
# unmerged data
assert result.merging_stats is not None
out = StringIO()
result.merging_stats.show(out=out)
assert ("R-merge: 0.073" in out.getvalue())
assert approx_equal(result.estimate_d_min(min_i_over_sigma=10),
1.9645,
eps=0.001)
# FIXME PDB doesn't actually have unit cell!
# test detection of symmetry in reference file
if (pdb_file is not None):
args = [hkl_file, pdb_file]
result = xtriage.run(args=args, out=null_out())
