def run(args, out=sys.stdout, quiet=False):
cmdline = iotbx.phil.process_command_line_with_files(
args=args,
master_phil=get_master_phil(),
pdb_file_def="model",
usage_string=usage_string)
params = cmdline.work.extract()
if (params.model is None):
raise Usage(usage_string)
pdb_in = cmdline.get_file(params.model, force_type="pdb")
hierarchy = pdb_in.file_object.hierarchy
result = mmtbx.validation.rotalyze.rotalyze(
pdb_hierarchy=hierarchy,
data_version="8000", #params.data_version,
show_errors=params.show_errors,
outliers_only=params.outliers_only,
out=out,
quiet=quiet)
if params.verbose:
result.show_old_output(out=out, verbose=True)
if params.wxplot:
try:
import wxtbx.app
except ImportError, e:
raise Sorry("wxPython not available.")
else:
app = wxtbx.app.CCTBXApp(0)
result.display_wx_plots()
app.MainLoop()
def run(args=(), params=None, out=sys.stdout):
import wxtbx.app
app = wxtbx.app.CCTBXApp(0)
if (len(args) == 0):
from wxtbx.command_line.inspect_r_free_flags import ask_for_file
file_name = ask_for_file(parent=None)
else:
file_name = args[0]
display_file_info(file_name)
app.MainLoop()
def run(args, out=sys.stdout, quiet=False):
cmdline = iotbx.phil.process_command_line_with_files(
args=args,
master_phil=get_master_phil(),
pdb_file_def="model",
usage_string=usage_string)
params = cmdline.work.extract()
if (params.model is None and params.model_list is None):
raise Usage(usage_string)
if params.model:
models = [params.model]
elif params.model_list:
models = params.model_list.split(',')
params.verbose = False
results = []
for model in models:
pdb_in = cmdline.get_file(model, force_type="pdb")
hierarchy = pdb_in.file_object.hierarchy
hierarchy.atoms().reset_i_seq()
result = mmtbx.validation.ramalyze.ramalyze(
pdb_hierarchy=hierarchy,
show_errors=None,
outliers_only=params.outliers_only,
out=out,
quiet=quiet)
results.append(result)
if params.model_list:
print '\nmodel : %s' % model
result.show_summary()
# combine
result = results[0]
for i in range(1, len(results)):
result += results[i]
if params.verbose:
result.show_old_output(out=out, verbose=True)
if params.plot:
plot_file_base = os.path.splitext(os.path.basename(params.model))[0]
result.write_plots(plot_file_base=plot_file_base,
out=out,
show_labels=params.show_labels)
if params.wxplot:
try:
import wxtbx.app
except ImportError, e:
raise Sorry("wxPython not available.")
else:
app = wxtbx.app.CCTBXApp(0)
result.display_wx_plots()
app.MainLoop()
def run(self):
results = []
for model_name in self.data_manager.get_model_names():
hierarchy = self.data_manager.get_model(model_name).get_hierarchy()
hierarchy.atoms().reset_i_seq()
result = ramalyze(pdb_hierarchy=hierarchy,
show_errors=None,
outliers_only=self.params.outliers_only,
out=self.logger,
quiet=False)
results.append(result)
if len(self.data_manager.get_model_names()) > 1:
self.params.verbose = False
print('\nmodel : %s' % model_name, file=self.logger)
# combine models
result = results[0]
for i in range(1, len(results)):
result += results[i]
if self.params.verbose:
result.show_old_output(out=self.logger, verbose=True)
if self.params.plot:
plot_file_base = self.params.output_prefix
if plot_file_base is None:
plot_file_base = os.path.splitext(
os.path.basename(
self.data_manager.get_model_names()[0]))[0]
result.write_plots(plot_file_base=plot_file_base,
out=self.logger,
show_labels=self.params.show_labels,
point_style=self.params.point_style,
markerfacecolor=self.params.markerfacecolor,
show_filling=self.params.show_filling,
show_contours=self.params.show_contours,
dpi=self.params.dpi,
markeredgecolor=self.params.markeredgecolor,
markersize=self.params.markersize)
if self.params.wxplot:
try:
import wxtbx.app
except ImportError as e:
raise Sorry("wxPython not available.")
else:
app = wxtbx.app.CCTBXApp(0)
result.display_wx_plots()
app.MainLoop()
def compute(hierarchies,
params,
log,
quiet=False,
plot_file_base_default=None):
results = []
for hierarchy in hierarchies:
result = ramalyze(pdb_hierarchy=hierarchy,
show_errors=None,
outliers_only=params.outliers_only,
out=log,
quiet=quiet)
results.append(result)
# combine models
result = results[0]
for i in range(1, len(results)):
result += results[i]
if params.verbose:
result.show_old_output(out=log, verbose=True)
if params.plot:
plot_file_base = params.output_prefix
if plot_file_base is None:
plot_file_base = plot_file_base_default
result.write_plots(plot_file_base=plot_file_base,
out=log,
show_labels=params.show_labels,
point_style=params.point_style,
markerfacecolor=params.markerfacecolor,
show_filling=params.show_filling,
show_contours=params.show_contours,
dpi=params.dpi,
markeredgecolor=params.markeredgecolor,
markersize=params.markersize)
if params.wxplot:
try:
import wxtbx.app
except ImportError as e:
raise Sorry("wxPython not available.")
else:
app = wxtbx.app.CCTBXApp(0)
result.display_wx_plots()
app.MainLoop()
def run(args, out=sys.stdout):
parser = argparse.ArgumentParser()
parser.add_argument("files",nargs="*")
parser.add_argument("-s", "--Sampling_Angle", dest="sampling_angle", help="Don't mess with this unless you've also made the corresponding change in ringer. By default it is 5, which is identical to the default in ringer.", nargs='?', default=5)
parser.add_argument("-r", "--Residues", dest="residues")
parser.add_argument("--gui", dest="show_gui", action="store_true",
default=False)
args = parser.parse_args(args)
#if (not args.show_gui):
try :
import matplotlib
except ImportError as e :
print("WARNING: matplotlib not present, plotting disabled", file=out)
matplotlib = None
args.show_gui = False
else :
matplotlib.use("Agg")
app = None
for file_name in args.files :
result = mmtbx.ringer.em_scoring.main(
file_name=file_name,
sampling_angle=args.sampling_angle,
out=out,
quiet=(matplotlib is None)).show_summary(out=out)
file_name = os.path.basename(file_name)
if (args.show_gui):
import wxtbx.plots.emringer
import wxtbx.app
if (app is None):
app = wxtbx.app.CCTBXApp(0)
f1 = wxtbx.plots.emringer.peaks_plot_frame(
parent=None,
title="Histogramss for %s" % file_name)
f1.SetResult(result)
f1.Show()
f2 = wxtbx.plots.emringer.threshold_plot_frame(
parent=None,
title="Statistics across all thresholds for %s" % file_name)
f2.SetResult(result)
f2.Show()
if (args.show_gui):
app.MainLoop()
def run(self):
hierarchy = self.data_manager.get_model().get_hierarchy()
result = rotalyze(
pdb_hierarchy=hierarchy,
data_version="8000",#was 'params.data_version', no options currently
show_errors=self.params.show_errors,
outliers_only=self.params.outliers_only,
out=self.logger,
quiet=False)
if self.params.verbose:
result.show_old_output(out=self.logger, verbose=True)
if self.params.wxplot :
try :
import wxtbx.app
except ImportError as e :
raise Sorry("wxPython not available.")
else :
app = wxtbx.app.CCTBXApp(0)
result.display_wx_plots()
app.MainLoop()
def run (args,
out=sys.stdout,
program_name="phenix.molprobity",
ignore_missing_modules=False,
return_input_objects=False) : # for testing
rotarama_dir = libtbx.env.find_in_repositories(
relative_path="chem_data/rotarama_data",
test=os.path.isdir)
if (rotarama_dir is None) :
raise ImportError("Rotamer and Ramachandran distributions not available; "+
"you will need these to run MolProbity.")
elif (((not libtbx.env.has_module("reduce")) or
(not libtbx.env.has_module("probe"))) and
(not ignore_missing_modules)) :
raise ImportError("Reduce and/or Probe not configured.")
import mmtbx.validation.molprobity
import mmtbx.command_line
cmdline = mmtbx.command_line.load_model_and_data(
args=args,
master_phil=get_master_phil(),
require_data=False,
create_fmodel=True,
process_pdb_file=True,
usage_string=usage_string,
prefer_anomalous=True,
out=out)
params = cmdline.params
fmodel = cmdline.fmodel
if (params.output.maps is Auto) and (fmodel is not None) :
params.output.maps = True
elif (params.output.maps == True) and (fmodel is None) :
raise Sorry("Map output requires experimental data.")
if (params.molprobity.keep_hydrogens is Auto) :
params.molprobity.keep_hydrogens = \
( (params.input.scattering_table == "neutron") or
(params.pdb_interpretation.use_neutron_distances) )
header_info = mmtbx.validation.molprobity.pdb_header_info(
pdb_file=params.input.pdb.file_name[0],
pdb_hierarchy=cmdline.pdb_hierarchy)
pdb_prefix = os.path.splitext(os.path.basename(
params.input.pdb.file_name[0]))[0]
if (params.output.prefix is None) :
params.output.prefix = "molprobity"
probe_file = None
if (params.output.probe_dots) or (params.output.kinemage) :
probe_file = params.output.prefix + "_probe.txt"
raw_data = cmdline.raw_data
# check map parameters
from mmtbx.real_space_correlation import check_map_file
check_map_file(None, params.input.maps)
validation = mmtbx.validation.molprobity.molprobity(
model=cmdline.model,
fmodel=fmodel,
flags=params.molprobity.flags,
sequences=cmdline.sequence,
raw_data=cmdline.raw_data,
unmerged_data=cmdline.unmerged_i_obs,
header_info=header_info,
keep_hydrogens=params.molprobity.keep_hydrogens,
nuclear=params.pdb_interpretation.use_neutron_distances,
save_probe_unformatted_file=probe_file,
min_cc_two_fofc=params.molprobity.min_cc_two_fofc,
n_bins_data=params.molprobity.n_bins,
outliers_only=params.molprobity.outliers_only,
use_pdb_header_resolution_cutoffs=\
params.molprobity.use_pdb_header_resolution_cutoffs,
count_anomalous_pairs_separately=\
params.molprobity.count_anomalous_pairs_separately,
use_internal_variance=params.input.unmerged_data.use_internal_variance,
file_name=params.input.pdb.file_name[0],
ligand_selection=params.molprobity.ligand_selection,
rotamer_library=params.molprobity.rotamer_library,
map_params=params)
map_file = None
# model cannot be pickled
validation.model = None
# polygon statistics
validation.polygon_stats = validation.get_polygon_statistics(
params.polygon.keys_to_show)
if ('pdb_header_r_work' in params.polygon.keys_to_show):
validation.polygon_stats['pdb_header_r_work'] = header_info.r_work
if ('pdb_header_r_free' in params.polygon.keys_to_show):
validation.polygon_stats['pdb_header_r_free'] = header_info.r_free
if (not params.output.quiet) :
out2 = multi_out()
out2.register("stdout", out)
f = open(params.output.prefix + ".out", "w")
out2.register("txt_out", f)
validation.show(out=out2,
outliers_only=params.molprobity.outliers_only,
show_percentiles=params.output.percentiles)
f.close()
print >> out, ""
print >> out, "Results written to %s.out" % params.output.prefix
if (params.output.kinemage) :
if (cmdline.pdb_hierarchy.models_size() == 1) :
assert (probe_file is not None)
import mmtbx.kinemage.validation
cmdline.pdb_hierarchy.atoms().reset_i_seq()
kin_file = "%s.kin" % params.output.prefix
kin_out = \
mmtbx.kinemage.validation.export_molprobity_result_as_kinemage(
result=validation,
pdb_hierarchy=cmdline.pdb_hierarchy,
geometry=cmdline.geometry,
probe_file=probe_file,
keep_hydrogens=params.molprobity.keep_hydrogens,
pdbID=pdb_prefix)
f = open(kin_file, "w")
f.write(kin_out)
f.close()
if (not params.output.quiet) :
print >> out, "Wrote kinemage to %s" % kin_file
else :
print >> out, "Kinemage output not available for multiple MODELs."
if (params.output.pickle) :
easy_pickle.dump("%s.pkl" % params.output.prefix, validation)
if (not params.output.quiet) :
print >> out, "Saved result to %s.pkl" % params.output.prefix
if (params.output.coot) :
coot_file = "%s_coot.py" % params.output.prefix
validation.write_coot_script(coot_file)
if (not params.output.quiet) :
print >> out, "Wrote script for Coot: %s" % coot_file
if (params.output.maps == True) :
import mmtbx.maps.utils
import iotbx.map_tools
map_file = "%s_maps.mtz" % params.output.prefix
two_fofc_map, fofc_map = mmtbx.maps.utils.get_maps_from_fmodel(
fmodel=fmodel,
fill_missing_f_obs=params.output.map_options.fill_missing_f_obs,
exclude_free_r_reflections=\
params.output.map_options.exclude_free_r_reflections)
anom_map = None
if (fmodel.f_obs().anomalous_flag()) :
anom_map = mmtbx.maps.utils.get_anomalous_map(fmodel)
iotbx.map_tools.write_map_coeffs(
file_name=map_file,
fwt_coeffs=two_fofc_map,
delfwt_coeffs=fofc_map,
anom_coeffs=anom_map)
print >> out, "Wrote map coefficients to %s" % map_file
else :
print >> out, ""
validation.show_summary(out=out, show_percentiles=params.output.percentiles)
if (params.output.wxplots) :
try :
import wxtbx.app
except ImportError, e :
raise Sorry("wxPython not available.")
else :
app = wxtbx.app.CCTBXApp(0)
validation.display_wx_plots()
app.MainLoop()
# LIBTBX_PRE_DISPATCHER_INCLUDE_SH export PHENIX_GUI_ENVIRONMENT=1
# LIBTBX_SET_DISPATCHER_NAME wxtbx.xtriage
# LIBTBX_SET_DISPATCHER_NAME mmtbx.xtriage_gui
from __future__ import absolute_import, division, print_function
import wxtbx.xtriage
import wxtbx.app
import sys
if (__name__ == "__main__"):
from mmtbx.scaling import xtriage
result = xtriage.run(args=sys.argv[1:],
data_file_name="xtriage_data.pkl")
app = wxtbx.app.CCTBXApp(0)
frame = wxtbx.xtriage.XtriageFrame(parent=None,
title="Xtriage",
size=(900,600))
frame.SetResult(result)
frame.Show()
app.MainLoop()
def run(args):
app = wxtbx.app.CCTBXApp(0)
frame = anomalous_scattering.AnomPlotFrame(
parent=None, title="Anomalous scattering plot")
frame.Show()
app.MainLoop()
