def run(args): log = sys.stdout if (len(args) == 0): args = ["--help"] command_line = (option_parser(usage="%s [options] pdb_file" % libtbx.env.dispatcher_name).option( None, "--buffer_layer", action="store", type="float", default=5)).process(args=args, nargs=1) pdb_inp = iotbx.pdb.input(file_name=command_line.args[0]) model = mmtbx.model.manager(model_input=pdb_inp) box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=model.get_sites_cart(), buffer_layer=command_line.options.buffer_layer) model.set_sites_cart(box.sites_cart) # Bad hack, never repeat. In fact, all the boxing functionality should # go into mmtbx.model.manager model._crystal_symmetry = box.crystal_symmetry() print('REMARK %s --buffer-layer=%.6g %s' % (libtbx.env.dispatcher_name, command_line.options.buffer_layer, show_string(command_line.args[0])), file=log) print('REMARK %s' % date_and_time(), file=log) print(model.model_as_pdb(), file=log)
def get_inputs(args, log, master_params): """ Eventually, this will be centralized. """ cmdline = process_command_line_with_files(args=args, master_phil=master_params, pdb_file_def='model_file_name') params = cmdline.work.extract() # Model file_names = params.model_file_name pdb_combined = combine_unique_pdb_files(file_names=file_names) pdb_inp = iotbx.pdb.input(source_info=None, lines=flex.std_string(pdb_combined.raw_records), raise_sorry_if_format_error=True) # Crystal symmetry fake_crystal_symmetry = False crystal_symmetry = pdb_inp.crystal_symmetry() if (crystal_symmetry is None or crystal_symmetry.is_empty() or crystal_symmetry.is_nonsence()): fake_crystal_symmetry = True from cctbx import uctbx crystal_symmetry = \ uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=pdb_inp.atoms().extract_xyz(), buffer_layer=5).crystal_symmetry() # model = mmtbx.model.manager(model_input=pdb_inp, crystal_symmetry=crystal_symmetry) # return group_args(params=params, pdb_file_names=file_names, model=model, fake_crystal_symmetry=fake_crystal_symmetry)
def run(args): if (len(args) == 0): args = ["--help"] from libtbx.option_parser import option_parser import libtbx.load_env command_line = (option_parser( usage="%s [options] pdb_file" % libtbx.env.dispatcher_name) .option(None, "--buffer_layer", action="store", type="float", default=5) ).process(args=args, nargs=1) import iotbx.pdb pdb_inp = iotbx.pdb.input(file_name=command_line.args[0]) atoms = pdb_inp.atoms() from cctbx import uctbx box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=atoms.extract_xyz(), buffer_layer=command_line.options.buffer_layer) atoms.set_xyz(new_xyz=box.sites_cart) from libtbx.str_utils import show_string print 'REMARK %s --buffer-layer=%.6g %s' % ( libtbx.env.dispatcher_name, command_line.options.buffer_layer, show_string(command_line.args[0])) from libtbx.utils import date_and_time print 'REMARK %s' % date_and_time() print iotbx.pdb.format_cryst1_record(crystal_symmetry=box.crystal_symmetry()) print pdb_inp.construct_hierarchy().as_pdb_string(append_end=True),
def reorder(path, prefix): pdb_inp = iotbx.pdb.input(file_name="%s%s.pdb"%(path,prefix)) h = pdb_inp.construct_hierarchy() rg = list(h.residue_groups()) rg.reverse() # c = iotbx.pdb.hierarchy.chain(id="A") for rg_ in rg: c.append_residue_group(rg_.detached_copy()) # r = iotbx.pdb.hierarchy.root() m = iotbx.pdb.hierarchy.model() r.append_model(m) m.append_chain(c) atoms = r.atoms() # box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=atoms.extract_xyz(), buffer_layer=3.) atoms.set_xyz(new_xyz=box.sites_cart) # fo = open("%s-new.pdb"%prefix,"w") print >> fo, iotbx.pdb.format_cryst1_record( crystal_symmetry=box.crystal_symmetry()) for a in atoms: a = a.set_b(30.) print >> fo, a.format_atom_record() fo.close()
def run(args): log = sys.stdout if (len(args) == 0): args = ["--help"] command_line = (option_parser(usage="%s [options] pdb_file" % libtbx.env.dispatcher_name).option( None, "--buffer_layer", action="store", type="float", default=5)).process(args=args, nargs=1) pdb_inp = iotbx.pdb.input(file_name=command_line.args[0]) atoms = pdb_inp.atoms() box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=atoms.extract_xyz(), buffer_layer=command_line.options.buffer_layer) atoms.set_xyz(new_xyz=box.sites_cart) print >> log, 'REMARK %s --buffer-layer=%.6g %s' % ( libtbx.env.dispatcher_name, command_line.options.buffer_layer, show_string(command_line.args[0])) print >> log, 'REMARK %s' % date_and_time() iotbx.pdb.write_whole_pdb_file( output_file=log, pdb_hierarchy=pdb_inp.construct_hierarchy(), crystal_symmetry=box.crystal_symmetry(), ss_annotation=pdb_inp.extract_secondary_structure(log=null_out()))
def generate_perfect_helix( rs_values, ts_values, angular_rs_values, radial_eta, angular_eta, angular_zeta, n_residues=10, residue_code="G", ): """ Compute AEV values for the perfect helix. """ perfect_helix_ph = ssb.secondary_structure_from_sequence( ssb.alpha_helix_str, residue_code * n_residues) box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=perfect_helix_ph.atoms().extract_xyz(), buffer_layer=5) model = mmtbx.model.manager(model_input=None, crystal_symmetry=box.crystal_symmetry(), pdb_hierarchy=perfect_helix_ph, build_grm=True, log=null_out()) return AEV( model=model, rs_values=rs_values, ts_values=ts_values, angular_rs_values=angular_rs_values, radial_eta=radial_eta, angular_eta=angular_eta, angular_zeta=angular_zeta, ).get_values()
def exercise_non_crystallographic_unit_cell_with_the_sites_in_its_center(): sites_cart = flex.vec3_double([(-5., -5., -5.)]) box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=sites_cart, buffer_layer=5) assert approx_equal(box.unit_cell.parameters(), (10, 10, 10, 90, 90, 90)) assert approx_equal(box.sites_cart, [(5.0, 5.0, 5.0)]) assert box.crystal_symmetry().space_group_info().type().number() == 1
def exercise_non_crystallographic_unit_cell_with_the_sites_in_its_center(): sites_cart = flex.vec3_double([(-5.,-5.,-5.)]) box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart = sites_cart, buffer_layer = 5) assert approx_equal(box.unit_cell.parameters(), (10, 10, 10, 90, 90, 90)) assert approx_equal(box.sites_cart, [(5.0, 5.0, 5.0)]) assert box.crystal_symmetry().space_group_info().type().number() == 1
def run(self): # I'm guessing self.data_manager, self.params and self.logger # are already defined here... # this must be mmtbx.model.manager? model = self.data_manager.get_model() atoms = model.get_atoms() all_bsel = flex.bool(atoms.size(), False) for selection_string in self.params.atom_selection_program.inselection: print("Selecting '%s'" % selection_string, file=self.logger) isel = model.iselection(string=selection_string) all_bsel.set_selected(isel, True) if self.params.atom_selection_program.write_pdb_file is None: print(" %d atom%s selected" % plural_s(isel.size()), file=self.logger) for atom in atoms.select(isel): print(" %s" % atom.format_atom_record(), file=self.logger) print("", file=self.logger) if self.params.atom_selection_program.write_pdb_file is not None: print("Writing file:", show_string( self.params.atom_selection_program.write_pdb_file), file=self.logger) ss_ann = model.get_ss_annotation() if not model.crystal_symmetry() or \ (not model.crystal_symmetry().unit_cell()): model = shift_and_box_model(model, shift_model=False) selected_model = model.select(all_bsel) if (ss_ann is not None): selected_model.set_ss_annotation(ss_ann.\ filter_annotation( hierarchy=selected_model.get_hierarchy(), asc=selected_model.get_atom_selection_cache(), remove_short_annotations=False, remove_3_10_helices=False, remove_empty_annotations=True, concatenate_consecutive_helices=False, split_helices_with_prolines=False, filter_sheets_with_long_hbonds=False)) if self.params.atom_selection_program.cryst1_replacement_buffer_layer is not None: box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=selected_model.get_atoms().extract_xyz(), buffer_layer=self.params.atom_selection_program. cryst1_replacement_buffer_layer) sp = crystal.special_position_settings(box.crystal_symmetry()) sites_frac = box.sites_frac() xrs_box = selected_model.get_xray_structure( ).replace_sites_frac(box.sites_frac()) xray_structure_box = xray.structure(sp, xrs_box.scatterers()) selected_model.set_xray_structure(xray_structure_box) pdb_str = selected_model.model_as_pdb() f = open(self.params.atom_selection_program.write_pdb_file, 'w') f.write(pdb_str) f.close() print("", file=self.logger)
def run(args, command_name=libtbx.env.dispatcher_name): parser = argparse.ArgumentParser( prog=command_name, usage='%s pdb_file "atom_selection" [...]' % command_name) parser.add_argument("file_name", nargs=1, help="File name of the model file") parser.add_argument( "inselections", help="Atom selection strings", nargs='+', ) parser.add_argument("--write-pdb-file", action="store", help="write selected atoms to new PDB file", default=None) parser.add_argument( "--cryst1-replacement-buffer-layer", action="store", type=float, help="replace CRYST1 with pseudo unit cell covering the selected" " atoms plus a surrounding buffer layer", default=None) co = parser.parse_args(args) pdb_inp = iotbx.pdb.input(file_name=co.file_name[0]) model = mmtbx.model.manager(model_input=pdb_inp, process_input=True) atoms = model.get_atoms() all_bsel = flex.bool(atoms.size(), False) for selection_string in co.inselections: print selection_string isel = model.iselection(selstr=selection_string) all_bsel.set_selected(isel, True) if (not co.write_pdb_file): print " %d atom%s selected" % plural_s(isel.size()) for atom in atoms.select(isel): print " %s" % atom.format_atom_record() print if (co.write_pdb_file): print "Writing file:", show_string(co.write_pdb_file) selected_model = model.select(all_bsel) if (co.cryst1_replacement_buffer_layer is not None): box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=selected_model.get_atoms().extract_xyz(), buffer_layer=co.cryst1_replacement_buffer_layer) sp = crystal.special_position_settings(box.crystal_symmetry()) sites_frac = box.sites_frac() xrs_box = selected_model.get_xray_structure().replace_sites_frac( box.sites_frac()) xray_structure_box = xray.structure(sp, xrs_box.scatterers()) selected_model.set_xray_structure(xray_structure_box) pdb_str = selected_model.model_as_pdb() f = open(co.write_pdb_file, 'w') f.write(pdb_str) f.close() print
def process_inputs(self, prefix): broadcast(m=prefix, log=self.log) self.pdb_file_names = list(self.inputs.pdb_file_names) if (self.params.file_name is not None): self.pdb_file_names.append(self.params.file_name) #================================================= cs = self.inputs.crystal_symmetry is_non_crystallographic_unit_cell = False import iotbx.pdb pdb_combined = combine_unique_pdb_files(file_names=self.pdb_file_names) pdb_inp = iotbx.pdb.input(lines=pdb_combined.raw_records, source_info=None) if (cs is None): cs = pdb_inp.crystal_symmetry() if (cs is None): is_non_crystallographic_unit_cell = True box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=pdb_inp.atoms().extract_xyz(), buffer_layer=10) cs = box.crystal_symmetry() cif_objects = list(self.inputs.cif_objects) if (len(self.params.restraints) > 0): import iotbx.cif for file_name in self.params.restraints: cif_object = iotbx.cif.reader(file_path=file_name, strict=False).model() cif_objects.append((file_name, cif_object)) if (self.params.restraints_directory is not None): restraint_files = os.listdir(self.params.restraints_directory) for file_name in restraint_files: if (file_name.endswith(".cif")): full_path = os.path.join(self.params.restraints_directory, file_name) cif_object = iotbx.cif.reader(file_path=full_path, strict=False).model() cif_objects.append((full_path, cif_object)) self.model = mmtbx.model.manager( model_input=pdb_inp, crystal_symmetry=cs, restraint_objects=cif_objects, stop_for_unknowns=self.params.stop_for_unknowns, log=self.log) self.model.process(pdb_interpretation_params=self.params, make_restraints=True) self.ncs_obj = self.model.get_ncs_obj() self.output_crystal_symmetry = not is_non_crystallographic_unit_cell self.sites_cart_start = self.model.get_xray_structure().sites_cart( ).deep_copy() if (self.params.show_states): self.states_collector = mmtbx.utils.states( xray_structure=self.model.get_xray_structure(), pdb_hierarchy=self.model.get_hierarchy()) self.setup_output_file_names()
def run(self): # I'm guessing self.data_manager, self.params and self.logger # are already defined here... # this must be mmtbx.model.manager? model = self.data_manager.get_model() atoms = model.get_atoms() all_bsel = flex.bool(atoms.size(), False) for selection_string in self.params.atom_selection_program.inselection: print("Selecting '%s'" % selection_string, file=self.logger) isel = model.iselection(selstr=selection_string) all_bsel.set_selected(isel, True) if self.params.atom_selection_program.write_pdb_file is None: print(" %d atom%s selected" % plural_s(isel.size()), file=self.logger) for atom in atoms.select(isel): print(" %s" % atom.format_atom_record(), file=self.logger) print("", file=self.logger) if self.params.atom_selection_program.write_pdb_file is not None: print("Writing file:", show_string( self.params.atom_selection_program.write_pdb_file), file=self.logger) selected_model = model.select(all_bsel) if self.params.atom_selection_program.cryst1_replacement_buffer_layer is not None: box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=selected_model.get_atoms().extract_xyz(), buffer_layer=self.params.atom_selection_program. cryst1_replacement_buffer_layer) sp = crystal.special_position_settings(box.crystal_symmetry()) sites_frac = box.sites_frac() xrs_box = selected_model.get_xray_structure( ).replace_sites_frac(box.sites_frac()) xray_structure_box = xray.structure(sp, xrs_box.scatterers()) selected_model.set_xray_structure(xray_structure_box) pdb_str = selected_model.model_as_pdb() f = open(self.params.atom_selection_program.write_pdb_file, 'w') f.write(pdb_str) f.close() print("", file=self.logger)
def xray_structure_of_one_atom(site_cart, buffer_layer, a, b, scatterer_chemical_type = "C"): custom_dict = \ {scatterer_chemical_type: eltbx.xray_scattering.gaussian([a],[b])} box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart = site_cart, buffer_layer = buffer_layer) crystal_symmetry = crystal.symmetry(unit_cell = box.unit_cell, space_group_symbol = "p 1") site_frac =crystal_symmetry.unit_cell().fractionalization_matrix()*site_cart scatterer = flex.xray_scatterer(( [xray.scatterer(scatterer_chemical_type, site = site_frac[0], u = 0.0)])) xray_structure = xray.structure(special_position_settings = None, scatterers = scatterer, crystal_symmetry = crystal_symmetry) xray_structure.scattering_type_registry(custom_dict = custom_dict) return xray_structure
def run(self): self.model = self.data_manager.get_model() cs = self.model.crystal_symmetry() if(cs is None or cs.is_empty() or cs.is_nonsense()): print("Crystal symmetry undefined, creating fake P1 box.") box_crystal_symmetry = \ uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart = self.model.get_sites_cart(), buffer_layer = 5).crystal_symmetry() self.model.set_crystal_symmetry_if_undefined(cs = box_crystal_symmetry) print('Performing manipulations', file=self.logger) self.model = mmtbx.pdbtools.modify( model = self.model, params = self.params.modify, log = self.logger).get_results().model # Write output model file input_file_name_base = os.path.basename( self.data_manager.get_default_model_name())[:-4] if( self.model.input_model_format_cif()): extension = ".cif" elif(self.model.input_model_format_pdb()): extension = ".pdb" if(self.params.output.prefix is not None): output_file_name = self.params.output.prefix if(self.params.output.suffix is not None): output_file_name = output_file_name + self.params.output.suffix else: output_file_name = input_file_name_base + self.params.output.suffix output_file_name = output_file_name + extension ofn = self.get_default_output_filename( prefix=output_file_name, suffix=None, serial=Auto) print('Writing output model', file=self.logger) output_cs=True if(cs is None): output_cs = False self.data_manager.write_model_file(self.model.model_as_str( output_cs=output_cs), ofn) self.result = ofn
def __init__( self, model, # shifted, with shift_manager map_data=None, # shifted map_data params=None, log=sys.stdout, verbose=True): t_0 = time() self.model = model # self.cif_objects = cif_objects self.params = params self.log = log self.verbose = verbose # self.shift_manager = self.model.get_shift_manager() self.rmsd_from_start = None self.init_model_statistics = None self.init_gm_model_statistics = None self.after_ss_idealization = None self.after_loop_idealization = None self.after_rotamer_fixing = None self.final_model_statistics = None self.user_supplied_map = map_data self.reference_map = None # Whole map for all NCS copies self.master_map = None # Map for only one NCS copy, or == reference_map if no NCS self.init_ref_map = None # separate map for initial GM. Should be tighter than the 2 above params = mmtbx.model.manager.get_default_pdb_interpretation_params() params.pdb_interpretation.clash_guard.nonbonded_distance_threshold = None params.pdb_interpretation.peptide_link.ramachandran_restraints = True params.pdb_interpretation.peptide_link.restrain_rama_outliers = self.params.restrain_rama_outliers params.pdb_interpretation.peptide_link.restrain_rama_allowed = self.params.restrain_rama_allowed params.pdb_interpretation.peptide_link.restrain_allowed_outliers_with_emsley = self.params.restrain_allowed_outliers_with_emsley params.pdb_interpretation.peptide_link.rama_weight = self.params.rama_weight params.pdb_interpretation.peptide_link.oldfield.weight_scale = self.params.oldfield.weight_scale params.pdb_interpretation.peptide_link.oldfield.plot_cutoff = self.params.oldfield.plot_cutoff params.pdb_interpretation.peptide_link.apply_peptide_plane = True if self.params.loop_idealization.make_all_trans: params.pdb_interpretation.peptide_link.apply_all_trans = self.params.apply_all_trans params.pdb_interpretation.nonbonded_weight = self.params.nonbonded_weight params.pdb_interpretation.c_beta_restraints = True params.pdb_interpretation.max_reasonable_bond_distance = None params.pdb_interpretation.ncs_search.enabled = True params.pdb_interpretation.ncs_search.chain_max_rmsd = 4.0 params.pdb_interpretation.ncs_search.chain_similarity_threshold = 0.99 params.pdb_interpretation.ncs_search.residue_match_radius = 999.0 params.pdb_interpretation.restraints_library.rdl = True params.pdb_interpretation.secondary_structure = self.params.secondary_structure self.params_for_model = params self.model.set_pdb_interpretation_params(params) self.model.process_input_model(make_restraints=True) self.original_hierarchy = self.model.get_hierarchy().deep_copy( ) # original pdb_h, without any processing self.original_boxed_hierarchy = None # original and boxed (if needed) self.filtered_ncs_restr_group_list = [] self.init_ss_annotation = self.model.get_ss_annotation() # various checks, shifts, trims self.cs = self.original_cs = self.model.crystal_symmetry() # check self.cs (copy-paste from secondary_sturcure_restraints) corrupted_cs = False if self.cs is not None: if [self.cs.unit_cell(), self.cs.space_group()].count(None) > 0: corrupted_cs = True self.cs = None elif self.cs.unit_cell().volume() < 10: corrupted_cs = True self.cs = None # couple checks if pdb_h is ok o_c = self.original_hierarchy.overall_counts() o_c.raise_duplicate_atom_labels_if_necessary() # o_c.raise_residue_groups_with_multiple_resnames_using_same_altloc_if_necessary() o_c.raise_chains_with_mix_of_proper_and_improper_alt_conf_if_necessary( ) o_c.raise_improper_alt_conf_if_necessary() if len(self.original_hierarchy.models()) > 1: raise Sorry("Multi model files are not supported") ca_only_present = False for c in self.original_hierarchy.only_model().chains(): if c.is_ca_only(): ca_only_present = True if ca_only_present: raise Sorry( "Don't support models with chains containing only CA atoms.") self.original_boxed_hierarchy = self.model.get_hierarchy().deep_copy() self.shift_vector = None if self.cs is None: assert self.model.get_shift_manager() is None # should it happen here? if corrupted_cs: print("Symmetry information is corrupted, ", file=self.log) else: print("Symmetry information was not found, ", file=self.log) print("putting molecule in P1 box.", file=self.log) self.log.flush() from cctbx import uctbx box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=self.model.get_sites_cart(), buffer_layer=3) # Creating new xrs from box, inspired by extract_box_around_model_and_map sp = crystal.special_position_settings(box.crystal_symmetry()) sites_frac = box.sites_frac() xrs_box = self.model.get_xray_structure().replace_sites_frac( box.sites_frac()) xray_structure_box = xray.structure(sp, xrs_box.scatterers()) self.model.set_xray_structure(xray_structure_box) self.cs = box.crystal_symmetry() self.shift_vector = box.shift_vector if self.shift_vector is not None and self.params.debug: txt = self.model.model_as_pdb() with open("%s_boxed.pdb" % self.params.output_prefix, 'w') as f: f.write(txt) if self.params.trim_alternative_conformations: self.model.remove_alternative_conformations( always_keep_one_conformer=True) self.model = self.model.remove_hydrogens() self.model_h = None self.time_for_init = time() - t_0
def run(args, params=None, out=sys.stdout, log=sys.stderr): # params keyword is for running program from GUI dialog if (((len(args) == 0) and (params is None)) or ((len(args) > 0) and ((args[0] == "-h") or (args[0] == "--help")))): show_usage() return # parse command-line arguments if (params is None): pcl = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, pdb_file_def="file_name") work_params = pcl.work.extract() # or use parameters defined by GUI else: work_params = params pdb_files = work_params.file_name work_params.secondary_structure.enabled = True assert work_params.format in [ "phenix", "phenix_refine", "phenix_bonds", "pymol", "refmac", "kinemage", "pdb" ] if work_params.quiet: out = cStringIO.StringIO() pdb_combined = iotbx.pdb.combine_unique_pdb_files(file_names=pdb_files) pdb_structure = iotbx.pdb.input(source_info=None, lines=flex.std_string( pdb_combined.raw_records)) cs = pdb_structure.crystal_symmetry() corrupted_cs = False if cs is not None: if [cs.unit_cell(), cs.space_group()].count(None) > 0: corrupted_cs = True cs = None elif cs.unit_cell().volume() < 10: corrupted_cs = True cs = None if cs is None: if corrupted_cs: print >> out, "Symmetry information is corrupted, " else: print >> out, "Symmetry information was not found, " print >> out, "putting molecule in P1 box." from cctbx import uctbx atoms = pdb_structure.atoms() box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=atoms.extract_xyz(), buffer_layer=3) atoms.set_xyz(new_xyz=box.sites_cart) cs = box.crystal_symmetry() defpars = mmtbx.model.manager.get_default_pdb_interpretation_params() defpars.pdb_interpretation.automatic_linking.link_carbohydrates = False defpars.pdb_interpretation.c_beta_restraints = False defpars.pdb_interpretation.clash_guard.nonbonded_distance_threshold = None model = mmtbx.model.manager(model_input=pdb_structure, crystal_symmetry=cs, pdb_interpretation_params=defpars, stop_for_unknowns=False) pdb_hierarchy = model.get_hierarchy() geometry = model.get_restraints_manager().geometry if len(pdb_hierarchy.models()) != 1: raise Sorry("Multiple models not supported.") ss_from_file = None if (hasattr(pdb_structure, "extract_secondary_structure") and not work_params.ignore_annotation_in_file): ss_from_file = pdb_structure.extract_secondary_structure() m = manager(pdb_hierarchy=pdb_hierarchy, geometry_restraints_manager=geometry, sec_str_from_pdb_file=ss_from_file, params=work_params.secondary_structure, verbose=work_params.verbose) # bp_p = nucleic_acids.get_basepair_plane_proxies( # pdb_hierarchy, # m.params.secondary_structure.nucleic_acid.base_pair, # geometry) # st_p = nucleic_acids.get_stacking_proxies( # pdb_hierarchy, # m.params.secondary_structure.nucleic_acid.stacking_pair, # geometry) # hb_b, hb_a = nucleic_acids.get_basepair_hbond_proxies(pdb_hierarchy, # m.params.secondary_structure.nucleic_acid.base_pair) result_out = cStringIO.StringIO() # prefix_scope="refinement.pdb_interpretation" # prefix_scope="" prefix_scope = "" if work_params.format == "phenix_refine": prefix_scope = "refinement.pdb_interpretation" elif work_params.format == "phenix": prefix_scope = "pdb_interpretation" ss_phil = None working_phil = m.as_phil_str(master_phil=sec_str_master_phil) phil_diff = sec_str_master_phil.fetch_diff(source=working_phil) if work_params.format in ["phenix", "phenix_refine"]: comment = "\n".join([ "# These parameters are suitable for use in e.g. phenix.real_space_refine", "# or geometry_minimization. To use them in phenix.refine add ", "# 'refinement.' if front of pdb_interpretation." ]) if work_params.format == "phenix_refine": comment = "\n".join([ "# These parameters are suitable for use in phenix.refine only.", "# To use them in other Phenix tools remove ", "# 'refinement.' if front of pdb_interpretation." ]) print >> result_out, comment if (prefix_scope != ""): print >> result_out, "%s {" % prefix_scope if work_params.show_all_params: working_phil.show(prefix=" ", out=result_out) else: phil_diff.show(prefix=" ", out=result_out) if (prefix_scope != ""): print >> result_out, "}" elif work_params.format == "pdb": print >> result_out, m.actual_sec_str.as_pdb_str() elif work_params.format == "phenix_bonds": raise Sorry("Not yet implemented.") elif work_params.format in ["pymol", "refmac", "kinemage"]: m.show_summary(log=out) (hb_proxies, hb_angle_proxies, planarity_proxies, parallelity_proxies) = m.create_all_new_restraints( pdb_hierarchy=pdb_hierarchy, grm=geometry, log=out) if hb_proxies.size() > 0: if work_params.format == "pymol": file_load_add = "load %s" % work_params.file_name[0] # surprisingly, pymol handles filenames with whitespaces without quotes... print >> result_out, file_load_add bonds_in_format = hb_proxies.as_pymol_dashes( pdb_hierarchy=pdb_hierarchy) elif work_params.format == "kinemage": bonds_in_format = hb_proxies.as_kinemage( pdb_hierarchy=pdb_hierarchy) else: bonds_in_format = hb_proxies.as_refmac_restraints( pdb_hierarchy=pdb_hierarchy) print >> result_out, bonds_in_format if hb_angle_proxies.size() > 0: if work_params.format == "pymol": angles_in_format = hb_angle_proxies.as_pymol_dashes( pdb_hierarchy=pdb_hierarchy) print >> result_out, angles_in_format result = result_out.getvalue() out_prefix = os.path.basename(work_params.file_name[0]) if work_params.output_prefix is not None: out_prefix = work_params.output_prefix filename = "%s_ss.eff" % out_prefix if work_params.format == "pymol": filename = "%s_ss.pml" % out_prefix outf = open(filename, "w") outf.write(result) outf.close() print >> out, result return os.path.abspath(filename)
def run(args=None, pdb_inp=None, pdb_hierarchy=None, cs=None, params=None, out=sys.stdout, log=sys.stderr): if (pdb_hierarchy is None): assert args is not None # params keyword is for running program from GUI dialog if (((len(args) == 0) and (params is None)) or ((len(args) > 0) and ((args[0] == "-h") or (args[0] == "--help")))): show_usage() return # parse command-line arguments if (params is None): pcl = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, pdb_file_def="file_name") work_params = pcl.work.extract() # or use parameters defined by GUI else: work_params = params pdb_files = work_params.file_name pdb_combined = iotbx.pdb.combine_unique_pdb_files(file_names=pdb_files) pdb_structure = iotbx.pdb.input(source_info=None, lines=flex.std_string( pdb_combined.raw_records)) pdb_h = pdb_structure.construct_hierarchy() else: work_params = params if work_params is None: work_params = master_phil.extract() pdb_h = pdb_hierarchy atoms = pdb_h.atoms() ss_log = cStringIO.StringIO() try: if (pdb_inp is not None): pdb_structure = pdb_inp ss_annot = pdb_structure.extract_secondary_structure(log=ss_log) except Sorry as e: print >> out, " Syntax error in SS: %s" % e.message return if work_params.nproc < 1: work_params.nproc = 1 ss_log_cont = ss_log.getvalue() n_bad_helices = ss_log_cont.count("Bad HELIX") n_bad_sheets = ss_log_cont.count("Bad SHEET") if ss_annot is None or ss_annot.is_empty(): print >> out, "No SS annotation, nothing to analyze" return if n_bad_helices > 0: print >> out, "Number of bad helices: %d" % n_bad_helices if n_bad_helices > 0: print >> out, "Number of bad sheets: %d" % n_bad_sheets if len(pdb_h.models()) != 1: raise Sorry("Multiple models not supported.") if not pdb_h.contains_protein(): print >> out, "Protein is not found in the model" return if pdb_h.is_ca_only(): print >> out, "Error: CA-only model" return if is_ca_and_something(pdb_h): print >> out, "CA-only and something model" return if some_chains_are_ca(pdb_h): print >> out, "some chains are CA-only" return corrupted_cs = False if cs is not None: if [cs.unit_cell(), cs.space_group()].count(None) > 0: corrupted_cs = True cs = None elif cs.unit_cell().volume() < 10: corrupted_cs = True cs = None if cs is None: if corrupted_cs: print >> out, "Symmetry information is corrupted, " else: print >> out, "Symmetry information was not found, " print >> out, "putting molecule in P1 box." from cctbx import uctbx atoms = pdb_structure.atoms() box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=atoms.extract_xyz(), buffer_layer=3) atoms.set_xyz(new_xyz=box.sites_cart) cs = box.crystal_symmetry() n_total_helix_sheet_records = ss_annot.get_n_helices( ) + ss_annot.get_n_sheets() n_bad_helix_sheet_records = 0 # Empty stuff: empty_annots = ss_annot.remove_empty_annotations(pdb_h) number_of_empty_helices = empty_annots.get_n_helices() number_of_empty_sheets = empty_annots.get_n_sheets() n_bad_helix_sheet_records += (number_of_empty_helices + number_of_empty_sheets) if number_of_empty_helices > 0: print >> out, "Helices without corresponding atoms in the model (%d):" % number_of_empty_helices for h in empty_annots.helices: print >> out, " ", h.as_pdb_str() if number_of_empty_sheets > 0: print >> out, "Sheets without corresponding atoms in the model (%d):" % number_of_empty_sheets for sh in empty_annots.sheets: print >> out, " ", sh.as_pdb_str() print >> out, "Checking annotations thoroughly, use nproc=<number> if it is too slow..." hsh_tuples = [] for h in ss_annot.helices: hsh_tuples.append(([h], [])) for sh in ss_annot.sheets: hsh_tuples.append(([], [sh])) calc_ss_stats = gather_ss_stats( pdb_h, mediocre_hbond_cutoff=work_params.mediocre_hbond_cutoff, bad_hbond_cutoff=work_params.bad_hbond_cutoff) results = [] if len(hsh_tuples) > 0: results = easy_mp.pool_map(processes=work_params.nproc, fixed_func=calc_ss_stats, args=hsh_tuples) cumm_n_hbonds = 0 cumm_n_bad_hbonds = 0 cumm_n_mediocre_hbonds = 0 cumm_n_rama_out = 0 cumm_n_wrong_reg = 0 n_elem_with_wrong_rama = 0 n_elem_with_rama_out = 0 n_elem_with_bad_hbond = 0 # # Hydrogen Bonds in Proteins: Role and Strength # Roderick E Hubbard, Muhammad Kamran Haider # ENCYCLOPEDIA OF LIFE SCIENCES & 2010, John Wiley & Sons, Ltd. www.els.net # # See also: http://proteopedia.org/wiki/index.php/Hydrogen_bonds # for ss_elem, r in zip(ss_annot.helices + ss_annot.sheets, results): if r is not None: n_hbonds, n_bad_hbonds, n_mediocre_hbonds, hb_lens, n_outliers, n_wrong_region = r cumm_n_hbonds += n_hbonds cumm_n_bad_hbonds += n_bad_hbonds cumm_n_mediocre_hbonds += n_mediocre_hbonds cumm_n_rama_out += n_outliers cumm_n_wrong_reg += n_wrong_region if n_wrong_region > 0: n_elem_with_wrong_rama += 1 if n_outliers > 0: n_elem_with_rama_out += 1 if n_bad_hbonds > 0: n_elem_with_bad_hbond += 1 if n_bad_hbonds + n_outliers + n_wrong_region > 0: n_bad_helix_sheet_records += 1 if n_bad_hbonds + n_mediocre_hbonds + n_outliers + n_wrong_region > 0: # this is bad annotation, printing it to log with separate stats: print >> out, "Bad annotation found:" print >> out, "%s" % ss_elem.as_pdb_str() print >> out, " Total hb: %d, mediocre: %d, bad: %d, Rama outliers: %d, Rama wrong %d" % ( n_hbonds, n_mediocre_hbonds, n_bad_hbonds, n_outliers, n_wrong_region) print >> out, "-" * 80 # n1 = percentage of bad SS elements (per given model); # bad here means: n_bad_hbonds + n_outliers + n_wrong_region > 0 n1 = safe_div(n_bad_helix_sheet_records, n_total_helix_sheet_records) * 100. # n2 = percentage of SS elements that have at least one residue belonging to a wrong region of Ramachandran plot (per given model); n2 = safe_div(n_elem_with_wrong_rama, n_total_helix_sheet_records) * 100. # n3 = percentage of SS elements that have at least one residue being a Ramachandran plot outlier (per given model); n3 = safe_div(n_elem_with_rama_out, n_total_helix_sheet_records) * 100. # n4 = percentage of bad H bonds (per given model). n4 = safe_div(cumm_n_bad_hbonds, cumm_n_hbonds) * 100. # No per SS element separation # percentage of SS elements that have at least one bad H bond (per given model) n5 = safe_div(n_elem_with_bad_hbond, n_total_helix_sheet_records) * 100. print >> out, "Overall info:" print >> out, " Total HELIX+SHEET recods :", n_total_helix_sheet_records print >> out, " Total bad HELIX+SHEET recods :", n_bad_helix_sheet_records print >> out, " Total declared H-bonds :", cumm_n_hbonds print >> out, " Total mediocre H-bonds (%.1f-%.1fA):" % ( work_params.mediocre_hbond_cutoff, work_params.bad_hbond_cutoff), \ cumm_n_mediocre_hbonds print >> out, " Total bad H-bonds (>%.1fA) :" % work_params.bad_hbond_cutoff, \ cumm_n_bad_hbonds print >> out, " Total Ramachandran outliers :", cumm_n_rama_out print >> out, " Total wrong Ramachandrans :", cumm_n_wrong_reg print >> out, "All done." if work_params.filter_annotation: filtered_ann = ss_annot.filter_annotation(hierarchy=pdb_h) print >> out, "Filtered annotation:" print >> out, filtered_ann.as_pdb_str() return group_args(n_total_helix_sheet_records=n_total_helix_sheet_records, n_bad_helix_sheet_records=n_bad_helix_sheet_records, n_hbonds=cumm_n_hbonds, n_mediocre_hbonds=cumm_n_mediocre_hbonds, n_bad_hbonds=cumm_n_bad_hbonds, n_rama_out=cumm_n_rama_out, n_wrong_reg=cumm_n_wrong_reg, n1=n1, n2=n2, n3=n3, n4=n4, n5=n5)
def run (args, params=None, out=sys.stdout, log=sys.stderr) : # params keyword is for running program from GUI dialog if ( ((len(args) == 0) and (params is None)) or ((len(args) > 0) and ((args[0] == "-h") or (args[0] == "--help"))) ): show_usage() return # parse command-line arguments if (params is None): pcl = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, pdb_file_def="file_name") work_params = pcl.work.extract() # or use parameters defined by GUI else: work_params = params pdb_files = work_params.file_name work_params.secondary_structure.enabled=True assert work_params.format in ["phenix", "phenix_refine", "phenix_bonds", "pymol", "refmac", "kinemage", "pdb"] if work_params.quiet : out = cStringIO.StringIO() pdb_combined = iotbx.pdb.combine_unique_pdb_files(file_names=pdb_files) pdb_structure = iotbx.pdb.input(source_info=None, lines=flex.std_string(pdb_combined.raw_records)) cs = pdb_structure.crystal_symmetry() corrupted_cs = False if cs is not None: if [cs.unit_cell(), cs.space_group()].count(None) > 0: corrupted_cs = True cs = None elif cs.unit_cell().volume() < 10: corrupted_cs = True cs = None if cs is None: if corrupted_cs: print >> out, "Symmetry information is corrupted, " else: print >> out, "Symmetry information was not found, " print >> out, "putting molecule in P1 box." from cctbx import uctbx atoms = pdb_structure.atoms() box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=atoms.extract_xyz(), buffer_layer=3) atoms.set_xyz(new_xyz=box.sites_cart) cs = box.crystal_symmetry() from mmtbx.monomer_library import pdb_interpretation, server import mmtbx import mmtbx.command_line.geometry_minimization mon_lib_srv = server.server() ener_lib = server.ener_lib() defpars = mmtbx.command_line.geometry_minimization.master_params().extract() defpars.pdb_interpretation.automatic_linking.link_carbohydrates=False defpars.pdb_interpretation.c_beta_restraints=False defpars.pdb_interpretation.clash_guard.nonbonded_distance_threshold=None processed_pdb_file = pdb_interpretation.process( mon_lib_srv = mon_lib_srv, ener_lib = ener_lib, pdb_inp = pdb_structure, crystal_symmetry = cs, params = defpars.pdb_interpretation, force_symmetry = True) pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy geometry = processed_pdb_file.geometry_restraints_manager() geometry.pair_proxies(processed_pdb_file.xray_structure().sites_cart()) pdb_hierarchy.atoms().reset_i_seq() if len(pdb_hierarchy.models()) != 1 : raise Sorry("Multiple models not supported.") ss_from_file = None if hasattr(pdb_structure, "extract_secondary_structure"): ss_from_file = pdb_structure.extract_secondary_structure() m = manager(pdb_hierarchy=pdb_hierarchy, geometry_restraints_manager=geometry, sec_str_from_pdb_file=ss_from_file, params=work_params.secondary_structure, verbose=work_params.verbose) # bp_p = nucleic_acids.get_basepair_plane_proxies( # pdb_hierarchy, # m.params.secondary_structure.nucleic_acid.base_pair, # geometry) # st_p = nucleic_acids.get_stacking_proxies( # pdb_hierarchy, # m.params.secondary_structure.nucleic_acid.stacking_pair, # geometry) # hb_b, hb_a = nucleic_acids.get_basepair_hbond_proxies(pdb_hierarchy, # m.params.secondary_structure.nucleic_acid.base_pair) result_out = cStringIO.StringIO() # prefix_scope="refinement.pdb_interpretation" # prefix_scope="" prefix_scope="" if work_params.format == "phenix_refine": prefix_scope = "refinement.pdb_interpretation" elif work_params.format == "phenix": prefix_scope = "pdb_interpretation" ss_phil = None working_phil = m.as_phil_str(master_phil=sec_str_master_phil) phil_diff = sec_str_master_phil.fetch_diff(source=working_phil) if work_params.format in ["phenix", "phenix_refine"]: comment = "\n".join([ "# These parameters are suitable for use in e.g. phenix.real_space_refine", "# or geometry_minimization. To use them in phenix.refine add ", "# 'refinement.' if front of pdb_interpretation."]) if work_params.format == "phenix_refine": comment = "\n".join([ "# These parameters are suitable for use in phenix.refine only.", "# To use them in other Phenix tools remove ", "# 'refinement.' if front of pdb_interpretation."]) print >> result_out, comment if (prefix_scope != "") : print >> result_out, "%s {" % prefix_scope if work_params.show_all_params : working_phil.show(prefix=" ", out=result_out) else : phil_diff.show(prefix=" ", out=result_out) if (prefix_scope != "") : print >> result_out, "}" elif work_params.format == "pdb": print >> result_out, m.actual_sec_str.as_pdb_str() elif work_params.format == "phenix_bonds" : raise Sorry("Not yet implemented.") elif work_params.format in ["pymol", "refmac", "kinemage"] : m.show_summary(log=out) (hb_proxies, hb_angle_proxies, planarity_proxies, parallelity_proxies) = m.create_all_new_restraints( pdb_hierarchy=pdb_hierarchy, grm=geometry, log=out) if hb_proxies.size() > 0: if work_params.format == "pymol" : bonds_in_format = hb_proxies.as_pymol_dashes( pdb_hierarchy=pdb_hierarchy) elif work_params.format == "kinemage" : bonds_in_format = hb_proxies.as_kinemage( pdb_hierarchy=pdb_hierarchy) else : bonds_in_format = hb_proxies.as_refmac_restraints( pdb_hierarchy=pdb_hierarchy) print >> result_out, bonds_in_format result = result_out.getvalue() filename = "%s_ss.eff" %os.path.basename(work_params.file_name[0]) outf = open(filename, "w") outf.write(result) outf.close() print >> out, result return os.path.abspath(filename)
def box_pdb(pdb_hierarchy): sites_cart = pdb_hierarchy.atoms().extract_xyz() box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=sites_cart, buffer_layer=10) pdb_hierarchy.atoms().set_xyz(box.sites_cart) return group_args(pdb_hierarchy=pdb_hierarchy, cs=box.crystal_symmetry())
def __init__(self, args, master_phil, out=sys.stdout, process_pdb_file=True, require_data=True, create_fmodel=True, prefer_anomalous=None, force_non_anomalous=False, set_wavelength_from_model_header=False, set_inelastic_form_factors=None, usage_string=None, create_log_buffer=False, remove_unknown_scatterers=False, generate_input_phil=False): import mmtbx.monomer_library.pdb_interpretation import mmtbx.monomer_library.server import mmtbx.utils import mmtbx.model from iotbx import crystal_symmetry_from_any import iotbx.phil if generate_input_phil: assert isinstance(master_phil, basestring) master_phil = generate_master_phil_with_inputs( phil_string=master_phil) if isinstance(master_phil, str): master_phil = iotbx.phil.parse(master_phil) if (usage_string is not None): if (len(args) == 0) or ("--help" in args): raise Usage("""%s\n\nFull parameters:\n%s""" % (usage_string, master_phil.as_str(prefix=" "))) if (force_non_anomalous): assert (not prefer_anomalous) assert (set_inelastic_form_factors in [None, "sasaki", "henke"]) self.args = args self.master_phil = master_phil self.processed_pdb_file = self.pdb_inp = None self.pdb_hierarchy = self.xray_structure = None self.geometry = None self.sequence = None self.fmodel = None self.f_obs = None self.r_free_flags = None self.intensity_flag = None self.raw_data = None self.raw_flags = None self.test_flag_value = None self.miller_arrays = None self.hl_coeffs = None self.cif_objects = [] self.log = out if ("--quiet" in args) or ("quiet=True" in args): self.log = null_out() elif create_log_buffer: self.log = multi_out() self.log.register(label="stdout", file_object=out) self.log.register(label="log_buffer", file_object=StringIO()) make_header("Collecting inputs", out=self.log) cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil=master_phil, pdb_file_def="input.pdb.file_name", reflection_file_def="input.xray_data.file_name", cif_file_def="input.monomers.file_name", seq_file_def="input.sequence") self.working_phil = cmdline.work params = self.working_phil.extract() if len(params.input.pdb.file_name) == 0: raise Sorry("At least one PDB file is required as input.") self.cif_file_names = params.input.monomers.file_name self.pdb_file_names = params.input.pdb.file_name # SYMMETRY HANDLING - PDB FILES self.crystal_symmetry = pdb_symm = None for pdb_file_name in params.input.pdb.file_name: pdb_symm = crystal_symmetry_from_any.extract_from(pdb_file_name) if (pdb_symm is not None): break # DATA INPUT data_and_flags = hkl_symm = hkl_in = None if (params.input.xray_data.file_name is None): if (require_data): raise Sorry( "At least one reflections file is required as input.") else: # FIXME this may still require that the data file has full crystal # symmetry defined (although for MTZ input this will not be a problem) make_sub_header("Processing X-ray data", out=self.log) hkl_in = file_reader.any_file(params.input.xray_data.file_name) hkl_in.check_file_type("hkl") hkl_server = hkl_in.file_server symm = hkl_server.miller_arrays[0].crystal_symmetry() if ((symm is None) or (symm.space_group() is None) or (symm.unit_cell() is None)): if (pdb_symm is not None): from iotbx.reflection_file_utils import reflection_file_server print >> self.log, \ "No symmetry in X-ray data file - using PDB symmetry:" pdb_symm.show_summary(f=out, prefix=" ") hkl_server = reflection_file_server( crystal_symmetry=pdb_symm, reflection_files=[hkl_in.file_object]) else: raise Sorry( "No crystal symmetry information found in input files." ) if (hkl_server is None): hkl_server = hkl_in.file_server data_and_flags = mmtbx.utils.determine_data_and_flags( reflection_file_server=hkl_server, parameters=params.input.xray_data, data_parameter_scope="input.xray_data", flags_parameter_scope="input.xray_data.r_free_flags", prefer_anomalous=prefer_anomalous, force_non_anomalous=force_non_anomalous, log=self.log) self.intensity_flag = data_and_flags.intensity_flag self.raw_data = data_and_flags.raw_data self.raw_flags = data_and_flags.raw_flags self.test_flag_value = data_and_flags.test_flag_value self.f_obs = data_and_flags.f_obs self.r_free_flags = data_and_flags.r_free_flags self.miller_arrays = hkl_in.file_server.miller_arrays hkl_symm = self.raw_data.crystal_symmetry() if len(self.cif_file_names) > 0: for file_name in self.cif_file_names: cif_obj = mmtbx.monomer_library.server.read_cif( file_name=file_name) self.cif_objects.append((file_name, cif_obj)) # SYMMETRY HANDLING - COMBINED if (hkl_symm is not None): use_symmetry = hkl_symm # check for weird crystal symmetry # modified from mmtbx.command_line.secondary_structure_restraints # plan to centralize functionality in another location # ------------------------------------------------------------------------- cs = pdb_symm corrupted_cs = False if cs is not None: if [cs.unit_cell(), cs.space_group()].count(None) > 0: corrupted_cs = True cs = None elif cs.unit_cell().volume() < 10: corrupted_cs = True cs = None if cs is None: if corrupted_cs: print >> out, "Symmetry information is corrupted,", else: print >> out, "Symmetry information was not found,", if (hkl_symm is not None): print >> out, "using symmetry from data." cs = hkl_symm else: print >> out, "putting molecule in P1 box." pdb_combined = iotbx.pdb.combine_unique_pdb_files( file_names=self.pdb_file_names) pdb_structure = iotbx.pdb.input(source_info=None, lines=flex.std_string( pdb_combined.raw_records)) atoms = pdb_structure.atoms() box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=atoms.extract_xyz(), buffer_layer=3) atoms.set_xyz(new_xyz=box.sites_cart) cs = box.crystal_symmetry() pdb_symm = cs # ------------------------------------------------------------------------- from iotbx.symmetry import combine_model_and_data_symmetry self.crystal_symmetry = combine_model_and_data_symmetry( model_symmetry=pdb_symm, data_symmetry=hkl_symm) if (self.crystal_symmetry is not None) and (self.f_obs is not None): self.f_obs = self.f_obs.customized_copy( crystal_symmetry=self.crystal_symmetry).eliminate_sys_absent( ).set_info(self.f_obs.info()) self.r_free_flags = self.r_free_flags.customized_copy( crystal_symmetry=self.crystal_symmetry).eliminate_sys_absent( ).set_info(self.r_free_flags.info()) # EXPERIMENTAL PHASES target_name = "ml" if hasattr(params.input, "experimental_phases"): flag = params.input.use_experimental_phases if (flag in [True, Auto]): phases_file = params.input.experimental_phases.file_name if (phases_file is None): phases_file = params.input.xray_data.file_name phases_in = hkl_in else: phases_in = file_reader.any_file(phases_file) phases_in.check_file_type("hkl") phases_in.file_server.err = self.log # redirect error output space_group = self.crystal_symmetry.space_group() point_group = space_group.build_derived_point_group() hl_coeffs = mmtbx.utils.determine_experimental_phases( reflection_file_server=phases_in.file_server, parameters=params.input.experimental_phases, log=self.log, parameter_scope="input.experimental_phases", working_point_group=point_group, symmetry_safety_check=True) if (hl_coeffs is not None): hl_coeffs = hl_coeffs.map_to_asu() if hl_coeffs.anomalous_flag(): if (not self.f_obs.anomalous_flag()): hl_coeffs = hl_coeffs.average_bijvoet_mates() elif self.f_obs.anomalous_flag(): hl_coeffs = hl_coeffs.generate_bijvoet_mates() self.hl_coeffs = hl_coeffs.matching_set( other=self.f_obs, data_substitute=(0, 0, 0, 0)) target_name = "mlhl" # PDB INPUT self.unknown_residues_flag = False self.unknown_residues_error_message = False pdb_combined = mmtbx.utils.combine_unique_pdb_files( file_names=params.input.pdb.file_name, ) pdb_combined.report_non_unique(out=self.log) pdb_raw_records = pdb_combined.raw_records try: self.pdb_inp = iotbx.pdb.input( source_info=None, lines=flex.std_string(pdb_raw_records)) except ValueError, e: raise Sorry("Model format (PDB or mmCIF) error:\n%s" % str(e))
def __init__(self, args, master_phil, out=sys.stdout, process_pdb_file=True, require_data=True, create_fmodel=True, prefer_anomalous=None, force_non_anomalous=False, set_wavelength_from_model_header=False, set_inelastic_form_factors=None, usage_string=None, create_log_buffer=False, remove_unknown_scatterers=False, generate_input_phil=False): import mmtbx.monomer_library.pdb_interpretation import mmtbx.monomer_library.server import mmtbx.utils import mmtbx.model from iotbx import crystal_symmetry_from_any import iotbx.phil if generate_input_phil: from six import string_types assert isinstance(master_phil, string_types) master_phil = generate_master_phil_with_inputs( phil_string=master_phil) if isinstance(master_phil, str): master_phil = iotbx.phil.parse(master_phil) if (usage_string is not None): if (len(args) == 0) or ("--help" in args): raise Usage("""%s\n\nFull parameters:\n%s""" % (usage_string, master_phil.as_str(prefix=" "))) if (force_non_anomalous): assert (not prefer_anomalous) assert (set_inelastic_form_factors in [None, "sasaki", "henke"]) self.args = args self.master_phil = master_phil self.processed_pdb_file = self.pdb_inp = None self.pdb_hierarchy = self.xray_structure = None self.geometry = None self.sequence = None self.fmodel = None self.f_obs = None self.r_free_flags = None self.intensity_flag = None self.raw_data = None self.raw_flags = None self.test_flag_value = None self.miller_arrays = None self.hl_coeffs = None self.cif_objects = [] self.log = out if ("--quiet" in args) or ("quiet=True" in args): self.log = null_out() elif create_log_buffer: self.log = multi_out() self.log.register(label="stdout", file_object=out) self.log.register(label="log_buffer", file_object=StringIO()) make_header("Collecting inputs", out=self.log) cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil=master_phil, pdb_file_def="input.pdb.file_name", reflection_file_def="input.xray_data.file_name", cif_file_def="input.monomers.file_name", seq_file_def="input.sequence") self.working_phil = cmdline.work params = self.working_phil.extract() if len(params.input.pdb.file_name) == 0: raise Sorry("At least one PDB file is required as input.") self.cif_file_names = params.input.monomers.file_name self.pdb_file_names = params.input.pdb.file_name # SYMMETRY HANDLING - PDB FILES self.crystal_symmetry = pdb_symm = None for pdb_file_name in params.input.pdb.file_name: pdb_symm = crystal_symmetry_from_any.extract_from(pdb_file_name) if (pdb_symm is not None): break # DATA INPUT data_and_flags = hkl_symm = hkl_in = None if (params.input.xray_data.file_name is None): if (require_data): raise Sorry( "At least one reflections file is required as input.") else: # FIXME this may still require that the data file has full crystal # symmetry defined (although for MTZ input this will not be a problem) make_sub_header("Processing X-ray data", out=self.log) hkl_in = file_reader.any_file(params.input.xray_data.file_name) hkl_in.check_file_type("hkl") hkl_server = hkl_in.file_server symm = hkl_server.miller_arrays[0].crystal_symmetry() if ((symm is None) or (symm.space_group() is None) or (symm.unit_cell() is None)): if (pdb_symm is not None): from iotbx.reflection_file_utils import reflection_file_server print( "No symmetry in X-ray data file - using PDB symmetry:", file=self.log) pdb_symm.show_summary(f=out, prefix=" ") hkl_server = reflection_file_server( crystal_symmetry=pdb_symm, reflection_files=[hkl_in.file_object]) else: raise Sorry( "No crystal symmetry information found in input files." ) if (hkl_server is None): hkl_server = hkl_in.file_server data_and_flags = mmtbx.utils.determine_data_and_flags( reflection_file_server=hkl_server, parameters=params.input.xray_data, data_parameter_scope="input.xray_data", flags_parameter_scope="input.xray_data.r_free_flags", prefer_anomalous=prefer_anomalous, force_non_anomalous=force_non_anomalous, log=self.log) self.intensity_flag = data_and_flags.intensity_flag self.raw_data = data_and_flags.raw_data self.raw_flags = data_and_flags.raw_flags self.test_flag_value = data_and_flags.test_flag_value self.f_obs = data_and_flags.f_obs self.r_free_flags = data_and_flags.r_free_flags self.miller_arrays = hkl_in.file_server.miller_arrays hkl_symm = self.raw_data.crystal_symmetry() if len(self.cif_file_names) > 0: for file_name in self.cif_file_names: cif_obj = mmtbx.monomer_library.server.read_cif( file_name=file_name) self.cif_objects.append((file_name, cif_obj)) # SYMMETRY HANDLING - COMBINED if (hkl_symm is not None): use_symmetry = hkl_symm # check for weird crystal symmetry # modified from mmtbx.command_line.secondary_structure_restraints # plan to centralize functionality in another location # ------------------------------------------------------------------------- cs = pdb_symm corrupted_cs = False if cs is not None: if [cs.unit_cell(), cs.space_group()].count(None) > 0: corrupted_cs = True cs = None elif cs.unit_cell().volume() < 10: corrupted_cs = True cs = None if cs is None: if corrupted_cs: print("Symmetry information is corrupted,", end=' ', file=out) else: print("Symmetry information was not found,", end=' ', file=out) if (hkl_symm is not None): print("using symmetry from data.", file=out) cs = hkl_symm else: print("putting molecule in P1 box.", file=out) pdb_combined = iotbx.pdb.combine_unique_pdb_files( file_names=self.pdb_file_names) pdb_structure = iotbx.pdb.input(source_info=None, lines=flex.std_string( pdb_combined.raw_records)) atoms = pdb_structure.atoms() box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=atoms.extract_xyz(), buffer_layer=3) atoms.set_xyz(new_xyz=box.sites_cart) cs = box.crystal_symmetry() pdb_symm = cs # ------------------------------------------------------------------------- from iotbx.symmetry import combine_model_and_data_symmetry self.crystal_symmetry = combine_model_and_data_symmetry( model_symmetry=pdb_symm, data_symmetry=hkl_symm) if (self.crystal_symmetry is not None) and (self.f_obs is not None): self.f_obs = self.f_obs.customized_copy( crystal_symmetry=self.crystal_symmetry).eliminate_sys_absent( ).set_info(self.f_obs.info()) self.r_free_flags = self.r_free_flags.customized_copy( crystal_symmetry=self.crystal_symmetry).eliminate_sys_absent( ).set_info(self.r_free_flags.info()) # EXPERIMENTAL PHASES target_name = "ml" if hasattr(params.input, "experimental_phases"): flag = params.input.use_experimental_phases if (flag in [True, Auto]): phases_file = params.input.experimental_phases.file_name if (phases_file is None): phases_file = params.input.xray_data.file_name phases_in = hkl_in else: phases_in = file_reader.any_file(phases_file) phases_in.check_file_type("hkl") phases_in.file_server.err = self.log # redirect error output space_group = self.crystal_symmetry.space_group() point_group = space_group.build_derived_point_group() hl_coeffs = mmtbx.utils.determine_experimental_phases( reflection_file_server=phases_in.file_server, parameters=params.input.experimental_phases, log=self.log, parameter_scope="input.experimental_phases", working_point_group=point_group, symmetry_safety_check=True) if (hl_coeffs is not None): hl_coeffs = hl_coeffs.map_to_asu() if hl_coeffs.anomalous_flag(): if (not self.f_obs.anomalous_flag()): hl_coeffs = hl_coeffs.average_bijvoet_mates() elif self.f_obs.anomalous_flag(): hl_coeffs = hl_coeffs.generate_bijvoet_mates() self.hl_coeffs = hl_coeffs.matching_set( other=self.f_obs, data_substitute=(0, 0, 0, 0)) target_name = "mlhl" # PDB INPUT self.unknown_residues_flag = False self.unknown_residues_error_message = False pdb_combined = mmtbx.utils.combine_unique_pdb_files( file_names=params.input.pdb.file_name, ) pdb_combined.report_non_unique(out=self.log) pdb_raw_records = pdb_combined.raw_records try: self.pdb_inp = iotbx.pdb.input( source_info=None, lines=flex.std_string(pdb_raw_records)) except ValueError as e: raise Sorry("Model format (PDB or mmCIF) error:\n%s" % str(e)) if (remove_unknown_scatterers): h = self.pdb_inp.construct_hierarchy() known_sel = h.atom_selection_cache().selection("not element X") if known_sel.count(False) > 0: self.pdb_inp = iotbx.pdb.input( source_info=None, lines=h.select(known_sel).as_pdb_string()) model_params = mmtbx.model.manager.get_default_pdb_interpretation_params( ) pdb_interp_params = getattr(params, "pdb_interpretation", None) if pdb_interp_params is None: pdb_interp_params = iotbx.phil.parse( input_string=mmtbx.monomer_library.pdb_interpretation. grand_master_phil_str, process_includes=True).extract() pdb_interp_params = pdb_interp_params.pdb_interpretation model_params.pdb_interpretation = pdb_interp_params stop_for_unknowns = getattr(pdb_interp_params, "stop_for_unknowns", False) or remove_unknown_scatterers if not process_pdb_file: stop_for_unknowns = True and not remove_unknown_scatterers self.model = mmtbx.model.manager( model_input=self.pdb_inp, crystal_symmetry=self.crystal_symmetry, restraint_objects=self.cif_objects, pdb_interpretation_params=model_params, process_input=False, stop_for_unknowns=stop_for_unknowns, log=self.log) if process_pdb_file: make_sub_header("Processing PDB file(s)", out=self.log) self.model.process_input_model(make_restraints=True) full_grm = self.model.get_restraints_manager() self.geometry = full_grm.geometry self.processed_pdb_file = self.model._processed_pdb_file # to remove later XXX self.xray_structure = self.model.get_xray_structure() self.pdb_hierarchy = self.model.get_hierarchy() self.pdb_hierarchy.atoms().reset_i_seq() # wavelength if (params.input.energy is not None): if (params.input.wavelength is not None): raise Sorry("Both wavelength and energy have been specified!") params.input.wavelength = 12398.424468024265 / params.input.energy if (set_wavelength_from_model_header and params.input.wavelength is None): wavelength = self.pdb_inp.extract_wavelength() if (wavelength is not None): print("", file=self.log) print("Using wavelength = %g from PDB header" % wavelength, file=self.log) params.input.wavelength = wavelength # set scattering table if (data_and_flags is not None): self.model.setup_scattering_dictionaries( scattering_table=params.input.scattering_table, d_min=self.f_obs.d_min(), log=self.log, set_inelastic_form_factors=set_inelastic_form_factors, iff_wavelength=params.input.wavelength) self.xray_structure.show_summary(f=self.log) # FMODEL SETUP if (create_fmodel) and (data_and_flags is not None): make_sub_header("F(model) initialization", out=self.log) skip_twin_detection = getattr(params.input, "skip_twin_detection", True) twin_law = getattr(params.input, "twin_law", None) if (twin_law is Auto): if (self.hl_coeffs is not None): raise Sorry( "Automatic twin law determination not supported when " + "experimental phases are used.") elif (not skip_twin_detection): twin_law = Auto if (twin_law is Auto): print("Twinning will be detected automatically.", file=self.log) self.fmodel = mmtbx.utils.fmodel_simple( xray_structures=[self.xray_structure], scattering_table=params.input.scattering_table, f_obs=self.f_obs, r_free_flags=self.r_free_flags, skip_twin_detection=skip_twin_detection, target_name=target_name, log=self.log) else: if ((twin_law is not None) and (self.hl_coeffs is not None)): raise Sorry( "Automatic twin law determination not supported when " + "experimental phases are used.") self.fmodel = mmtbx.utils.fmodel_manager( f_obs=self.f_obs, xray_structure=self.xray_structure, r_free_flags=self.r_free_flags, twin_law=params.input.twin_law, hl_coeff=self.hl_coeffs, target_name=target_name) self.fmodel.update_all_scales(params=None, log=self.log, optimize_mask=True, show=True) self.fmodel.info().show_rfactors_targets_scales_overall( out=self.log) # SEQUENCE if (params.input.sequence is not None): seq_file = file_reader.any_file(params.input.sequence, force_type="seq", raise_sorry_if_errors=True) self.sequence = seq_file.file_object # UNMERGED DATA self.unmerged_i_obs = None if hasattr(params.input, "unmerged_data"): if (params.input.unmerged_data.file_name is not None): self.unmerged_i_obs = load_and_validate_unmerged_data( f_obs=self.f_obs, file_name=params.input.unmerged_data.file_name, data_labels=params.input.unmerged_data.labels, log=self.log) self.params = params print("", file=self.log) print("End of input processing", file=self.log)
def get_model_stat(file_name): pdb_inp = iotbx.pdb.input(file_name=file_name) atoms = pdb_inp.atoms() box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=atoms.extract_xyz(), buffer_layer=5) atoms.set_xyz(new_xyz=box.sites_cart) ph = pdb_inp.construct_hierarchy() if (all_single_atom_residues(ph=ph)): return None raw_recs = ph.as_pdb_string( crystal_symmetry=box.crystal_symmetry()).splitlines() # params = monomer_library.pdb_interpretation.master_params.extract() params.clash_guard.nonbonded_distance_threshold = None params.disable_uc_volume_vs_n_atoms_check = False params.use_neutron_distances = True params.restraints_library.cdl = False processed_pdb_file = monomer_library.pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, raw_records=raw_recs, params=params, log=null_out()) xrs = processed_pdb_file.xray_structure() sctr_keys = xrs.scattering_type_registry().type_count_dict().keys() has_hd = "H" in sctr_keys or "D" in sctr_keys restraints_manager = processed_pdb_file.geometry_restraints_manager( show_energies=False, assume_hydrogens_all_missing=not has_hd, plain_pairs_radius=5.0) a_mean, b_mean = get_bonds_angles_rmsd( restraints_manager=restraints_manager, xrs=xrs) energies_sites = \ restraints_manager.energies_sites( sites_cart = xrs.sites_cart(), compute_gradients = False) nonbonded_distances = energies_sites.nonbonded_distances() number_of_worst_clashes = (nonbonded_distances < 0.5).count(True) # ramalyze_obj = ramalyze(pdb_hierarchy=ph, outliers_only=False) ramachandran_outliers = ramalyze_obj.percent_outliers rotamer_outliers = rotalyze(pdb_hierarchy=ph, outliers_only=False).percent_outliers c_beta_dev = cbetadev(pdb_hierarchy=ph, outliers_only=True, out=null_out()).get_outlier_count() omglz = omegalyze.omegalyze(pdb_hierarchy=ph, quiet=True) n_cis_proline = omglz.n_cis_proline() n_cis_general = omglz.n_cis_general() n_twisted_proline = omglz.n_twisted_proline() n_twisted_general = omglz.n_twisted_general() # clsc = clashscore(pdb_hierarchy=ph).get_clashscore() mpscore = molprobity_score(clashscore=clsc, rota_out=rotamer_outliers, rama_fav=ramalyze_obj.percent_favored) # occ = atoms.extract_occ() bs = atoms.extract_b() # return group_args(b_mean=b_mean, a_mean=a_mean, number_of_worst_clashes=number_of_worst_clashes, ramachandran_outliers=ramachandran_outliers, rotamer_outliers=rotamer_outliers, c_beta_dev=c_beta_dev, n_cis_proline=n_cis_proline, n_cis_general=n_cis_general, n_twisted_proline=n_twisted_proline, n_twisted_general=n_twisted_general, o=occ.min_max_mean().as_tuple(), b=bs.min_max_mean().as_tuple(), mpscore=mpscore, clsc=clsc, n_atoms=atoms.size())
def create_super_sphere(pdb_hierarchy, crystal_symmetry, select_within_radius, link_min=1.0, link_max=2.0, r=None): if (r is None): # This is equivalent to (but much faster): # #r = grm.geometry.pair_proxies().nonbonded_proxies.\ # get_symmetry_interacting_indices_unique( # sites_cart = pdb_hierarchy.atoms().extract_xyz()) # sites_cart = pdb_hierarchy.atoms().extract_xyz() sst = crystal_symmetry.special_position_settings().site_symmetry_table( sites_cart=sites_cart) r = {} from cctbx import crystal cutoff = select_within_radius + 1 # +1 is nonbonded buffer conn_asu_mappings = crystal_symmetry.special_position_settings().\ asu_mappings(buffer_thickness=cutoff) conn_asu_mappings.process_sites_cart(original_sites=sites_cart, site_symmetry_table=sst) conn_pair_asu_table = crystal.pair_asu_table( asu_mappings=conn_asu_mappings) conn_pair_asu_table.add_all_pairs(distance_cutoff=cutoff) pair_generator = crystal.neighbors_fast_pair_generator( conn_asu_mappings, distance_cutoff=cutoff) for pair in pair_generator: rt_mx_i = conn_asu_mappings.get_rt_mx_i(pair) rt_mx_j = conn_asu_mappings.get_rt_mx_j(pair) rt_mx_ji = rt_mx_i.inverse().multiply(rt_mx_j) if str(rt_mx_ji) == "x,y,z": continue r.setdefault(pair.j_seq, []).append(rt_mx_ji) for k, v in zip(r.keys(), r.values()): # remove duplicates! r[k] = list(set(v)) c = iotbx.pdb.hierarchy.chain( id="SS") # all symmetry related full residues fm = crystal_symmetry.unit_cell().fractionalization_matrix() om = crystal_symmetry.unit_cell().orthogonalization_matrix() selection = r.keys() for rg in pdb_hierarchy.residue_groups(): keep = False for i in rg.atoms().extract_i_seq(): if (i in selection): keep = True break if (keep): ops = r[i] for op in ops: rg_ = rg.detached_copy() xyz = rg_.atoms().extract_xyz() new_xyz = flex.vec3_double() for xyz_ in xyz: t1 = fm * flex.vec3_double([xyz_]) t2 = op * t1[0] t3 = om * flex.vec3_double([t2]) new_xyz.append(t3[0]) rg_.atoms().set_xyz(new_xyz) rg_.link_to_previous = True c.append_residue_group(rg_) resseq = 0 for rg in c.residue_groups(): rg.resseq = "%4d" % resseq resseq += 1 # Now we need to re-order residues and group by chains so that they can be # linked by pdb interpretation. super_sphere_hierarchy = pdb_hierarchy.deep_copy() # all_chains = iotbx.pdb.utils.all_chain_ids() all_chains = [chid.strip() for chid in all_chains] for cid in list(set([i.id for i in pdb_hierarchy.chains()])): all_chains.remove(cid) all_chains = iter(all_chains) # def get_atom(atoms, name): for a in atoms: if (a.name.strip().lower() == name.strip().lower()): return a.xyz residue_groups_i = list(c.residue_groups()) residue_groups_j = list(c.residue_groups()) residue_groups_k = list() # standard aa residues only # def dist(r1, r2): return math.sqrt((r1[0] - r2[0])**2 + (r1[1] - r2[1])**2 + (r1[2] - r2[2])**2) # def grow_chain(residue_groups_j, chunk, ci): n_linked = 0 for rgj in residue_groups_j: nj = get_atom(atoms=rgj.atoms(), name="N") if (nj is None): continue d_ci_nj = dist(ci, nj) if (d_ci_nj < link_max and d_ci_nj > link_min): n_linked += 1 chunk.append(rgj) residue_groups_j.remove(rgj) break return n_linked, rgj # Find all isolated single residues, and also save starters starters = [] for rgi in residue_groups_i: ci = get_atom(atoms=rgi.atoms(), name="C") ni = get_atom(atoms=rgi.atoms(), name="N") if (ci is None or ni is None): # collect non-proteins c = iotbx.pdb.hierarchy.chain(id=all_chains.next()) c.append_residue_group(rgi) super_sphere_hierarchy.models()[0].append_chain(c) continue residue_groups_k.append(rgi) c_linked = 0 n_linked = 0 for rgj in residue_groups_j: cj = get_atom(atoms=rgj.atoms(), name="C") nj = get_atom(atoms=rgj.atoms(), name="N") if (cj is None or nj is None): continue d_ci_nj = dist(ci, nj) d_ni_cj = dist(ni, cj) if (d_ci_nj < link_max and d_ci_nj > link_min): n_linked += 1 if (d_ni_cj < link_max and d_ni_cj > link_min): c_linked += 1 assert c_linked in [1, 0], c_linked # Either linked or not! assert n_linked in [1, 0], n_linked # Either linked or not! if (c_linked == 0 and n_linked == 0): # isolated single residue c = iotbx.pdb.hierarchy.chain(id=all_chains.next()) rgi.link_to_previous = True c.append_residue_group(rgi) super_sphere_hierarchy.models()[0].append_chain(c) elif (c_linked == 0): # collect c-terminal residues starters.append(rgi) # Grow continuous chains from remaining residues starting from c-terminals for rgi in starters: ci = get_atom(atoms=rgi.atoms(), name="C") chunk = [rgi] n_linked = 1 while n_linked == 1: n_linked, rgj = grow_chain(residue_groups_k, chunk, ci) if (n_linked == 1): ci = get_atom(atoms=rgj.atoms(), name="C") c = iotbx.pdb.hierarchy.chain(id=all_chains.next()) for i, rg in enumerate(chunk): rg.resseq = "%4d" % i c.append_residue_group(rg) super_sphere_hierarchy.models()[0].append_chain(c) # box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=super_sphere_hierarchy.atoms().extract_xyz(), buffer_layer=10) cs_super_sphere = box.crystal_symmetry() return group_args(hierarchy=super_sphere_hierarchy, crystal_symmetry=cs_super_sphere, selection_r=r)
def __init__(self, pdb_input, cif_objects=None, params=None, log=sys.stdout, verbose=True): t_0 = time() self.pdb_input = pdb_input self.cif_objects = cif_objects self.params = params self.log = log self.verbose = verbose self.rmsd_from_start = None self.init_model_statistics = None self.after_ss_idealization = None self.after_loop_idealization = None self.after_rotamer_fixing = None self.final_model_statistics = None self.reference_map = None self.whole_grm = None self.master_grm = None self.working_grm = None self.mon_lib_srv = None self.ener_lib = None self.rotamer_manager = None self.rama_manager = rama_eval() self.original_hierarchy = None # original pdb_h, without any processing self.original_boxed_hierarchy = None # original and boxed (if needed) self.whole_pdb_h = None # boxed with processing (AC trimming, H trimming,...) self.master_pdb_h = None # master copy in case of NCS self.working_pdb_h = None # one to use for fixing (master_pdb_h or working_pdb_h) # various checks, shifts, trims self.cs = self.pdb_input.crystal_symmetry() # check self.cs (copy-paste from secondary_sturcure_restraints) corrupted_cs = False if self.cs is not None: if [self.cs.unit_cell(), self.cs.space_group()].count(None) > 0: corrupted_cs = True self.cs = None elif self.cs.unit_cell().volume() < 10: corrupted_cs = True self.cs = None self.original_hierarchy = self.pdb_input.construct_hierarchy() # couple checks if pdb_h is ok o_c = self.original_hierarchy.overall_counts() o_c.raise_duplicate_atom_labels_if_necessary() o_c.raise_residue_groups_with_multiple_resnames_using_same_altloc_if_necessary() o_c.raise_chains_with_mix_of_proper_and_improper_alt_conf_if_necessary() o_c.raise_improper_alt_conf_if_necessary() if len(self.original_hierarchy.models()) > 1: raise Sorry("Multi model files are not supported") ca_only_present = False for c in self.original_hierarchy.only_model().chains(): if c.is_ca_only(): ca_only_present = True if ca_only_present: raise Sorry("Don't support models with chains containing only CA atoms.") self.original_boxed_hierarchy = self.original_hierarchy.deep_copy() self.original_boxed_hierarchy.reset_atom_i_seqs() self.shift_vector = None if self.cs is None: if corrupted_cs: print >> self.log, "Symmetry information is corrupted, " else: print >> self.log, "Symmetry information was not found, " print >> self.log, "putting molecule in P1 box." self.log.flush() from cctbx import uctbx atoms = self.original_boxed_hierarchy.atoms() box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=atoms.extract_xyz(), buffer_layer=3) atoms.set_xyz(new_xyz=box.sites_cart) self.cs = box.crystal_symmetry() self.shift_vector = box.shift_vector # self.original_boxed_hierarchy.write_pdb_file(file_name="original_boxed_h.pdb") if self.shift_vector is not None: write_whole_pdb_file( file_name="%s_boxed.pdb" % self.params.output_prefix, pdb_hierarchy=self.original_boxed_hierarchy, crystal_symmetry=self.cs, ss_annotation=self.pdb_input.extract_secondary_structure()) asc = self.original_boxed_hierarchy.atom_selection_cache() if self.params.trim_alternative_conformations: sel = asc.selection("altloc ' '") self.whole_pdb_h = self.original_boxed_hierarchy.select(sel).deep_copy() print >> self.log, "Atoms in original/working model: %d/%d" % ( self.original_boxed_hierarchy.atoms_size(), self.whole_pdb_h.atoms_size()) else: self.whole_pdb_h = self.original_boxed_hierarchy.deep_copy() # self.whole_pdb_h.reset_atom_i_seqs() # Trimming hydrogens # Many intermediate variables are needed due to strange behavior of # selections described in # iotbx/pdb/tst_hierarchy.py:exercise_selection_and_deep_copy() asc2 = self.whole_pdb_h.atom_selection_cache() h_sel = asc2.selection("not (element H or element D)") temp_h = self.whole_pdb_h.select(h_sel) self.whole_pdb_h = temp_h.deep_copy() self.whole_pdb_h.reset_atom_i_seqs() self.init_model_statistics = geometry_no_grm( pdb_hierarchy=iotbx.pdb.input( source_info=None, lines=self.whole_pdb_h.as_pdb_string()).construct_hierarchy(), molprobity_scores=True) self.time_for_init = time()-t_0
def stats(model, prefix, no_ticks=True): # Get rid of H, multi-model, no-protein and single-atom residue models if (model.percent_of_single_atom_residues() > 20): return None sel = model.selection(string="protein") if (sel.count(True) == 0): return None ssr = "protein and not (element H or element D or resname UNX or resname UNK or resname UNL)" sel = model.selection(string=ssr) model = model.select(sel) if (len(model.get_hierarchy().models()) > 1): return None # Add H; this looses CRYST1 ! rr = run_reduce_with_timeout( stdin_lines=model.get_hierarchy().as_pdb_string().splitlines(), file_name=None, parameters="-oh -his -flip -keep -allalt -pen9999 -", override_auto_timeout_with=None) # Create model; this is a single-model pure protein with new H added pdb_inp = iotbx.pdb.input(source_info=None, lines=rr.stdout_lines) model = mmtbx.model.manager(model_input=None, build_grm=True, pdb_hierarchy=pdb_inp.construct_hierarchy(), process_input=True, log=null_out()) box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=model.get_sites_cart(), buffer_layer=5) model.set_sites_cart(box.sites_cart) model._crystal_symmetry = box.crystal_symmetry() # N = 10 SS = get_ss_selections(hierarchy=model.get_hierarchy()) HB_all = find( model=model.select(flex.bool(model.size(), True)), a_DHA_cutoff=90).get_params_as_arrays(replace_with_empty_threshold=N) HB_alpha = find( model=model.select(SS.both.h_sel), a_DHA_cutoff=90).get_params_as_arrays(replace_with_empty_threshold=N) HB_beta = find( model=model.select(SS.both.s_sel), a_DHA_cutoff=90).get_params_as_arrays(replace_with_empty_threshold=N) print(HB_all.d_HA.size()) result_dict = {} result_dict["all"] = HB_all result_dict["alpha"] = HB_alpha result_dict["beta"] = HB_beta # result_dict["loop"] = get_selected(sel=loop_sel) # Load histograms for reference high-resolution d_HA and a_DHA pkl_fn = libtbx.env.find_in_repositories( relative_path="mmtbx") + "/nci/d_HA_and_a_DHA_high_res.pkl" assert os.path.isfile(pkl_fn) ref = easy_pickle.load(pkl_fn) # import matplotlib as mpl mpl.use('Agg') import matplotlib.pyplot as plt fig = plt.figure(figsize=(10, 10)) kwargs = dict(histtype='bar', bins=20, range=[1.6, 3.0], alpha=.8) for j, it in enumerate([["alpha", 1], ["beta", 3], ["all", 5]]): key, i = it ax = plt.subplot(int("32%d" % i)) if (no_ticks): #ax.set_xticks([]) ax.set_yticks([]) if (j in [0, 1]): ax.tick_params(bottom=False) ax.set_xticklabels([]) ax.tick_params(axis="x", labelsize=12) ax.tick_params(axis="y", labelsize=12, left=False, pad=-2) ax.text(0.98, 0.92, key, size=12, horizontalalignment='right', transform=ax.transAxes) HB = result_dict[key] if HB is None: continue w1 = np.ones_like(HB.d_HA) / HB.d_HA.size() ax.hist(HB.d_HA, color="orangered", weights=w1, rwidth=0.3, **kwargs) # start, end1, end2 = 0, max(ref.distances[key].vals), \ round(max(ref.distances[key].vals),2) if (not no_ticks): plt.yticks([0.01, end1], ["0", end2], visible=True, rotation="horizontal") if (key == "alpha"): plt.ylim(0, end2 + 0.02) elif (key == "beta"): plt.ylim(0, end2 + 0.02) elif (key == "all"): plt.ylim(0, end2 + 0.02) else: assert 0 # if (j == 0): ax.set_title("Distance", size=15) bins = list(flex.double(ref.distances[key].bins)) ax.bar(bins, ref.distances[key].vals, alpha=.3, width=0.07) # kwargs = dict(histtype='bar', bins=20, range=[90, 180], alpha=.8) for j, it in enumerate([["alpha", 2], ["beta", 4], ["all", 6]]): key, i = it ax = plt.subplot(int("32%d" % i)) if (j in [0, 1]): ax.tick_params(bottom=False) ax.set_xticklabels([]) if (no_ticks): #ax.set_xticks([]) ax.set_yticks([]) ax.tick_params(axis="x", labelsize=12) ax.tick_params(axis="y", labelsize=12, left=False, pad=-2) ax.text(0.98, 0.92, key, size=12, horizontalalignment='right', transform=ax.transAxes) ax.text(0.98, 0.92, key, size=12, horizontalalignment='right', transform=ax.transAxes) #if(j in [0,1]): ax.plot_params(bottom=False) HB = result_dict[key] if HB is None: continue w1 = np.ones_like(HB.a_DHA) / HB.a_DHA.size() ax.hist(HB.a_DHA, color="orangered", weights=w1, rwidth=0.3, **kwargs) # start, end1, end2 = 0, max(ref.angles[key].vals), \ round(max(ref.angles[key].vals),2) if (not no_ticks): plt.yticks([0.01, end1], ["0", end2], visible=True, rotation="horizontal") if (key == "alpha"): plt.ylim(0, end2 + 0.02) elif (key == "beta"): plt.ylim(0, end2 + 0.02) elif (key == "all"): plt.ylim(0, end2 + 0.02) else: assert 0 # if (j == 0): ax.set_title("Angle", size=15) ax.bar(ref.angles[key].bins, ref.angles[key].vals, width=4.5, alpha=.3) plt.subplots_adjust(wspace=0.12, hspace=0.025) if (no_ticks): plt.subplots_adjust(wspace=0.025, hspace=0.025) #fig.savefig("%s.png"%prefix, dpi=1000) fig.savefig("%s.pdf" % prefix)