def get_ligand_buffer_models(model, qmr, verbose=False, write_steps=False): from cctbx.maptbx.box import shift_and_box_model if WRITE_STEPS_GLOBAL: write_steps = True ligand_model = select_and_reindex(model, qmr.selection) # # check for to sparse selections like a ligand in two monomers # if len(ligand_model.get_atoms()) == 0: raise Sorry('selection "%s" results in empty model' % qmr.selection) if write_steps: write_pdb_file(ligand_model, 'model_selection.pdb', None) assert qmr.selection.find('within') == -1 buffer_selection_string = 'residues_within(%s, %s)' % (qmr.buffer, qmr.selection) buffer_model = select_and_reindex(model, buffer_selection_string) buffer_model.remove_alternative_conformations( always_keep_one_conformer=True) for residue_group in buffer_model.get_hierarchy().residue_groups(): if (residue_group.atom_groups_size() != 1): raise Sorry("Not implemented: cannot run QI on buffer " + "molecules with alternate conformations") if write_steps: write_pdb_file(buffer_model, 'pre_super_cell.pdb', None) super_cell_and_prune(buffer_model, ligand_model, qmr.buffer, write_steps=write_steps) buffer_model_p1 = shift_and_box_model(model=buffer_model) for atom1, atom2 in zip(buffer_model_p1.get_atoms(), buffer_model.get_atoms()): atom1.tmp = atom2.tmp for atom1 in buffer_model.get_atoms(): for atom2 in ligand_model.get_atoms(): if atom1.id_str() == atom2.id_str(): atom2.xyz = atom1.xyz break buffer_model = buffer_model_p1 buffer_model.unset_restraints_manager() buffer_model.log = null_out() buffer_model.process(make_restraints=True) if write_steps: write_pdb_file(buffer_model, 'pre_add_terminii.pdb', None) add_hydrogen_atoms_to_model(buffer_model, use_capping_hydrogens=qmr.capping_groups) buffer_model.unset_restraints_manager() buffer_model.process(make_restraints=True) if write_steps: write_pdb_file(buffer_model, 'post_add_terminii.pdb', None) ligand_atoms = ligand_model.get_atoms() buffer_atoms = buffer_model.get_atoms() for atom1 in ligand_atoms: for atom2 in buffer_atoms: if atom1.id_str() == atom2.id_str(): break else: raise Sorry('''Bug alert Atom %s from ligand does not appear in buffer. Contact Phenix with input files. ''' % atom1.quote()) use_neutron_distances_in_model_in_place(ligand_model) use_neutron_distances_in_model_in_place(buffer_model) if write_steps: write_pdb_file(buffer_model, 'post_neutron_cluster.pdb', None) write_pdb_file(ligand_model, 'post_neutron_ligand.pdb', None) return ligand_model, buffer_model
def test_3(): """ test for command-line tool iotbx.unique_with_biomt""" inp = iotbx.pdb.input(source_info=None, lines=pdb_str_0) model = mmtbx.model.manager(model_input=inp) model.expand_with_BIOMT_records() model = shift_and_box_model(model) sel = model.selection("chain '0' or chain 'C' or chain 'F' or chain 'I' or chain 'L' or chain 'O' or chain 'R' or chain 'U' or chain 'X'") model = model.select(sel) pdb_str = model.model_as_pdb() fname = 'tst_reduce_model_with_biomt_test3.pdb' with open(fname, 'w') as f: f.write(pdb_str) assert os.path.isfile(fname) cmd = "iotbx.unique_with_biomt %s" % fname print(cmd) easy_run.call(cmd) res_fname = 'tst_reduce_model_with_biomt_test3_unique_biomt_000.cif' assert_lines_in_file(res_fname, """ ATOM 1 N . LYS 0 151 ? 72.74200 43.65400 193.22800 14.010 14.01000 N ? A ? 1 1""") assert_lines_in_file(res_fname, """ _pdbx_struct_assembly_gen.asym_id_list 1 (1-9) A""") cmd = "iotbx.unique_with_biomt %s chain_id_to_leave='C' output.serial=1" % fname print(cmd) easy_run.call(cmd) res_fname = 'tst_reduce_model_with_biomt_test3_unique_biomt_001.cif' assert_lines_in_file(res_fname, """ ATOM 1 N . LYS C 151 ? 186.74500 185.38200 236.77300 14.010 14.01000 N ? A ? 1 1""") assert_lines_in_file(res_fname, """ _pdbx_struct_assembly_gen.asym_id_list 1 (1-9) A""")
def run(self): # self.model = self.data_manager.get_model() # shift_and_box_model creates a new model object, so the format needs to # be obtained here if self.params.output.format == 'Auto': if self.model.input_model_format_pdb(): self.params.output.format = 'pdb' elif self.model.input_model_format_cif(): self.params.output.format = 'cif' self.model = shift_and_box_model(model=self.model, box_cushion=self.params.buffer_layer) # Get output filename if not provided fn = self.data_manager.get_default_model_name() basename = os.path.splitext(os.path.basename(fn))[0] if self.params.output.prefix is None: self.params.output.prefix = basename self.data_manager.set_default_output_filename( self.get_default_output_filename()) # save output output_fn = self.data_manager.write_model_file( self.model, format=self.params.output.format) print('Created file', output_fn, file=self.logger)
def get_map_model_managers(): # Set up source data from iotbx.map_model_manager import map_model_manager mmm = map_model_manager() mmm.generate_map(wrapping=True) second_model=mmm.model().deep_copy() mmm.box_all_maps_around_model_and_shift_origin() mmm.map_manager().set_wrapping(False) mmm.set_log(sys.stdout) #now get a second one from scitbx import matrix r=matrix.sqr((-0.8090,0.5878,0.0000, -0.5878,-0.8090,-0.0000, 0.0000,-0.0000,1.0000,)) t = matrix.col((100,0,0)) new_sites_cart = r.elems*mmm.model().get_sites_cart() + t.elems second_model.set_sites_cart(new_sites_cart) from cctbx.maptbx.box import shift_and_box_model second_model = shift_and_box_model(second_model) second_mmm = map_model_manager(model=second_model) second_mmm.generate_map(model=second_model,wrapping=True) second_mmm.box_all_maps_around_model_and_shift_origin(box_cushion=10) second_mmm.map_manager().set_wrapping(False) second_mmm.set_log(sys.stdout) print(mmm.model().get_sites_cart()[0]) print(second_mmm.model().get_sites_cart()[0]) return mmm, second_mmm
def get_ligand_buffer_models(model, qmr, verbose=False, write_steps=False): from cctbx.maptbx.box import shift_and_box_model ligand_model = select_and_reindex(model, qmr.selection) if len(ligand_model.get_atoms())==0: raise Sorry('selection "%s" results in empty model' % qmr.selection) buffer_selection_string = 'residues_within(%s, %s)' % (qmr.buffer, qmr.selection) buffer_model = select_and_reindex(model, buffer_selection_string) buffer_model.remove_alternative_conformations(always_keep_one_conformer=True) for residue_group in buffer_model.get_hierarchy().residue_groups(): if (residue_group.atom_groups_size() != 1): raise Sorry("Not implemented: cannot run QI on buffer "+ "molecules with alternate conformations") if write_steps: write_pdb_file(buffer_model, 'pre_super_cell.pdb', None) super_cell_and_prune(buffer_model, ligand_model, qmr.buffer, write_steps=write_steps) buffer_model_p1 = shift_and_box_model(model=buffer_model) for atom1, atom2 in zip(buffer_model_p1.get_atoms(), buffer_model.get_atoms()): atom1.tmp=atom2.tmp buffer_model = buffer_model_p1 buffer_model.unset_restraints_manager() buffer_model.log=null_out() buffer_model.process(make_restraints=True) if write_steps: write_pdb_file(buffer_model, 'pre_add_terminii.pdb', None) add_hydrogen_atoms_to_model(buffer_model, use_capping_hydrogens=qmr.capping_groups) buffer_model.unset_restraints_manager() buffer_model.process(make_restraints=True) return ligand_model, buffer_model
def run(self): # I'm guessing self.data_manager, self.params and self.logger # are already defined here... # this must be mmtbx.model.manager? model = self.data_manager.get_model() atoms = model.get_atoms() all_bsel = flex.bool(atoms.size(), False) for selection_string in self.params.atom_selection_program.inselection: print("Selecting '%s'" % selection_string, file=self.logger) isel = model.iselection(string=selection_string) all_bsel.set_selected(isel, True) if self.params.atom_selection_program.write_pdb_file is None: print(" %d atom%s selected" % plural_s(isel.size()), file=self.logger) for atom in atoms.select(isel): print(" %s" % atom.format_atom_record(), file=self.logger) print("", file=self.logger) if self.params.atom_selection_program.write_pdb_file is not None: print("Writing file:", show_string( self.params.atom_selection_program.write_pdb_file), file=self.logger) ss_ann = model.get_ss_annotation() if not model.crystal_symmetry() or \ (not model.crystal_symmetry().unit_cell()): model = shift_and_box_model(model, shift_model=False) selected_model = model.select(all_bsel) if (ss_ann is not None): selected_model.set_ss_annotation(ss_ann.\ filter_annotation( hierarchy=selected_model.get_hierarchy(), asc=selected_model.get_atom_selection_cache(), remove_short_annotations=False, remove_3_10_helices=False, remove_empty_annotations=True, concatenate_consecutive_helices=False, split_helices_with_prolines=False, filter_sheets_with_long_hbonds=False)) if self.params.atom_selection_program.cryst1_replacement_buffer_layer is not None: box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=selected_model.get_atoms().extract_xyz(), buffer_layer=self.params.atom_selection_program. cryst1_replacement_buffer_layer) sp = crystal.special_position_settings(box.crystal_symmetry()) sites_frac = box.sites_frac() xrs_box = selected_model.get_xray_structure( ).replace_sites_frac(box.sites_frac()) xray_structure_box = xray.structure(sp, xrs_box.scatterers()) selected_model.set_xray_structure(xray_structure_box) pdb_str = selected_model.model_as_pdb() f = open(self.params.atom_selection_program.write_pdb_file, 'w') f.write(pdb_str) f.close() print("", file=self.logger)
def test_2(): inp = iotbx.pdb.input(source_info=None, lines=pdb_str_0) model = mmtbx.model.manager(model_input=inp) model.expand_with_BIOMT_records() model = shift_and_box_model(model) model.search_for_ncs() model.setup_ncs_constraints_groups(filter_groups=True) assert model.ncs_constraints_present() assert not model.can_be_unique_with_biomt() assert "" == model.model_as_mmcif(try_unique_with_biomt=True)
def run(self): models = [] for model_name in self.data_manager.get_model_names(): models.append(self.data_manager.get_model(model_name)) # model = self.data_manager.get_model() self.inp_fn = os.path.basename( self.data_manager.get_default_model_name())[:-4] self.rama_z = rama_z.rama_z(models=models, log=self.logger) if len(models) == 1: model = models[0] cs = model.crystal_symmetry() if cs is None: model = shift_and_box_model(model) self._write_plots_if_needed(model, label='whole', type_of_plot='whole') helix_sel, sheet_sel, loop_sel = self.rama_z.get_ss_selections() if model.get_hierarchy().models_size() != 1: print( "Warning! Outputting partial models and plots are not supported \ for multi-model files", file=self.logger) else: for sel, label in [(helix_sel, "helix"), (sheet_sel, "sheet"), (loop_sel, "loop")]: selected_model = model.select(sel) if self.params.write_HSL_models: pdb_str = selected_model.model_as_pdb() fn = "%s" % self.get_default_output_filename( prefix='%s_' % self.inp_fn, suffix=label, serial=Auto) print("Writing out partial model: %s" % fn, file=self.logger) self.data_manager.write_model_file(selected_model, filename=fn) self._write_plots_if_needed(selected_model, label, type_of_plot='HSL') result = self.get_results() res_info = self.rama_z.get_detailed_values() print("Individual residues info:", file=self.logger) print("Residue name, type, SS, (phi, psi), Z", file=self.logger) for i in res_info: print('%4s %10s %1s (%7.2f, %7.2f) %7.4f' % (i[2], res_type_labels[i[1]], i[3], i[4], i[5], i[6]), file=self.logger) print(result.as_string(prefix=""), file=self.logger)
def test_1(): inp = iotbx.pdb.input(source_info=None, lines=pdb_str_0) model = mmtbx.model.manager(model_input=inp) model.expand_with_BIOMT_records() model = shift_and_box_model(model) sel = model.selection("chain '0' or chain 'C' or chain 'F' or chain 'I' or chain 'L' or chain 'O' or chain 'R' or chain 'U' or chain 'X'") model = model.select(sel) model.search_for_ncs() model.setup_ncs_constraints_groups(filter_groups=True) n1 = model.get_number_of_atoms() assert n1 == 648, n1 assert model.ncs_constraints_present() nrgl = model.get_ncs_groups() assert len(nrgl[0].master_iselection) == 72 assert len(nrgl[0].copies) == 8 # nrgl._show() # print (model.can_be_unique_with_biomt()) cif_txt = model.model_as_mmcif(try_unique_with_biomt=True) # print (cif_txt) assert_lines_in_text(cif_txt, """ loop_ _pdbx_struct_assembly_gen.assembly_id _pdbx_struct_assembly_gen.oper_expression _pdbx_struct_assembly_gen.asym_id_list 1 (1-9) A""") assert_lines_in_text(cif_txt, """ loop_ _pdbx_struct_assembly.id _pdbx_struct_assembly.details _pdbx_struct_assembly.method_details _pdbx_struct_assembly.oligomeric_details _pdbx_struct_assembly.oligomeric_count 1 'Symmetry assembly' ? ? ? """) assert_lines_in_text(cif_txt, """ _pdbx_struct_oper_list.vector[1] _pdbx_struct_oper_list.vector[2] _pdbx_struct_oper_list.vector[3] 1 'point symmetry operation' ? ? 1.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0""") inp = iotbx.pdb.input(source_info=None, lines=cif_txt) m2 = mmtbx.model.manager(model_input=inp) n2_1 = m2.get_number_of_atoms() assert n2_1 == 72 m2.expand_with_BIOMT_records() n2_2 = m2.get_number_of_atoms() # print (n1, n2) assert n1 == n2_2, "%d, %d" % (n1, n2)
def __init__( self, model, mmm=None, take_ncs_from_map=True, solvent_sel_str=solvent_sel_str, solvent_chain_mode="nearest", write_debug=False, write_debug_dir=os.getcwd(), out=None, ): if model.crystal_symmetry() is None: model = shift_and_box_model(model, shift_model=False) self.model = model self.mmm = mmm self.solvent_sel_str = solvent_sel_str assert solvent_chain_mode in ["nearest", "unique"] self.solvent_chain_mode = solvent_chain_mode self.write_debug = write_debug self.write_debug_dir = write_debug_dir self.out = out self.devnull = open(os.devnull, "w") # set up ncs relationships self.ncs_input_obj, self.ncs_group = self.generate_ncs_group() if self.assert_ncs_covers_all(self.model, self.ncs_group) is False: print( "NCS selection does not cover all atoms, will try to add solvent " "to the nearest non-solvent chain") self.model = self.solvent_to_nearest_chain(self.model) self.ncs_group = self.generate_ncs_group() assert self.assert_ncs_covers_all(self.model, self.ncs_group) # modify ncs_group transformations based on map if take_ncs_from_map and mmm is None: print( "\nNo map model manager. Cannot take symmetry from map...", file=self.out, ) elif take_ncs_from_map: print("\nSearching for symmetry in map...", file=self.out) self.ncs_group = self.take_ncs_from_map(self.mmm, self.ncs_group)
def generate_mock_rms_fc_list(self, n_bins=None, d_min=None, map_model_manager=None, model=None, out=null_out()): mmm = map_model_manager if not model: from cctbx.development.create_models_or_maps import generate_model model = generate_model(n_residues=100, b_iso=0, log=null_out()) # shift the model and return it with new crystal_symmetry from cctbx.maptbx.box import shift_and_box_model model = shift_and_box_model(model=model, crystal_symmetry=mmm.crystal_symmetry()) model.set_shift_cart((0, 0, 0)) model = mmm.remove_model_outside_map(model=model, boundary=0, return_as_new_model=True) map_id_model_map = 'map_for_mock_data' out_sav = mmm.log mmm.set_log(null_out()) mmm.generate_map(model=model, gridding=mmm.get_any_map_manager().map_data().all(), d_min=d_min, map_id=map_id_model_map) map_coeffs = mmm.get_map_manager_by_id( map_id_model_map).map_as_fourier_coefficients(d_min=d_min) mmm.remove_map_manager_by_id(map_id=map_id_model_map) mmm.set_log(out_sav) f_array = get_map_coeffs_as_fp_phi(map_coeffs, n_bins=n_bins, d_min=d_min).f_array rms_fc_list = flex.double() for i_bin in f_array.binner().range_used(): sel = f_array.binner().selection(i_bin) fc = map_coeffs.select(sel) f_array_fc = map_coeffs_to_fp(fc) rms_fc = f_array_fc.data().norm() rms_fc_list.append(rms_fc) self.rms_fc_list = rms_fc_list
def generate_mock_rms_fc_list(self, n_bins=None, d_min=None, map_model_manager=None, model=None, k_sol=None, b_sol=None, n_bins_use=None, out=null_out()): mmm = map_model_manager if not model: from cctbx.development.create_models_or_maps import generate_model model = generate_model(n_residues=100, b_iso=0, log=null_out()) # shift the model and return it with new crystal_symmetry from cctbx.maptbx.box import shift_and_box_model model = shift_and_box_model(model=model, crystal_symmetry=mmm.crystal_symmetry()) model.set_shift_cart((0, 0, 0)) model = mmm.remove_model_outside_map(model=model, boundary=0, return_as_new_model=True) map_id_model_map = 'map_for_mock_data' out_sav = mmm.log mmm.set_log(null_out()) mmm.generate_map(model=model, gridding=mmm.get_any_map_manager().map_data().all(), d_min=d_min, k_sol=k_sol, b_sol=b_sol, map_id=map_id_model_map) self.rms_fc_list = mmm.get_rms_f_list(map_id=map_id_model_map, d_min=d_min, n_bins=n_bins).rms_f_list self.n_bins_use = n_bins_use # just save it mmm.remove_map_manager_by_id(map_id=map_id_model_map) mmm.set_log(out_sav)
def RunProbeTests(inFileName): #======================================================================== # Call the test functions for the libraries we test. ret = probeext.DotSpheres_test() assert len(ret) == 0, "DotSpheres_test() failed: " + ret ret = probeext.SpatialQuery_test() assert len(ret) == 0, "SpatialQuery_test() failed: " + ret ret = probeext.Scoring_test() assert len(ret) == 0, "Scoring_test() failed: " + ret AtomTypes.Test() Helpers.Test() #======================================================================== # Now ensure that we can use the C++-wrapped classes as intended to make sure # that the wrapping code or parameters have not changed. #======================================================================== # Make sure we can get at the DotSphere objects and their methods cache = probeext.DotSphereCache(10) sphere1 = cache.get_sphere(1) dots = sphere1.dots() #======================================================================== # Make sure we can fill in an ExtraAtomInfoList and pass it to scoring # Generate an example data model with a small molecule in it unless we've # been given a file name to open. if inFileName is not None and len(inFileName) > 0: # Read a model from a file using the DataManager dm = DataManager() dm.process_model_file(inFileName) model = dm.get_model(inFileName) else: # Generate a small-molecule model using the map model manager mmm = map_model_manager( ) # get an initialized instance of the map_model_manager mmm.generate_map( ) # get a model from a generated small library model and calculate a map for it model = mmm.model() # get the model # Fix up bogus unit cell when it occurs by checking crystal symmetry. cs = model.crystal_symmetry() if (cs is None) or (cs.unit_cell() is None): model = shift_and_box_model(model=model) # Get the list of all atoms in the model atoms = model.get_atoms() # Get the bonding information we'll need to exclude our bonded neighbors. try: p = mmtbx.model.manager.get_default_pdb_interpretation_params() model.process(make_restraints=True, pdb_interpretation_params=p) # make restraints geometry = model.get_restraints_manager().geometry sites_cart = model.get_sites_cart() # cartesian coordinates bond_proxies_simple, asu = \ geometry.get_all_bond_proxies(sites_cart = sites_cart) except Exception as e: raise Exception("Could not get bonding information for input file: " + str(e)) bondedNeighbors = Helpers.getBondedNeighborLists(atoms, bond_proxies_simple) # Traverse the hierarchy and look up the extra data to be filled in. class philLike: def __init__(self, useImplicitHydrogenDistances=False): self.implicit_hydrogens = useImplicitHydrogenDistances self.set_polar_hydrogen_radius = True ret = Helpers.getExtraAtomInfo(model, bondedNeighbors, useNeutronDistances=False, probePhil=philLike(False)) extra = ret.extraAtomInfo # Construct a SpatialQuery and fill in the atoms. Ensure that we can make a # query within 1000 Angstroms of the origin. sq = probeext.SpatialQuery(atoms) nb = sq.neighbors((0, 0, 0), 0, 1000) # Construct a DotScorer object. # Find the radius of each atom in the structure and construct dot spheres for # them. Find the atoms that are bonded to them and add them to an excluded list. # Then compute the score for each of them and report the summed score over the # whole molecule the way that Reduce will. ds = probeext.DotScorer(extra) total = 0 badBumpTotal = 0 for a in atoms: rad = extra.getMappingFor(a).vdwRadius assert rad > 0, "Invalid radius for atom look-up: " + a.name + " rad = " + str( rad) sphere = cache.get_sphere(rad) # Excluded atoms that are bonded to me or to one of my neightbors. # It has the side effect of excluding myself if I have any neighbors. # Construct as a set to avoid duplicates. exclude = set() for n in bondedNeighbors[a]: exclude.add(n) for n2 in bondedNeighbors[n]: exclude.add(n2) exclude = list(exclude) dots = sphere.dots() res = ds.score_dots(a, 1.0, sq, rad * 3, 0.25, exclude, sphere.dots(), sphere.density(), False) total += res.totalScore() if res.hasBadBump: badBumpTotal += 1 # Test calling the single-dot checking code as will be used by Probe to make sure # all of the Python linkage is working dotOffset = [1, 0, 0] check = ds.check_dot(atoms[0], dotOffset, 1, atoms, [atoms[0]]) overlapType = check.overlapType # Test calling the interaction_type method to be sure Python linkage is working interactionType = ds.interaction_type(check.overlapType, check.gap) #======================================================================== # Regression test a Probe2 run against a snippet of a file, comparing the output # to the output generated by a previous version of the program. If there are # differences, report that this is the case and recommend verifying that the # differences are intentional and replacing the stored output. data_dir = libtbx.env.under_dist(module_name="mmtbx", path=os.path.join("regression", "pdbs"), test=os.path.isdir) model_file = os.path.join(data_dir, 'Fe_1brf_snip_reduced.pdb') kin_dir = libtbx.env.under_dist(module_name="mmtbx", path=os.path.join("regression", "kins"), test=os.path.isdir) kin_file = os.path.join(kin_dir, 'Fe_1brf_snip_reduced.kin') temp_file = os.path.join(tempfile._get_default_tempdir(), next(tempfile._get_candidate_names()) + ".kin") try: my_env = os.environ exe_name = 'mmtbx.probe2' if platform.system() == 'Windows': exe_name += '.bat' if subprocess.check_call([ exe_name, 'source_selection="all"', 'approach=self', 'output.separate_worse_clashes=True', 'output.file_name=' + temp_file, 'include_mainchain_mainchain=True', 'output.add_kinemage_keyword=True', model_file ], env=my_env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL): raise Exception( "Call to subprocess to regression test had nonzero return") except Exception as e: raise Exception("Could not call subprocess to do regression test: " + str(e)) with open(temp_file) as ft: ft_text = ft.readlines() with open(kin_file) as fk: fk_text = fk.readlines() instructions = ( " Use KiNG or another program to see what changed and then determine if the " + "differences are expected. If so, replace " + kin_file + " with the new file.") if len(ft_text) != len(fk_text): raise Exception("Different number of lines in " + temp_file + " and " + kin_file + instructions) for i in range(3, len(ft_text)): if ft_text[i] != fk_text[i]: print('Line', i, 'from each file:') print(ft_text[i]) print(fk_text[i]) raise Exception("Line " + str(i) + " in " + temp_file + " and " + kin_file + "differ." + instructions)
def run(self): # String describing the run that will be output to the specified file. outString = 'reduce2 v.{}, run {}\n'.format(version, datetime.now().strftime("%Y-%m-%d %H:%M:%S")) for a in sys.argv: outString += ' {}'.format(a) outString += '\n' make_sub_header('Loading Model', out=self.logger) # Get our model. self.model = self.data_manager.get_model() # Fix up bogus unit cell when it occurs by checking crystal symmetry. cs = self.model.crystal_symmetry() if (cs is None) or (cs.unit_cell() is None): self.model = shift_and_box_model(model = self.model) if self.params.approach == 'add': # Add Hydrogens to the model make_sub_header('Adding Hydrogens', out=self.logger) startAdd = work_clock() reduce_add_h_obj = reduce_hydrogen.place_hydrogens( model = self.model, n_terminal_charge=self.params.n_terminal_charge, stop_for_unknowns=True ) reduce_add_h_obj.run() self.model = reduce_add_h_obj.get_model() doneAdd = work_clock() # Interpret the model after shifting and adding Hydrogens to it so that # all of the needed fields are filled in when we use them below. # @todo Remove this once place_hydrogens() does all the interpretation we need. make_sub_header('Interpreting Hydrogenated Model', out=self.logger) startInt = work_clock() self.model.get_hierarchy().sort_atoms_in_place() self.model.get_hierarchy().atoms().reset_serial() p = mmtbx.model.manager.get_default_pdb_interpretation_params() p.pdb_interpretation.allow_polymer_cross_special_position=True p.pdb_interpretation.clash_guard.nonbonded_distance_threshold=None p.pdb_interpretation.use_neutron_distances = self.params.use_neutron_distances p.pdb_interpretation.proceed_with_excessive_length_bonds=True #p.pdb_interpretation.sort_atoms=True self.model.process(make_restraints=True, pdb_interpretation_params=p) # make restraints doneInt = work_clock() make_sub_header('Optimizing', out=self.logger) startOpt = work_clock() Optimizers.probePhil = self.params.probe opt = Optimizers.FastOptimizer(self.params.add_flip_movers, self.model, probeRadius=0.25, altID=self.params.alt_id, preferenceMagnitude=self.params.preference_magnitude) doneOpt = work_clock() outString += opt.getInfo() outString += 'Time to Add Hydrogen = '+str(doneAdd-startAdd)+'\n' outString += 'Time to Interpret = '+str(doneInt-startInt)+'\n' outString += 'Time to Optimize = '+str(doneOpt-startOpt)+'\n' else: # Removing Hydrogens from the model rather than adding them. make_sub_header('Removing Hydrogens', out=self.logger) sel = self.model.selection("element H") for a in self.model.get_atoms(): if sel[a.i_seq]: a.parent().remove_atom(a) # Re-process the model because we have removed some atoms that were previously # bonded. Don't make restraints during the reprocessing. # We had to do this to keep from crashing on a call to pair_proxies when generating # mmCIF files, so we always do it for safety. self.model.process(make_restraints=False, pdb_interpretation_params=p) make_sub_header('Writing output', out=self.logger) # Write the description output to the specified file. of = open(self.params.output.description_file_name,"w") of.write(outString) of.close() # Determine whether to write a PDB or CIF file and write the appropriate text output. # Then determine the output file name and write it there. if str(self.params.output.suffix).lower() == "pdb": txt = self.model.model_as_pdb() suffix = ".pdb" else: txt = self.model.model_as_mmcif() suffix = ".cif" if self.params.output.model_file_base_name is not None: base = self.params.output.model_file_base_name else: file_name = self.data_manager.get_model_names()[0] base = os.path.splitext(os.path.basename(file_name))[0] + "_reduced" fullname = base+suffix with open(fullname, 'w') as f: f.write(txt) print('Wrote',fullname,'and',self.params.output.description_file_name, file = self.logger) # Report profiling info if we've been asked to in the Phil parameters if self.params.profile: print('Profile results:') import pstats profile_params = {'sort_by': 'time', 'num_entries': 20} self._pr.disable() ps = pstats.Stats(self._pr).sort_stats(profile_params['sort_by']) ps.print_stats(profile_params['num_entries'])
def run(self): ''' Function that places H atoms ''' model_has_bogus_cs = False # TODO temporary fix until the code is moved to model class # check if box cussion of 5 A is enough to prevent symm contacts cs = self.model.crystal_symmetry() if (cs is None) or (cs.unit_cell() is None): self.model = shift_and_box_model(model=self.model) model_has_bogus_cs = True # Remove existing H if requested self.n_H_initial = self.model.get_hd_selection().count(True) if not self.keep_existing_H: self.model = self.model.select(~self.model.get_hd_selection()) t0 = time.time() # Add H atoms and place them at center of coordinates pdb_hierarchy = self.add_missing_H_atoms_at_bogus_position() if print_time: print("add_missing_H_atoms_at_bogus_position:", round(time.time() - t0, 2)) #print(pdb_hierarchy.composition().n_hd) # f = open("intermediate1.pdb","w") # f.write(self.model.model_as_pdb()) # place N-terminal propeller hydrogens # if self.n_terminal_charge != 'no_charge': # for m in pdb_hierarchy.models(): # for chain in m.chains(): # rgs = chain.residue_groups()[0] # # by default, place NH3 only at residue with resseq 1 # if (self.n_terminal_charge == 'residue_one' and rgs.resseq_as_int() != 1): # continue # elif (self.n_terminal_charge == 'first_in_chain'): # pass # for ag in rgs.atom_groups(): # if (get_class(name=ag.resname) in # ['common_amino_acid', 'modified_amino_acid', 'd_amino_acid']): # if ag.get_atom('H'): # ag.remove_atom(ag.get_atom('H')) # rc = add_n_terminal_hydrogens_to_residue_group(rgs) # # rc is always empty list? pdb_hierarchy.sort_atoms_in_place() pdb_hierarchy.atoms().reset_serial() # f = open("intermediate2.pdb","w") # f.write(self.model.model_as_pdb()) p = mmtbx.model.manager.get_default_pdb_interpretation_params() p.pdb_interpretation.clash_guard.nonbonded_distance_threshold = None p.pdb_interpretation.use_neutron_distances = self.use_neutron_distances p.pdb_interpretation.proceed_with_excessive_length_bonds = True #p.pdb_interpretation.automatic_linking.link_metals = True t0 = time.time() #p.pdb_interpretation.restraints_library.cdl=False # XXX this triggers a bug !=360 ro = self.model.get_restraint_objects() self.model = mmtbx.model.manager( model_input=None, pdb_hierarchy=pdb_hierarchy, stop_for_unknowns=self.stop_for_unknowns, crystal_symmetry=self.model.crystal_symmetry(), restraint_objects=ro, log=null_out()) self.model.process(pdb_interpretation_params=p, make_restraints=True) if print_time: print("get new model obj and grm:", round(time.time() - t0, 2)) #f = open("intermediate3.pdb","w") #f.write(self.model.model_as_pdb()) # Only keep H that have been parameterized in riding H procedure sel_h = self.model.get_hd_selection() if sel_h.count(True) == 0: return # get rid of isolated H atoms. #For example when heavy atom is missing, H needs not to be placed sel_isolated = self.model.isolated_atoms_selection() self.sel_lone_H = sel_h & sel_isolated self.model = self.model.select(~self.sel_lone_H) t0 = time.time() # get riding H manager --> parameterize all H atoms sel_h = self.model.get_hd_selection() self.model.setup_riding_h_manager(use_ideal_dihedral=True) riding_h_manager = self.model.riding_h_manager if riding_h_manager is None: return sel_h_in_para = flex.bool( [bool(x) for x in riding_h_manager.h_parameterization]) sel_h_not_in_para = sel_h_in_para.exclusive_or(sel_h) self.site_labels_no_para = [ atom.id_str().replace('pdb=', '').replace('"', '') for atom in self.model.get_hierarchy().atoms().select(sel_h_not_in_para) ] # self.model = self.model.select(~sel_h_not_in_para) if print_time: print("set up riding H manager and some cleanup:", round(time.time() - t0, 2)) # f = open("intermediate4.pdb","w") # f.write(model.model_as_pdb()) if self.validate_e: t0 = time.time() self.validate_electrons() if print_time: print("validate electrons:", round(time.time() - t0, 2)) t0 = time.time() # Reset occupancies, ADPs and idealize H atom positions self.model.reset_adp_for_hydrogens(scale=self.adp_scale) self.model.reset_occupancy_for_hydrogens_simple() self.model.idealize_h_riding() if print_time: print("reset adp, occ; idealize:", round(time.time() - t0, 2)) t0 = time.time() self.exclude_H_on_links() if print_time: print("all links:", round(time.time() - t0, 2)) # place N-terminal propeller hydrogens if self.n_terminal_charge != 'no_charge': hierarchy = self.model.get_hierarchy() for m in hierarchy.models(): for chain in m.chains(): rgs = chain.residue_groups()[0] # by default, place NH3 only at residue with resseq 1 if (self.n_terminal_charge == 'residue_one' and rgs.resseq_as_int() != 1): continue elif (self.n_terminal_charge == 'first_in_chain'): pass add_charge = True for ag in rgs.atom_groups(): if (get_class(name=ag.resname) in [ 'common_amino_acid', 'modified_amino_acid', 'd_amino_acid' ]): if ag.get_atom('N'): N = ag.get_atom('N') if N.i_seq in self.exclusion_iseqs: add_charge = False if ag.get_atom('H'): H = ag.get_atom('H') ag.remove_atom(H) H_label = H.id_str().replace('pdb=', '').replace( '"', '') if H_label in self.site_labels_no_para: self.site_labels_no_para.remove(H_label) if add_charge: rc = add_n_terminal_hydrogens_to_residue_group(rgs) hierarchy.sort_atoms_in_place() hierarchy.atoms().reset_serial() self.model = mmtbx.model.manager( model_input=None, pdb_hierarchy=hierarchy, stop_for_unknowns=self.stop_for_unknowns, crystal_symmetry=self.model.crystal_symmetry(), restraint_objects=ro, log=null_out()) self.n_H_final = self.model.get_hd_selection().count(True)
def RunProbeTests(inFileName): #======================================================================== # Call the test functions for the libraries we test. ret = probeext.DotSpheres_test() assert len(ret) == 0, "DotSpheres_test() failed: " + ret ret = probeext.SpatialQuery_test() assert len(ret) == 0, "SpatialQuery_test() failed: " + ret ret = probeext.Scoring_test() assert len(ret) == 0, "Scoring_test() failed: " + ret AtomTypes.Test() Helpers.Test() #======================================================================== # Now ensure that we can use the C++-wrapped classes as intended to make sure # that the wrapping code or parameters have not changed. #======================================================================== # Make sure we can get at the DotSphere objects and their methods cache = probeext.DotSphereCache(10) sphere1 = cache.get_sphere(1) dots = sphere1.dots() #======================================================================== # Make sure we can fill in an ExtraAtomInfoList and pass it to scoring # Generate an example data model with a small molecule in it if inFileName is not None and len(inFileName) > 0: # Read a model from a file using the DataManager dm = DataManager() dm.process_model_file(inFileName) model = dm.get_model(inFileName) else: # Generate a small-molecule model using the map model manager mmm = map_model_manager( ) # get an initialized instance of the map_model_manager mmm.generate_map( ) # get a model from a generated small library model and calculate a map for it model = mmm.model() # get the model # Fix up bogus unit cell when it occurs by checking crystal symmetry. cs = model.crystal_symmetry() if (cs is None) or (cs.unit_cell() is None): model = shift_and_box_model(model=model) # Get the list of all atoms in the model atoms = model.get_atoms() # Get the bonding information we'll need to exclude our bonded neighbors. try: p = mmtbx.model.manager.get_default_pdb_interpretation_params() model.process(make_restraints=True, pdb_interpretation_params=p) # make restraints geometry = model.get_restraints_manager().geometry sites_cart = model.get_sites_cart() # cartesian coordinates bond_proxies_simple, asu = \ geometry.get_all_bond_proxies(sites_cart = sites_cart) except Exception as e: raise Exception("Could not get bonding information for input file: " + str(e)) bondedNeighbors = Helpers.getBondedNeighborLists(atoms, bond_proxies_simple) # Traverse the hierarchy and look up the extra data to be filled in. ret = Helpers.getExtraAtomInfo(model) extra = ret.extraAtomInfo # Construct a SpatialQuery and fill in the atoms. Ensure that we can make a # query within 1000 Angstroms of the origin. sq = probeext.SpatialQuery(atoms) nb = sq.neighbors((0, 0, 0), 0, 1000) # Construct a DotScorer object. # Find the radius of each atom in the structure and construct dot spheres for # them. Find the atoms that are bonded to them and add them to an excluded list. # Then compute the score for each of them and report the summed score over the # whole molecule the way that Reduce will. ds = probeext.DotScorer(extra) total = 0 badBumpTotal = 0 for a in atoms: rad = extra.getMappingFor(a).vdwRadius assert rad > 0, "Invalid radius for atom look-up: " + a.name + " rad = " + str( rad) sphere = cache.get_sphere(rad) # Excluded atoms that are bonded to me or to one of my neightbors. # It has the side effect of excluding myself if I have any neighbors. # Construct as a set to avoid duplicates. exclude = set() for n in bondedNeighbors[a]: exclude.add(n) for n2 in bondedNeighbors[n]: exclude.add(n2) exclude = list(exclude) dots = sphere.dots() res = ds.score_dots(a, 1.0, sq, rad * 3, 0.25, exclude, sphere.dots(), sphere.density(), False) total += res.totalScore() if res.hasBadBump: badBumpTotal += 1 # Test calling the single-dot checking code as will be used by Probe to make sure # all of the Python linkage is working dotOffset = [1, 0, 0] check = ds.check_dot(atoms[0], dotOffset, 1, atoms, [atoms[0]]) overlapType = check.overlapType # Test calling the interaction_type method to be sure Python linkage is working interactionType = ds.interaction_type(check.overlapType, check.gap)
def run(self): ''' Function that places H atoms ''' model_has_bogus_cs = False # TODO temporary fix until the code is moved to model class # check if box cussion of 5 A is enough to prevent symm contacts cs = self.model.crystal_symmetry() if cs is None: self.model = shift_and_box_model(model=self.model) model_has_bogus_cs = True # Remove existing H if requested self.n_H_initial = self.model.get_hd_selection().count(True) if not self.keep_existing_H: self.model = self.model.select(~self.model.get_hd_selection()) # Add H atoms and place them at center of coordinates pdb_hierarchy = self.add_missing_H_atoms_at_bogus_position() pdb_hierarchy.atoms().reset_serial() #pdb_hierarchy.sort_atoms_in_place() p = mmtbx.model.manager.get_default_pdb_interpretation_params() p.pdb_interpretation.clash_guard.nonbonded_distance_threshold = None p.pdb_interpretation.use_neutron_distances = self.use_neutron_distances p.pdb_interpretation.proceed_with_excessive_length_bonds = True #p.pdb_interpretation.restraints_library.cdl=False # XXX this triggers a bug !=360 ro = self.model.get_restraint_objects() self.model = mmtbx.model.manager( model_input=None, pdb_hierarchy=pdb_hierarchy, build_grm=True, stop_for_unknowns=self.stop_for_unknowns, crystal_symmetry=self.model.crystal_symmetry(), restraint_objects=ro, pdb_interpretation_params=p, log=null_out()) #f = open("intermediate1.pdb","w") #f.write(self.model.model_as_pdb()) # Only keep H that have been parameterized in riding H procedure sel_h = self.model.get_hd_selection() if sel_h.count(True) == 0: return # get rid of isolated H atoms. #For example when heavy atom is missing, H needs not to be placed sel_isolated = self.model.isolated_atoms_selection() self.sel_lone_H = sel_h & sel_isolated self.model = self.model.select(~self.sel_lone_H) # get riding H manager --> parameterize all H atoms sel_h = self.model.get_hd_selection() self.model.setup_riding_h_manager(use_ideal_dihedral=True) sel_h_in_para = flex.bool( [bool(x) for x in self.model.riding_h_manager.h_parameterization]) sel_h_not_in_para = sel_h_in_para.exclusive_or(sel_h) self.site_labels_no_para = [ atom.id_str().replace('pdb=', '').replace('"', '') for atom in self.model.get_hierarchy().atoms().select(sel_h_not_in_para) ] # self.model = self.model.select(~sel_h_not_in_para) self.exclude_H_on_disulfides() #self.exclude_h_on_coordinated_S() # f = open("intermediate2.pdb","w") # f.write(model.model_as_pdb()) # Reset occupancies, ADPs and idealize H atom positions self.model.reset_adp_for_hydrogens(scale=self.adp_scale) self.model.reset_occupancy_for_hydrogens_simple() self.model.idealize_h_riding() self.exclude_h_on_coordinated_S() # self.n_H_final = self.model.get_hd_selection().count(True)
def generate_model(file_name=None, n_residues=None, start_res=None, b_iso=30, box_cushion=5, space_group_number=1, output_model_file_name=None, shake=None, random_seed=None, log=sys.stdout): ''' generate_model: Simple utility for generating a model for testing purposes. This function typically accessed and tested through map_model_manager Summary ------- Generate a model from a user-specified file or from some examples available in the cctbx. Cut out specified number of residues, shift to place on positive side of origin, optionally set b values to b_iso, place in box with buffering of box_cushion on all edges, optionally randomly shift (shake) atomic positions by rms of shake A, and write out to output_model_file_name and return model object. Parameters: file_name (string, None): File containing model (PDB, CIF format) n_residues (int, 10): Number of residues to include start_res (int, None): Starting residue number b_iso (float, 30): B-value (ADP) to use for all atoms box_cushion (float, 5): Buffer (A) around model space_group_number (int, 1): Space group to use output_model_file_name (string, None): File for output model shake (float, None): RMS variation to add (A) in shake random_seed (int, None): Random seed for shake Returns: model.manager object (model) in a box defined by a crystal_symmetry object ''' # Get the parameters space_group_number = int(space_group_number) if n_residues is not None: n_residues = int(n_residues) box_cushion = float(box_cushion) if start_res: start_res = int(start_res) if shake: shake = float(shake) if random_seed: random_seed = int(random_seed) import random random.seed(random_seed) random_seed = random.randint(1, 714717) flex.set_random_seed(random_seed) # Choose file with coordinates if not file_name: if not n_residues: n_residues = 10 # default import libtbx.load_env iotbx_regression = os.path.join( libtbx.env.find_in_repositories("iotbx"), 'regression') if n_residues < 25: file_name = os.path.join(iotbx_regression, 'secondary_structure', '5a63_chainBp.pdb') # starts at 219 if not start_res: start_res = 219 elif n_residues < 167: file_name = os.path.join(iotbx_regression, 'secondary_structure', '3jd6_noh.pdb') # starts at 58 if not start_res: start_res = 58 else: file_name = os.path.join(iotbx_regression, 'secondary_structure', '4a7h_chainC.pdb') # starts at 9 if not start_res: start_res = 9 else: # have file_name if start_res is None: start_res = 1 if not n_residues: n_residues = 100000 # a big number # Read in coordinates and cut out the part of the model we want from iotbx.data_manager import DataManager dm = DataManager(['model']) dm.process_model_file(file_name) model = dm.get_model(file_name) if not model.crystal_symmetry() or not model.crystal_symmetry().unit_cell( ): from cctbx.maptbx.box import shift_and_box_model model = shift_and_box_model(model=model, box_cushion=box_cushion) selection = model.selection('resseq %s:%s' % (start_res, start_res + n_residues - 1)) model = model.select(selection) # shift the model and return it with new crystal_symmetry from cctbx.maptbx.box import shift_and_box_model model = shift_and_box_model(model=model, box_cushion=box_cushion) if b_iso is not None: b_values = flex.double(model.get_sites_cart().size(), b_iso) ph = model.get_hierarchy() ph.atoms().set_b(b_values) # Optionally shake model if shake: model = shake_model(model, shake=shake) if output_model_file_name: f = open(output_model_file_name, 'w') print("%s" % (model.model_as_pdb()), file=f) f.close() print("Writing model with %s residues and b_iso=%s from %s to %s" % (n_residues, b_iso, file_name, output_model_file_name), file=log) else: print("Generated model with %s residues and b_iso=%s from %s " % (n_residues, b_iso, file_name), file=log) return model
def __init__(self, model, params, log = None): self.log = log self.params = params self.model = model self._neutralize_scatterers() if not model.crystal_symmetry() or not model.crystal_symmetry().unit_cell(): # Make it up from cctbx.maptbx.box import shift_and_box_model model = shift_and_box_model(model, shift_model=False) self.pdb_hierarchy = model.get_hierarchy() self.crystal_symmetry = model.crystal_symmetry() if(self.log is None): self.log = sys.stdout self.xray_structure = model.get_xray_structure() asc = self.pdb_hierarchy.atom_selection_cache( special_position_settings=crystal.special_position_settings( crystal_symmetry = self.crystal_symmetry)) if(self.params.random_seed is not None): random.seed(self.params.random_seed) flex.set_random_seed(self.params.random_seed) self.top_selection = flex.smart_selection( flags=flex.bool(self.xray_structure.scatterers().size(), True)) if(self.params.selection is not None): self.top_selection = flex.smart_selection( flags=asc.selection(self.params.selection)) self._rotate_about_axis() self._process_adp() self._process_sites() self._process_occupancies() self._put_in_box() self._change_of_basis() # Up to this point we are done with self.xray_structure self.model.set_xray_structure(self.xray_structure) self.pdb_hierarchy = self.model.get_hierarchy() # Now only manipulations that use self.pdb_hierarchy are done ### segID manipulations if (params.set_seg_id_to_chain_id): if (params.clear_seg_id): raise Sorry("Parameter conflict - set_seg_id_to_chain_id=True and "+ "clear_seg_id=True. Please choose only one of these options.") for atom in self.pdb_hierarchy.atoms(): labels = atom.fetch_labels() atom.segid = "%-4s" % labels.chain_id elif (params.clear_seg_id): for atom in self.pdb_hierarchy.atoms(): atom.segid = " " if(self.params.set_chemical_element_simple_if_necessary or self.params.rename_chain_id.old_id or self.params.renumber_residues or self.params.increment_resseq or self.params.convert_semet_to_met or self.params.convert_met_to_semet or self.params.set_charge.charge or self.params.truncate_to_polyala or self.params.truncate_to_polygly or self.params.remove_alt_confs or self.params.move_waters_last or self.params.remove_fraction or self.params.keep or self.params.remove): # del self.xray_structure # it is invalide below this point self._set_chemical_element_simple_if_necessary() self._rename_chain_id() self._renumber_residues() self._convert_semet_to_met() self._convert_met_to_semet() self._set_atomic_charge() self._truncate_to_poly_ala() self._truncate_to_poly_gly() self._remove_alt_confs() self._move_waters() self._remove_atoms() self._apply_keep_remove() # Here goes really nasty hack. Never repeat it. # It is here because I don't have clear idea about how to handle # such dramatic changes in number of atoms etc that just was performed # for hierarchy. self.pdb_hierarchy.reset_atom_i_seqs() self.pdb_hierarchy.atoms_reset_serial() self.model._pdb_hierarchy = self.pdb_hierarchy self.model._xray_structure = self.pdb_hierarchy.extract_xray_structure( crystal_symmetry=self.model.crystal_symmetry()) self.model._update_atom_selection_cache() self.model._update_has_hd() self.model.get_hierarchy().atoms().reset_i_seq()
def add(model, use_neutron_distances = False, adp_scale = 1, exclude_water = True, protein_only = False, stop_for_unknowns = False, keep_existing_H = False): """ Add H atoms to a model Parameters ---------- use_neutron_distances : bool use neutron distances instead of X-ray adp_scale : float scale factor for isotropic B of H atoms. B(H-atom) = adp_scale * B(parent non-H atom) keep_existing_H : bool keep existing H atoms in model, only place missing H Returns ------- model mmtbx model object with H atoms """ model_has_bogus_cs = False # TODO temporary fix until the code is moved to model class # check if box cussion of 5 A is enough to prevent symm contacts cs = model.crystal_symmetry() if cs is None: model = shift_and_box_model(model = model) model_has_bogus_cs = True # Remove existing H if requested if( not keep_existing_H): model = model.select(~model.get_hd_selection()) pdb_hierarchy = model.get_hierarchy() mon_lib_srv = model.get_mon_lib_srv() """ for pmodel in pdb_hierarchy.models(): for chain in pmodel.chains(): for residue_group in chain.residue_groups(): for conformer in residue_group.conformers(): for residue in conformer.residues(): print list(residue.atoms().extract_name()) """ add_missing_H_atoms_at_bogus_position(pdb_hierarchy = pdb_hierarchy, mon_lib_srv = mon_lib_srv, protein_only = protein_only) pdb_hierarchy.atoms().reset_serial() #pdb_hierarchy.sort_atoms_in_place() p = mmtbx.model.manager.get_default_pdb_interpretation_params() p.pdb_interpretation.clash_guard.nonbonded_distance_threshold=None p.pdb_interpretation.use_neutron_distances = use_neutron_distances p.pdb_interpretation.proceed_with_excessive_length_bonds=True #p.pdb_interpretation.restraints_library.cdl=False # XXX this triggers a bug !=360 ro = model.get_restraint_objects() model = mmtbx.model.manager( model_input = None, pdb_hierarchy = pdb_hierarchy, build_grm = True, stop_for_unknowns = stop_for_unknowns, crystal_symmetry = model.crystal_symmetry(), restraint_objects = ro, pdb_interpretation_params = p, log = null_out()) # f = open("intermediate1.pdb","w") # f.write(model.model_as_pdb()) # # Remove lone H # sel_h = model.get_hd_selection() # sel_isolated = model.isolated_atoms_selection() # sel_lone = sel_h & sel_isolated # model = model.select(~sel_lone) # # Only keep H that have been parameterized in riding H procedure sel_h = model.get_hd_selection() model.setup_riding_h_manager(use_ideal_dihedral = True) sel_h_in_para = flex.bool( [bool(x) for x in model.riding_h_manager.h_parameterization]) sel_h_not_in_para = sel_h_in_para.exclusive_or(sel_h) model = model.select(~sel_h_not_in_para) model = exclude_h_on_SS(model = model) model = exclude_h_on_coordinated_S(model = model) # f = open("intermediate2.pdb","w") # f.write(model.model_as_pdb()) # Reset occupancies, ADPs and idealize model.reset_adp_for_hydrogens(scale = adp_scale) model.reset_occupancy_for_hydrogens_simple() model.idealize_h_riding() # return model