def run(args): if (len(args) == 0 or "--help" in args or "--h" in args or "-h" in args): raise Usage(usage()) import iotbx.pdb import iotbx.utils master_phil = get_master_phil() args = list(args) input_objects = iotbx.utils.process_command_line_inputs( args=args, master_phil=master_phil, input_types=("pdb",)) work_phil = master_phil.fetch(sources=input_objects["phil"]) work_params = work_phil.extract() if len(input_objects["pdb"]) != 1: summary, header = self.get_summary_and_header("ramalyze") raise Usage(summary) file_obj = input_objects["pdb"][0] file_name = file_obj.file_name pdb_io = iotbx.pdb.input(file_name) pdb_hierarchy = pdb_io.construct_hierarchy() pdb_hierarchy.reset_i_seq_if_necessary() cis_peptides, trans_peptides, outliers = \ analyze(pdb_hierarchy=pdb_hierarchy) show(cis_peptides=cis_peptides, trans_peptides=trans_peptides, outliers=outliers, cis_only=work_params.analyze_peptides.cis_only)
def process_input(argv=None, flag_mkdir=True): user_phil = [] if argv == None: master_phil.show() raise Usage( "Use the above list of parameters to generate your input file (.phil). For more information, run prime.postrefine -h." ) else: for arg in argv: if os.path.isfile(arg): user_phil.append(iotbx.phil.parse(open(arg).read())) elif (os.path.isdir(arg)): user_phil.append(iotbx.phil.parse("""data=\"%s\"""" % arg)) else: if arg == '--help' or arg == '-h': print txt_help master_phil.show(attributes_level=1) raise Usage( "Run prime.run to generate a list of initial parameters." ) else: try: user_phil.append(iotbx.phil.parse(arg)) except RuntimeError, e: raise Sorry("Unrecognized argument '%s' (error: %s)" % (arg, str(e)))
def run(args): try: from cxi_xdr_xes.cftbx.cspad_ana import db as db except ImportError: raise Sorry("Trial logging not supported for this installation. Contact the developers for access.") phil = iotbx.phil.process_command_line(args=args, master_string=master_phil) params = phil.work.extract() if params.db.host is None: raise Usage("Please provide a host name") if params.db.name is None: raise Usage("Please provide a database name") if params.db.user is None: raise Usage("Please provide a user name") if params.db.password is None: import getpass password = getpass.getpass() else: password = params.db.password try: dbobj = db.dbconnect(host=params.db.host, db=params.db.name, username=params.db.user, password=password) except Exception, e: raise Sorry(e)
def initialize(self, args): import iotbx.phil from xfel.command_line.cxi_merge import master_phil if ("--help" in args): iotbx.phil.parse(master_phil).show(attributes_level=2) return 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 ((work_params.d_min is None) or (work_params.data is None) or ((work_params.model is None) and work_params.scaling.algorithm != "mark1")): command_name = os.environ["LIBTBX_DISPATCHER_NAME"] raise Usage(command_name + " " "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, work_params.raw_data.sdfac_refine, work_params.raw_data.errors_from_sample_residuals ].count(True) > 1: raise Usage( "Specify only one of sdfac_auto, sdfac_refine or errors_from_sample_residuals." ) # 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! log = open("%s.log" % work_params.output.prefix, "w") out = multi_out() out.register("log", log, atexit_send_to=None) out.register("stdout", sys.stdout) print >> out, "I model" if work_params.model is not None: from xfel.merging.general_fcalc import run as run_fmodel i_model = run_fmodel(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 >> out, "Target unit cell and space group:" print >> out, " ", work_params.target_unit_cell print >> out, " ", work_params.target_space_group from xfel.command_line.cxi_merge import consistent_set_and_model self.miller_set, self.i_model = consistent_set_and_model( work_params, i_model) self.work_params = work_params self.frame_files = get_observations(work_params) self.out = out
def validate(self, comm): base_Script.validate(self) if (self.params.rescale_with_average_cell): raise Usage("""Rescaling_with_average_cell not supported with MPI (Would require a second round of scaling, inefficient).""") if (self.params.mpi.cs == True and comm.Get_size() <= 1): raise Usage( "Client-server algorithm requires a minimum size of 2 MPI ranks to process data. Currently size=%d" % comm.Get_size())
def run(args, out=sys.stdout): show_development_warning(out=out) if (len(args) == 0) or ("--help" in args): raise Usage("""\ cctbx.patterson_map data.mtz [options] Calculates a simple or anomalous difference Patterson map. Output is in CCP4 format. Full options: %s """ % master_phil.as_str(prefix=" ")) import iotbx.phil from cctbx.array_family import flex from cctbx import miller from cctbx import xray hkl_in = None sources = [] cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil=master_phil, reflection_file_def="data") params = cmdline.work.extract() if (params.data is None): raise Usage("mmtbx.patterson_map data [options]\n\nFull parameters:\n%s" % master_phil.as_str(prefix=" ")) f_obs = extract_data( file_name=params.data, expected_labels=params.labels, out=out) if (f_obs is None): raise Sorry("No suitable data found.") f_obs = prepare_f_obs(f_obs, params=params) final_array = f_obs # default is_anom = False if (f_obs.anomalous_flag()): if (params.map_type in ["auto", "anom"]): print >> out, "Output will be anomalous Patterson map" is_anom = True final_array = f_obs.anomalous_differences() final_array = abs(final_array) if (params.diff_limit is not None): final_array = final_array.select(final_array.data() < params.diff_limit) else : final_array = f_obs.average_bijvoet_mates() map = calculate_patterson_map(data=final_array, params=params, normalize=is_anom) if (params.map_file_name is None): base = os.path.splitext(os.path.basename(params.data))[0] params.map_file_name = base + "_patt.ccp4" map.as_ccp4_map( file_name=params.map_file_name) print >> out, "Wrote %s" % params.map_file_name
def run(args=(), params=None, out=sys.stdout): if (len(args) == 0) and (params is None): raise Usage(""" iotbx.file_reader filename [force_type=None] (where force_type can be optionally set to one of these keywords: %s) """ % ",".join(iotbx.file_reader.standard_file_types)) user_phil = [] for arg in args: if (os.path.isfile(arg)): user_phil.append( libtbx.phil.parse("""file_reader.file_name='%s'""" % arg)) else: if (arg.startswith("force_type")): arg = "file_reader." + arg try: user_phil.append(libtbx.phil.parse(arg)) except RuntimeError as e: print(e) print("Unrecognized argument '%s'" % arg) params = master_phil.fetch(sources=user_phil).extract() validate_params(params) f = file_reader.any_file(file_name=params.file_reader.file_name, valid_types=file_reader.standard_file_types, force_type=params.file_reader.force_type) f.show_summary(out=out)
def run(self): ''' Parse the options. ''' # Parse the command line arguments params, options = self.parser.parse_args(show_diff_phil=True) self.params = params if params.tag is None: raise Usage(self.parser.usage) level_json = "%s_%d_refined_experiments_level%d.json" level_pickle = "%s_%d_refined_reflections_level%d.mpack" command = "cspad.detector_congruence %s %s %s %s hierarchy_level=%d show_plots=False" help_strs = [ "detector as a whole block", "quadrants", "sensors, I.E. 2x1s", "ASICs, I.E. individual tiles" ] for i in range(3): c = command % (level_json % (params.tag, 1, i), level_pickle % (params.tag, 1, i), level_json % (params.tag, 2, i), level_pickle % (params.tag, 2, i), i) print "*" * 80 print "Showing statistics for detector at level %d (%s)" % ( i, help_strs[i]) print "*" * 80 print c result = easy_run.fully_buffered(c).raise_if_errors() result.show_stdout()
def run(args): if ("--help" in args) or ("--options" in args): raise Usage("""\ phenix.compare_datasets data1.mtz data2.mtz Side-by-side visualization of pseudo-precession planes through reciprocal space for a pair of datasets - essentially a duplex version of 2D view in phenix.data_viewer. """) a = wx.App(0) app_icon = wx.EmptyIcon() app_icon.CopyFromBitmap(icons.hklview_2d.GetBitmap()) if (wx.VERSION >= (2, 9)): tb_icon = wx.TaskBarIcon(wx.TBI_DOCK) else: tb_icon = wx.TaskBarIcon() tb_icon.SetIcon(app_icon, "PHENIX data viewer") frame = comparison.ComparisonFrame(None, -1, "Dataset comparison") frame.Show() file_name_1 = file_name_2 = None for arg in args: if (os.path.isfile(arg)): if (file_name_1 is None): file_name_1 = arg elif (file_name_2 is None): file_name_2 = arg else: raise Sorry("Only two files at a time are supported.") if (file_name_1 is not None) and (file_name_2 is not None): frame.load_files(file_name_1, file_name_2) a.SetTopWindow(frame) a.Bind(wx.EVT_WINDOW_DESTROY, lambda evt: tb_icon.Destroy(), frame) a.MainLoop()
def format_usage_message(self): raise Usage("""\ phenix.dynamics: perform simple dynamics to perturb a model Usage examples: phenix.dynamics model.pdb phenix.dynamics model.pdb ligands.cif """)
def run (args, out=sys.stdout) : if (len(args) == 0) or ("--help" in args) : raise Usage("""\ mmtbx.compare_ligands model1.pdb model2.pdb ligand_code=LIG Given a pair of PDB files and a ligand ID, identifies equivalent copies of the ligand in each model and calculates RMSDs between them. Used for validating ligand fitting tools in Phenix.""") import iotbx.phil class _cmdline (iotbx.phil.process_command_line_with_files) : def process_other (self, arg) : if (len(arg) <= 3) and (arg.isalnum()) : return iotbx.phil.parse("""ligand_code=%s""" % arg) cmdline = _cmdline( args=args, master_phil_string=master_phil, pdb_file_def="pdb_file") params = cmdline.work.extract() if (len(params.pdb_file) != 2) : raise Sorry("Exactly two PDB files required as input.") if (params.ligand_code is None) : raise Sorry("Must specify ligand ID (ligand_code=LIG)") from mmtbx.validation import ligands rmsds, pbss = ligands.compare_ligands( ligand_code=params.ligand_code, pdb_file_1=params.pdb_file[0], pdb_file_2=params.pdb_file[1], exclude_hydrogens=params.exclude_hydrogens, verbose=params.verbose, out=out) if (len(rmsds) == 0) : raise Sorry("No matching ligands found!")
def run(args=(), params=None, out=None): if (out is None): out = sys.stdout if (params is None): if (len(args) == 0): raise Usage("pdb_split_chains.py model.pdb") import iotbx.phil cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil=master_phil, pdb_file_def="split_chains.pdb_file") params = cmdline.work.extract() validate_params(params) params = params.split_chains if (params.output_dir is None): params.output_dir = os.getcwd() if (params.output_base is None): params.output_base = os.path.basename( os.path.splitext(params.pdb_file)[0]) from iotbx import file_reader from iotbx.pdb.hierarchy import new_hierarchy_from_chain pdb_in = file_reader.any_file(params.pdb_file, force_type="pdb") pdb_in.check_file_type("pdb") symm = pdb_in.file_object.crystallographic_section() hierarchy = pdb_in.file_object.hierarchy if (len(hierarchy.models()) > 1): raise Sorry( "Multi-model PDB files are not supported. You can use " + "iotbx.pdb.split_models to break the structure into individual model " + "files.") id_counts = {} outputs = [] for chain in hierarchy.models()[0].chains(): main_conf = chain.conformers()[0] if (params.exclude_heteroatoms): if ((not main_conf.is_protein()) and (not main_conf.is_na())): continue elif (len(chain.residue_groups()) == 1): continue id = chain.id if (id == " "): id = "_" if (id_counts.get(id, 0) > 0): suffix = "%s-%d" % (id, id_counts[id] + 1) else: suffix = id if (not id in id_counts): id_counts[id] = 0 id_counts[id] += 1 output_file = os.path.join(params.output_dir, "%s_%s.pdb" % (params.output_base, suffix)) f = open(output_file, "w") if (params.preserve_symmetry): f.write("\n".join(symm)) f.write("\n") new_hierarchy = new_hierarchy_from_chain(chain) f.write(new_hierarchy.as_pdb_string()) f.close() outputs.append(output_file) print >> out, "Wrote chain '%s' to %s" % (chain.id, output_file) return outputs
def usage(): raise Usage("""\ %s file1.pdb file2.pdb [...] or define the environment variable PDB_MIRROR_PDB to join all fragment files in the PDB.""" % command_name)
def run(args): if (len(args) != 2): raise Usage("""\ iotbx.cns.transfer_crystal_symmetry any_symmetry_source_file cns_input_file ********************************************* NOTE: the cns_input_file is changed in place. *********************************************""") # for file_name in args: if (not os.path.exists(file_name)): raise Sorry("No such file: %s" % show_string(file_name)) source, target = args crystal_symmetry = crystal_symmetry_from_any.extract_from(source) if (crystal_symmetry is None): raise Sorry("Unknown file format or unit cell and/or space group" " missing from file: " + show_string(source)) cns_space_group_symbol = cns.space_group_symbols.cns_format( space_group_info=crystal_symmetry.space_group_info()) if (cns_space_group_symbol is None): raise Sorry("Space group not available in CNS: %s" % show_string(str(crystal_symmetry.space_group_info()))) sg = '"%s"' % cns_space_group_symbol a, b, c, alpha, beta, gamma = [ "%.6g" % p for p in crystal_symmetry.unit_cell().parameters() ] parameter_names = ["sg", "a", "b", "c", "alpha", "beta", "gamma"] parameters_found = dict(zip(parameter_names, [0] * len(parameter_names))) parameters_changed = [] lines_out = [] detect_binary = detect_binary_file(monitor_initial=100) try: cns_inp = open(target).read().splitlines() except IOError, e: raise Sorry("Error reading file %s (%s)" % (show_string(target), str(e)))
def run(args, out=sys.stdout): if (len(args) == 0) or ("--help" in args): raise Usage("mmtbx.rigid_bond_test model.pdb") from mmtbx.monomer_library import pdb_interpretation import mmtbx.restraints import mmtbx.model import iotbx.phil cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil=master_phil, pdb_file_def="model", cif_file_def="restraints") params = cmdline.work.extract() validate_params(params) processed_pdb_file = pdb_interpretation.run(args=[params.model] + params.restraints) geometry = processed_pdb_file.geometry_restraints_manager( show_energies=True) restraints_manager = mmtbx.restraints.manager(geometry=geometry, normalization=True) model = mmtbx.model.manager( xray_structure=processed_pdb_file.xray_structure(), pdb_hierarchy=processed_pdb_file.all_chain_proxies.pdb_hierarchy, restraints_manager=restraints_manager, log=out) make_header("Rigid-bond test", out=out) model.show_rigid_bond_test(out=out, use_id_str=True, prefix=" ")
def run(args): if ("--help" in args or "-h" in args): print("Write a SLAC metrology file from a CSPAD CBF. Parameters:") master_phil.show(attributes_level=2) return user_phil = [] for arg in args: 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.cbf_header is None or \ params.out_metrology_file is None: raise Usage("%s cbf_header=<path> out_metrology_file=<path>" % libtbx.env.dispatcher_name) if not os.path.exists(params.cbf_header): raise Sorry("File not found: %s" % params.cbf_header) print("Converting", params.cbf_header, "to", params.out_metrology_file) geometry = GeometryAccessFromCspadCBF(params.cbf_header) geometry.save_pars_in_file(params.out_metrology_file)
def run(args): if (len(args) == 0): n_iterations = 1000 elif (len(args) == 1): n_iterations = int(args[0]) assert n_iterations > 0 else: from libtbx.utils import Usage raise Usage("scitbx.show_exp_times [n_iterations]") evar = "LIBTBX_NO_LD_PRELOAD" evar_set = evar in os.environ if (evar_set): print("%s set:" % evar) else: print("%s not set:" % evar) from scitbx.math.tests.tst_exp_functions import \ exercise_with_random_arguments as exercise exercise(n_arguments=10000, n_iterations=n_iterations) print() sys.stdout.flush() if (not evar_set): if ("LD_PRELOAD" in os.environ): del os.environ["LD_PRELOAD"] os.environ[evar] = "1" from libtbx import easy_run easy_run.call(command="scitbx.show_exp_times %d" % n_iterations)
def run(args): if ("--help" in args or "-h" in args) : print "Write a CBF header from a SLAC metrology file. Parameters:" master_phil.show(attributes_level=2) return user_phil = [] for arg in args: if (os.path.isfile(arg)) : user_phil.append(libtbx.phil.parse("""metrology_file=\"%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.metrology_file is None) : master_phil.show() raise Usage("metrology_file must be defined (either metrology_file=XXX, or the file path alone).") assert params.plot is not None assert params.out is not None print params.metrology_file metro = read_slac_metrology(params.metrology_file, plot=params.plot) write_cspad_cbf(None, metro, 'cbf', None, params.out, None, 0, header_only=True)
def run(args): phil = iotbx.phil.process_command_line(args=args, master_string=master_phil).show() work_params = phil.work.extract() if ("--help" in args): libtbx.phil.parse(master_phil.show()) return if ((work_params.run_numbers is None and work_params.outdir_template is None) or (work_params.outdir_template is None) or (work_params.bravais_setting_id is None)): from libtbx.utils import Usage raise Usage( "cxi.plotcv " "run_numbers=16,17,18,19,20,21,22,23,24,25,26,27,71,72,73 " "outdir_template=/reg/data/ana11/cxi/cxi49812/scratch/april_2012/r%%04d/042/stdout " "bravais_setting_id=5") if work_params.show_plots is True: from matplotlib import pyplot as plt # special import from xfel.cxi.correction_vector_plot import run_correction_vector_plot run_correction_vector_plot(work_params) return None
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): from iotbx.pdb.remediation import remediator from iotbx import file_reader if (params is None): interpreter = master_phil.command_line_argument_interpreter() pdb_file = None sources = [] for arg in args: if os.path.isfile(arg): input_file = file_reader.any_file(arg) if (input_file.file_type == "pdb"): pdb_file = input_file sources.append( interpreter.process(arg="file_name=\"%s\"" % arg)) else: arg_phil = interpreter.process(arg=arg) sources.append(arg_phil) work_phil = master_phil.fetch(sources=sources) work_params = work_phil.extract() else: # XXX for phenix GUI work_params = params if (work_params.remediator.output_file is None): base, ext = os.path.splitext(work_params.remediator.file_name) work_params.remediator.output_file = base + "_remediated.pdb" if (work_params.remediator.file_name is None): if (pdb_file is None): summary = remediator.Program.description raise Usage(summary) else: work_params.remediator.file_name = pdb_file.file_name params = work_params.remediator remediator.remediator(params) return work_params.remediator.output_file
def show_usage(): help_msg = """\ iotbx.pdb.flip_symmetric_amino_acids model.pdb """ raise Usage(help_msg)
def run(args=(), params=None, out=sys.stdout): if (len(args) == 0) and (params is None): raise Usage("iotbx.pdb.add_conformations model.pdb [selection=...]\n" + "Full parameters:\n" + master_phil.as_str()) from iotbx import file_reader pdb_in = None if (params is None): user_phil = [] interpreter = master_phil.command_line_argument_interpreter( home_scope="") for arg in args: if os.path.isfile(arg): f = file_reader.any_file(os.path.abspath(arg)) if (f.file_type == "pdb"): pdb_in = f.file_object user_phil.append( libtbx.phil.parse("add_conformations.pdb_file=\"%s\"" % f.file_name)) elif (f.file_type == "phil"): user_phil.append(f.file_object) else: raise Sorry("Unknown file type '%s' (%s)" % (f.file_type, arg)) else: try: arg_phil = interpreter.process(arg=arg) except RuntimeError, e: raise Sorry("Error parsing '%s': %s" % (arg, str(e))) else: user_phil.append(arg_phil)
def run(args, out=sys.stdout, quiet=None): """ Calculates nonbonded clashscore using MolProbity (PROBE) Returns: When verbose=True the function print detailed results to log When verbose=False it will print clashscore """ cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, pdb_file_def="model", usage_string=usage_string) params = cmdline.work.extract() if (params.model is None): raise Usage(usage_string) # if do_flips, make keep_hydrogens false if params.do_flips : params.keep_hydrogens = False pdb_in = cmdline.get_file(params.model, force_type="pdb") hierarchy = pdb_in.file_object.hierarchy result = clashscore( pdb_hierarchy=hierarchy, fast = params.fast, condensed_probe = params.condensed_probe, keep_hydrogens=params.keep_hydrogens, nuclear=params.nuclear, out=out, verbose=params.verbose and not quiet, b_factor_cutoff=params.b_factor_cutoff, do_flips=params.do_flips) if params.verbose: result.show_old_output(out=out) else: print >> out,round(result.get_clashscore(),2)
def run(args): verbose = False mtz_file_names = [] for arg in args: if (arg == "--help"): from libtbx.utils import Usage raise Usage("iotbx.python tst_dano.py [your_dano.mtz] [--verbose]") elif (arg == "--verbose"): verbose = True else: mtz_file_names.append(arg) exercise_systematic(verbose) if (len(mtz_file_names) == 0): import libtbx.load_env import os op = os.path have_regression = libtbx.env.has_module("phenix_regression") if have_regression: mtz_file_names.append(libtbx.env.find_in_repositories( relative_path="phenix_regression/reflection_files/dano.mtz", test=op.isfile, optional=False)) else: print 'Skipping tests on dano.mtz: no phenix_regression' for mtz_file_name in mtz_file_names: recycle_dano_mtz(mtz_file_name) for missing in [None, "+", "-"]: recycle_one_dano(missing, verbose) print "OK"
def run(args, out=sys.stdout): import optparse if (len(args) == 0) or ("--help" in args): raise Usage(""" mmtbx.validation_summary model.pdb Prints a brief summary of validation criteria, including Ramachandran statistics, rotamer outliers, clashscore, C-beta deviations, plus R-factors and RMS(bonds)/RMS(angles) if found in PDB header. (This is primarily used for evaluating the output of refinement tests; general users are advised to run phenix.model_vs_data or the validation GUI.) """) parser = optparse.OptionParser() options, args = parser.parse_args(args) pdb_file = args[0] if (not os.path.isfile(pdb_file)): raise Sorry("Not a file: %s" % pdb_file) from iotbx.file_reader import any_file pdb_in = any_file(pdb_file, force_type="pdb").check_file_type("pdb") hierarchy = pdb_in.file_object.hierarchy xrs = pdb_in.file_object.input.xray_structures_simple() s = None extra = "" if (len(xrs) == 1): s = summary(pdb_file=pdb_file) else: s = ensemble(pdb_hierarchy=hierarchy, n_models=len(xrs)) extra = " (%d models)" % len(xrs) print("", file=out) print("Validation summary for %s%s:" % (pdb_file, extra), file=out) s.show(out=out, prefix=" ", show_percentiles=True) print("", file=out) return s
def run(args): if (len(args) == 0): from libtbx.utils import Usage import libtbx.load_env raise Usage("%s your.cbf ..." % libtbx.env.dispatcher_name) for file_name in args: process(file_name)
def run(args): if (len(args) != 2): from libtbx.utils import Usage import libtbx.load_env raise Usage("%s first.pdb second.pdb" % libtbx.env.dispatcher_name) import iotbx.pdb inp_hier = [] lbls_sets = [] for file_name in args: pdb_inp = iotbx.pdb.input(file_name=file_name) print "%6d atoms in %s" % (pdb_inp.atoms().size(), file_name) pdb_hierarchy = pdb_inp.construct_hierarchy() inp_hier.append((pdb_inp, pdb_hierarchy)) # need to keep hierarchy alive to get all labels lbls_set = set() for atom in pdb_inp.atoms(): lbls = atom.id_str() if (lbls in lbls_set): raise RuntimeError("Duplicate atom labels: %s" % lbls) lbls_set.add(lbls) lbls_sets.append(lbls_set) print "%6d matching atom labels" % (len(lbls_sets[0].intersection( lbls_sets[1]))) def show_missing(i, j): diff = lbls_sets[j].difference(lbls_sets[i]) print "%6d missing in %s" % (len(diff), args[i]) for atom in inp_hier[j][0].atoms(): lbls = atom.id_str() if (lbls in diff): print " %s" % lbls show_missing(0, 1) show_missing(1, 0)
def run(args, command_name=libtbx.env.dispatcher_name): if (len(args) == 0): raise Usage("%s cif [...]" % command_name) for file_name in args: obj_count = cif_triage.check_comp(file_name=file_name) if (obj_count == 0): raise Sorry("No data found in file: %s" % show_string(file_name)) print "OK"
def show_usage(): help_msg = """\ iotbx.pdb.sort_atoms model.pdb Sort atoms in residues so they will be in the same order in all residues. Also renumbers atoms (atom serial number field 7-11 columns).""" raise Usage(help_msg)