def run(pdb_file, cif_file): from mmtbx.monomer_library import server import iotbx from mmtbx.monomer_library import pdb_interpretation pdb_inp = iotbx.pdb.input(file_name=pdb_file) pdb_hierarchy = pdb_inp.construct_hierarchy() raw_lines = pdb_hierarchy.as_pdb_string( crystal_symmetry=pdb_inp.crystal_symmetry()) f=file(cif_file, "rb") ligand_cif = f.read() f.close() cif_object = iotbx.cif.model.cif() iotbx.cif.reader(input_string=ligand_cif, cif_object=cif_object, strict=False) mon_lib_srv = server.server() ener_lib = server.ener_lib() for srv in [mon_lib_srv, ener_lib]: srv.process_cif_object(cif_object=cif_object, file_name="LIGAND") processed_pdb = pdb_interpretation.process( mon_lib_srv, ener_lib, raw_records=raw_lines) geometry_restraints_manager = processed_pdb.geometry_restraints_manager()
def exercise(): verbose = "--verbose" in sys.argv[1:] list_cif = server.mon_lib_list_cif() srv = server.server(list_cif=list_cif) open("tmp.cif", "w").write(tmp_cif) srv.process_cif(file_name="tmp.cif") comp_comp_id = srv.get_comp_comp_id_direct(comp_id="tst") motif = comp_comp_id.as_geometry_restraints_motif() out = StringIO() motif.show(out=out) if (verbose): sys.stdout.write(out.getvalue()) assert not show_diff(out.getvalue(), expected_out_tst_comp) for link_link_id in srv.link_link_id_list: out = StringIO() link_link_id.as_geometry_restraints_motif_manipulation().show(out=out) if (verbose): sys.stdout.write(out.getvalue()) if (link_link_id.chem_link.id == "tst_lnk"): assert not show_diff(out.getvalue(), expected_out_tst_lnk) for mod_mod_id in srv.mod_mod_id_list: out = StringIO() mod_mod_id.as_geometry_restraints_motif_manipulation().show(out=out) if (verbose): sys.stdout.write(out.getvalue()) if (mod_mod_id.chem_mod.id == "tst_mod"): assert not show_diff(out.getvalue(), expected_out_tst_mod) print "OK"
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) mon_lib_srv = server.server() ener_lib = server.ener_lib() processed_pdb_file = pdb_interpretation.process(mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, file_name=co.file_name[0], log=sys.stdout) print acp = processed_pdb_file.all_chain_proxies selection_cache = acp.pdb_hierarchy.atom_selection_cache() atoms = acp.pdb_atoms all_bsel = flex.bool(atoms.size(), False) for selection_string in co.inselections: print selection_string isel = acp.iselection(string=selection_string, cache=selection_cache) 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) sel_hierarchy = acp.pdb_hierarchy.select(all_bsel) if (co.cryst1_replacement_buffer_layer is None): crystal_symmetry = acp.special_position_settings else: import cctbx.crystal crystal_symmetry = cctbx.crystal.non_crystallographic_symmetry( sites_cart=sel_hierarchy.atoms().extract_xyz(), buffer_layer=co.cryst1_replacement_buffer_layer) write_whole_pdb_file(file_name=co.write_pdb_file, processed_pdb_file=processed_pdb_file, pdb_hierarchy=sel_hierarchy, crystal_symmetry=crystal_symmetry) print
def test_solvent_model(): # correct values p = pdb.input(source_info='string',lines=test_pdb) sr = p.xray_structure_simple().scattering_type_registry() # test values p1 = pdb.input(source_info='string',lines=test_pdb) mls = server.server() el = server.ener_lib() ip = pdb_interpretation.process(mon_lib_srv=mls,ener_lib=el,pdb_inp=p1) sg = structure_generator() sg.add_species(p,1) sm = solvent_model() sm.interpreted_pdb = ip sm.xyz = sg.species[0].xyz new_sr = sm.add_bulk_solvent(sr) assert(new_sr.sum_of_scattering_factors_at_diffraction_angle_0() < sr.sum_of_scattering_factors_at_diffraction_angle_0()) sm.bulk_solvent_scale = 0.0 new_sr = sm.add_bulk_solvent(sr) assert(approx_equal(sr.sum_of_scattering_factors_at_diffraction_angle_0(), new_sr.sum_of_scattering_factors_at_diffraction_angle_0())) sm.boundary_layer_scale = 0.0 new_sr = sm.add_boundary_layer_solvent(new_sr) assert(approx_equal(sr.sum_of_scattering_factors_at_diffraction_angle_0(), new_sr.sum_of_scattering_factors_at_diffraction_angle_0())) sm.boundary_layer_scale = 0.6 new_sr = sm.add_boundary_layer_solvent(new_sr) assert(new_sr.sum_of_scattering_factors_at_diffraction_angle_0() > sr.sum_of_scattering_factors_at_diffraction_angle_0())
def exercise_model_utils () : pdb_in = get_1yjp_pdb() residue = pdb_in.hierarchy.only_model().chains()[0].residue_groups()[0].only_atom_group() sele = pdb_in.hierarchy.atom_selection_cache().selection("resname TYR") water_sel = building.get_nearby_water_selection( pdb_hierarchy=pdb_in.hierarchy, xray_structure=pdb_in.input.xray_structure_simple(), selection=sele) assert (list(water_sel.iselection()) == [59, 60, 61, 62, 63]) from mmtbx.monomer_library import idealized_aa from mmtbx.monomer_library import server mon_lib_srv = server.server() ideal_dict = idealized_aa.residue_dict() for resname, hierarchy in ideal_dict.iteritems() : residue = hierarchy.only_model().only_chain().only_residue_group().only_atom_group() result = building.generate_sidechain_clusters(residue, mon_lib_srv) if (len(result) == 0) : # no side-chain clusters for UNK as well assert (residue.resname in ["ALA", "GLY", "UNK"]), residue.resname # show_chain_resseq_ranges resids = [ (1,''),(2,''),(2,'A'),(4,''),(5,''),(6,''),(10,'B') ] import iotbx.pdb.hierarchy chain = iotbx.pdb.hierarchy.chain(id='A') for (resseq, icode) in resids : rg = iotbx.pdb.hierarchy.residue_group(resseq="%4d" % resseq, icode=icode) chain.append_residue_group(rg) out = StringIO() building.show_chain_resseq_ranges(chain.residue_groups(), out=out, prefix=" ") assert out.getvalue() == """ chain 'A': 1-2A,4-6,10B\n""", out.getvalue()
def run(args): list_cif = server.mon_lib_list_cif() srv = server.server(list_cif=list_cif) for comp_id in args: comp_comp_id = srv.get_comp_comp_id_direct(comp_id=comp_id) motif = comp_comp_id.as_geometry_restraints_motif() motif.show()
def exercise_1(): processed_pdb_file = pdb_interpretation.process( mon_lib_srv = server.server(), ener_lib = server.ener_lib(), raw_records = flex.std_string(pdb_str_1.splitlines()), strict_conflict_handling = True, force_symmetry = True, log = None) grm = processed_pdb_file.geometry_restraints_manager() pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy sites_cart = pdb_hierarchy.atoms().extract_xyz() # c-beta restraints are added by default!!! assert len(grm.get_c_beta_torsion_proxies()) == 4 #test global selection and removing c-beta restraints tst_boolsel = pdb_hierarchy.atom_selection_cache().selection("resname TYR") tst_iselection = tst_boolsel.iselection() #test global selection grm2 = grm.select(iselection=tst_iselection) assert len(grm2.get_c_beta_torsion_proxies()) == 2 grm2 = grm.select(selection=tst_boolsel) assert len(grm2.get_c_beta_torsion_proxies()) == 2 #remove a selection grm.remove_c_beta_torsion_restraints_in_place(selection=tst_iselection) assert len(grm.get_c_beta_torsion_proxies()) == 2 #add a selection grm.remove_c_beta_torsion_restraints_in_place() assert len(grm.get_c_beta_torsion_proxies()) == 0 c_beta_torsion_proxies = c_beta.get_c_beta_torsion_proxies( pdb_hierarchy, selection=tst_iselection, sigma=2.5) assert len(c_beta_torsion_proxies) == 2
def get_reference_dihedral_proxies(reference_hierarchy_list, reference_file_list, mon_lib_srv=None, ener_lib=None, crystal_symmetry=None, restraint_objects=None, monomer_parameters=None, log=None): from mmtbx.monomer_library import server if log is None: log = sys.stdout if mon_lib_srv is None: mon_lib_srv = server.server() if ener_lib is None: ener_lib = server.ener_lib() reference_dihedral_proxies = {} for file_name, pdb_hierarchy in zip(reference_file_list, reference_hierarchy_list): dihedral_proxies = get_complete_dihedral_proxies( pdb_hierarchy=pdb_hierarchy, mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, crystal_symmetry=crystal_symmetry, restraint_objects=restraint_objects, monomer_parameters=monomer_parameters, log=log) reference_dihedral_proxies[file_name] = dihedral_proxies return reference_dihedral_proxies
def run (args, out=sys.stdout, quiet=False) : from mmtbx.monomer_library import pdb_interpretation from mmtbx.monomer_library import server import iotbx.pdb 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 = iotbx.pdb.input(source_info=params.model, file_name=params.model) mon_lib_srv = server.server() ener_lib = server.ener_lib() processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, pdb_inp=pdb_in, substitute_non_crystallographic_unit_cell_if_necessary=True) pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy geometry = processed_pdb_file.geometry_restraints_manager() result = rna_validation( pdb_hierarchy=pdb_hierarchy, geometry_restraints_manager=geometry, params=params, outliers_only=params.outliers_only) result.show(out=out) return result
def get_reference_dihedral_proxies( reference_hierarchy_list, reference_file_list, mon_lib_srv=None, ener_lib=None, crystal_symmetry=None, log=None): from mmtbx.monomer_library import server if log is None: log = sys.stdout if mon_lib_srv is None: mon_lib_srv = server.server() if ener_lib is None: ener_lib = server.ener_lib() reference_dihedral_proxies = {} for file_name, pdb_hierarchy in zip(reference_file_list, reference_hierarchy_list): dihedral_proxies = get_complete_dihedral_proxies( pdb_hierarchy=pdb_hierarchy, mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, crystal_symmetry=crystal_symmetry, log=log) reference_dihedral_proxies[file_name]=dihedral_proxies return reference_dihedral_proxies
def run(args, out=sys.stdout, quiet=False): from mmtbx.monomer_library import pdb_interpretation from mmtbx.monomer_library import server import iotbx.pdb 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 = iotbx.pdb.input(source_info=params.model, file_name=params.model) mon_lib_srv = server.server() ener_lib = server.ener_lib() processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, pdb_inp=pdb_in, substitute_non_crystallographic_unit_cell_if_necessary=True) pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy geometry = processed_pdb_file.geometry_restraints_manager() result = rna_validation( pdb_hierarchy=pdb_hierarchy, geometry_restraints_manager=geometry, params=params, outliers_only=params.outliers_only) result.show(out=out) return result
def get_pdb_hierarchy_from_restraints(code): from mmtbx.monomer_library import server from iotbx import pdb mon_lib_server = server.server() path = mon_lib_server.get_comp_comp_id_direct(code, return_filename=True) cif_obj = server.read_cif(path) ligand_inp = pdb.pdb_input(source_info="Model from %s" % path, lines=flex.split_lines("")) ligand_hierarchy = ligand_inp.construct_hierarchy() model = pdb.hierarchy.model() chain = pdb.hierarchy.chain() chain.id = 'Z' rg = pdb.hierarchy.residue_group() ag = pdb.hierarchy.atom_group() for block, loops in cif_obj.blocks.items(): if block == 'comp_list': continue for loop in loops.iterloops(): for row in loop.iterrows(): if '_chem_comp_atom.comp_id' not in row: break ag.resname = row['_chem_comp_atom.comp_id'] atom = pdb.hierarchy.atom() atom.name = row['_chem_comp_atom.atom_id'] atom.element = '%2s' % row['_chem_comp_atom.type_symbol'] atom.xyz = ( float(row['_chem_comp_atom.x']), float(row['_chem_comp_atom.y']), float(row['_chem_comp_atom.z']), ) ag.append_atom(atom) rg.append_atom_group(ag) chain.append_residue_group(rg) model.append_chain(chain) ligand_hierarchy.append_model(model) ligand_hierarchy.atoms().reset_i_seq() return ligand_hierarchy
def exercise_3(): pdb_raw = """\ ATOM 1 CA GLY A 1 -0.227 9.888 -15.197 1.00 54.04 C ATOM 2 CA GLY A 2 -0.227 9.888 -15.197 1.00 54.04 C ATOM 3 CA GLY A 3 -0.227 9.888 -15.197 1.00 54.04 C ATOM 4 CA GLY A 4 -0.227 9.888 -15.197 1.00 54.04 C ATOM 5 CA GLY A 5 -0.227 9.888 -15.197 1.00 54.04 C ATOM 6 CA GLY A 6 -0.227 9.888 -15.197 1.00 54.04 C ATOM 7 CA GLY A 7 -0.227 9.888 -15.197 1.00 54.04 C ATOM 8 CA GLY A 8 -0.227 9.888 -15.197 1.00 54.04 C ATOM 9 CA GLY A 9 -0.227 9.888 -15.197 1.00 54.04 C ATOM 10 CA GLY A 10 -0.227 9.888 -15.197 1.00 54.04 C HETATM 11 N SEP A 11 -2.112 0.368 -0.991 1.00 20.00 A N HETATM 12 CA SEP A 11 -0.692 0.284 -0.951 1.00 20.00 A C HETATM 13 CB SEP A 11 -0.234 0.166 0.485 1.00 20.00 A C HETATM 14 OG SEP A 11 1.130 -0.184 0.515 1.00 20.00 A O HETATM 15 C SEP A 11 -0.237 -0.930 -1.727 1.00 20.00 A C HETATM 16 O SEP A 11 -0.767 -2.051 -1.509 1.00 20.00 A O HETATM 18 P SEP A 11 1.922 -0.008 1.871 1.00 20.00 A P HETATM 19 O1P SEP A 11 2.139 1.462 2.140 1.00 20.00 A O HETATM 20 O2P SEP A 11 3.259 -0.703 1.767 1.00 20.00 A O-1 HETATM 21 O3P SEP A 11 1.127 -0.614 3.002 1.00 20.00 A O-1 END""" mon_lib_srv = server.server() ener_lib = server.ener_lib() pdb_in = iotbx.pdb.hierarchy.input(pdb_string=pdb_raw) xrs = pdb_in.input.xray_structure_simple() processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, raw_records=pdb_in.hierarchy.as_pdb_string(crystal_symmetry=xrs), crystal_symmetry=xrs, log=null_out()) pdb_in.hierarchy.atoms().reset_i_seq() ligand_sel = pdb_in.hierarchy.atom_selection_cache().selection( "resname SEP") mstats = model_properties.model_statistics( pdb_hierarchy=pdb_in.hierarchy, xray_structure=xrs, all_chain_proxies=processed_pdb_file.all_chain_proxies, ligand_selection=ligand_sel, ignore_hd=True) out = StringIO() mstats.show(out=out) assert (mstats.n_protein == 10) assert ("Ligands:" in out.getvalue()) assert approx_equal(mstats.macromolecules.b_mean, 54.04) # now with just the raw selection string mstats = model_properties.model_statistics( pdb_hierarchy=pdb_in.hierarchy, xray_structure=xrs, all_chain_proxies=processed_pdb_file.all_chain_proxies, ligand_selection="resname SEP", ignore_hd=True) out = StringIO() mstats.show(out=out) assert (mstats.n_protein == 10) assert ("Ligands:" in out.getvalue())
def create_all_new_restraints(self, pdb_hierarchy, grm, log=sys.stdout): # initialize cache and monomer library server for underlying procedures if self.mon_lib_srv is None: from mmtbx.monomer_library import server self.mon_lib_srv = server.server() plane_cache = {} t0 = time.time() proteins_hbonds, prot_angle_proxies = self.create_protein_hbond_proxies( log=log, annotation=self.actual_sec_str) t1 = time.time() # print >> log, " Time for creating protein proxies:%f" % (t1-t0) stacking_proxies = nucleic_acids.get_stacking_proxies( pdb_hierarchy=pdb_hierarchy, stacking_phil_params=self.params.secondary_structure.\ nucleic_acid.stacking_pair, grm=grm, mon_lib_srv=self.mon_lib_srv, plane_cache=plane_cache) t2 = time.time() # print >> log, " Time for creating stacking proxies:%f" % (t2-t1) (hb_bond_proxies, hb_angle_proxies, planarity_bp_proxies, parallelity_bp_proxies) = nucleic_acids.get_basepair_proxies( pdb_hierarchy=pdb_hierarchy, bp_phil_params=self.params.secondary_structure.nucleic_acid.base_pair, grm=grm, mon_lib_srv=self.mon_lib_srv, plane_cache=plane_cache, hbond_distance_cutoff=self.params.secondary_structure.\ nucleic_acid.hbond_distance_cutoff, scale_bonds_sigma=self.params.secondary_structure.\ nucleic_acid.scale_bonds_sigma) t4 = time.time() # print >> log, " Time for creating basepair proxies (hbond, angle, planarity):%f" % (t4-t2) self.stats = { 'n_protein_hbonds': 0, 'n_na_hbonds': 0, 'n_na_hbond_angles': 0, 'n_na_basepairs': 0, 'n_na_stacking_pairs': 0 } print(" Restraints generated for nucleic acids:", file=log) print(" %d hydrogen bonds" % len(hb_bond_proxies), file=log) print(" %d hydrogen bond angles" % len(hb_angle_proxies), file=log) print(" %d basepair planarities" % len(planarity_bp_proxies), file=log) print(" %d basepair parallelities" % len(parallelity_bp_proxies), file=log) print(" %d stacking parallelities" % len(stacking_proxies), file=log) all_hbonds = proteins_hbonds.deep_copy() all_hbonds.extend(hb_bond_proxies) all_angle = prot_angle_proxies.deep_copy() all_angle.extend(hb_angle_proxies) return (all_hbonds, all_angle, planarity_bp_proxies, parallelity_bp_proxies + stacking_proxies)
def run(args, residue_type, expected_results): verbose = "--verbose" in args debug = "--debug" in args pdb_files = libtbx.env.find_in_repositories( relative_path="phenix_regression/%s_pdb_files" % residue_type, test=os.path.isdir) if (pdb_files is None): print "Skipping tst_%s_interpretation: input files not available" \ % residue_type return mon_lib_srv = server.server() ener_lib = server.ener_lib() for file_name in os.listdir(pdb_files): if (file_name[-4:] not in [".ent", ".pdb"]): continue if (verbose): log = sys.stdout else: log = null_out() processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, file_name=os.path.join(pdb_files, file_name), log=log) for mm in processed_pdb_file.all_chain_proxies.all_monomer_mappings: residue_name = mm.residue_name if (mm.classification == "RNA"): for c in ["2", "3"]: expected_mod = "%rna"+c+"p_pur" if (mm.residue_name.find(expected_mod) > 0): residue_name = mm.residue_name.replace(expected_mod, "") break expected_mod = "%rna"+c+"p_pyr" if (mm.residue_name.find(expected_mod) > 0): residue_name = mm.residue_name.replace(expected_mod, "") break assert len(mm.duplicate_atoms) == 0 assert len(mm.ignored_atoms) == 0 assert not mm.is_unusual unexpected_names = [atom.name for atom in mm.unexpected_atoms] result = [ residue_name, len(mm.expected_atoms), unexpected_names, mm.classification, mm.is_terminus, mm.incomplete_info] key = file_name[:-4] if (debug): print '"%s":' % key print " ", str(result)+"," print " ", str(expected_results[key])+"," if (expected_results is not None): assert result == expected_results[key], "%s not %s" % ( result, expected_results[key], ) print "OK"
def exercise () : from mmtbx.building.alternate_conformations import conformer_generation from mmtbx.monomer_library import server import iotbx.pdb.hierarchy generate_inputs() params = master_phil().extract() mon_lib_srv = server.server() pdb_in = iotbx.pdb.hierarchy.input(file_name="shear_frag_single.pdb") hierarchy = pdb_in.hierarchy pdb_atoms = hierarchy.atoms() pdb_atoms.reset_i_seq() sites_cart = pdb_atoms.extract_xyz() xrs = pdb_in.input.xray_structure_simple() models = [] prev_res = next_res = next_next_res = None for chain in hierarchy.only_model().chains() : residue_groups = chain.residue_groups() n_rg = len(residue_groups) # should be 4 for i_res, residue_group in enumerate(residue_groups) : sites_orig = sites_cart.deep_copy() next_res = next_next_res = None if (i_res < (n_rg - 1)) : next_res = residue_groups[i_res+1].atom_groups()[0] if (i_res < (n_rg - 2)) : next_next_res = residue_groups[i_res+2].atom_groups()[0] atom_groups = residue_group.atom_groups() primary_conf = atom_groups[0] out = StringIO() confs = [] for conf in conformer_generation.generate_single_residue_confs( atom_group=primary_conf, sites_cart=sites_cart.deep_copy(), mon_lib_srv=mon_lib_srv, params=params.torsion_search, prev_residue=prev_res, next_residue=next_res, next_next_residue=next_next_res, backrub=False, shear=True) : conf.show_summary(out=out) confs.append(conf) prev_res = primary_conf if (confs is None) : continue if (i_res == 1) : assert (""" A ILE 7 None 4.0 mt""") for conf in confs : sites_new = sites_cart.set_selected(conf.sites_selection, conf.sites_selected()) pdb_atoms.set_xyz(sites_new) models.append(hierarchy.only_model().detached_copy()) new_hierarchy = iotbx.pdb.hierarchy.root() for i_model, conf in enumerate(models) : conf.id = str(i_model + 1) new_hierarchy.append_model(conf) open("shear_frag_naive_ensemble.pdb", "w").write( new_hierarchy.as_pdb_string())
def run(args, residue_type, expected_results): verbose = "--verbose" in args debug = "--debug" in args pdb_files = libtbx.env.find_in_repositories( relative_path="phenix_regression/%s_pdb_files" % residue_type, test=os.path.isdir) if (pdb_files is None): print "Skipping tst_%s_interpretation: input files not available" \ % residue_type return mon_lib_srv = server.server() ener_lib = server.ener_lib() for file_name in os.listdir(pdb_files): if (file_name[-4:] not in [".ent", ".pdb"]): continue if (verbose): log = sys.stdout else: log = null_out() processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, file_name=os.path.join(pdb_files, file_name), log=log) for mm in processed_pdb_file.all_chain_proxies.all_monomer_mappings: residue_name = mm.residue_name if (mm.classification == "RNA"): for c in ["2", "3"]: expected_mod = "%rna" + c + "p_pur" if (mm.residue_name.find(expected_mod) > 0): residue_name = mm.residue_name.replace( expected_mod, "") break expected_mod = "%rna" + c + "p_pyr" if (mm.residue_name.find(expected_mod) > 0): residue_name = mm.residue_name.replace( expected_mod, "") break assert len(mm.duplicate_atoms) == 0 assert len(mm.ignored_atoms) == 0 assert not mm.is_unusual unexpected_names = [atom.name for atom in mm.unexpected_atoms] result = [ residue_name, len(mm.expected_atoms), unexpected_names, mm.classification, mm.is_terminus, mm.incomplete_info ] key = file_name[:-4] if (debug): print '"%s":' % key print " ", str(result) + "," print " ", str(expected_results[key]) + "," if (expected_results is not None): assert result == expected_results[key], "%s not %s" % ( result, expected_results[key], ) print "OK"
def exercise_3 () : pdb_raw = """\ ATOM 1 CA GLY A 1 -0.227 9.888 -15.197 1.00 54.04 C ATOM 2 CA GLY A 2 -0.227 9.888 -15.197 1.00 54.04 C ATOM 3 CA GLY A 3 -0.227 9.888 -15.197 1.00 54.04 C ATOM 4 CA GLY A 4 -0.227 9.888 -15.197 1.00 54.04 C ATOM 5 CA GLY A 5 -0.227 9.888 -15.197 1.00 54.04 C ATOM 6 CA GLY A 6 -0.227 9.888 -15.197 1.00 54.04 C ATOM 7 CA GLY A 7 -0.227 9.888 -15.197 1.00 54.04 C ATOM 8 CA GLY A 8 -0.227 9.888 -15.197 1.00 54.04 C ATOM 9 CA GLY A 9 -0.227 9.888 -15.197 1.00 54.04 C ATOM 10 CA GLY A 10 -0.227 9.888 -15.197 1.00 54.04 C HETATM 11 N SEP A 11 -2.112 0.368 -0.991 1.00 20.00 A N HETATM 12 CA SEP A 11 -0.692 0.284 -0.951 1.00 20.00 A C HETATM 13 CB SEP A 11 -0.234 0.166 0.485 1.00 20.00 A C HETATM 14 OG SEP A 11 1.130 -0.184 0.515 1.00 20.00 A O HETATM 15 C SEP A 11 -0.237 -0.930 -1.727 1.00 20.00 A C HETATM 16 O SEP A 11 -0.767 -2.051 -1.509 1.00 20.00 A O HETATM 18 P SEP A 11 1.922 -0.008 1.871 1.00 20.00 A P HETATM 19 O1P SEP A 11 2.139 1.462 2.140 1.00 20.00 A O HETATM 20 O2P SEP A 11 3.259 -0.703 1.767 1.00 20.00 A O-1 HETATM 21 O3P SEP A 11 1.127 -0.614 3.002 1.00 20.00 A O-1 END""" mon_lib_srv = server.server() ener_lib = server.ener_lib() pdb_in = iotbx.pdb.hierarchy.input(pdb_string=pdb_raw) xrs = pdb_in.input.xray_structure_simple() processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, raw_records=pdb_in.hierarchy.as_pdb_string(crystal_symmetry=xrs), crystal_symmetry=xrs, log=null_out()) pdb_in.hierarchy.atoms().reset_i_seq() ligand_sel = pdb_in.hierarchy.atom_selection_cache().selection("resname SEP") mstats = model_properties.model_statistics( pdb_hierarchy=pdb_in.hierarchy, xray_structure=xrs, all_chain_proxies=processed_pdb_file.all_chain_proxies, ligand_selection=ligand_sel, ignore_hd=True) out = StringIO() mstats.show(out=out) assert (mstats.n_protein == 10) assert ("Ligands:" in out.getvalue()) assert approx_equal(mstats.macromolecules.b_mean, 54.04) # now with just the raw selection string mstats = model_properties.model_statistics( pdb_hierarchy=pdb_in.hierarchy, xray_structure=xrs, all_chain_proxies=processed_pdb_file.all_chain_proxies, ligand_selection="resname SEP", ignore_hd=True) out = StringIO() mstats.show(out=out) assert (mstats.n_protein == 10) assert ("Ligands:" in out.getvalue())
def create_all_new_restraints(self, pdb_hierarchy, grm, log=sys.stdout): # initialize cache and monomer library server for underlying procedures if self.mon_lib_srv is None: from mmtbx.monomer_library import server self.mon_lib_srv = server.server() plane_cache = {} t0 = time.time() proteins_hbonds = self.create_protein_hbond_proxies( log=log, annotation=self.actual_sec_str) t1 = time.time() # print >> log, " Time for creating protein proxies:%f" % (t1-t0) stacking_proxies = nucleic_acids.get_stacking_proxies( pdb_hierarchy=pdb_hierarchy, stacking_phil_params=self.params.secondary_structure.\ nucleic_acid.stacking_pair, grm=grm, mon_lib_srv=self.mon_lib_srv, plane_cache=plane_cache) t2 = time.time() # print >> log, " Time for creating stacking proxies:%f" % (t2-t1) planarity_bp_proxies, parallelity_bp_proxies = nucleic_acids.\ get_basepair_plane_proxies( pdb_hierarchy=pdb_hierarchy, bp_phil_params=self.params.secondary_structure.nucleic_acid.base_pair, grm=grm, mon_lib_srv=self.mon_lib_srv, plane_cache=plane_cache) t3 = time.time() # print >> log, " Time for creating planar/parall proxies:%f" % (t3-t2) hb_bond_proxies, hb_angle_proxies = nucleic_acids.\ get_basepair_hbond_proxies( pdb_hierarchy=pdb_hierarchy, bp_phil_params=self.params.secondary_structure.nucleic_acid.base_pair, hbond_distance_cutoff=self.params.secondary_structure.\ nucleic_acid.hbond_distance_cutoff) t4 = time.time() # print >> log, " Time for creating hbond-angle proxies:%f" % (t4-t3) self.stats = {'n_protein_hbonds':0, 'n_na_hbonds':0, 'n_na_hbond_angles':0, 'n_na_basepairs':0, 'n_na_stacking_pairs':0} print >> log, " Restraints generated for nucleic acids:" print >> log, " %d hydrogen bonds" % len(hb_bond_proxies) print >> log, " %d hydrogen bond angles" % len(hb_angle_proxies) print >> log, " %d basepair planarities" % len(planarity_bp_proxies) print >> log, " %d basepair parallelities" % len(parallelity_bp_proxies) print >> log, " %d stacking parallelities" % len(stacking_proxies) all_hbonds = proteins_hbonds.deep_copy() all_hbonds.extend(hb_bond_proxies) return (all_hbonds, hb_angle_proxies, planarity_bp_proxies, parallelity_bp_proxies+stacking_proxies)
def exercise(): list_cif = server.mon_lib_list_cif() srv = server.server(list_cif=list_cif) print("srv.root_path:", srv.root_path) table_of_contents = [] n_get_comp_comp_id_successes = 0 unknown_type_energy_counts = dict_with_default_0() missing_angle_definitions_counts = dict_with_default_0() missing_bond_values_counts = dict_with_default_0() missing_angle_values_counts = dict_with_default_0() for first_char in string.lowercase + string.digits: sub_dir = os.path.join(srv.root_path, first_char) if (not os.path.isdir(sub_dir)): continue for node in os.listdir(sub_dir): if (not node.lower().endswith(".cif")): continue comp_id = node[:-4] if (comp_id.endswith("_EL")): continue if (comp_id in ["CON_CON", "PRN_PRN"]): comp_id = comp_id[:3] if (comp_id.upper() != comp_id): print("Mixed case:", os.path.join(first_char, node)) comp_comp_id = srv.get_comp_comp_id_direct(comp_id=comp_id) if (comp_comp_id is None): print("Error instantiating comp_comp_id %s (%s)" % (comp_id, os.path.join(sub_dir, node))) else: n_get_comp_comp_id_successes += 1 table_of_contents.append(" ".join( [comp_id.upper(), os.path.join(first_char, node)])) status = detect_unknown_type_energy(comp_id=comp_id, comp_comp_id=comp_comp_id) unknown_type_energy_counts[status] += 1 status = detect_missing_angle_definitions( comp_id=comp_id, comp_comp_id=comp_comp_id) missing_angle_definitions_counts[status] += 1 status = detect_missing_bond_values(comp_id=comp_id, comp_comp_id=comp_comp_id) missing_bond_values_counts[status] += 1 status = detect_missing_angle_values(comp_id=comp_id, comp_comp_id=comp_comp_id) missing_angle_values_counts[status] += 1 if (1 and status != "ok"): print('svn rm "%s"' % os.path.join(first_char, node)) print("number of cif files read successfully:", n_get_comp_comp_id_successes) print("unknown type_energy counts:", unknown_type_energy_counts) print("missing bond angle definitions counts:", \ missing_angle_definitions_counts) print("missing bond values counts:", missing_bond_values_counts) print("missing angle values counts:", missing_angle_values_counts) print("writing file table_of_contents") open("table_of_contents", "w").write("\n".join(table_of_contents) + "\n")
def initialize(self, prefix): if (self.log is None) : self.log = sys.stdout if(len(self.args)==0): self.format_usage_message() parsed = self.master_params() self.inputs = mmtbx.utils.process_command_line_args(args = self.args, master_params = parsed) self.params = self.inputs.params.extract() if(self.params.silent): self.log = StringIO() broadcast(m=prefix, log = self.log) self.inputs.params.show(prefix=" ", out=self.log) if(len(self.args)==0): sys.exit(0) self.mon_lib_srv = server.server()
def exercise(): list_cif = server.mon_lib_list_cif() srv = server.server(list_cif=list_cif) print "srv.root_path:", srv.root_path table_of_contents = [] n_get_comp_comp_id_successes = 0 unknown_type_energy_counts = dict_with_default_0() missing_angle_definitions_counts = dict_with_default_0() missing_bond_values_counts = dict_with_default_0() missing_angle_values_counts = dict_with_default_0() for first_char in string.lowercase+string.digits: sub_dir = os.path.join(srv.root_path, first_char) if (not os.path.isdir(sub_dir)): continue for node in os.listdir(sub_dir): if (not node.lower().endswith(".cif")): continue comp_id = node[:-4] if (comp_id.endswith("_EL")): continue if (comp_id in ["CON_CON", "PRN_PRN"]): comp_id = comp_id[:3] if (comp_id.upper() != comp_id): print "Mixed case:", os.path.join(first_char, node) comp_comp_id = srv.get_comp_comp_id_direct(comp_id=comp_id) if (comp_comp_id is None): print "Error instantiating comp_comp_id %s (%s)" % ( comp_id, os.path.join(sub_dir, node)) else: n_get_comp_comp_id_successes += 1 table_of_contents.append( " ".join([comp_id.upper(), os.path.join(first_char, node)])) status = detect_unknown_type_energy( comp_id=comp_id, comp_comp_id=comp_comp_id) unknown_type_energy_counts[status] += 1 status = detect_missing_angle_definitions( comp_id=comp_id, comp_comp_id=comp_comp_id) missing_angle_definitions_counts[status] += 1 status = detect_missing_bond_values( comp_id=comp_id, comp_comp_id=comp_comp_id) missing_bond_values_counts[status] += 1 status = detect_missing_angle_values( comp_id=comp_id, comp_comp_id=comp_comp_id) missing_angle_values_counts[status] += 1 if (1 and status != "ok"): print 'svn rm "%s"' % os.path.join(first_char, node) print "number of cif files read successfully:", n_get_comp_comp_id_successes print "unknown type_energy counts:", unknown_type_energy_counts print "missing bond angle definitions counts:", \ missing_angle_definitions_counts print "missing bond values counts:", missing_bond_values_counts print "missing angle values counts:", missing_angle_values_counts print "writing file table_of_contents" open("table_of_contents", "w").write("\n".join(table_of_contents)+"\n")
def reprocess_pdb(pdb_hierarchy, crystal_symmetry, cif_objects, out): from mmtbx.monomer_library import pdb_interpretation from mmtbx.monomer_library import server mon_lib_srv = server.server() ener_lib = server.ener_lib() for cif_object in cif_objects: for srv in [mon_lib_srv, ener_lib]: srv.process_cif_object(cif_object=cif_object) return pdb_interpretation.process(mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, raw_records=pdb_hierarchy.as_pdb_string( crystal_symmetry=crystal_symmetry), crystal_symmetry=crystal_symmetry, log=out)
def reprocess_pdb (pdb_hierarchy, crystal_symmetry, cif_objects, out) : from mmtbx.monomer_library import pdb_interpretation from mmtbx.monomer_library import server mon_lib_srv = server.server() ener_lib = server.ener_lib() for cif_object in cif_objects : for srv in [mon_lib_srv, ener_lib]: srv.process_cif_object(cif_object=cif_object) return pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, raw_records=pdb_hierarchy.as_pdb_string(crystal_symmetry=crystal_symmetry), crystal_symmetry=crystal_symmetry, log=out)
def get_pdb_inputs(pdb_str): processed_pdb_file = pdb_interpretation.process( mon_lib_srv=server.server(), ener_lib=server.ener_lib(), raw_records=flex.std_string(pdb_str.splitlines()), strict_conflict_handling=True, force_symmetry=True, log=None) xrs = processed_pdb_file.xray_structure(show_summary=False) geometry_restraints_manager = geometry_minimization.\ get_geometry_restraints_manager(processed_pdb_file, xrs) pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy return group_args(ph=pdb_hierarchy, grm=geometry_restraints_manager, xrs=xrs)
def get_pdb_inputs(pdb_str): processed_pdb_file = pdb_interpretation.process( mon_lib_srv = server.server(), ener_lib = server.ener_lib(), raw_records = flex.std_string(pdb_str.splitlines()), strict_conflict_handling = True, force_symmetry = True, log = None) xrs = processed_pdb_file.xray_structure(show_summary = False) geometry_restraints_manager = geometry_minimization.\ get_geometry_restraints_manager(processed_pdb_file, xrs) pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy return group_args( ph = pdb_hierarchy, grm = geometry_restraints_manager, xrs = xrs)
def get_complete_dihedral_proxies( pdb_hierarchy=None, file_name=None, raw_records=None, mon_lib_srv=None, ener_lib=None, crystal_symmetry=None, log=None): # # This function is called only for reference files, that were not processed # yet. For the main file only get_dihedrals_and_phi_psi below is called. # assert [pdb_hierarchy, file_name, raw_records].count(None) == 2 from mmtbx.monomer_library import server, pdb_interpretation import cStringIO if log is None: log = sys.stdout if mon_lib_srv is None: mon_lib_srv = server.server() if ener_lib is None: ener_lib = server.ener_lib() if pdb_hierarchy is not None: raw_records = pdb_hierarchy.as_pdb_string() if raw_records is not None: if (isinstance(raw_records, str)): raw_records = flex.split_lines(raw_records) work_params = pdb_interpretation.master_params.extract() work_params.c_beta_restraints=False work_params.automatic_linking.link_none=True work_params.clash_guard.nonbonded_distance_threshold = None processed_pdb_file_local = \ pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, params=work_params, file_name=file_name, raw_records=raw_records, strict_conflict_handling=False, crystal_symmetry=crystal_symmetry, force_symmetry=True, log=cStringIO.StringIO(), substitute_non_crystallographic_unit_cell_if_necessary=True) return get_dihedrals_and_phi_psi(processed_pdb_file_local)
def get_mstats(pdb_raw): mon_lib_srv = server.server() ener_lib = server.ener_lib() pdb_in = iotbx.pdb.hierarchy.input(pdb_string=pdb_raw) xrs = pdb_in.input.xray_structure_simple() processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, raw_records=pdb_in.hierarchy.as_pdb_string(crystal_symmetry=xrs), crystal_symmetry=xrs, log=null_out()) pdb_in.hierarchy.atoms().reset_i_seq() mstats = model_properties.model_statistics( pdb_hierarchy=pdb_in.hierarchy, xray_structure=xrs, all_chain_proxies=processed_pdb_file.all_chain_proxies, ignore_hd=True) return mstats
def __init__(self, pdb_file_name=None, raw_records=None): # assert count(pdb_file_name, raw_records)==1 if pdb_file_name: self.pdb_inp = iotbx.pdb.input(file_name=pdb_file_name) else: self.pdb_inp = iotbx.pdb.input(lines=raw_records, source_info='raw_records') self.hierarchy = self.pdb_inp.construct_hierarchy() self.mon_lib_srv = server.server() self.ener_lib = server.ener_lib() self.processed_pdb = pdb_interpretation.process( self.mon_lib_srv, self.ener_lib, file_name=pdb_file_name, raw_records=raw_records) self.geometry_restraints_manager = self.processed_pdb.geometry_restraints_manager( ) self.atom_elements = {}
def get_complete_dihedral_proxies( pdb_hierarchy=None, file_name=None, raw_records=None, mon_lib_srv=None, ener_lib=None, crystal_symmetry=None, restraint_objects=None, monomer_parameters=None, log=None): # # This function is called only for reference files, that were not processed # yet. For the main file only get_dihedrals_and_phi_psi below is called. # Still used for reference model torsion restraints # import mmtbx.model assert [pdb_hierarchy, file_name, raw_records].count(None) == 2 from mmtbx.monomer_library import server, pdb_interpretation if log is None: log = sys.stdout if mon_lib_srv is None: mon_lib_srv = server.server() if ener_lib is None: ener_lib = server.ener_lib() if pdb_hierarchy is not None: raw_records = pdb_hierarchy.as_pdb_string() if raw_records is not None: if (isinstance(raw_records, str)): raw_records = flex.split_lines(raw_records) work_params = mmtbx.model.manager.get_default_pdb_interpretation_params() work_params.pdb_interpretation.c_beta_restraints=False work_params.pdb_interpretation.automatic_linking.link_none=True work_params.pdb_interpretation.clash_guard.nonbonded_distance_threshold = None pdb_inp = input(lines=raw_records, source_info=None) model = mmtbx.model.manager( model_input = pdb_inp, build_grm = True, pdb_interpretation_params=work_params, restraint_objects=restraint_objects, monomer_parameters=monomer_parameters, log=null_out()) return get_dihedrals_and_phi_psi(model)
def get_complete_dihedral_proxies(pdb_hierarchy=None, file_name=None, raw_records=None, mon_lib_srv=None, ener_lib=None, crystal_symmetry=None, log=None): # # This function is called only for reference files, that were not processed # yet. For the main file only get_dihedrals_and_phi_psi below is called. # Still used for reference model torsion restraints # assert [pdb_hierarchy, file_name, raw_records].count(None) == 2 from mmtbx.monomer_library import server, pdb_interpretation import cStringIO if log is None: log = sys.stdout if mon_lib_srv is None: mon_lib_srv = server.server() if ener_lib is None: ener_lib = server.ener_lib() if pdb_hierarchy is not None: raw_records = pdb_hierarchy.as_pdb_string() if raw_records is not None: if (isinstance(raw_records, str)): raw_records = flex.split_lines(raw_records) work_params = pdb_interpretation.master_params.extract() work_params.c_beta_restraints = False work_params.automatic_linking.link_none = True work_params.clash_guard.nonbonded_distance_threshold = None processed_pdb_file_local = \ pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, params=work_params, file_name=file_name, raw_records=raw_records, strict_conflict_handling=False, crystal_symmetry=crystal_symmetry, force_symmetry=True, log=cStringIO.StringIO(), substitute_non_crystallographic_unit_cell_if_necessary=True) return get_dihedrals_and_phi_psi(processed_pdb_file_local)
def get_geometry_restraints_manager(pdb_filename, #pdb_inp, #pdb_hierarchy, ): t0=time.time() from mmtbx.monomer_library import server from mmtbx.monomer_library import pdb_interpretation #lines = pdb_hierarchy.as_pdb_string( # crystal_symmetry=pdb_inp.crystal_symmetry(), # ) mon_lib_srv = server.server() ener_lib = server.ener_lib() processed_pdb = pdb_interpretation.process( mon_lib_srv, ener_lib, #raw_records=lines, file_name=pdb_filename, ) geometry_restraints_manager = processed_pdb.geometry_restraints_manager() print 'time',time.time()-t0 return geometry_restraints_manager
def get_geometry_restraints_manager(pdb_filename, #pdb_inp, #pdb_hierarchy, ): t0 = time.time() from mmtbx.monomer_library import server from mmtbx.monomer_library import pdb_interpretation #lines = pdb_hierarchy.as_pdb_string( # crystal_symmetry=pdb_inp.crystal_symmetry(), # ) mon_lib_srv = server.server() ener_lib = server.ener_lib() processed_pdb = pdb_interpretation.process( mon_lib_srv, ener_lib, #raw_records=lines, file_name=pdb_filename, ) geometry_restraints_manager = processed_pdb.geometry_restraints_manager() print 'time', time.time() - t0 return geometry_restraints_manager
def init_afitt(self, params, pdb_hierarchy, log): if hasattr(params, "afitt"): use_afitt = params.afitt.use_afitt if (use_afitt): from mmtbx.geometry_restraints import afitt # this only seems to work for a single ligand # multiple ligands are using the monomers input if params.afitt.ligand_file_name is None: ligand_paths = params.input.monomers.file_name else: ligand_paths = [params.afitt.ligand_file_name] afitt.validate_afitt_params(params.afitt) ligand_names = params.afitt.ligand_names.split(',') if len(ligand_names) != len(ligand_paths) and len( ligand_names) == 1: # get restraints library instance of ligand from mmtbx.monomer_library import server for ligand_name in ligand_names: result = server.server().get_comp_comp_id_direct( ligand_name) if result is not None: so = result.source_info # not the smartest way if so.find("file:") == 0: ligand_paths = [so.split(":")[1].strip()] if len(ligand_names) != len(ligand_paths): raise Sorry("need restraint CIF files for each ligand") make_header("Initializing AFITT", out=log) #print >> log, " ligands: %s" % params.afitt.ligand_file_name afitt_object = afitt.afitt_object(ligand_paths, ligand_names, pdb_hierarchy, params.afitt.ff, params.afitt.scale) print >> log, afitt_object afitt_object.check_covalent(self.geometry) # afitt log output afitt_object.initial_energies = afitt.get_afitt_energy( ligand_paths, ligand_names, pdb_hierarchy, params.afitt.ff, pdb_hierarchy.atoms().extract_xyz(), self.geometry) self.afitt_object = afitt_object
def read_dummy_type(file_name=None, pdb_inp=None): assert ((file_name is not None) or (pdb_inp is not None)) mon_lib_srv = server.server() ener_lib = server.ener_lib() if (pdb_inp is None): tmp_obj = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, file_name=file_name).all_chain_proxies else: tmp_obj = pdb_interpretation.process(mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, pdb_inp=pdb_inp).all_chain_proxies ats = tmp_obj.nonbonded_energy_type_registry.symbols els = tmp_obj.scattering_type_registry.symbols for i in range(ats.size()): if ats[i] == "": ats[i] = els[i] return ats
def run_validation(self) : # get required elements to run: # - pdb_hierarchy and geometry pdb_in = iotbx.pdb.input(file_name=self.pdb_file) mon_lib_srv = server.server() ener_lib = server.ener_lib() processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, pdb_inp=pdb_in, substitute_non_crystallographic_unit_cell_if_necessary=True) pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy geometry = processed_pdb_file.geometry_restraints_manager() # - params import mmtbx.command_line.rna_validate params = mmtbx.command_line.rna_validate.get_master_phil().extract() # run rna_validation self.result = rna_validation( pdb_hierarchy=pdb_hierarchy, geometry_restraints_manager=geometry, params=params, outliers_only=False)
def exercise_2 () : pdb_raw = """\ ATOM 6407 N GLY A 388 -0.783 9.368 -16.436 1.00 51.96 N ATOM 6408 CA GLY A 388 -0.227 9.888 -15.197 1.00 54.04 C ATOM 6409 C GLY A 388 -0.637 11.320 -14.897 1.00 55.86 C ATOM 6410 O GLY A 388 -1.728 11.738 -15.347 1.00 56.70 O ATOM 6411 OXT GLY A 388 0.129 12.024 -14.203 1.00 56.98 O ATOM 6412 D GLY A 388 -0.460 9.727 -17.309 1.00 51.44 D ATOM 6413 HA2 GLY A 388 -0.561 9.258 -14.385 1.00 54.07 H ATOM 6414 HA3 GLY A 388 0.843 9.835 -15.243 1.00 54.13 H TER 6415 GLY A 388 HETATM 6416 D D8U A 401 -12.236 -13.695 -42.992 1.00 15.23 D HETATM 6417 O DOD A1001 -4.151 -5.107 -38.592 1.00 13.40 O HETATM 6418 D1 DOD A1001 -4.760 -5.026 -39.326 1.00 15.45 D HETATM 6419 D2 DOD A1001 -4.625 -4.741 -37.845 1.00 14.81 D """ mon_lib_srv = server.server() ener_lib = server.ener_lib() pdb_in = iotbx.pdb.hierarchy.input(pdb_string=pdb_raw) xrs = pdb_in.input.xray_structure_simple() processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, raw_records=pdb_in.hierarchy.as_pdb_string(crystal_symmetry=xrs), crystal_symmetry=xrs, log=null_out()) pdb_in.hierarchy.atoms().reset_i_seq() mstats = model_properties.model_statistics( pdb_hierarchy=pdb_in.hierarchy, xray_structure=xrs, all_chain_proxies=processed_pdb_file.all_chain_proxies, ignore_hd=True) out = StringIO() mstats.show(out=out) assert ("Ligands:" in out.getvalue()) assert ("B_iso: mean = 15.2 max = 15.2 min = 15.2" in out.getvalue())
def initialize(self, prefix): if (self.log is None) : self.log = sys.stdout if(len(self.args)==0): self.format_usage_message() parsed = self.master_params() self.inputs = mmtbx.utils.process_command_line_args(args = self.args, master_params = parsed) self.params = self.inputs.params.extract() if(self.params.silent): self.log = StringIO() broadcast(m=prefix, log = self.log) self.inputs.params.show(prefix=" ", out=self.log) if(len(self.args)==0): sys.exit(0) self.mon_lib_srv = server.server() ########################## # adjust some parameters # ########################## if hasattr(self.params, "amber"): if self.params.amber.use_amber: self.params.pdb_interpretation.sort_atoms=False print >> self.log, "%s\n %s\n%s" % ( '-'*40, 'Automatic sorting of atoms turned off.', '-'*40, )
def exercise(): verbose = "--verbose" in sys.argv[1:] quick = "--quick" in sys.argv[1:] list_cif = server.mon_lib_list_cif() srv = server.server(list_cif=list_cif) print("srv.root_path:", srv.root_path) default_switch = "--default_off" not in sys.argv[1:] if (False or default_switch): monomers_with_commas = {} atom_id_counts = dicts.with_default_value(0) for row_id in list_cif.cif["comp_list"]["_chem_comp.id"]: if (quick and random.random() < 0.95): continue if (verbose): print("id:", row_id) comp_comp_id = srv.get_comp_comp_id_direct(comp_id=row_id) if (comp_comp_id is None): print("Could not instantiating comp_comp_id(%s)" % row_id) else: has_primes = False has_commas = False for atom in comp_comp_id.atom_list: atom_id_counts[atom.atom_id] += 1 if (atom.atom_id.find("'") >= 0): has_primes = True if (atom.atom_id.find(",") >= 0): has_commas = True if (has_commas): monomers_with_commas[ comp_comp_id.chem_comp.id] = has_primes print(monomers_with_commas) atom_ids = flex.std_string(list(atom_id_counts.keys())) counts = flex.size_t(list(atom_id_counts.values())) perm = flex.sort_permutation(data=counts, reverse=True) atom_ids = atom_ids.select(perm) counts = counts.select(perm) for atom_id, count in zip(atom_ids, counts): print(atom_id, count) if (False or default_switch): for row in list_cif.cif["comp_list"]["_chem_comp"].iterrows(): if (quick and random.random() < 0.95): continue if (verbose): print("id:", row["_chem_comp.id"]) comp_comp_id = srv.get_comp_comp_id_direct( comp_id=row["_chem_comp.id"]) check_chem_comp(cif_types.chem_comp(**row), comp_comp_id) if ("--pickle" in sys.argv[1:]): easy_pickle.dump("mon_lib.pickle", srv) if (False or default_switch): comp = srv.get_comp_comp_id_direct("GLY") comp.show() mod = srv.mod_mod_id_dict["COO"] comp.apply_mod(mod).show() if (False or default_switch): comp = srv.get_comp_comp_id_direct("LYS") comp.show() mod = srv.mod_mod_id_dict["B2C"] comp.apply_mod(mod).show() if (False or default_switch): for row in list_cif.cif["comp_list"]["_chem_comp"].iterrows(): if (quick and random.random() < 0.95): continue comp_comp_id = srv.get_comp_comp_id_direct(row["_chem_comp.id"]) if (comp_comp_id is not None): if (comp_comp_id.classification == "peptide"): print(comp_comp_id.chem_comp.id, comp_comp_id.chem_comp.name, end=' ') print(row["_chem_comp.group"], end=' ') grp = row["_chem_comp.group"].lower().strip() if (grp not in ("l-peptide", "d-peptide", "polymer")): print("LOOK", end=' ') #if (not os.path.isdir("look")): os.makedirs("look") #open("look/%s.cif" % row["_chem_comp.id"], "w").write( #open(comp_comp_id.file_name).read()) print() elif (row["_chem_comp.group"].lower().find("peptide") >= 0 or comp_comp_id.chem_comp.group.lower().find("peptide") >= 0): print(comp_comp_id.chem_comp.id, comp_comp_id.chem_comp.name, end=' ') print(row["_chem_comp.group"], "MISMATCH") if (comp_comp_id.classification in ("RNA", "DNA")): print(comp_comp_id.chem_comp.id, comp_comp_id.chem_comp.name, end=' ') print(row["_chem_comp.group"], end=' ') if (comp_comp_id.classification != row["_chem_comp.group"].strip()): print(comp_comp_id.classification, "MISMATCH", end=' ') print() elif (row["_chem_comp.group"].lower().find("NA") >= 0 or comp_comp_id.chem_comp.group.lower().find("NA") >= 0): print(comp_comp_id.chem_comp.id, comp_comp_id.chem_comp.name, end=' ') print(row["_chem_comp.group"], "MISMATCH") if (False or default_switch): for row in list_cif.cif["comp_list"]["_chem_comp"].iterrows(): if (quick and random.random() < 0.95): continue comp_comp_id = srv.get_comp_comp_id_direct(row["_chem_comp.id"]) if (comp_comp_id is not None): planes = comp_comp_id.get_planes() for plane in planes: dist_esd_dict = {} for plane_atom in plane.plane_atoms: dist_esd_dict[str(plane_atom.dist_esd)] = 0 # FIXME: might break compat for py2/3 because indexing a values call if (len(dist_esd_dict) != 1 or list(dist_esd_dict.keys())[0] != "0.02"): print(comp_comp_id.chem_comp.id, plane.plane_id, end=' ') print(list(dist_esd_dict.keys())) if (False or default_switch): standard_amino_acids = [ "GLY", "VAL", "ALA", "LEU", "ILE", "PRO", "MET", "PHE", "TRP", "SER", "THR", "TYR", "CYS", "ASN", "GLN", "ASP", "GLU", "LYS", "ARG", "HIS" ] for row in list_cif.cif["comp_list"]["_chem_comp"].iterrows(): is_standard_aa = row["_chem_comp.id"] in standard_amino_acids if (1 and not is_standard_aa): continue comp_comp_id = srv.get_comp_comp_id_direct(row["_chem_comp.id"]) if (is_standard_aa): assert comp_comp_id is not None assert comp_comp_id.chem_comp.group.strip() == "L-peptide" if (comp_comp_id is not None): print(comp_comp_id.chem_comp.id.strip(), end=' ') print(comp_comp_id.chem_comp.name.strip(), end=' ') print(comp_comp_id.chem_comp.group.strip()) for tor in comp_comp_id.tor_list: print(" tor:", tor.atom_id_1, tor.atom_id_2, end=' ') print(tor.atom_id_3, tor.atom_id_4, tor.value_angle, end=' ') print(tor.value_angle_esd, tor.period) for chir in comp_comp_id.chir_list: print(" chir:", chir.atom_id_centre, chir.atom_id_1, end=' ') print(chir.atom_id_2, chir.atom_id_3, chir.volume_sign) if (False or default_switch): elib = server.ener_lib() if (False or default_switch): for syn in elib.lib_synonym.items(): print(syn) if (False or default_switch): for vdw in elib.lib_vdw: vdw.show() print("OK")
def exercise_1 () : pdb_raw = """\ ATOM 1134 N LYS A 82 5.933 36.285 21.572 1.00 70.94 N ATOM 1135 CA LYS A 82 6.564 37.423 20.931 1.00 76.69 C ATOM 1136 C LYS A 82 5.553 38.547 20.756 1.00 78.75 C ATOM 1137 O LYS A 82 5.325 39.038 19.654 1.00 86.47 O ATOM 1138 CB LYS A 82 7.179 37.024 19.583 1.00 82.32 C ATOM 1139 CG LYS A 82 8.190 38.035 19.048 0.00 70.34 C ATOM 1140 CD LYS A 82 9.429 38.129 19.944 0.00 67.69 C ATOM 1141 CE LYS A 82 9.983 39.545 20.014 0.00 64.44 C ATOM 1142 NZ LYS A 82 10.933 39.832 18.908 0.00 61.45 N ATOM 1143 H LYS A 82 5.139 36.115 21.291 1.00 85.12 H ATOM 1144 HA LYS A 82 7.279 37.749 21.501 1.00 92.03 H ATOM 1145 HB2 LYS A 82 6.469 36.939 18.928 1.00 98.78 H ATOM 1146 HB3 LYS A 82 7.636 36.175 19.687 1.00 98.78 H ATOM 1147 HG2 LYS A 82 8.476 37.762 18.163 0.00 84.41 H ATOM 1148 HG3 LYS A 82 7.775 38.912 19.011 0.00 84.41 H ATOM 1149 HD2 LYS A 82 9.193 37.853 20.843 0.00 81.23 H ATOM 1150 HD3 LYS A 82 10.122 37.551 19.589 0.00 81.23 H ATOM 1151 HE2 LYS A 82 9.249 40.177 19.952 0.00 77.33 H ATOM 1152 HE3 LYS A 82 10.453 39.662 20.854 0.00 77.33 H ATOM 1153 HZ1 LYS A 82 11.237 40.666 18.977 0.00 73.75 H ATOM 1154 HZ2 LYS A 82 10.523 39.738 18.123 0.00 73.75 H ATOM 1155 HZ3 LYS A 82 11.621 39.269 18.944 0.00 73.75 H ATOM 1156 N LYS A 83 4.936 38.927 21.866 1.00 75.79 N ATOM 1157 CA LYS A 83 4.177 40.172 21.966 1.00 82.80 C ATOM 1158 C LYS A 83 4.081 40.508 23.460 1.00 86.23 C ATOM 1159 O LYS A 83 2.978 40.521 24.017 1.00 79.81 O ATOM 1160 CB LYS A 83 2.790 40.044 21.332 1.00 79.16 C ATOM 1161 CG LYS A 83 2.038 41.342 21.175 0.00 70.42 C ATOM 1162 CD LYS A 83 2.072 41.803 19.735 0.00 66.90 C ATOM 1163 CE LYS A 83 1.295 43.089 19.552 0.00 62.46 C ATOM 1164 NZ LYS A 83 1.004 43.350 18.118 0.00 60.73 N ATOM 1165 H LYS A 83 4.940 38.470 22.594 1.00 90.95 H ATOM 1166 HA LYS A 83 4.658 40.885 21.518 1.00 99.36 H ATOM 1167 HB2 LYS A 83 2.251 39.459 21.887 1.00 95.00 H ATOM 1168 HB3 LYS A 83 2.890 39.655 20.449 1.00 95.00 H ATOM 1169 HG2 LYS A 83 1.113 41.213 21.435 0.00 84.51 H ATOM 1170 HG3 LYS A 83 2.453 42.024 21.726 0.00 84.51 H ATOM 1171 HD2 LYS A 83 2.992 41.962 19.471 0.00 80.28 H ATOM 1172 HD3 LYS A 83 1.672 41.123 19.171 0.00 80.28 H ATOM 1173 HE2 LYS A 83 0.452 43.024 20.027 0.00 74.95 H ATOM 1174 HE3 LYS A 83 1.818 43.830 19.896 0.00 74.95 H ATOM 1175 HZ1 LYS A 83 0.521 42.683 17.780 0.00 72.87 H ATOM 1176 HZ2 LYS A 83 1.764 43.417 17.661 0.00 72.87 H ATOM 1177 HZ3 LYS A 83 0.548 44.109 18.034 0.00 72.87 H ATOM 3630 N ASN A 242 -5.454 -3.027 1.145 0.00 67.69 N ATOM 3631 CA ASN A 242 -4.759 -2.535 -0.037 0.00 65.44 C ATOM 3632 C ASN A 242 -5.734 -2.397 -1.208 0.00 63.57 C ATOM 3633 O ASN A 242 -6.425 -3.357 -1.552 0.00 63.94 O ATOM 3634 CB ASN A 242 -3.626 -3.503 -0.392 0.00 63.13 C ATOM 3635 CG ASN A 242 -2.802 -3.044 -1.576 0.00 63.58 C ATOM 3636 OD1 ASN A 242 -2.524 -1.862 -1.731 0.00 65.52 O ATOM 3637 ND2 ASN A 242 -2.399 -3.988 -2.416 0.00 62.17 N ATOM 3638 H ASN A 242 -5.562 -3.880 1.129 0.00 81.22 H ATOM 3639 HA ASN A 242 -4.375 -1.665 0.151 0.00 78.53 H ATOM 3640 HB2 ASN A 242 -3.032 -3.587 0.370 0.00 75.76 H ATOM 3641 HB3 ASN A 242 -4.007 -4.368 -0.611 0.00 75.76 H ATOM 3642 HD21 ASN A 242 -1.929 -3.779 -3.104 0.00 74.60 H ATOM 3643 HD22 ASN A 242 -2.609 -4.810 -2.272 0.00 74.60 H ATOM 2 CA ALYS A 32 10.574 8.177 11.768 0.40 71.49 C ATOM 3 CB ALYS A 32 9.197 8.686 12.246 0.40 74.71 C ATOM 2 CA BLYS A 32 10.574 8.177 11.768 0.40 71.49 C ATOM 3 CB BLYS A 32 9.197 8.686 12.246 0.40 74.71 C ATOM 5 CA AVAL A 33 11.708 5.617 14.332 0.50 71.42 C ATOM 6 CB AVAL A 33 11.101 4.227 14.591 0.50 71.47 C ATOM 5 CA BVAL A 33 11.708 5.617 14.332 0.40 71.42 C ATOM 6 CB BVAL A 33 11.101 4.227 14.591 0.40 71.47 C TER ATOM 1 N GLU X 18 -13.959 12.159 -6.598 1.00260.08 N ATOM 2 CA GLU X 18 -13.297 13.465 -6.628 1.00269.83 C ATOM 3 C GLU X 18 -11.946 13.282 -7.309 1.00269.18 C ATOM 4 CB GLU X 18 -13.128 14.035 -5.210 1.00261.96 C ATOM 5 CG GLU X 18 -14.455 14.401 -4.522 1.00263.56 C ATOM 6 CD GLU X 18 -14.291 15.239 -3.242 1.00264.89 C ATOM 7 OE1 GLU X 18 -14.172 14.646 -2.143 1.00264.24 O ATOM 8 OE2 GLU X 18 -14.309 16.498 -3.306 1.00264.37 O1- HETATM 614 S SO4 B 101 14.994 20.601 10.862 0.00 7.02 S HETATM 615 O1 SO4 B 101 14.234 20.194 12.077 0.00 7.69 O HETATM 616 O2 SO4 B 101 14.048 21.062 9.850 0.00 9.28 O HETATM 617 O3 SO4 B 101 15.905 21.686 11.261 0.00 8.01 O HETATM 618 O4 SO4 B 101 15.772 19.454 10.371 0.00 8.18 O TER HETATM 122 O HOH S 1 5.334 8.357 8.032 1.00 0.00 O HETATM 123 O HOH S 2 5.396 15.243 10.734 1.00202.95 O HETATM 124 O HOH S 3 -25.334 18.357 18.032 0.00 20.00 O """ mon_lib_srv = server.server() ener_lib = server.ener_lib() pdb_in = iotbx.pdb.hierarchy.input(pdb_string=pdb_raw) xrs = pdb_in.input.xray_structure_simple() processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, raw_records=pdb_in.hierarchy.as_pdb_string(crystal_symmetry=xrs), crystal_symmetry=xrs, log=null_out()) pdb_in.hierarchy.atoms().reset_i_seq() mstats = model_properties.model_statistics( pdb_hierarchy=pdb_in.hierarchy, xray_structure=xrs, all_chain_proxies=processed_pdb_file.all_chain_proxies, ignore_hd=True) out = StringIO() mstats.show(out=out) #print out.getvalue() assert not show_diff(out.getvalue(), """\ Overall: Number of atoms = 50 (anisotropic = 0) B_iso: mean = 96.0 max = 269.8 min = 0.0 Occupancy: mean = 0.47 max = 1.00 min = 0.00 warning: 22 atoms with zero occupancy 67 total B-factor or occupancy problem(s) detected Atoms or residues with zero occupancy: LYS A 82 CG occ=0.00 LYS A 82 CD occ=0.00 LYS A 82 CE occ=0.00 LYS A 82 NZ occ=0.00 LYS A 83 CG occ=0.00 LYS A 83 CD occ=0.00 LYS A 83 CE occ=0.00 LYS A 83 NZ occ=0.00 ASN A 242 (all) occ=0.00 SO4 B 101 (all) occ=0.00 HOH S 3 O occ=0.00 Macromolecules: Number of atoms = 42 (anisotropic = 0) B_iso: mean = 108.0 max = 269.8 min = 60.7 Occupancy: mean = 0.51 max = 1.00 min = 0.00 warning: 16 atoms with zero occupancy 57 total B-factor or occupancy problem(s) detected Ligands: Number of atoms = 5 (anisotropic = 0) B_iso: mean = 8.0 max = 9.3 min = 7.0 Occupancy: mean = 0.00 max = 0.00 min = 0.00 warning: 5 atoms with zero occupancy 6 total B-factor or occupancy problem(s) detected Waters: Number of atoms = 3 (anisotropic = 0) B_iso: mean = 74.3 max = 202.9 min = 0.0 Occupancy: mean = 0.67 max = 1.00 min = 0.00 warning: 1 atoms with zero occupancy 4 total B-factor or occupancy problem(s) detected (Hydrogen atoms not included in overall counts.) """) assert (len(mstats.all.bad_adps) == 1) assert (mstats.all.n_zero_b == 1) mstats2 = loads(dumps(mstats)) out1 = StringIO() out2 = StringIO() mstats.show(out=out1) mstats2.show(out=out2) assert (out1.getvalue() == out2.getvalue()) # now with ignore_hd=False mstats3 = model_properties.model_statistics( pdb_hierarchy=pdb_in.hierarchy, xray_structure=xrs, all_chain_proxies=processed_pdb_file.all_chain_proxies, ignore_hd=False) out2 = StringIO() mstats3.show(out=out2) assert (out2.getvalue() != out.getvalue()) assert (""" LYS A 83 HZ3 occ=0.00""" in out2.getvalue()) outliers = mstats3.all.as_gui_table_data(include_zoom=True) assert (len(outliers) == 84) # test with all_chain_proxies undefined mstats4 = model_properties.model_statistics( pdb_hierarchy=pdb_in.hierarchy, xray_structure=xrs, all_chain_proxies=None, ignore_hd=False) outliers = mstats4.all.as_gui_table_data(include_zoom=True) assert (len(outliers) == 84)
def run(args): assert len(args) == 0 srv = server.server() standard_amino_acids = [ "GLY", "VAL", "ALA", "LEU", "ILE", "PRO", "MET", "PHE", "TRP", "SER", "THR", "TYR", "CYS", "ASN", "GLN", "ASP", "GLU", "LYS", "ARG", "HIS"] for comp_id in standard_amino_acids: comp_comp_id = srv.get_comp_comp_id_direct(comp_id) print comp_comp_id.chem_comp.id.strip(), print comp_comp_id.chem_comp.name.strip(), print comp_comp_id.chem_comp.group.strip() hydrogens = {} for atom in comp_comp_id.atom_list: if (atom.type_symbol == "H"): hydrogens[atom.atom_id] = 0 bond_counts = dict(hydrogens) for bond in comp_comp_id.bond_list: for atom_id in [bond.atom_id_1, bond.atom_id_2]: if (atom_id in hydrogens): bond_counts[atom_id] += 1 if (bond_counts.values() != [1] * len(bond_counts)): print "bad bond counts:", bond_counts raise AssertionError angle_counts = dict(hydrogens) for angle in comp_comp_id.angle_list: for atom_id in [angle.atom_id_1, angle.atom_id_2, angle.atom_id_3]: if (atom_id in hydrogens): angle_counts[atom_id] += 1 #print angle_counts assert min(angle_counts.values()) > 0 assert max(angle_counts.values()) <= 3 for atom_id,count in angle_counts.items(): if (count == 3): print "three angles:", atom_id for bond in comp_comp_id.bond_list: atom_ids = [bond.atom_id_1, bond.atom_id_2] if (atom_id in atom_ids): print " bond:", atom_ids for angle in comp_comp_id.angle_list: atom_ids = [angle.atom_id_1, angle.atom_id_2, angle.atom_id_3] if (atom_id in atom_ids): print " angle:", atom_ids, angle.value_angle tor_counts = dict(hydrogens) for tor in comp_comp_id.tor_list: for atom_id in [tor.atom_id_1, tor.atom_id_2, tor.atom_id_3, tor.atom_id_4]: if (atom_id in hydrogens): tor_counts[atom_id] += 1 #print tor_counts assert max(tor_counts.values()) <= 1 print "no tor:", tor_counts.values().count(0) chir_counts = dict(hydrogens) for chir in comp_comp_id.chir_list: for atom_id in [chir.atom_id_centre, chir.atom_id_1, chir.atom_id_2, chir.atom_id_3]: if (atom_id in hydrogens): chir_counts[atom_id] += 1 #print chir_counts assert max(chir_counts.values()) == 0 plane_counts = dict(hydrogens) for plane in comp_comp_id.get_planes(): for plane_atom in plane.plane_atoms: if (plane_atom.atom_id in hydrogens): plane_counts[plane_atom.atom_id] += 1 #print plane_counts assert max(plane_counts.values()) <= 1 for atom_id,count in plane_counts.items(): if (count == 0): continue assert angle_counts[atom_id] == 2
def run (args, out=None ): if (out is None) : out = sys.stdout from mmtbx.building.alternate_conformations import density_sampling import mmtbx.maps.utils import mmtbx.utils from mmtbx.monomer_library import server import iotbx.pdb.hierarchy get_class = iotbx.pdb.common_residue_names_get_class mon_lib_srv = server.server() cmdline = mmtbx.utils.cmdline_load_pdb_and_data( args=args, master_phil=master_phil, process_pdb_file=False, scattering_table="n_gaussian") params = cmdline.params working_phil = master_phil.format(python_object=params) master_phil.fetch_diff(source=working_phil).show(out=out) fmodel = cmdline.fmodel hierarchy = cmdline.pdb_hierarchy sele_cache = hierarchy.atom_selection_cache() assert (params.selection is not None) selection = sele_cache.selection(params.selection) assert (selection.count(True) > 0) have_results = False pdb_atoms = hierarchy.atoms() sites_cart = pdb_atoms.extract_xyz() ensembles = [] t1 = time.time() for chain in hierarchy.only_model().chains() : prev_residue = next_residue = None residue_groups = chain.residue_groups() n_groups = len(residue_groups) for i_res, residue_group in enumerate(residue_groups) : if (i_res < n_groups - 1) : next_residue = residue_groups[i_res+1].atom_groups()[0] i_seqs = residue_group.atoms().extract_i_seq() if (selection.select(i_seqs).all_eq(True)) : atom_group = residue_group.only_atom_group() if (get_class(atom_group.resname) != "common_amino_acid") : continue confs = density_sampling.screen_residue( residue=atom_group, prev_residue=prev_residue, next_residue=next_residue, sites_cart=sites_cart, fmodel=fmodel, mon_lib_srv=mon_lib_srv, params=params, map_file_name="map_coeffs.mtz", out=out) ensemble = [] for conf in confs : conf_atoms = conf.set_atom_sites(pdb_atoms) pdb_lines = [] for atom in conf_atoms : pdb_lines.append(atom.format_atom_record()) ensemble.append("\n".join(pdb_lines)) ensembles.append(ensemble) prev_residue = residue_group.atom_groups()[0] if (len(ensembles) == 0) : raise Sorry("No alternate conformations found.") t2 = time.time() print >> out, "search time: %.1fs" % (t2-t1) for i_ens, ensemble in enumerate(ensembles) : ensemble_hierarchy = iotbx.pdb.hierarchy.root() for k, model_str in enumerate(ensemble) : input = iotbx.pdb.hierarchy.input(pdb_string=model_str) model = input.hierarchy.only_model().detached_copy() model.id = str(k+1) ensemble_hierarchy.append_model(model) f = open("ensemble_%d.pdb" % (i_ens+1), "w") f.write(ensemble_hierarchy.as_pdb_string()) f.close() print "wrote ensemble_%d.pdb" % (i_ens+1) if (params.coot) : easy_run.call("coot --pdb %s --auto map_coeffs.mtz --pdb ensemble.pdb" % params.input.pdb.file_name[0])
params = pdb_interpretation.master_params.fetch().extract() params.peptide_link.ramachandran_restraints = True processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, params=params, raw_records=pdb_str.split("\n"), log=StringIO()) grm = processed_pdb_file.geometry_restraints_manager() nprox = grm.ramachandran_manager.get_n_proxies() assert nprox == correct_nprox, ""+\ "Want to get %d rama proxies, got %d" % (correct_nprox, nprox) if __name__ == "__main__" : import time mon_lib_srv = server.server() ener_lib = server.ener_lib() t0 = time.time() exercise_basic() t1 = time.time() exercise_lbfgs_simple(mon_lib_srv, ener_lib, ("--verbose" in sys.argv) or ("-v" in sys.argv)) t2 = time.time() if ("--full" in sys.argv): exercise_lbfgs_big(mon_lib_srv, ener_lib, ("--verbose" in sys.argv) or ("-v" in sys.argv)) t3 = time.time() exercise_geo_output(mon_lib_srv, ener_lib) t4 = time.time() #
def run(args): assert len(args) == 0 srv = server.server() standard_amino_acids = [ "GLY", "VAL", "ALA", "LEU", "ILE", "PRO", "MET", "PHE", "TRP", "SER", "THR", "TYR", "CYS", "ASN", "GLN", "ASP", "GLU", "LYS", "ARG", "HIS" ] for comp_id in standard_amino_acids: comp_comp_id = srv.get_comp_comp_id_direct(comp_id) print comp_comp_id.chem_comp.id.strip(), print comp_comp_id.chem_comp.name.strip(), print comp_comp_id.chem_comp.group.strip() hydrogens = {} for atom in comp_comp_id.atom_list: if (atom.type_symbol == "H"): hydrogens[atom.atom_id] = 0 bond_counts = dict(hydrogens) for bond in comp_comp_id.bond_list: for atom_id in [bond.atom_id_1, bond.atom_id_2]: if (atom_id in hydrogens): bond_counts[atom_id] += 1 if (bond_counts.values() != [1] * len(bond_counts)): print "bad bond counts:", bond_counts raise AssertionError angle_counts = dict(hydrogens) for angle in comp_comp_id.angle_list: for atom_id in [angle.atom_id_1, angle.atom_id_2, angle.atom_id_3]: if (atom_id in hydrogens): angle_counts[atom_id] += 1 #print angle_counts assert min(angle_counts.values()) > 0 assert max(angle_counts.values()) <= 3 for atom_id, count in angle_counts.items(): if (count == 3): print "three angles:", atom_id for bond in comp_comp_id.bond_list: atom_ids = [bond.atom_id_1, bond.atom_id_2] if (atom_id in atom_ids): print " bond:", atom_ids for angle in comp_comp_id.angle_list: atom_ids = [ angle.atom_id_1, angle.atom_id_2, angle.atom_id_3 ] if (atom_id in atom_ids): print " angle:", atom_ids, angle.value_angle tor_counts = dict(hydrogens) for tor in comp_comp_id.tor_list: for atom_id in [ tor.atom_id_1, tor.atom_id_2, tor.atom_id_3, tor.atom_id_4 ]: if (atom_id in hydrogens): tor_counts[atom_id] += 1 #print tor_counts assert max(tor_counts.values()) <= 1 print "no tor:", tor_counts.values().count(0) chir_counts = dict(hydrogens) for chir in comp_comp_id.chir_list: for atom_id in [ chir.atom_id_centre, chir.atom_id_1, chir.atom_id_2, chir.atom_id_3 ]: if (atom_id in hydrogens): chir_counts[atom_id] += 1 #print chir_counts assert max(chir_counts.values()) == 0 plane_counts = dict(hydrogens) for plane in comp_comp_id.get_planes(): for plane_atom in plane.plane_atoms: if (plane_atom.atom_id in hydrogens): plane_counts[plane_atom.atom_id] += 1 #print plane_counts assert max(plane_counts.values()) <= 1 for atom_id, count in plane_counts.items(): if (count == 0): continue assert angle_counts[atom_id] == 2
def exercise(): verbose = "--verbose" in sys.argv[1:] quick = "--quick" in sys.argv[1:] list_cif = server.mon_lib_list_cif() srv = server.server(list_cif=list_cif) print "srv.root_path:", srv.root_path default_switch = "--default_off" not in sys.argv[1:] if (False or default_switch): monomers_with_commas = {} atom_id_counts = dicts.with_default_value(0) for row_id in list_cif.cif["comp_list"]["_chem_comp.id"]: if (quick and random.random() < 0.95): continue if (verbose): print "id:", row_id comp_comp_id = srv.get_comp_comp_id_direct(comp_id=row_id) if (comp_comp_id is None): print "Error instantiating comp_comp_id(%s)" % row_id else: has_primes = False has_commas = False for atom in comp_comp_id.atom_list: atom_id_counts[atom.atom_id] += 1 if (atom.atom_id.find("'") >= 0): has_primes = True if (atom.atom_id.find(",") >= 0): has_commas = True if (has_commas): monomers_with_commas[comp_comp_id.chem_comp.id] = has_primes print monomers_with_commas atom_ids = flex.std_string(atom_id_counts.keys()) counts = flex.size_t(atom_id_counts.values()) perm = flex.sort_permutation(data=counts, reverse=True) atom_ids = atom_ids.select(perm) counts = counts.select(perm) for atom_id,count in zip(atom_ids, counts): print atom_id, count if (False or default_switch): for row in list_cif.cif["comp_list"]["_chem_comp"].iterrows(): if (quick and random.random() < 0.95): continue if (verbose): print "id:", row["_chem_comp.id"] comp_comp_id = srv.get_comp_comp_id_direct(comp_id=row["_chem_comp.id"]) check_chem_comp(cif_types.chem_comp(**row), comp_comp_id) if ("--pickle" in sys.argv[1:]): easy_pickle.dump("mon_lib.pickle", srv) if (False or default_switch): comp = srv.get_comp_comp_id_direct("GLY") comp.show() mod = srv.mod_mod_id_dict["COO"] comp.apply_mod(mod).show() if (False or default_switch): comp = srv.get_comp_comp_id_direct("LYS") comp.show() mod = srv.mod_mod_id_dict["B2C"] comp.apply_mod(mod).show() if (False or default_switch): for row in list_cif.cif["comp_list"]["_chem_comp"].iterrows(): if (quick and random.random() < 0.95): continue comp_comp_id = srv.get_comp_comp_id_direct(row["_chem_comp.id"]) if (comp_comp_id is not None): if (comp_comp_id.classification == "peptide"): print comp_comp_id.chem_comp.id, comp_comp_id.chem_comp.name, print row["_chem_comp.group"], grp = row["_chem_comp.group"].lower().strip() if (grp not in ("l-peptide", "d-peptide", "polymer")): print "LOOK", #if (not os.path.isdir("look")): os.makedirs("look") #open("look/%s.cif" % row["_chem_comp.id"], "w").write( #open(comp_comp_id.file_name).read()) print elif (row["_chem_comp.group"].lower().find("peptide") >= 0 or comp_comp_id.chem_comp.group.lower().find("peptide") >= 0): print comp_comp_id.chem_comp.id, comp_comp_id.chem_comp.name, print row["_chem_comp.group"], "MISMATCH" if (comp_comp_id.classification in ("RNA", "DNA")): print comp_comp_id.chem_comp.id, comp_comp_id.chem_comp.name, print row["_chem_comp.group"], if (comp_comp_id.classification != row["_chem_comp.group"].strip()): print comp_comp_id.classification, "MISMATCH", print elif (row["_chem_comp.group"].lower().find("NA") >= 0 or comp_comp_id.chem_comp.group.lower().find("NA") >= 0): print comp_comp_id.chem_comp.id, comp_comp_id.chem_comp.name, print row["_chem_comp.group"], "MISMATCH" if (False or default_switch): for row in list_cif.cif["comp_list"]["_chem_comp"].iterrows(): if (quick and random.random() < 0.95): continue comp_comp_id = srv.get_comp_comp_id_direct(row["_chem_comp.id"]) if (comp_comp_id is not None): planes = comp_comp_id.get_planes() for plane in planes: dist_esd_dict = {} for plane_atom in plane.plane_atoms: dist_esd_dict[str(plane_atom.dist_esd)] = 0 if (len(dist_esd_dict) != 1 or dist_esd_dict.keys()[0] != "0.02"): print comp_comp_id.chem_comp.id, plane.plane_id, print dist_esd_dict.keys() if (False or default_switch): standard_amino_acids = [ "GLY", "VAL", "ALA", "LEU", "ILE", "PRO", "MET", "PHE", "TRP", "SER", "THR", "TYR", "CYS", "ASN", "GLN", "ASP", "GLU", "LYS", "ARG", "HIS"] for row in list_cif.cif["comp_list"]["_chem_comp"].iterrows(): is_standard_aa = row["_chem_comp.id"] in standard_amino_acids if (1 and not is_standard_aa): continue comp_comp_id = srv.get_comp_comp_id_direct(row["_chem_comp.id"]) if (is_standard_aa): assert comp_comp_id is not None assert comp_comp_id.chem_comp.group.strip() == "L-peptide" if (comp_comp_id is not None): print comp_comp_id.chem_comp.id.strip(), print comp_comp_id.chem_comp.name.strip(), print comp_comp_id.chem_comp.group.strip() for tor in comp_comp_id.tor_list: print " tor:", tor.atom_id_1, tor.atom_id_2, print tor.atom_id_3, tor.atom_id_4, tor.value_angle, print tor.value_angle_esd, tor.period for chir in comp_comp_id.chir_list: print " chir:", chir.atom_id_centre, chir.atom_id_1, print chir.atom_id_2, chir.atom_id_3, chir.volume_sign if (False or default_switch): elib = server.ener_lib() if (False or default_switch): for syn in elib.lib_synonym.items(): print syn if (False or default_switch): for vdw in elib.lib_vdw: vdw.show() print "OK"
def get_mon_lib_server(ligand_cif_file_names=None): mon_lib_server = server.server() if ligand_cif_file_names: for fn in ligand_cif_file_names: mon_lib_server.process_cif(file_name=fn) return mon_lib_server
def run(args, command_name=libtbx.env.dispatcher_name): if (len(args) == 0): args = ["--help"] command_line = (option_parser( usage='%s pdb_file "atom_selection" [...]' % command_name) .option(None, "--write_pdb_file", action="store", type="string", default=None, help="write selected atoms to new PDB file", metavar="FILE") .option(None, "--cryst1_replacement_buffer_layer", action="store", type="float", default=None, help="replace CRYST1 with pseudo unit cell covering the selected" " atoms plus a surrounding buffer layer", metavar="WIDTH") ).process(args=args, min_nargs=2) co = command_line.options mon_lib_srv = server.server() ener_lib = server.ener_lib() processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, file_name=command_line.args[0], log=sys.stdout) print acp = processed_pdb_file.all_chain_proxies hierarchy=acp.pdb_hierarchy asc=hierarchy.atom_selection_cache() sel=asc.selection(string = "chain 'A' and resid 1 through 8 and icode ' '") h1=hierarchy.select(sel) # keep original hierarchy too print h1.as_pdb_string() selection_cache = acp.pdb_hierarchy.atom_selection_cache() atoms = acp.pdb_atoms all_bsel = flex.bool(atoms.size(), False) for selection_string in command_line.args[1:]: print selection_string isel = acp.iselection(string=selection_string, cache=selection_cache) 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) sel_hierarchy = acp.pdb_hierarchy.select(all_bsel) if (co.cryst1_replacement_buffer_layer is None): crystal_symmetry = acp.special_position_settings else: import cctbx.crystal crystal_symmetry = cctbx.crystal.non_crystallographic_symmetry( sites_cart=sel_hierarchy.atoms().extract_xyz(), buffer_layer=co.cryst1_replacement_buffer_layer) write_whole_pdb_file( file_name=co.write_pdb_file, processed_pdb_file=processed_pdb_file, pdb_hierarchy=sel_hierarchy, crystal_symmetry=crystal_symmetry) print
def morph_models (params, out=None, debug=False) : assert len(params.morph.pdb_file) > 1 assert (len(params.morph.frames) == (len(params.morph.pdb_file) - 1)) if (out is None) : out = sys.stdout from mmtbx.monomer_library import pdb_interpretation, server from iotbx import file_reader pdb_hierarchies = [] for pdb_file in params.morph.pdb_file : pdb_in = file_reader.any_file(pdb_file, force_type="pdb") pdb_in.check_file_type("pdb") hierarchy = pdb_in.file_object.hierarchy pdb_hierarchies.append(hierarchy) new_pdb = homogenize_structures( pdb_hierarchies=pdb_hierarchies, delete_waters=params.morph.delete_waters, debug=debug) mon_lib_srv = server.server() ener_lib = server.ener_lib() for cif_file in params.morph.cif_file : print "Loading CIF file %s" % cif_file cif_object = server.read_cif(file_name=cif_file) mon_lib_serv.process_cif_object(cif_object=cif_object, file_name=cif_file) ener_lib.process_cif_object(cif_object=cif_object, file_name=cif_file) if (params.morph.minimization.interpolate_dihedrals) : params.pdb_interpretation.peptide_link.discard_psi_phi = False processed_pdb_file = pdb_interpretation.process( mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, params=params.pdb_interpretation, pdb_inp=new_pdb[0], substitute_non_crystallographic_unit_cell_if_necessary=True) all_chain_proxies = processed_pdb_file.all_chain_proxies static_coords = [ all_chain_proxies.pdb_hierarchy.atoms().extract_xyz() ] for pdb_inp in new_pdb[1:] : sites = pdb_inp.atoms().extract_xyz() static_coords.append(sites) if (params.morph.fitting.align_atoms is not None) : print >> out, "Superposing on initial structure..." selection_cache = all_chain_proxies.pdb_hierarchy.atom_selection_cache() selection = selection_cache.selection(params.morph.fitting.align_atoms) if (selection.count(True) == 0) : raise Sorry("No atoms in alignment selection!") i_ref = params.morph.fitting.reference_structure sites_fixed = static_coords[i_ref] j = 0 while (j < len(static_coords)) : if (j != i_ref) : sites_moving = static_coords[j] assert (len(sites_moving) == len(sites_fixed) > 0) if (params.morph.fitting.sieve_fit) : from scitbx.math import superpose lsq_fit = superpose.sieve_fit( sites_fixed=sites_fixed, sites_moving=sites_moving, selection=selection) sites_moving_new = lsq_fit.r.elems * sites_moving + lsq_fit.t.elems else : sites_moving_new = fit_sites( sites_fixed=sites_fixed, sites_moving=sites_moving, selection=selection) assert (sites_moving_new.size() == sites_moving.size()) static_coords[j] = sites_moving_new j += 1 print >> out, "Ready to morph" morphs = [] restraints_manager = processed_pdb_file.geometry_restraints_manager() for i in range(len(params.morph.pdb_file) - 1) : morph = adiabatic_mapping( pdb_hierarchy=all_chain_proxies.pdb_hierarchy, restraints_manager=restraints_manager, start_coords = static_coords[i], end_coords = static_coords[i+1], params = params.morph.minimization, nsteps = params.morph.frames[i], out=out) morphs.append(morph) serial = 1 if (params.morph.output_directory is not None) : output_base = os.path.join(params.morph.output_directory, params.morph.output_prefix) else : output_base = params.morph.output_prefix for i, morph in enumerate(morphs) : serial = morph.write_pdb_files( output_base=output_base, serial=serial, serial_format=params.morph.serial_format, pause=params.morph.pause, pause_at_end=(i == (len(morphs) - 1)), log=out) f = open("%s.pml" % output_base, "w") for i in range(1, serial) : format_base = "%s_%s" % (output_base, params.morph.serial_format) print >> f, "load %s.pdb, morph" % (format_base % i) f.close() print >> out, "PyMOL script is %s.pml" % output_base
def adjust_geometry_proxies_registeries(hierarchy, #bond_params_table, #bond_asu_table, gpr, error_i_seqs, log=None, ): t0=time.time() mon_lib_srv = server.server() pdb_atoms = hierarchy.atoms() sites_cart = pdb_atoms.extract_xyz() resnames=[] bond_counters = [0,0] angle_counters = [0,0] checked=[] atoms_added={} for i_seq in error_i_seqs: atom = pdb_atoms[i_seq] ag = atom.parent() if ag.resname in checked: continue rg = ag.parent() # need to be able to check in user defined location monomer_restraints = mon_lib_srv.get_comp_comp_id_direct( ag.resname, pH_range="low", ) checked.append(ag.resname) if monomer_restraints is None: continue atom_dict = monomer_restraints.atom_dict() resnames.append('"%s%s %s%5s"' % (' ', ag.resname, rg.parent().id, rg.resseq, )) for bond in monomer_restraints.bond_list: atom1 = ag.get_atom(bond.atom_id_1) if atom1 is None: continue atom2 = ag.get_atom(bond.atom_id_2) if atom2 is None: continue i_seqs = [atom1.i_seq, atom2.i_seq] i_seqs.sort() bond_table_entry = gpr.bond_simple.table[i_seqs[0]] if i_seqs[1] in bond_table_entry: bond_simple = gpr.bond_simple.proxies[i_seqs[0]] bond_simple.distance_ideal = bond.value_dist bond_simple.weight=1/bond.value_dist_esd**2 bond_counters[0]+=1 else: proxy = geometry_restraints.bond_simple_proxy( i_seqs=i_seqs, distance_ideal=bond.value_dist, weight=1/(bond.value_dist_esd**2), ) gpr.bond_simple.proxies.append(proxy) atoms_added[atom1.i_seq] = atom_dict.get(atom1.name.strip(), None) atoms_added[atom2.i_seq] = atom_dict.get(atom2.name.strip(), None) bond_counters[1]+=1 lookup={} for angle in monomer_restraints.angle_list: atom1 = ag.get_atom(angle.atom_id_1) if atom1 is None: continue atom2 = ag.get_atom(angle.atom_id_2) if atom2 is None: continue atom3 = ag.get_atom(angle.atom_id_3) if atom3 is None: continue i_seqs = (atom1.i_seq, atom2.i_seq, atom3.i_seq) lookup[i_seqs]=angle i_seqs = (atom3.i_seq, atom2.i_seq, atom1.i_seq) lookup[i_seqs]=angle for angle_proxy in gpr.angle.proxies: if angle_proxy.i_seqs in lookup: i_seqs = angle_proxy.i_seqs angle = lookup[i_seqs] angle_proxy.angle_ideal = angle.value_angle angle_proxy.weight = 1/angle.value_angle_esd**2 angle_counters[0]+=1 del lookup[i_seqs] i_seqs = list(i_seqs) i_seqs.reverse() del lookup[tuple(i_seqs)] if lookup: done = [] for i_seqs in lookup: if i_seqs in done: continue proxy = geometry_restraints.angle_proxy( i_seqs=i_seqs, angle_ideal=angle.value_angle, weight=1/angle.value_angle_esd**2, ) gpr.angle.add_if_not_duplicated(proxy) angle_counters[1]+=1 i_seqs=list(i_seqs) i_seqs.reverse() done.append(tuple(i_seqs)) if resnames: print >> log, "\n Adjusted restraints in %d residue(s) for low pH in %0.1fs" % ( len(resnames), time.time()-t0, ) print >> log, " Residues changed" for resname in resnames: print >> log, " %s" % resname print >> log, " Changed %d bond restraint(s), added %d bond restraint(s)" % ( bond_counters[0], bond_counters[1], ) print >> log, " Changed %d angle restraint(s), added %d angle restraint(s)\n" % ( angle_counters[0], angle_counters[1], ) #else: # print >> log, " Time to perform restraint checks: %0.1f" % (time.time()-t0) return atoms_added
params.pdb_interpretation.ramachandran_plot_restraints.inject_emsley8k_into_oldfield_favored = False pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None) model = mmtbx.model.manager(model_input=pdb_inp, pdb_interpretation_params=params, log=null_out(), build_grm=True) grm = model.get_restraints_manager().geometry nprox = grm.ramachandran_manager.get_n_proxies() assert nprox == correct_nprox, ""+\ "Want to get %d rama proxies, got %d" % (correct_nprox, nprox) if __name__ == "__main__": import time mon_lib_srv = server.server() ener_lib = server.ener_lib() t0 = time.time() exercise_basic() t1 = time.time() exercise_lbfgs_simple(mon_lib_srv, ener_lib, ("--verbose" in sys.argv) or ("-v" in sys.argv)) t2 = time.time() if ("--full" in sys.argv): exercise_lbfgs_big(mon_lib_srv, ener_lib, ("--verbose" in sys.argv) or ("-v" in sys.argv)) t3 = time.time() exercise_geo_output(mon_lib_srv, ener_lib) exercise_manager_selection(mon_lib_srv, ener_lib) t4 = time.time() exercise_ramachandran_selections(mon_lib_srv, ener_lib)
def exercise(): from mmtbx.building.alternate_conformations import density_sampling from mmtbx.utils import fmodel_simple from mmtbx.monomer_library import server from iotbx import file_reader import iotbx.pdb.hierarchy generate_inputs() fmodel_params = """ high_resolution = 1.2 r_free_flags_fraction = 0.1 add_sigmas = True pdb_file = ser_frag.pdb output { label = F type = *real complex file_name = ser_frag.mtz } fmodel.k_sol = 0.3 fmodel.b_sol = 20 """ open("ser_frag_fmodel.eff", "w").write(fmodel_params) assert (easy_run.fully_buffered("phenix.fmodel ser_frag_fmodel.eff"). raise_if_errors().return_code == 0) assert os.path.isfile("ser_frag.mtz") mtz_in = file_reader.any_file("ser_frag.mtz") f_obs = mtz_in.file_server.miller_arrays[0] flags = mtz_in.file_server.miller_arrays[1] flags = flags.customized_copy(data=(flags.data() == 1)) mon_lib_srv = server.server() pdb_in = iotbx.pdb.hierarchy.input(file_name="ser_frag_single.pdb") hierarchy = pdb_in.hierarchy pdb_atoms = hierarchy.atoms() pdb_atoms.reset_i_seq() sites_cart = pdb_atoms.extract_xyz() xrs = pdb_in.input.xray_structure_simple() fmodel = fmodel_simple(f_obs=f_obs, xray_structures=[xrs], scattering_table="n_gaussian", r_free_flags=flags, skip_twin_detection=True) models = [] prev_res = next_res = next_next_res = None for chain in hierarchy.only_model().chains(): residue_groups = chain.residue_groups() n_rg = len(residue_groups) for i_res, residue_group in enumerate(residue_groups): sites_orig = sites_cart.deep_copy() next_res = next_next_res = None if (i_res < (n_rg - 1)): next_res = residue_groups[i_res + 1].atom_groups()[0] if (i_res < (n_rg - 2)): next_next_res = residue_groups[i_res + 2].atom_groups()[0] atom_groups = residue_group.atom_groups() primary_conf = atom_groups[0] out = StringIO() confs = density_sampling.screen_residue( residue=primary_conf, prev_residue=prev_res, next_residue=next_res, next_next_residue=next_next_res, sites_cart=sites_cart, fmodel=fmodel, mon_lib_srv=mon_lib_srv, params=None, backrub=True, shear=False, verbose=True, out=out) prev_res = primary_conf if (confs is None): continue # TODO tweak density sampling to allow a backrubbed conformer with a # chi1 t rotamer for Ser 99 if (i_res == 1): assert (""" A SER 99 20.0 None t""" in out.getvalue()) for conf in confs: sites_new = sites_cart.set_selected(conf.sites_selection, conf.sites_selected()) pdb_atoms.set_xyz(sites_new) models.append(hierarchy.only_model().detached_copy()) confs = density_sampling.screen_residue( residue=primary_conf, prev_residue=prev_res, next_residue=next_res, next_next_residue=next_next_res, sites_cart=sites_cart, fmodel=fmodel, mon_lib_srv=mon_lib_srv, params=None, backrub=False, out=out) if (i_res == 1): print len(confs) new_hierarchy = iotbx.pdb.hierarchy.root() for i_model, conf in enumerate(models): conf.id = str(i_model + 1) new_hierarchy.append_model(conf) open("ser_frag_guided_ensemble.pdb", "w").write(new_hierarchy.as_pdb_string())
def adjust_geometry_restraints_manager(hierarchy, grm, error_i_seqs, log=None, ): # obsolete t0=time.time() mon_lib_srv = server.server() pdb_atoms = hierarchy.atoms() sites_cart = pdb_atoms.extract_xyz() resnames=[] bond_counters = [0,0] angle_counters = [0,0] checked=[] for i_seq in error_i_seqs: atom = pdb_atoms[i_seq] ag = atom.parent() if ag.resname in checked: continue rg = ag.parent() # need to be able to check in user defined location monomer_restraints = mon_lib_srv.get_comp_comp_id_direct( ag.resname, pH_range="low", ) checked.append(ag.resname) if monomer_restraints is None: continue resnames.append('"%s%s %s%5s"' % (' ', ag.resname, rg.parent().id, rg.resseq, )) for bond in monomer_restraints.bond_list: bond.show() atom1 = ag.get_atom(bond.atom_id_1) atom2 = ag.get_atom(bond.atom_id_2) i_seqs = (atom1.i_seq, atom2.i_seq) bond_param = grm.bond_params_table.lookup(*list(i_seqs)) if bond_param: bond_param.distance_ideal = bond.value_dist bond_counters[0]+=1 else: proxy = geometry_restraints.bond_simple_proxy( i_seqs=i_seqs, distance_ideal=bond.value_dist, weight=1/(bond.value_dist_esd**2), ) grm.add_new_bond_restraints_in_place([proxy], sites_cart) bond_counters[1]+=1 lookup={} for angle in monomer_restraints.angle_list: atom1 = ag.get_atom(angle.atom_id_1) atom2 = ag.get_atom(angle.atom_id_2) atom3 = ag.get_atom(angle.atom_id_3) i_seqs = (atom1.i_seq, atom2.i_seq, atom3.i_seq) lookup[i_seqs]=angle i_seqs = (atom3.i_seq, atom2.i_seq, atom1.i_seq) lookup[i_seqs]=angle for angle_proxy in grm.angle_proxies: if angle_proxy.i_seqs in lookup: i_seqs = angle_proxy.i_seqs angle = lookup[i_seqs] angle_proxy.angle_ideal = angle.value_angle angle_proxy.weight = 1/angle.value_angle_esd**2 angle_counters[0]+=1 del lookup[i_seqs] i_seqs = list(i_seqs) i_seqs.reverse() del lookup[tuple(i_seqs)] if lookup: done = [] for i_seqs in lookup: if i_seqs in done: continue proxy = geometry_restraints.angle_proxy( i_seqs=i_seqs, angle_ideal=angle.value_angle, weight=1/angle.value_angle_esd**2, ) grm.add_angles_in_place([proxy]) angle_counters[1]+=1 i_seqs=list(i_seqs) i_seqs.reverse() done.append(tuple(i_seqs))
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)