def run(args): assert len(args) == 1 # Read file into pdb_input class inp = iotbx.pdb.input(file_name=args[0]) # create a model manager model = mmtbx.model.manager(model_input=inp) # get number of atoms in the input model n_atoms = model.get_number_of_atoms() # extract atom coordinates old_sites_cart = model.get_sites_cart() # generate random additions random_addition = flex.vec3_double( flex.random_double(size=n_atoms * 3) - 0.5) # actually add them to old coordinates new_xyz = old_sites_cart + random_addition # Update coordinates in model manager model.set_sites_cart(sites_cart=new_xyz) # get xray structure xrs = model.get_xray_structure() # reset B-factors (min=1, max=20) # generate array of new B-factors new_b = flex.random_double(size=n_atoms, factor=19) + 1 # set them in xray structure xrs.set_b_iso(values=new_b) # update model manager with this xray structure model.set_xray_structure(xrs) # output result in PDB format to the screen print model.model_as_pdb() print "END"
def exercise3(pdb_str, type_list_known): pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None) model = mmtbx.model.manager( model_input = pdb_inp, build_grm = True) pdb_hierarchy = model.get_hierarchy() sites_cart = model.get_sites_cart() atoms = pdb_hierarchy.atoms() model.setup_riding_h_manager() riding_h_manager = model.get_riding_h_manager() h_para = riding_h_manager.h_parameterization diagnostics = riding_h_manager.diagnostics( sites_cart = sites_cart, threshold = 0.05) h_distances = diagnostics.h_distances type_list = diagnostics.type_list number_h = model.get_hd_selection().count(True) number_h_para = len(h_para) - h_para.count(None) assert (number_h_para == number_h-2), 'Not all H atoms are parameterized' for ih in h_distances: labels = atoms[ih].fetch_labels() assert (h_distances[ih] < 0.2), \ 'distance too large: %s atom: %s (%s) residue: %s ' \ % (h_para[ih].htype, atoms[ih].name, ih, labels.resseq.strip()) for type1, type2 in zip(type_list, type_list_known): assert (type1 == type2)
def run(args): log = sys.stdout if (len(args) == 0): args = ["--help"] command_line = (option_parser(usage="%s [options] pdb_file" % libtbx.env.dispatcher_name).option( None, "--buffer_layer", action="store", type="float", default=5)).process(args=args, nargs=1) pdb_inp = iotbx.pdb.input(file_name=command_line.args[0]) model = mmtbx.model.manager(model_input=pdb_inp) box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=model.get_sites_cart(), buffer_layer=command_line.options.buffer_layer) model.set_sites_cart(box.sites_cart) # Bad hack, never repeat. In fact, all the boxing functionality should # go into mmtbx.model.manager model._crystal_symmetry = box.crystal_symmetry() print('REMARK %s --buffer-layer=%.6g %s' % (libtbx.env.dispatcher_name, command_line.options.buffer_layer, show_string(command_line.args[0])), file=log) print('REMARK %s' % date_and_time(), file=log) print(model.model_as_pdb(), file=log)
def exercise1(pdb_str, cif_str): model = prepare_inputs(pdb_str, cif_str) riding_h_manager = model.get_riding_h_manager() atoms = model.get_hierarchy().atoms() h_para = riding_h_manager.h_parameterization diagnostics = riding_h_manager.diagnostics( sites_cart=model.get_sites_cart(), threshold=0.05) h_distances = diagnostics.h_distances type_list = diagnostics.type_list # number of H atoms number_h = model.get_hd_selection().count(True) number_h_para = len(h_para) - h_para.count(None) assert (number_h_para == number_h), 'Not all H atoms are parameterized' for ih in h_distances: # One atom is expected to be moved if (ih == 16): continue labels = atoms[ih].fetch_labels() assert (h_distances[ih] < 0.1), \ 'distance too large: %s atom: %s (%s) residue: %s ' \ % (h_para[ih].htype, atoms[ih].name, ih, labels.resseq.strip()) for type1, type2 in zip(type_list, type_list_known1): assert (type1 == type2)
def exercise_1(): pdb_inp = iotbx.pdb.input(lines=flex.std_string(pdb_str_1.splitlines()), source_info=None) model = mmtbx.model.manager(model_input=pdb_inp) model.process(make_restraints=True) grm = model.get_restraints_manager().geometry pdb_hierarchy = model.get_hierarchy() sites_cart = model.get_sites_cart() # 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 exercise(pdb_str): pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None) model = mmtbx.model.manager(model_input=pdb_inp, log=null_out()) model.process(make_restraints=True) pdb_hierarchy = model.get_hierarchy() sites_cart = model.get_sites_cart() atoms = pdb_hierarchy.atoms() model.setup_riding_h_manager() riding_h_manager = model.get_riding_h_manager() h_parameterization = riding_h_manager.h_parameterization diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart, threshold=0.05) diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart, threshold=0.05) h_distances = diagnostics.h_distances number_h = model.get_hd_selection().count(True) number_h_para = len(h_parameterization) - h_parameterization.count(None) # There are 90 H atoms in pdb_string, check if all of them are recognized assert (number_h_para == number_h), 'Not all H atoms are parameterized' for ih in h_distances: labels = atoms[ih].fetch_labels() assert (h_distances[ih] < 0.01), \ 'distance too large: %s atom: %s (%s) residue: %s ' \ % (h_parameterization[ih].htype, atoms[ih].name, ih, labels.resseq.strip())
def exercise(pdb_str, use_ideal_bonds_angles): # -------------------------------------------------------------- # code to switch off CDL # -------------------------------------------------------------- #params_line = grand_master_phil_str #params = iotbx.phil.parse( # input_string=params_line, process_includes=True).extract() #params.pdb_interpretation.restraints_library.cdl=False # --------------------------------------------------------------- pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None) model = mmtbx.model.manager(model_input=pdb_inp, log=null_out(), build_grm=True) pdb_hierarchy = model.get_hierarchy() geometry_restraints = model.get_restraints_manager().geometry xray_structure = model.get_xray_structure() sites_cart = model.get_sites_cart() grf = cctbx.geometry_restraints.flags.flags(default=True) minimized = mmtbx.refinement.geometry_minimization.lbfgs( sites_cart=sites_cart, correct_special_position_tolerance=1.0, geometry_restraints_manager=geometry_restraints, geometry_restraints_flags=grf, lbfgs_termination_params=scitbx.lbfgs.termination_parameters( max_iterations=500)) xray_structure.set_sites_cart(sites_cart) pdb_hierarchy.adopt_xray_structure(xray_structure) atoms = pdb_hierarchy.atoms() sites_cart = xray_structure.sites_cart() riding_h_manager = riding.manager( pdb_hierarchy=pdb_hierarchy, geometry_restraints=geometry_restraints, use_ideal_bonds_angles=use_ideal_bonds_angles) h_parameterization = riding_h_manager.h_parameterization diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart, threshold=0.05) h_distances = diagnostics.h_distances number_h = model.get_hd_selection().count(True) number_h_para = len(h_parameterization) - h_parameterization.count(None) assert (number_h_para == number_h), 'Not all H atoms are parameterized' for ih in h_distances: labels = atoms[ih].fetch_labels() if use_ideal_bonds_angles: assert (h_distances[ih] < 0.03), \ 'distance too large: %s atom: %s (%s) residue: %s ' \ % (h_parameterization[ih].htype, atoms[ih].name, ih, labels.resseq.strip()) else: assert (h_distances[ih] < 1e-7), \ 'distance too large: %s atom: %s (%s) residue: %s distance %s' \ % (h_parameterization[ih].htype, atoms[ih].name, ih, labels.resseq.strip(), h_distances[ih])
def get_bounds_around_model( map_manager=None, model=None, box_cushion=None, ): ''' Calculate the lower and upper bounds to box around a model Allow bounds to go outside the available box (this has to be dealt with at the boxing stage) ''' # get items needed to do the shift cs = map_manager.crystal_symmetry() uc = cs.unit_cell() sites_cart = model.get_sites_cart() sites_frac = uc.fractionalize(sites_cart) map_data = map_manager.map_data() # convert box_cushion into fractional vector cushion_frac = flex.double(uc.fractionalize((box_cushion, ) * 3)) # find fractional corners frac_min = sites_frac.min() frac_max = sites_frac.max() frac_max = list(flex.double(frac_max) + cushion_frac) frac_min = list(flex.double(frac_min) - cushion_frac) # find corner grid nodes all_orig = map_data.all() lower_bounds = [ifloor(f * n) for f, n in zip(frac_min, all_orig)] upper_bounds = [iceil(f * n) for f, n in zip(frac_max, all_orig)] return group_args( lower_bounds=lower_bounds, upper_bounds=upper_bounds, )
def run(pdb_file_name): pdb_inp = iotbx.pdb.input(file_name=pdb_file_name) params = mmtbx.model.manager.get_default_pdb_interpretation_params() model = mmtbx.model.manager( model_input = pdb_inp, pdb_interpretation_params = params, build_grm = True, stop_for_unknowns = False, log = null_out()) pdb_hierarchy = model.get_hierarchy() sites_cart_dc = model.get_sites_cart().deep_copy() angle = 0. # points_i_seqs = [483] # axis = [479,482] points_i_seqs = [559] axis = [556,557] while angle <= 360: atoms_xyz_tmp = flex.vec3_double(len(points_i_seqs)) atom_xyz_new = rotate_point_around_axis( axis_point_1 = sites_cart_dc[axis[0]], axis_point_2 = sites_cart_dc[axis[1]], point = sites_cart_dc[points_i_seqs[0]], angle = angle, deg = True) print (atom_xyz_new) atoms_xyz_tmp[0] = atom_xyz_new sites_cart_dc[points_i_seqs] = atoms_xyz_tmp[0] model.set_sites_cart(sites_cart = sites_cart_dc) with open(str(angle)+".pdb", "w") as of: print (model.model_as_pdb(),file=of) angle += 30.
def exercise(pdb_str): params = mmtbx.model.manager.get_default_pdb_interpretation_params() params.pdb_interpretation.use_neutron_distances = True pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None) model = mmtbx.model.manager(model_input=pdb_inp, log=null_out()) model.process(pdb_interpretation_params=params, make_restraints=True) pdb_hierarchy = model.get_hierarchy() sites_cart = model.get_sites_cart() atoms = pdb_hierarchy.atoms() model.setup_riding_h_manager() riding_h_manager = model.get_riding_h_manager() h_parameterization = riding_h_manager.h_parameterization diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart, threshold=0.05) h_distances = diagnostics.h_distances number_h = model.get_hd_selection().count(True) number_h_para = len(h_parameterization) - h_parameterization.count(None) if (pdb_str != pdb_str_02): assert (number_h_para == number_h), 'Not all H atoms are parameterized' # For each H atom, check if distance between computed H and that in input model is # not too large for ih in h_distances: labels = atoms[ih].fetch_labels() assert (h_distances[ih] < 0.1), \ 'distance too large: %s atom: %s (%s) residue: %s ' \ % (h_parameterization[ih].htype, atoms[ih].name, ih, labels.resseq.strip())
def exclude_h_on_SS(model): rm = model.get_restraints_manager() bond_proxies_simple, asu = rm.geometry.get_all_bond_proxies( sites_cart=model.get_sites_cart()) els = model.get_hierarchy().atoms().extract_element() ss_i_seqs = [] all_proxies = [p for p in bond_proxies_simple] for proxy in asu: all_proxies.append(proxy) for proxy in all_proxies: if (isinstance(proxy, ext.bond_simple_proxy)): i, j = proxy.i_seqs elif (isinstance(proxy, ext.bond_asu_proxy)): i, j = proxy.i_seq, proxy.j_seq else: assert 0 # never goes here if ([els[i], els[j] ].count("S") == 2): # XXX may be coordinated if metal edits used ss_i_seqs.extend([i, j]) sel_remove = flex.size_t() for proxy in all_proxies: if (isinstance(proxy, ext.bond_simple_proxy)): i, j = proxy.i_seqs elif (isinstance(proxy, ext.bond_asu_proxy)): i, j = proxy.i_seq, proxy.j_seq else: assert 0 # never goes here if (els[i] in ["H", "D"] and j in ss_i_seqs): sel_remove.append(i) if (els[j] in ["H", "D"] and i in ss_i_seqs): sel_remove.append(j) return model.select(~flex.bool(model.size(), sel_remove))
def run(maxnum_residues_in_cluster): result = [] for clustering in [True, False]: if 0: print(" clustering", clustering, "-"*30) model = get_model() fq = from_cctbx(restraints_manager = model.get_restraints_manager()) if(clustering): fm = fragments( working_folder = os.path.split("./ase/tmp_ase.pdb")[0]+ "/", clustering_method = betweenness_centrality_clustering, maxnum_residues_in_cluster = maxnum_residues_in_cluster, altloc_method = "subtract", charge_embedding = False, two_buffers = False, clustering = clustering, pdb_hierarchy = model.get_hierarchy().deep_copy(), qm_engine_name = "mopac", fast_interaction = True, crystal_symmetry = model.crystal_symmetry()) else: fc = fq fc = from_cluster( restraints_manager = fq, fragment_manager = fm, parallel_params = get_master_phil().extract()) energy, gradients = fc.target_and_gradients(sites_cart=model.get_sites_cart()) gradients = gradients.as_double() result.append(gradients.deep_copy()) diff = flex.abs(result[0] - result[1]) max_diff = flex.max(diff) #print " max(diff_grad):", max_diff assert max_diff < 1.e-9
def exercise3(pdb_str, type_list_known): pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None) params = mmtbx.model.manager.get_default_pdb_interpretation_scope( ).extract() params.pdb_interpretation.allow_polymer_cross_special_position = True model = mmtbx.model.manager(model_input=pdb_inp, log=null_out()) model.process(pdb_interpretation_params=params, make_restraints=True) pdb_hierarchy = model.get_hierarchy() sites_cart = model.get_sites_cart() atoms = pdb_hierarchy.atoms() model.setup_riding_h_manager() riding_h_manager = model.get_riding_h_manager() h_para = riding_h_manager.h_parameterization diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart, threshold=0.05) h_distances = diagnostics.h_distances type_list = diagnostics.type_list number_h = model.get_hd_selection().count(True) number_h_para = len(h_para) - h_para.count(None) assert (number_h_para == number_h - 2), 'Not all H atoms are parameterized' for ih in h_distances: labels = atoms[ih].fetch_labels() assert (h_distances[ih] < 0.2), \ 'distance too large: %s atom: %s (%s) residue: %s ' \ % (h_para[ih].htype, atoms[ih].name, ih, labels.resseq.strip()) for type1, type2 in zip(type_list, type_list_known): assert (type1 == type2)
def __init__(self, map_manager, model, box_cushion, wrapping=None, log=sys.stdout): self._map_manager = map_manager self._model = model self._force_wrapping = wrapping if wrapping is None: wrapping = self.map_manager().wrapping() self.basis_for_boxing_string = 'using_model, wrapping = %s' % ( wrapping) # safeguards assert isinstance(map_manager, iotbx.map_manager.map_manager) assert isinstance(model, mmtbx.model.manager) assert self._map_manager.map_data().accessor().origin() == (0, 0, 0) # Make sure working model and map_manager crystal_symmetry match assert map_manager.is_compatible_model(model) assert box_cushion >= 0 if self.map_manager().wrapping(): # map must be entire unit cell assert map_manager.unit_cell_grid == map_manager.map_data().all() # NOTE: We are going to use crystal_symmetry and sites_frac based on # the map_manager (the model could still have different crystal_symmetry) # get items needed to do the shift cs = map_manager.crystal_symmetry() uc = cs.unit_cell() sites_cart = model.get_sites_cart() sites_frac = uc.fractionalize(sites_cart) map_data = map_manager.map_data() # convert box_cushion into fractional vector cushion_frac = flex.double(uc.fractionalize((box_cushion, ) * 3)) # find fractional corners frac_min = sites_frac.min() frac_max = sites_frac.max() frac_max = list(flex.double(frac_max) + cushion_frac) frac_min = list(flex.double(frac_min) - cushion_frac) # find corner grid nodes all_orig = map_data.all() self.gridding_first = [ ifloor(f * n) for f, n in zip(frac_min, all_orig) ] self.gridding_last = [iceil(f * n) for f, n in zip(frac_max, all_orig)] # Ready with gridding...set up shifts and box crystal_symmetry self.set_shifts_and_crystal_symmetry() # Apply boxing to model, ncs, and map (if available) self.apply_to_model_ncs_and_map()
def run(model, max_cutoff=4.0, min_cutoff=1.5, hd=["H", "D"], acceptors=["O", "N", "S", "F", "CL"], protein_only=True): atoms = list(model.get_hierarchy().atoms()) sites_cart = model.get_sites_cart() crystal_symmetry = model.crystal_symmetry() fm = crystal_symmetry.unit_cell().fractionalization_matrix() om = crystal_symmetry.unit_cell().orthogonalization_matrix() pg = get_pair_generator(crystal_symmetry=crystal_symmetry, buffer_thickness=max_cutoff, sites_cart=sites_cart) get_class = iotbx.pdb.common_residue_names_get_class for p in pg.pair_generator: i, j = p.i_seq, p.j_seq ei, ej = atoms[i].element, atoms[j].element altloc_i = atoms[i].parent().altloc altloc_j = atoms[j].parent().altloc resseq_i = atoms[i].parent().parent().resseq resseq_j = atoms[j].parent().parent().resseq # pre-screen candidates begin one_is_hd = ei in hd or ej in hd other_is_acceptor = ei in acceptors or ej in acceptors dist = math.sqrt(p.dist_sq) assert dist <= max_cutoff is_candidate = one_is_hd and other_is_acceptor and dist >= min_cutoff and \ altloc_i == altloc_j and resseq_i != resseq_j if (protein_only): for it in [i, j]: resname = atoms[it].parent().resname is_candidate &= get_class(name=resname) == "common_amino_acid" if (not is_candidate): continue # pre-screen candidates end rt_mx_i = pg.conn_asu_mappings.get_rt_mx_i(p) rt_mx_j = pg.conn_asu_mappings.get_rt_mx_j(p) rt_mx_ji = rt_mx_i.inverse().multiply(rt_mx_j) print "%5.3f"%math.sqrt(p.dist_sq), \ "<", atoms[i].parent().resname, resseq_i, ei, atoms[i].name, ">", \ "<", atoms[j].parent().resname, resseq_j, ej, atoms[j].name, ">", \ rt_mx_ji, i, j, ### re-confirm distance between pairs ai = atoms[i] aj = atoms[j] if (str(rt_mx_ji) == "x,y,z"): d = math.sqrt((ai.xyz[0] - aj.xyz[0])**2 + (ai.xyz[1] - aj.xyz[1])**2 + (ai.xyz[2] - aj.xyz[2])**2) else: t1 = fm * flex.vec3_double([aj.xyz]) t2 = rt_mx_ji * t1[0] t3 = om * flex.vec3_double([t2]) d = math.sqrt((ai.xyz[0] - t3[0][0])**2 + (ai.xyz[1] - t3[0][1])**2 + (ai.xyz[2] - t3[0][2])**2) print "dist=%5.3f" % d
def run(): rmsd_dirs = ["0.3/", "0.6/", "0.9/", "1.2/", "1.5/"] base_names = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"] ref = get_reference() tmp_cntr1 = 0 print "Hbond analysis" print "model min max mean recovered bond_rmsd rama_favored clashscore" for sub_root in [ "./perturbed/", "./cctbx_opt/", "./xtb_opt_stpmax_0.3/", "./xtb_opt_stpmax_0.4/", "./xtb_opt_stpmax_0.5/", "./terachem_opt_final/" ]: print sub_root for rmsd_dir in rmsd_dirs: h_bonds = flex.double() rmsd_bonds = flex.double() rama_fav = flex.double() clashscore = flex.double() cntr = 0 for fn in base_names: file_name = sub_root + rmsd_dir + fn + ".pdb" if (not os.path.exists(file_name)): assert 0, file_name model = get_model(file_name) assert ref.h.is_similar_hierarchy(model.get_hierarchy()) g = model.geometry_statistics(use_hydrogens=False).result() rmsd_bonds.append(g.bond.mean) rama_fav.append(g.ramachandran.favored) clashscore.append(g.clash.score) #print g.bond.mean, g.clash.score, g.rotamer.outliers, g.c_beta.outliers, \ # g.ramachandran.outliers, g.ramachandran.allowed, g.ramachandran.favored sites_cart = model.get_sites_cart() if (sub_root.count("perturbed") > 0): tmp_cntr1 += 1 assert approx_equal( float(rmsd_dir.replace("/", "")), flex.mean( flex.sqrt((ref.sites_cart - sites_cart).dot())), 0.01) for pair in ref.h_bonds_i_seqs: d = dist(sites_cart[pair[0]], sites_cart[pair[1]]) h_bonds.append(d) cntr += 1 assert cntr == 10, cntr sel = h_bonds < 2.3 sel &= h_bonds > 1.6 if (h_bonds.size() > 0): print rmsd_dir, "%8.3f %8.3f %8.3f"%h_bonds.min_max_mean().as_tuple(), \ " %7.2f"%(sel.count(True)*100./(len(ref.h_bonds_i_seqs)*cntr)),\ " %6.4f %7.2f %4.2f"%(flex.mean(rmsd_bonds), flex.mean(rama_fav), flex.mean(clashscore)) else: print rmsd_dir, "N/A" # assert tmp_cntr1 == 50, tmp_cntr1
def compare_XH_bond_length_to_ideal(model): geometry = model.get_restraints_manager().geometry atoms = model.get_hierarchy().atoms() sites_cart = model.get_sites_cart() bond_proxies_simple, asu = \ geometry.get_all_bond_proxies(sites_cart = sites_cart) hd_selection = model.get_hd_selection() for bp in bond_proxies_simple: i, j = bp.i_seqs if hd_selection[i] or hd_selection[j]: assert approx_equal(atoms[i].distance(atoms[j]), bp.distance_ideal, eps=0.001)
def exercise1(): pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None) model = mmtbx.model.manager( model_input = pdb_inp, log = null_out()) model.process(make_restraints=True) pdb_hierarchy = model.get_hierarchy() sites_cart = model.get_sites_cart() atoms = pdb_hierarchy.atoms() model.setup_riding_h_manager() riding_h_manager = model.get_riding_h_manager() h_parameterization = riding_h_manager.h_parameterization number_h = model.get_hd_selection().count(True) number_h_para = len(h_parameterization) - h_parameterization.count(None) assert (number_h_para == number_h-1), 'Not all H atoms are parameterized' rc = h_parameterization[20] new_manager = riding_h_manager.deep_copy() new_h_parameterization = new_manager.h_parameterization rc_new = new_h_parameterization[20] assert (rc_new.htype == rc.htype) assert (rc_new.ih == rc.ih) assert (rc_new.a0 == rc.a0) assert (rc_new.a1 == rc.a1) assert (rc_new.a2 == rc.a2) assert (rc_new.a3 == rc.a3) assert (rc_new.a == rc.a) assert (rc_new.b == rc.b) assert (rc_new.h == rc.h) assert (rc_new.n == rc.n) assert (rc_new.disth == rc.disth) rc_new.htype = 'unk' rc_new.ih = 0 rc_new.a0 = 1 rc_new.a1 = 2 rc_new.a2 = 3 rc_new.a3 = 4 assert (rc_new.htype != rc.htype) assert (rc_new.ih != rc.ih) assert (rc_new.a0 != rc.a0) assert (rc_new.a1 != rc.a1) assert (rc_new.a2 != rc.a2) assert (rc_new.a3 != rc.a3)
def get_CNCO_bond_angle(model): geometry = model.get_restraints_manager() bond_proxies_simple, asu = geometry.geometry.get_all_bond_proxies( sites_cart=model.get_sites_cart()) bps_dict = {} [bps_dict.setdefault(p.i_seqs, True) for p in bond_proxies_simple] hierarchy = model.get_hierarchy() atom1s = [] atom2s = [] atom3s = [] results = [] for a in hierarchy.atoms(): if (not a.parent().resname == "MTN"): continue if a.element.strip().upper() == "C": atom1s.append(a) if a.element.strip().upper() == "N": atom2s.append(a) if a.element.strip().upper() == "O": atom3s.append(a) for i, a1 in enumerate(atom1s): for a2 in atom2s: if (not a1.is_in_same_conformer_as(a2)): continue if (not is_bonded(a1, a2, bps_dict)): continue for j, a4 in enumerate(atom1s): if (j <= i): continue if (not a4.is_in_same_conformer_as(a2)): continue if (not is_bonded(a4, a2, bps_dict)): continue if (not a1.is_in_same_conformer_as(a4)): continue if (is_bonded(a1, a4, bps_dict)): continue for a3 in atom3s: if (not a2.is_in_same_conformer_as(a3)): continue if (not is_bonded(a3, a2, bps_dict)): continue d12 = a1.distance(a2) d23 = a2.distance(a3) d24 = a2.distance(a4) angle123 = a2.angle(a1, a3, deg=True) angle124 = a2.angle(a1, a4, deg=True) angle324 = a2.angle(a3, a4, deg=True) result = group_args(atom_1=a1, atom_2=a2, atom_3=a3, atom_4=a4, d_C_L_N=d12, d_O_N=d23, d_C_R_N=d24, a_C_L_N_O=angle123, a_C_N_C=angle124, a_C_R_N_O=angle324) if (result is not None): results.append(result) return results
def run(prefix): """ Exercise combined energy and gradients from cluster qm. """ for restraints in ["cctbx", "qm"]: if 0: print("Using restraints:", restraints) result = [] for clustering in [True, False]: if 0: print(" clustering", clustering, "-" * 30) model = get_model() if (restraints == "qm"): fq = from_qm(pdb_hierarchy=model.get_hierarchy(), qm_engine_name="mopac", method="PM3", crystal_symmetry=model.crystal_symmetry(), clustering=clustering) else: fq = from_cctbx( restraints_manager=model.get_restraints_manager()) if (clustering): fm = fragments( working_folder=os.path.split("./ase/tmp_ase.pdb")[0] + "/", clustering_method=betweenness_centrality_clustering, maxnum_residues_in_cluster=8, charge_embedding=False, two_buffers=False, fast_interaction=True, pdb_hierarchy=model.get_hierarchy().deep_copy( ), # deep copy just in case qm_engine_name="mopac", crystal_symmetry=model.crystal_symmetry()) fc = from_cluster(restraints_manager=fq, fragment_manager=fm, parallel_params=get_master_phil().extract()) else: fc = fq energy, gradients = fc.target_and_gradients( sites_cart=model.get_sites_cart()) if (restraints == "qm"): energy = energy * (kcal / mol) * (kcal / mol) / Hartree gradients = gradients * (kcal / mol) * (kcal / mol) * (Bohr / Hartree) gradients = gradients.as_double() result.append(gradients.deep_copy()) # diff = flex.abs(result[0] - result[1]) max_diff = flex.max(diff)
def exercise2(pdb_str, cif_str): model = prepare_inputs(pdb_str, cif_str) riding_h_manager = model.get_riding_h_manager() atoms = model.get_hierarchy().atoms() h_para = riding_h_manager.h_parameterization diagnostics = riding_h_manager.diagnostics( sites_cart=model.get_sites_cart(), threshold=0.05) h_distances = diagnostics.h_distances type_list = diagnostics.type_list # number of H atoms number_h = model.get_hd_selection().count(True) number_h_para = len(h_para) - h_para.count(None) assert (number_h_para == 0), 'Not all H atoms are parameterized'
def exercise(): pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None) model = mmtbx.model.manager( model_input = pdb_inp, build_grm = True) pdb_hierarchy = model.get_hierarchy() sites_cart = model.get_sites_cart() atoms = pdb_hierarchy.atoms() model.setup_riding_h_manager() riding_h_manager = model.get_riding_h_manager() h_parameterization = riding_h_manager.h_parameterization diagnostics = riding_h_manager.diagnostics( sites_cart = sites_cart, threshold = 0.05) h_distances = diagnostics.h_distances type_list = diagnostics.type_list # number of H atoms in model number_h = model.get_hd_selection().count(True) # number of H in parameterization number_h_para = len(h_parameterization) - h_parameterization.count(None) # There are 152 H atoms in pdb_string, check if all of them are parameterized assert (number_h_para == number_h), 'Not all H atoms are parameterized' # For each H atom, check if distance compared to input model is not > 0.05 # 0.0014 = uncertainty for distance if uncertainty of coordinate = 0.001 for ih in h_distances: labels = atoms[ih].fetch_labels() assert (h_distances[ih] < 0.05), \ 'distance too large: %s atom: %s (%s) residue: %s ' \ % (h_parameterization[ih].htype, atoms[ih].name, ih, labels.resseq.strip()) # KEEP: useful for debugging #for ih in h_parameterization.keys(): # hp = h_parameterization[ih] # print "'"+hp.htype+"'"+',', for type1, type2 in zip(type_list, type_list_known): assert (type1 == type2)
def exclude_h_on_coordinated_S(model): # XXX if edits used it should be like in exclude_h_on_SS rm = model.get_restraints_manager().geometry els = model.get_hierarchy().atoms().extract_element() # Find possibly coordinated S exclusion_list = ["H","D","T","S","O","P","N","C","SE"] sel_s = [] for proxy in rm.pair_proxies().nonbonded_proxies.simple: i,j = proxy.i_seqs if(els[i] == "S" and not els[j] in exclusion_list): sel_s.append(i) if(els[j] == "S" and not els[i] in exclusion_list): sel_s.append(j) # Find H attached to possibly coordinated S bond_proxies_simple, asu = rm.get_all_bond_proxies( sites_cart = model.get_sites_cart()) sel_remove = flex.size_t() for proxy in bond_proxies_simple: i,j = proxy.i_seqs if(els[i] in ["H","D"] and j in sel_s): sel_remove.append(i) if(els[j] in ["H","D"] and i in sel_s): sel_remove.append(j) return model.select(~flex.bool(model.size(), sel_remove))
def exercise(): pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None) cif_object = iotbx.cif.reader(input_string=cif_str).model() # bla.cif does not exist, but cif_objects needs a filename in first position # of the tuple cif_objects = [('bla.cif', cif_object)] model = mmtbx.model.manager(model_input=pdb_inp, build_grm=True, restraint_objects=cif_objects) pdb_hierarchy = model.get_hierarchy() sites_cart = model.get_sites_cart() atoms = pdb_hierarchy.atoms() model.setup_riding_h_manager() riding_h_manager = model.get_riding_h_manager() h_para = riding_h_manager.h_parameterization diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart, threshold=0.05) h_distances = diagnostics.h_distances type_list = diagnostics.type_list # number of H atoms number_h = model.get_hd_selection().count(True) number_h_para = len(h_para) - h_para.count(None) assert (number_h_para == number_h), 'Not all H atoms are parameterized' for ih in h_distances: # One atom is expected to be moved if (ih == 16): continue labels = atoms[ih].fetch_labels() assert (h_distances[ih] < 0.1), \ 'distance too large: %s atom: %s (%s) residue: %s ' \ % (h_para[ih].htype, atoms[ih].name, ih, labels.resseq.strip()) for type1, type2 in zip(type_list, type_list_known): assert (type1 == type2)
def validate(pdb_str, threshold_bonds=0.02 * 4, threshold_angles=2.5 * 4): pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_str) params = mmtbx.model.manager.get_default_pdb_interpretation_params() params.pdb_interpretation.use_neutron_distances = True params.pdb_interpretation.restraints_library.cdl = False model = mmtbx.model.manager( model_input=pdb_inp, build_grm=True, stop_for_unknowns=True, #False, pdb_interpretation_params=params, log=null_out()) grm = model.get_restraints_manager().geometry sites_cart = model.get_sites_cart() b_deltas = flex.abs( grm.get_all_bond_proxies()[0].deltas(sites_cart=sites_cart)) b_outl = b_deltas.select(b_deltas > threshold_bonds) if (b_outl.size() > 0): return None a_deltas = flex.abs( grm.get_all_angle_proxies().deltas(sites_cart=sites_cart)) a_outl = a_deltas.select(a_deltas > threshold_angles) if (a_outl.size() > 0): return None return pdb_str
def exercise(): pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None) model = mmtbx.model.manager( model_input = pdb_inp, build_grm = True, log = null_out()) pdb_hierarchy = model.get_hierarchy() sites_cart = model.get_sites_cart() atoms = pdb_hierarchy.atoms() model.setup_riding_h_manager() riding_h_manager = model.get_riding_h_manager() h_parameterization = riding_h_manager.h_parameterization diagnostics = riding_h_manager.diagnostics( sites_cart = sites_cart, threshold = 0.05) h_distances = diagnostics.h_distances type_list = diagnostics.type_list number_h = model.get_hd_selection().count(True) number_h_para = len(h_parameterization) - h_parameterization.count(None) # There are 90 H atoms in pdb_string, check if all of them are recognized assert (number_h_para == number_h), 'Not all H atoms are parameterized' # For every H , check if distance between computed H and H in input model is # < 0.03 A for ih in h_distances: labels = atoms[ih].fetch_labels() assert (h_distances[ih] < 0.03), 'distance too large: %s atom: %s (%s) residue: %s ' \ % (h_parameterization[ih].htype, atoms[ih].name, ih, labels.resseq.strip()) # Check if parameterization types are correct for type1, type2 in zip(type_list, type_list_known): assert (type1 == type2)
def exercise1(): pdb_str = """ CRYST1 21.850 24.325 24.603 90.00 90.00 90.00 P 1 SCALE1 0.045767 0.000000 0.000000 0.00000 SCALE2 0.000000 0.041110 0.000000 0.00000 SCALE3 0.000000 0.000000 0.040645 0.00000 ATOM 1 N CYS D 37 8.132 18.794 15.343 1.00143.27 D N ANISOU 1 N CYS D 37 26762 17628 10046 -3652 3033 538 D N ATOM 2 CA CYS D 37 9.229 18.179 14.592 1.00143.16 D C ANISOU 2 CA CYS D 37 26739 17512 10144 -3661 2916 574 D C ATOM 3 C CYS D 37 10.551 18.924 14.744 1.00143.18 D C ANISOU 3 C CYS D 37 26760 17474 10166 -3627 2815 455 D C ATOM 4 O CYS D 37 11.615 18.295 14.696 1.00141.47 D O ANISOU 4 O CYS D 37 26571 17211 9972 -3636 2700 489 D O ATOM 5 CB CYS D 37 8.857 18.048 13.112 1.00144.61 D C ANISOU 5 CB CYS D 37 26841 17595 10509 -3672 2948 608 D C ATOM 6 SG CYS D 37 7.159 17.517 12.843 1.00142.64 D S ANISOU 6 SG CYS D 37 26553 17390 10253 -3704 3086 716 D S ATOM 7 H CYS D 37 7.635 19.325 14.885 1.00172.08 D H ATOM 8 HA CYS D 37 9.365 17.282 14.934 1.00171.95 D H ATOM 9 HB2 CYS D 37 8.970 18.910 12.683 1.00173.69 D H ATOM 10 HB3 CYS D 37 9.442 17.394 12.699 1.00173.69 D H ATOM 11 N CYS D 40 13.775 17.698 16.644 1.00154.41 D N ANISOU 11 N CYS D 40 28359 18912 11399 -3629 2475 474 D N ATOM 12 CA CYS D 40 14.636 16.639 16.128 1.00149.28 D C ANISOU 12 CA CYS D 40 27712 18183 10825 -3653 2369 564 D C ATOM 13 C CYS D 40 15.084 16.830 14.685 1.00148.00 D C ANISOU 13 C CYS D 40 27476 17888 10868 -3647 2342 540 D C ATOM 14 O CYS D 40 16.158 16.339 14.335 1.00149.38 D O ANISOU 14 O CYS D 40 27657 17989 11113 -3652 2233 563 D O ATOM 15 CB CYS D 40 13.921 15.279 16.208 1.00140.80 D C ANISOU 15 CB CYS D 40 26653 17143 9703 -3698 2398 729 D C ATOM 16 SG CYS D 40 13.262 14.779 17.830 1.00136.64 D S ANISOU 16 SG CYS D 40 26211 16771 8936 -3714 2439 794 D S ATOM 17 H CYS D 40 13.032 17.777 16.218 1.00185.45 D H ATOM 18 HA CYS D 40 15.432 16.588 16.680 1.00179.29 D H ATOM 19 HB2 CYS D 40 13.174 15.295 15.590 1.00169.12 D H ATOM 20 HB3 CYS D 40 14.548 14.592 15.932 1.00169.12 D H HETATM 21 NB HEC D1001 9.421 13.220 11.858 1.00140.59 N ANISOU 21 NB HEC D1001 26354 16953 10112 -3810 2765 1093 N HETATM 22 ND HEC D1001 12.886 11.034 12.753 1.00144.24 N ANISOU 22 ND HEC D1001 26954 17334 10517 -3839 2396 1214 N HETATM 23 C1A HEC D1001 12.227 10.592 9.833 1.00139.00 C ANISOU 23 C1A HEC D1001 26141 16470 10203 -3864 2452 1283 C HETATM 24 C1B HEC D1001 8.860 13.248 10.595 1.00143.63 C ANISOU 24 C1B HEC D1001 26666 17264 10645 -3817 2816 1110 C HETATM 25 C1C HEC D1001 10.125 13.804 14.697 1.00139.27 C ANISOU 25 C1C HEC D1001 26337 16981 9599 -3780 2714 1003 C HETATM 26 C1D HEC D1001 13.435 10.960 14.028 1.00134.69 C ANISOU 26 C1D HEC D1001 25819 16201 9156 -3833 2339 1204 C HETATM 27 C2A HEC D1001 11.928 10.386 8.429 1.00142.28 C ANISOU 27 C2A HEC D1001 26487 16789 10784 -3875 2476 1314 C HETATM 28 C2B HEC D1001 7.789 14.214 10.617 1.00141.94 C ANISOU 28 C2B HEC D1001 26417 17097 10418 -3798 2937 1044 C HETATM 29 C2C HEC D1001 10.451 14.023 16.100 1.00140.94 C ANISOU 29 C2C HEC D1001 26625 17289 9635 -3766 2687 965 C HETATM 30 C2D HEC D1001 14.546 10.022 13.991 1.00142.48 C ANISOU 30 C2D HEC D1001 26834 17133 10168 -3850 2214 1270 C HETATM 31 C3A HEC D1001 10.804 11.059 8.149 1.00136.41 C ANISOU 31 C3A HEC D1001 25701 16075 10056 -3866 2591 1279 C HETATM 32 C3B HEC D1001 7.744 14.781 11.826 1.00143.82 C ANISOU 32 C3B HEC D1001 26706 17431 10509 -3780 2957 983 C HETATM 33 C3C HEC D1001 11.528 13.271 16.400 1.00137.87 C ANISOU 33 C3C HEC D1001 26282 16879 9224 -3777 2567 1011 C HETATM 34 C3D HEC D1001 14.632 9.534 12.538 1.00144.35 C ANISOU 34 C3D HEC D1001 27005 17250 10590 -3867 2201 1319 C HETATM 35 C4A HEC D1001 10.358 11.714 9.366 1.00144.69 C ANISOU 35 C4A HEC D1001 26789 17236 10949 -3849 2645 1224 C HETATM 36 C4B HEC D1001 8.768 14.145 12.649 1.00137.78 C ANISOU 36 C4B HEC D1001 26012 16687 9651 -3787 2848 1015 C HETATM 37 C4C HEC D1001 11.920 12.537 15.214 1.00134.63 C ANISOU 37 C4C HEC D1001 25826 16356 8971 -3798 2515 1081 C HETATM 38 C4D HEC D1001 13.570 10.218 11.849 1.00138.72 C ANISOU 38 C4D HEC D1001 26232 16533 9944 -3858 2317 1280 C HETATM 39 CAA HEC D1001 12.769 9.532 7.451 1.00132.04 C ANISOU 39 CAA HEC D1001 25171 15378 9621 -3893 2385 1376 C HETATM 40 CAB HEC D1001 6.719 15.866 12.240 1.00138.71 C ANISOU 40 CAB HEC D1001 26042 16858 9803 -3757 3079 901 C HETATM 41 CAC HEC D1001 12.297 13.190 17.738 1.00135.76 C ANISOU 41 CAC HEC D1001 26101 16686 8794 -3768 2488 993 C HETATM 42 CAD HEC D1001 15.637 8.535 11.925 1.00138.75 C ANISOU 42 CAD HEC D1001 26295 16445 9980 -3888 2089 1394 C HETATM 43 CBA HEC D1001 11.998 8.251 7.139 1.00132.66 C ANISOU 43 CBA HEC D1001 25237 15456 9711 -3938 2416 1524 C HETATM 44 CBB HEC D1001 5.650 15.212 13.142 1.00135.28 C ANISOU 44 CBB HEC D1001 25642 16531 9227 -3784 3158 997 C HETATM 45 CBC HEC D1001 11.427 12.956 18.987 1.00146.99 C ANISOU 45 CBC HEC D1001 27580 18242 10026 -3778 2561 1040 C HETATM 46 CBD HEC D1001 14.919 7.222 11.642 1.00139.54 C ANISOU 46 CBD HEC D1001 26386 16545 10089 -3933 2120 1549 C HETATM 47 CGA HEC D1001 12.527 7.624 5.875 1.00128.84 C ANISOU 47 CGA HEC D1001 24714 14851 9389 -3953 2359 1570 C HETATM 48 CGD HEC D1001 15.891 6.207 11.098 1.00141.03 C ANISOU 48 CGD HEC D1001 26575 16642 10368 -3955 2011 1625 C HETATM 49 CHA HEC D1001 13.299 10.063 10.513 1.00146.02 C ANISOU 49 CHA HEC D1001 27088 17363 11029 -3868 2342 1305 C HETATM 50 CHB HEC D1001 9.227 12.490 9.500 1.00144.37 C ANISOU 50 CHB HEC D1001 26723 17255 10876 -3837 2764 1179 C HETATM 51 CHC HEC D1001 9.083 14.384 13.975 1.00144.74 C ANISOU 51 CHC HEC D1001 26964 17660 10370 -3774 2826 976 C HETATM 52 CHD HEC D1001 12.978 11.644 15.133 1.00137.25 C ANISOU 52 CHD HEC D1001 26183 16634 9330 -3815 2394 1143 C HETATM 53 CMA HEC D1001 10.090 11.136 6.782 1.00134.85 C ANISOU 53 CMA HEC D1001 25424 15802 10009 -3872 2656 1294 C HETATM 54 CMB HEC D1001 6.909 14.580 9.402 1.00138.00 C ANISOU 54 CMB HEC D1001 25835 16541 10059 -3798 3022 1038 C HETATM 55 CMC HEC D1001 9.714 15.017 17.030 1.00140.17 C ANISOU 55 CMC HEC D1001 26549 17298 9410 -3741 2781 878 C HETATM 56 CMD HEC D1001 15.472 9.587 15.143 1.00143.64 C ANISOU 56 CMD HEC D1001 27061 17330 10186 -3851 2112 1287 C HETATM 57 NA HEC D1001 11.246 11.403 10.381 1.00142.02 N ANISOU 57 NA HEC D1001 26521 16938 10501 -3848 2558 1228 N HETATM 58 NC HEC D1001 11.031 12.874 14.214 1.00135.40 N ANISOU 58 NC HEC D1001 25852 16413 9183 -3799 2607 1074 N HETATM 59 O1A HEC D1001 13.768 7.499 5.723 1.00127.91 O ANISOU 59 O1A HEC D1001 24612 14669 9319 -3944 2254 1548 O HETATM 60 O1D HEC D1001 15.705 5.000 11.405 1.00143.73 O ANISOU 60 O1D HEC D1001 26943 17007 10662 -3991 1995 1754 O HETATM 61 O2A HEC D1001 11.708 7.243 5.000 1.00126.20 O ANISOU 61 O2A HEC D1001 24330 14482 9138 -3973 2418 1629 O HETATM 62 O2D HEC D1001 16.850 6.595 10.375 1.00138.38 O ANISOU 62 O2D HEC D1001 26214 16212 10153 -3936 1943 1558 O HETATM 63 FE HEC D1001 11.115 12.157 12.415 1.00158.39 Fe ANISOU 63 FE HEC D1001 28683 19178 12321 -3824 2585 1151 Fe HETATM 64 HAB HEC D1001 6.266 16.109 11.430 1.00166.61 H HETATM 65 HAC HEC D1001 13.016 12.556 17.688 1.00163.06 H HETATM 66 HHA HEC D1001 13.931 9.523 9.993 1.00175.38 H HETATM 67 HHB HEC D1001 8.617 12.507 8.733 1.00173.40 H HETATM 68 HHC HEC D1001 8.518 15.025 14.454 1.00173.84 H HETATM 69 HHD HEC D1001 13.462 11.479 15.969 1.00164.85 H HETATM 70 HAA1 HEC D1001 13.619 9.309 7.860 1.00158.61 H HETATM 71 HAA2 HEC D1001 12.922 10.028 6.632 1.00158.61 H HETATM 72 HAD1 HEC D1001 16.364 8.380 12.549 1.00166.66 H HETATM 73 HAD2 HEC D1001 15.991 8.897 11.097 1.00166.66 H HETATM 74 HBA1 HEC D1001 11.058 8.462 7.024 1.00159.35 H HETATM 75 HBA2 HEC D1001 12.100 7.627 7.874 1.00159.35 H HETATM 76 HBB1 HEC D1001 5.203 14.504 12.651 1.00162.49 H HETATM 77 HBB2 HEC D1001 5.000 15.880 13.409 1.00162.49 H HETATM 78 HBB3 HEC D1001 6.076 14.841 13.930 1.00162.49 H HETATM 79 HBC1 HEC D1001 11.697 12.130 19.419 1.00176.54 H HETATM 80 HBC2 HEC D1001 10.495 12.894 18.725 1.00176.54 H HETATM 81 HBC3 HEC D1001 11.541 13.696 19.603 1.00176.54 H HETATM 82 HBD1 HEC D1001 14.216 7.374 10.991 1.00167.61 H HETATM 83 HBD2 HEC D1001 14.529 6.885 12.463 1.00167.61 H HETATM 84 HMA1 HEC D1001 9.181 10.779 6.867 1.00161.97 H HETATM 85 HMA2 HEC D1001 10.588 10.607 6.123 1.00161.97 H HETATM 86 HMA3 HEC D1001 10.048 12.069 6.487 1.00161.97 H HETATM 87 HMB1 HEC D1001 7.003 15.525 9.208 1.00165.76 H HETATM 88 HMB2 HEC D1001 5.981 14.382 9.604 1.00165.76 H HETATM 89 HMB3 HEC D1001 7.190 14.061 8.632 1.00165.76 H HETATM 90 HMC1 HEC D1001 9.327 14.535 17.777 1.00168.36 H HETATM 91 HMC2 HEC D1001 9.010 15.463 16.534 1.00168.36 H HETATM 92 HMC3 HEC D1001 10.343 15.677 17.362 1.00168.36 H HETATM 93 HMD1 HEC D1001 16.399 9.817 14.922 1.00172.53 H HETATM 94 HMD2 HEC D1001 15.399 8.618 15.274 1.00172.53 H HETATM 95 HMD3 HEC D1001 15.209 10.048 15.966 1.00172.53 H TER END """ edits = """ geometry_restraints.edits { bond { atom_selection_1 = chain D and resseq 40 and name SG atom_selection_2 = chain D and resseq 1001 and name CAC distance_ideal = 1.81 sigma = 0.05 } bond { atom_selection_1 = chain D and resseq 37 and name SG atom_selection_2 = chain D and resseq 1001 and name CAB distance_ideal = 1.81 sigma = 0.05 } angle { atom_selection_1 = chain D and resseq 40 and name SG atom_selection_2 = chain D and resseq 1001 and name CAC atom_selection_3 = chain D and resseq 1001 and name CBC angle_ideal = 109 sigma = 2 } angle { atom_selection_1 = chain D and resseq 40 and name SG atom_selection_2 = chain D and resseq 1001 and name CAC atom_selection_3 = chain D and resseq 1001 and name C3C angle_ideal = 109 sigma = 2 } angle { atom_selection_1 = chain D and resseq 37 and name SG atom_selection_2 = chain D and resseq 1001 and name CAB atom_selection_3 = chain D and resseq 1001 and name CBB angle_ideal = 109 sigma = 2 } angle { atom_selection_1 = chain D and resseq 1001 and name HAB atom_selection_2 = chain D and resseq 1001 and name CAB atom_selection_3 = chain D and resseq 37 and name SG angle_ideal = 109 sigma = 1.1 } angle { atom_selection_1 = chain D and resseq 1001 and name HAC atom_selection_2 = chain D and resseq 1001 and name CAC atom_selection_3 = chain D and resseq 40 and name SG angle_ideal = 109 sigma = 1.1 } } """ gm_phil = iotbx.phil.parse(input_string=grand_master_phil_str, process_includes=True) edits_phil = iotbx.phil.parse(edits) working_phil = gm_phil.fetch(edits_phil) params = working_phil.extract() # Make sure the angle edit is present assert (params.geometry_restraints.edits.angle[3].atom_selection_1 == \ "chain D and resseq 1001 and name HAB") pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None) model = mmtbx.model.manager(model_input=pdb_inp, build_grm=True, pdb_interpretation_params=params) pdb_hierarchy = model.get_hierarchy() sites_cart = model.get_sites_cart() atoms = pdb_hierarchy.atoms() model.setup_riding_h_manager() riding_h_manager = model.get_riding_h_manager() h_para = riding_h_manager.h_parameterization diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart, threshold=0.05) h_distances = diagnostics.h_distances type_list = diagnostics.type_list number_h = model.get_hd_selection().count(True) number_h_para = len(h_para) - h_para.count(None) for rc in h_para: if rc: assert (rc.ih != 63), 'Wrong atom not recognized.' # Test if number of paramterized H atoms is correct assert (number_h == number_h_para + 1), 'Not all H atoms are parameterized' type_list_known = [ 'alg1b', '3neigbs', '2tetra', '2tetra', 'alg1b', '3neigbs', '2tetra', '2tetra', '3neigbs', 'flat_2neigbs', 'flat_2neigbs', 'flat_2neigbs', 'flat_2neigbs', '2tetra', '2tetra', '2tetra', '2tetra', '2tetra', '2tetra', 'prop', 'prop', 'prop', 'prop', 'prop', 'prop', '2tetra', '2tetra', 'prop', 'prop', 'prop', 'prop', 'prop', 'prop', 'prop', 'prop', 'prop', 'prop', 'prop', 'prop' ] for ih in h_distances: # One H atom is expected to be far (HAC) if (ih == 64): continue labels = atoms[ih].fetch_labels() if (h_distances[ih] > 0.1): assert (h_distances[ih] < 0.1), \ 'distance too large: %s atom: %s (%s) residue: %s ' \ % (h_para[ih].htype, atoms[ih].name, ih, labels.resseq.strip()) # for type1, type2 in zip(type_list, type_list_known): assert (type1 == type2)
def exercise2(): pdb_str = """ CRYST1 16.660 12.742 18.240 90.00 90.00 90.00 P 1 SCALE1 0.060024 0.000000 0.000000 0.00000 SCALE2 0.000000 0.078481 0.000000 0.00000 SCALE3 0.000000 0.000000 0.054825 0.00000 ATOM 1 N TYR A 7 9.837 5.000 6.625 1.00 15.00 N ATOM 2 CA TYR A 7 10.084 6.426 6.798 1.00 15.00 C ATOM 3 C TYR A 7 11.431 6.813 6.197 1.00 15.00 C ATOM 4 O TYR A 7 11.660 6.642 5.000 1.00 15.00 O ATOM 5 CB TYR A 7 10.042 6.803 8.281 1.00 15.00 C ATOM 6 CG TYR A 7 8.697 6.593 8.948 1.00 15.00 C ATOM 7 CD1 TYR A 7 7.540 6.413 8.198 1.00 15.00 C ATOM 8 CD2 TYR A 7 8.586 6.575 10.332 1.00 15.00 C ATOM 9 CE1 TYR A 7 6.315 6.222 8.807 1.00 15.00 C ATOM 10 CE2 TYR A 7 7.364 6.384 10.950 1.00 15.00 C ATOM 11 CZ TYR A 7 6.233 6.208 10.183 1.00 15.00 C ATOM 12 OH TYR A 7 5.015 6.018 10.794 1.00 15.00 O ATOM 13 HA TYR A 7 9.398 6.930 6.331 1.00 15.00 H ATOM 14 HB2 TYR A 7 10.693 6.264 8.757 1.00 15.00 H ATOM 15 HB3 TYR A 7 10.270 7.742 8.369 1.00 15.00 H ATOM 16 HD1 TYR A 7 7.589 6.422 7.269 1.00 15.00 H ATOM 17 HD2 TYR A 7 9.347 6.694 10.853 1.00 15.00 H ATOM 18 HE1 TYR A 7 5.550 6.103 8.292 1.00 15.00 H ATOM 19 HE2 TYR A 7 7.306 6.375 11.878 1.00 15.00 H ATOM 20 HH TYR A 7 5.000 6.415 11.534 1.00 15.00 H TER HETATM 21 O HOH B 1 5.307 7.545 13.240 1.00 30.00 O TER END """ edits = """ geometry_restraints.edits { bond { atom_selection_1 = chain A and resseq 7 and name HH atom_selection_2 = chain B and resseq 1 and name O distance_ideal = 1.81 sigma = 0.05 } } """ type_list_known = [ '3neigbs', '2tetra', '2tetra', 'flat_2neigbs', 'flat_2neigbs', 'flat_2neigbs', 'flat_2neigbs', 'alg1b' ] gm_phil = iotbx.phil.parse(input_string=grand_master_phil_str, process_includes=True) edits_phil = iotbx.phil.parse(edits) working_phil = gm_phil.fetch(edits_phil) params = working_phil.extract() # Make sure the angle edit is present assert (params.geometry_restraints.edits.bond[0].atom_selection_1 == \ "chain A and resseq 7 and name HH") pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None) model = mmtbx.model.manager(model_input=pdb_inp, build_grm=True, pdb_interpretation_params=params) pdb_hierarchy = model.get_hierarchy() sites_cart = model.get_sites_cart() atoms = pdb_hierarchy.atoms() model.setup_riding_h_manager() riding_h_manager = model.get_riding_h_manager() h_para = riding_h_manager.h_parameterization diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart, threshold=0.05) h_distances = diagnostics.h_distances type_list = diagnostics.type_list number_h = model.get_hd_selection().count(True) number_h_para = len(h_para) - h_para.count(None) connectivity_manager = connectivity.determine_connectivity( pdb_hierarchy=pdb_hierarchy, geometry_restraints=model.get_restraints_manager().geometry) double_H = connectivity_manager.double_H # Test if number of paramterized H atoms is correct assert (number_h == number_h_para), 'Not all H atoms are parameterized' assert (double_H[19] == [11, 20]), 'H bound to two atoms wrongly recognized' assert (number_h_para == 8), 'Not all H atoms are parameterized' for ih in h_distances: labels = atoms[ih].fetch_labels() if (h_distances[ih] > 0.1): assert (h_distances[ih] < 0.1), \ 'distance too large: %s atom: %s (%s) residue: %s ' \ % (h_para[ih].htype, atoms[ih].name, ih, labels.resseq.strip()) for type1, type2 in zip(type_list, type_list_known): assert (type1 == type2)
def __init__( self, model, Hs=["H", "D"], As=["O", "N", "S", "F", "CL"], Ds=["O", "N", "S"], d_HA_cutoff=[1.4, 3.0], # original: [1.4, 2.4], d_DA_cutoff=[2.5, 3.5], # not used a_DHA_cutoff=120, # should be greater than this a_YAH_cutoff=[90, 180], # should be within this interval, not used protein_only=False): self.result = [] self.atoms = model.get_hierarchy().atoms() geometry = model.get_restraints_manager() bond_proxies_simple, asu = geometry.geometry.get_all_bond_proxies( sites_cart=model.get_sites_cart()) h_bonded_to = {} for p in bond_proxies_simple: i, j = p.i_seqs ei, ej = self.atoms[p.i_seqs[0]].element, self.atoms[ p.i_seqs[1]].element if (ei in Hs): h_bonded_to[i] = self.atoms[j] if (ej in Hs): h_bonded_to[j] = self.atoms[i] # sites_cart = model.get_sites_cart() crystal_symmetry = model.crystal_symmetry() fm = crystal_symmetry.unit_cell().fractionalization_matrix() om = crystal_symmetry.unit_cell().orthogonalization_matrix() pg = get_pair_generator(crystal_symmetry=crystal_symmetry, buffer_thickness=d_HA_cutoff[1], sites_cart=sites_cart) get_class = iotbx.pdb.common_residue_names_get_class for p in pg.pair_generator: i, j = p.i_seq, p.j_seq ei, ej = self.atoms[i].element, self.atoms[j].element altloc_i = self.atoms[i].parent().altloc altloc_j = self.atoms[j].parent().altloc resseq_i = self.atoms[i].parent().parent().resseq resseq_j = self.atoms[j].parent().parent().resseq # pre-screen candidates begin one_is_Hs = ei in Hs or ej in Hs other_is_acceptor = ei in As or ej in As d_HA = math.sqrt(p.dist_sq) assert d_HA <= d_HA_cutoff[1] is_candidate = one_is_Hs and other_is_acceptor and \ d_HA >= d_HA_cutoff[0] and \ altloc_i == altloc_j and resseq_i != resseq_j if (protein_only): for it in [i, j]: resname = self.atoms[it].parent().resname is_candidate &= get_class( name=resname) == "common_amino_acid" if (not is_candidate): continue if (ei in Hs and not h_bonded_to[i].element in As): continue if (ej in Hs and not h_bonded_to[j].element in As): continue # pre-screen candidates end rt_mx_i = pg.conn_asu_mappings.get_rt_mx_i(p) rt_mx_j = pg.conn_asu_mappings.get_rt_mx_j(p) rt_mx_ji = rt_mx_i.inverse().multiply(rt_mx_j) # if (ei in Hs): H = self.atoms[i] D = self.atoms[h_bonded_to[H.i_seq].i_seq] A = self.atoms[j] if (str(rt_mx_ji) != "x,y,z"): A = apply_symop_to_copy(A, rt_mx_ji, fm, om) if (ej in Hs): H = self.atoms[j] D = self.atoms[h_bonded_to[H.i_seq].i_seq] A = self.atoms[i] if (str(rt_mx_ji) != "x,y,z"): H = apply_symop_to_copy(H, rt_mx_ji, fm, om) D = apply_symop_to_copy(D, rt_mx_ji, fm, om) assert H.distance(D) < 1.15 # filter by a_DHA a_DHA = H.angle(A, D, deg=True) if (a_DHA < a_DHA_cutoff): continue # assert approx_equal(d_HA, H.distance(A), 1.e-3) self.result.append( group_args(i=i, j=j, symop=rt_mx_ji, d_HA=d_HA, a_DHA=a_DHA, d_AD=A.distance(D)))
def run(args, command_name="phenix.tls"): if (len(args) == 0): args = ["--help"] usage_fmt = "%s pdb_file [parameters: file or command line string]" des_fmt = "Example: %s model.pdb fit_tls_to.selection='%s' fit_tls_to.selection='%s'" command_line = (iotbx_option_parser( usage=usage_fmt % command_name, description=banner).option( "--show_defaults", action="store_true", help="Do not output to the screen (except errors).").option( "--silent", action="store_true", help="Suppress output to the screen.")).process(args=args) # log = sys.stdout if (not command_line.options.silent): utils.print_header("TLS tools", out=log) if (command_line.options.show_defaults): master_params.show(out=log) print(file=log) return if (not command_line.options.silent): print(banner, file=log) # processed_args = utils.process_command_line_args( args=command_line.args, master_params=master_params, log=log) reflection_files = processed_args.reflection_files if (processed_args.crystal_symmetry is None): raise Sorry("No crystal symmetry found.") if (len(processed_args.pdb_file_names) == 0): raise Sorry("No PDB file found.") params = processed_args.params if (not command_line.options.silent): utils.print_header("Input parameters", out=log) params.show(out=log) params = params.extract() # if (processed_args.crystal_symmetry.unit_cell() is None or processed_args.crystal_symmetry.space_group() is None): raise Sorry("No CRYST1 record found.") pdb_combined = iotbx.pdb.combine_unique_pdb_files( file_names=processed_args.pdb_file_names) pdb_combined.report_non_unique(out=log) if (len(pdb_combined.unique_file_names) == 0): raise Sorry("No coordinate file given.") raw_records = pdb_combined.raw_records try: pdb_inp = iotbx.pdb.input(source_info=None, lines=flex.std_string(raw_records)) except ValueError as e: raise Sorry("Model format (PDB or mmCIF) error:\n%s" % str(e)) model = mmtbx.model.manager( model_input=pdb_inp, restraint_objects=processed_args.cif_objects, crystal_symmetry=processed_args.crystal_symmetry, log=log) if (not command_line.options.silent): utils.print_header("TLS groups from PDB file header", out=log) pdb_inp_tls = mmtbx.tls.tools.tls_from_pdb_inp( remark_3_records=model._model_input.extract_remark_iii_records(3), pdb_hierarchy=model.get_hierarchy()) # tls_groups = [] if (pdb_inp_tls.tls_present): if (pdb_inp_tls.error_string is not None): raise Sorry(pdb_inp_tls.error_string) pdb_tls = mmtbx.tls.tools.extract_tls_from_pdb(pdb_inp_tls=pdb_inp_tls, model=model) tls_groups = pdb_tls.pdb_inp_tls.tls_params # tls_selections_strings = [] # if (len(tls_groups) == 0 and not command_line.options.silent): print("No TLS groups found in PDB file header.", file=log) else: for i_seq, tls_group in enumerate(tls_groups): tls_selections_strings.append(tls_group.selection_string) if (not command_line.options.silent): print("TLS group %d: %s" % (i_seq + 1, tls_group.selection_string), file=log) mmtbx.tls.tools.show_tls_one_group(tlso=tls_group, out=log) print(file=log) # if (len(tls_selections_strings) > 0 and len(params.selection) > 0): raise Sorry( "Two TLS selection sources found: PDB file header and parameters.") if (len(params.selection) > 0): tls_selections_strings = params.selection if ([params.combine_tls, params.extract_tls].count(True) > 1): raise Sorry( "Cannot simultaneously pereform: combine_tls and extract_tls") if ([params.combine_tls, params.extract_tls].count(True) > 0): if (len(tls_selections_strings) == 0): raise Sorry("No TLS selections found.") # if (len(tls_selections_strings)): if (not command_line.options.silent): utils.print_header("TLS groups selections", out=log) selections = utils.get_atom_selections( model=model, selection_strings=tls_selections_strings) if (not command_line.options.silent): print("Number of TLS groups: ", len(selections), file=log) print("Number of atoms: %d" % model.get_number_of_atoms(), file=log) n_atoms_in_tls = 0 for sel_a in selections: n_atoms_in_tls += sel_a.size() if (not command_line.options.silent): print("Number of atoms in TLS groups: %d" % n_atoms_in_tls, file=log) print(file=log) assert len(tls_selections_strings) == len(selections) if (not command_line.options.silent): for sel_a, sel_s in zip(selections, tls_selections_strings): print("Selection string:\n%s" % sel_s, file=log) print("selects %d atoms." % sel_a.size(), file=log) print(file=log) print("Ready-to-use in phenix.refine:\n", file=log) for sel_a, sel_s in zip(selections, tls_selections_strings): print(sel_s, file=log) # ofn = params.output_file_name if (ofn is None): ofn = os.path.splitext( os.path.basename(processed_args.pdb_file_names[0]))[0] if (len(processed_args.pdb_file_names) > 1): ofn = ofn + "_el_al" if (params.combine_tls): ofn = ofn + "_combine_tls.pdb" elif (params.extract_tls): ofn = ofn + "_extract_tls.pdb" else: ofn = None if (ofn is not None): ofo = open(ofn, "w") # if (params.extract_tls): utils.print_header( "Fit TLS matrices to B-factors of selected sets of atoms", out=log) tlsos = mmtbx.tls.tools.generate_tlsos( selections=selections, xray_structure=model.get_xray_structure(), value=0.0) for rt, rl, rs in [[1, 0, 1], [1, 1, 1], [0, 1, 1], [1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 1, 1], [0, 0, 1]] * 10: tlsos = mmtbx.tls.tools.tls_from_uanisos( xray_structure=model.get_xray_structure(), selections=selections, tlsos_initial=tlsos, number_of_macro_cycles=10, max_iterations=100, refine_T=rt, refine_L=rl, refine_S=rs, enforce_positive_definite_TL=params. enforce_positive_definite_TL, verbose=-1, out=log) mmtbx.tls.tools.show_tls(tlsos=tlsos, out=log) u_cart_from_tls = mmtbx.tls.tools.u_cart_from_tls( sites_cart=model.get_sites_cart(), selections=selections, tlsos=tlsos) unit_cell = model.get_xray_structure().unit_cell() for i_seq, sc in enumerate(model.get_xray_structure().scatterers()): if (u_cart_from_tls[i_seq] != (0, 0, 0, 0, 0, 0)): u_star_tls = adptbx.u_cart_as_u_star( unit_cell, tuple(u_cart_from_tls[i_seq])) sc.u_star = tuple( flex.double(sc.u_star) - flex.double(u_star_tls)) for sel in selections: model.get_xray_structure().convert_to_isotropic(selection=sel) mmtbx.tls.tools.remark_3_tls(tlsos=tlsos, selection_strings=tls_selections_strings, out=ofo) # if (params.combine_tls): utils.print_header("Combine B_tls with B_residual", out=log) mmtbx.tls.tools.combine_tls_and_u_local( xray_structure=model.get_xray_structure(), tls_selections=selections, tls_groups=tls_groups) print("All done.", file=log) # if (ofn is not None): utils.print_header("Write output PDB file %s" % ofn, out=log) model.set_sites_cart_from_xrs() pdb_str = model.model_as_pdb() ofo.write(pdb_str) ofo.close() print("All done.", file=log)