def run(self): # I'm guessing self.data_manager, self.params and self.logger # are already defined here... print('Using model: %s' % self.data_manager.get_default_model_name(), file=self.logger) # this must be mmtbx.model.manager? model = self.data_manager.get_model() self.cablam_id = cablam_idealization.cablam_idealization( model=model, params=self.params.cablam_idealization, log=self.logger) # I believe this should go to data_manager. Also not clear how output of # two files would affect data_manager. self.output_fname_base = os.path.splitext( self.data_manager.get_default_model_name( ))[0] + self.params.output.suffix if 'pdb' in self.params.output.format: str_to_output = model.model_as_pdb() fname = self.output_fname_base + ".pdb" print('Writing results: %s' % fname) self.data_manager.write_model_file(fname, str_to_output, self.params.output.overwrite) if 'mmcif' in self.params.output.format: str_to_output = model.model_as_mmcif() fname = self.output_fname_base + ".cif" print('Writing results: %s' % fname) self.data_manager.write_model_file(fname, str_to_output, self.params.output.overwrite)
def exercise_yes_sidechains(prefix="tst_one_resid_rotation_yes_sidechains"): pdb_inp = iotbx.pdb.input(lines=pdb_str.split('\n'), source_info=None) model = mmtbx.model.manager( model_input = pdb_inp) with open("%s_start.pdb" % prefix, 'w') as f: f.write(model.model_as_pdb()) ci = cablam_idealization(model = model, params=master_phil.extract().cablam_idealization, log=sys.stdout) pdb_txt = model.model_as_pdb()
def exercise_no_sidechains(prefix="tst_single_outliers_sur_no_sidechains"): pdb_inp = iotbx.pdb.input(lines=pdb_str.split('\n'), source_info=None) model = mmtbx.model.manager(model_input=pdb_inp) s = model.selection("name N or name CA or name C or name O") model = model.select(s) with open("%s_start.pdb" % prefix, 'w') as f: f.write(model.model_as_pdb()) ci = cablam_idealization(model=model, params=master_phil.extract().cablam_idealization, log=sys.stdout) with open("%s_end.pdb" % prefix, 'w') as f: f.write(model.model_as_pdb())
def run(self): # I'm guessing self.data_manager, self.params and self.logger # are already defined here... print('Using model: %s' % self.data_manager.get_default_model_name(), file=self.logger) # this must be mmtbx.model.manager? model = self.data_manager.get_model() self.output_fname_base = os.path.splitext( self.data_manager.get_default_model_name( ))[0] + self.params.output.suffix fo = open(self.output_fname_base + '.log', 'w') self.logger.register(label='logfile', file_object=fo) self.cablam_id = cablam_idealization.cablam_idealization( model=model, params=self.params.cablam_idealization, log=self.logger) results = self.cablam_id.get_results() print("Total number of tried outliers: %d" % results.n_tried_residues, file=self.logger) print("Number of rotated outliers: %d" % results.n_rotated_residues, file=self.logger) # I believe this should go to data_manager. Also not clear how output of # two files would affect data_manager. for m, fname_base in [(results.model, self.output_fname_base), (results.model_minimized, self.output_fname_base + "_minimized")]: if m is not None: if 'pdb' in self.params.output.format: str_to_output = model.model_as_pdb() fname = fname_base + ".pdb" print('Writing results: %s' % fname) self.data_manager.write_model_file( str_to_output, fname, self.params.output.overwrite) if 'mmcif' in self.params.output.format: str_to_output = model.model_as_mmcif() fname = fname_base + ".cif" print('Writing results: %s' % fname) self.data_manager.write_model_file( str_to_output, fname, self.params.output.overwrite)
def run(self): t_0 = time() self.ann = self.model.get_ss_annotation() self._setup_model_h() self.model.set_restraint_objects(self.model_h.get_restraint_objects()) self.model.process_input_model(make_restraints=True) # set SS restratins self.set_ss_restraints(self.ann) self.model.setup_ncs_constraints_groups() self.init_model_statistics = self.get_statistics(self.model) # # Cablam idealization # if self.params.debug: self.shift_and_write_result(model=self.model, fname_suffix="start") self.shift_and_write_result(model=self.model_h, fname_suffix="start_h") self.params.cablam_idealization.find_ss_after_fixes = False ci_results = cablam_idealization( model=self.model, params=self.params.cablam_idealization, log=self.log).get_results() self.model = ci_results.model self.after_cablam_statistics = self.get_statistics(self.model) if self.params.debug: self.shift_and_write_result(model=self.model, fname_suffix="cablam_id") # Here we are preparing maps if needed. if self.user_supplied_map is not None: self.prepare_user_map() if self.reference_map is None and self.params.use_map_for_reference: self.prepare_reference_map_3() if self.params.run_minimization_first: # running simple minimization and updating all # self.master, self.working, etc... # self.whole_pdb_h.reset_atom_i_seqs() if self.init_ref_map is None: self.prepare_init_reference_map() print("Minimization first", file=self.log) self.minimize( model=self.model, original_pdb_h=self.original_hierarchy, excl_string_selection=None, # don't need if we have map reference_map=self.init_ref_map, ) self.init_gm_model_statistics = self.get_statistics(self.model) if self.params.debug: self.shift_and_write_result(model=self.model, fname_suffix="init_gm") if (self.init_gm_model_statistics is not None and self.init_gm_model_statistics.ramachandran.outliers == 0 and self.init_gm_model_statistics.omega.twisted_general <= 0.01 and self.init_gm_model_statistics.omega.twisted_proline <= 0.01 and self.init_gm_model_statistics.omega.cis_general <= 0.01 and self.init_gm_model_statistics.omega.cis_proline <= 0.01 and self.init_gm_model_statistics.rotamer.outliers <= 0.01): print("Simple minimization was enough", file=self.log) # Early exit!!! self.shift_and_write_result(model=self.model, fname_suffix="all_idealized") if self.params.output_model_h: self.shift_and_write_result(model=self.model_h, fname_suffix="all_idealized_h") self.final_model_statistics = self.get_statistics(self.model) # self.original_boxed_hierarchy.write_pdb_file(file_name="original_boxed_end.pdb") self.time_for_run = time() - t_0 if self.params.output_pkl: easy_pickle.dump(file_name="%s.pkl" % self.params.output_prefix, obj=self.get_stats_obj()) return self.filtered_whole_ann = None if self.ann is not None: self.filtered_whole_ann = self.ann.deep_copy() print("Original SS annotation", file=self.log) print(self.ann.as_pdb_str(), file=self.log) if self.params.filter_input_ss: self.filtered_whole_ann = self.ann.filter_annotation( hierarchy=self.model.get_hierarchy(), asc=self.model.get_atom_selection_cache()) print("Filtered SS annotation", file=self.log) print(self.filtered_whole_ann.as_pdb_str(), file=self.log) self.model.set_ss_annotation(self.filtered_whole_ann) # getting grm with SS restraints self.update_ss_in_grm(self.filtered_whole_ann) if (self.ann is None or self.ann.get_n_helices() + self.ann.get_n_sheets() == 0 or not self.params.ss_idealization.enabled): print( "No secondary structure annotations found or SS idealization is disabled.", file=self.log) print("Secondary structure substitution step will be skipped", file=self.log) self.log.flush() # here we want to do geometry minimization anyway! negate_selection = None if self.reference_map is None: outlier_selection_txt = mmtbx.building.loop_closure.utils. \ rama_score_selection(self.model.get_hierarchy(), self.model.get_ramachandran_manager(), "outlier",1) print("outlier_selection_txt", outlier_selection_txt, file=self.log) negate_selection = "all" if outlier_selection_txt != "" and outlier_selection_txt is not None: negate_selection = "not (%s)" % outlier_selection_txt # if self.params.run_minimization_first: # self.minimize( # model=self.model, # original_pdb_h=self.whole_pdb_h, # ncs_restraints_group_list=self.filtered_ncs_restr_group_list, # excl_string_selection=negate_selection, # reference_map=self.reference_map) # self.original_boxed_hierarchy.write_pdb_file(file_name="original_boxed_h_1.pdb") else: if self.params.debug: self.params.ss_idealization.file_name_before_regularization = \ "%s_ss_before_reg.pdb" % self.params.output_prefix self.params.ss_idealization.skip_good_ss_elements = True ssb.substitute_ss(model=self.model, params=self.params.ss_idealization, reference_map=self.master_map, log=self.log) self.log.flush() self.after_ss_idealization = self.get_statistics(self.model) self.shift_and_write_result(model=self.model, fname_suffix="ss_ideal_stat") # Write resulting pdb file. if self.params.debug: self.shift_and_write_result( model=self.model, fname_suffix="ss_ideal", ) # self.params.loop_idealization.minimize_whole = not self.model.ncs_constraints_present() and self.params.loop_idealization.minimize_whole self.params.loop_idealization.debug = self.params.debug or self.params.loop_idealization.debug # self.params.loop_idealization.enabled = False # self.params.loop_idealization.variant_search_level = 0 print("Starting loop idealization", file=self.log) loop_ideal = loop_idealization(self.model, params=self.params.loop_idealization, reference_map=self.master_map, log=self.log, verbose=True) self.log.flush() if self.params.debug: self.shift_and_write_result(model=self.model, fname_suffix="rama_ideal") self.after_loop_idealization = self.get_statistics(self.model) # fixing remaining rotamer outliers if (self.params.additionally_fix_rotamer_outliers and self.after_loop_idealization.rotamer.outliers > 0.004): self.idealize_rotamers() self.after_rotamer_fixing = self.get_statistics(self.model) ref_hierarchy_for_final_gm = self.original_boxed_hierarchy if not self.params.use_starting_model_for_final_gm: ref_hierarchy_for_final_gm = self.model.get_hierarchy().deep_copy() ref_hierarchy_for_final_gm.reset_atom_i_seqs() if self.model.ncs_constraints_present(): print("Using ncs", file=self.log) # assert 0 else: print("Not using ncs", file=self.log) # assert 0 # need to update SS manager for the whole model here. if self.params.use_ss_restraints: ss_params = sec_str_master_phil.fetch().extract() ss_params.secondary_structure.protein.remove_outliers = not self.params.ss_idealization.enabled self.set_ss_restraints(ss_annotation=self.filtered_whole_ann, params=ss_params.secondary_structure) if self.params.run_minimization_last: print("loop_ideal.ref_exclusion_selection", loop_ideal.ref_exclusion_selection, file=self.log) print("Minimizing whole model", file=self.log) self.minimize( model=self.model, original_pdb_h=ref_hierarchy_for_final_gm, excl_string_selection=loop_ideal.ref_exclusion_selection, reference_map=self.reference_map) self.shift_and_write_result(model=self.model, fname_suffix="all_idealized") if self.params.output_model_h: self.shift_and_write_result(model=self.model_h, fname_suffix="all_idealized_h") self.final_model_statistics = self.get_statistics(self.model) self.time_for_run = time() - t_0 if self.params.output_pkl or self.params.debug: easy_pickle.dump(file_name="%s.pkl" % self.params.output_prefix, obj=self.get_stats_obj())
def run(self): t_0 = time() self.ann = self.model.get_ss_annotation() self.get_grm() self.model.setup_ncs_constraints_groups() self.init_model_statistics = self.get_statistics(self.model) # # Cablam idealization # self.params.cablam_idealization.find_ss_after_fixes = False ci_results = cablam_idealization( model=self.model, params=self.params.cablam_idealization, log=self.log).get_results() self.model = ci_results.model self.after_cablam_statistics = self.get_statistics(self.model) if self.params.debug: self.shift_and_write_result( model = self.model, fname_suffix="cablam_id") # Here we are preparing maps if needed. if self.user_supplied_map is not None: self.prepare_user_map() if self.reference_map is None and self.params.use_map_for_reference: self.prepare_reference_map_3() if self.params.run_minimization_first: # running simple minimization and updating all # self.master, self.working, etc... # self.whole_pdb_h.reset_atom_i_seqs() if self.init_ref_map is None: self.prepare_init_reference_map() print >> self.log, "Minimization first" self.minimize( model=self.model, original_pdb_h=self.original_hierarchy, excl_string_selection=None, # don't need if we have map reference_map=self.init_ref_map, ) self.init_gm_model_statistics = self.get_statistics(self.model) if self.params.debug: self.shift_and_write_result( model = self.model, fname_suffix="init_gm") if (self.init_gm_model_statistics is not None and self.init_gm_model_statistics.ramachandran.outliers == 0 and self.init_gm_model_statistics.omega.twisted_general <= 0.01 and self.init_gm_model_statistics.omega.twisted_proline <= 0.01 and self.init_gm_model_statistics.omega.cis_general <= 0.01 and self.init_gm_model_statistics.omega.cis_proline <= 0.01 and self.init_gm_model_statistics.rotamer.outliers <= 0.01): print >> self.log, "Simple minimization was enough" # Early exit!!! self.shift_and_write_result( model=self.model, fname_suffix="all_idealized") self.final_model_statistics = self.get_statistics(self.model) # self.original_boxed_hierarchy.write_pdb_file(file_name="original_boxed_end.pdb") self.time_for_run = time() - t_0 if self.params.output_pkl: easy_pickle.dump( file_name="%s.pkl" % self.params.output_prefix, obj = self.get_stats_obj()) return self.filtered_whole_ann = None if self.ann is not None: self.filtered_whole_ann = self.ann.deep_copy() print >> self.log, "Original SS annotation" print >> self.log, self.ann.as_pdb_str() if self.params.filter_input_ss: self.filtered_whole_ann = self.ann.filter_annotation( hierarchy=self.model.get_hierarchy(), asc=self.model.get_atom_selection_cache()) print >> self.log, "Filtered SS annotation" print >> self.log, self.filtered_whole_ann.as_pdb_str() self.model.set_ss_annotation(self.filtered_whole_ann) # getting grm with SS restraints self.update_ss_in_grm(self.filtered_whole_ann) if (self.ann is None or self.ann.get_n_helices() + self.ann.get_n_sheets() == 0 or not self.params.ss_idealization.enabled): print >> self.log, "No secondary structure annotations found or SS idealization is disabled." print >> self.log, "Secondary structure substitution step will be skipped" self.log.flush() # here we want to do geometry minimization anyway! negate_selection = None if self.reference_map is None: outlier_selection_txt = mmtbx.building.loop_closure.utils. \ rama_score_selection(self.model, self.model.get_ramachandran_manager(), "outlier",1) print >> self.log, "outlier_selection_txt", outlier_selection_txt negate_selection = "all" if outlier_selection_txt != "" and outlier_selection_txt is not None: negate_selection = "not (%s)" % outlier_selection_txt # if self.params.run_minimization_first: # self.minimize( # model=self.model, # original_pdb_h=self.whole_pdb_h, # ncs_restraints_group_list=self.filtered_ncs_restr_group_list, # excl_string_selection=negate_selection, # reference_map=self.reference_map) # self.original_boxed_hierarchy.write_pdb_file(file_name="original_boxed_h_1.pdb") else: if self.params.debug: self.params.ss_idealization.file_name_before_regularization = \ "%s_ss_before_reg.pdb" % self.params.output_prefix self.params.ss_idealization.skip_good_ss_elements = True ssb.substitute_ss( model = self.model, params=self.params.ss_idealization, verbose=self.params.verbose, reference_map=self.master_map, log=self.log) self.log.flush() self.after_ss_idealization = self.get_statistics(self.model) self.shift_and_write_result( model=self.model, fname_suffix="ss_ideal_stat") # Write resulting pdb file. if self.params.debug: self.shift_and_write_result( model=self.model, fname_suffix="ss_ideal", ) # self.params.loop_idealization.minimize_whole = not self.model.ncs_constraints_present() and self.params.loop_idealization.minimize_whole self.params.loop_idealization.debug = self.params.debug or self.params.loop_idealization.debug # self.params.loop_idealization.enabled = False # self.params.loop_idealization.variant_search_level = 0 print >> self.log, "Starting loop idealization" loop_ideal = loop_idealization( self.model, params=self.params.loop_idealization, reference_map=self.master_map, log=self.log, verbose=True) self.log.flush() if self.params.debug: self.shift_and_write_result( model = self.model, fname_suffix="rama_ideal") self.after_loop_idealization = self.get_statistics(self.model) # fixing remaining rotamer outliers if (self.params.additionally_fix_rotamer_outliers and self.after_loop_idealization.rotamer.outliers > 0.004): print >> self.log, "Fixing rotamers..." self.log.flush() if self.params.debug: self.shift_and_write_result( model = self.model, fname_suffix="just_before_rota") # run reduce assert (libtbx.env.has_module(name="reduce")) input_str = self.model.model_as_pdb(do_not_shift_back=True) build = "phenix.reduce" + " -quiet -build -allalt -NUC -" output = easy_run.fully_buffered(build, stdin_lines=input_str) p = mmtbx.model.manager.get_default_pdb_interpretation_params() p.pdb_interpretation.use_neutron_distances=True p.pdb_interpretation.ncs_search = self.params_for_model.pdb_interpretation.ncs_search p.pdb_interpretation.ncs_search.exclude_selection="water" h_input = iotbx.pdb.input(lines=output.stdout_lines, source_info=None) h_model = mmtbx.model.manager(model_input = h_input, process_input=True, restraint_objects=self.model._restraint_objects, pdb_interpretation_params=p) sel = h_model.get_hd_selection() h_model.setup_ncs_constraints_groups(filter_groups=True) h_model._update_master_sel() result = mmtbx.refinement.real_space.fit_residues.run( vdw_radii = h_model.get_vdw_radii(), bselection = h_model.get_master_selection(), pdb_hierarchy = h_model.get_hierarchy(), crystal_symmetry = self.model.crystal_symmetry(), map_data = self.master_map, rotamer_manager = mmtbx.idealized_aa_residues.rotamer_manager.load(), sin_cos_table = scitbx.math.sin_cos_table(n=10000), backbone_sample = False, mon_lib_srv = h_model.get_mon_lib_srv(), log = self.log) self.model.set_sites_cart( sites_cart = result.pdb_hierarchy.select(~sel).atoms().extract_xyz(), update_grm = True) self.model.set_sites_cart_from_hierarchy(multiply_ncs=True) if self.params.debug: self.shift_and_write_result( model = self.model, fname_suffix="rota_ideal") self.after_rotamer_fixing = self.get_statistics(self.model) ref_hierarchy_for_final_gm = self.original_boxed_hierarchy if not self.params.use_starting_model_for_final_gm: ref_hierarchy_for_final_gm = self.model.get_hierarchy().deep_copy() ref_hierarchy_for_final_gm.reset_atom_i_seqs() if self.model.ncs_constraints_present(): print >> self.log, "Using ncs" # assert 0 else: print >> self.log, "Not using ncs" # assert 0 # need to update SS manager for the whole model here. if self.params.use_ss_restraints: ss_params = sec_str_master_phil.fetch().extract() ss_params.secondary_structure.protein.remove_outliers = not self.params.ss_idealization.enabled self.set_ss_restraints( ss_annotation=self.filtered_whole_ann, params=ss_params.secondary_structure) if self.params.run_minimization_last: print >> self.log, "loop_ideal.ref_exclusion_selection", loop_ideal.ref_exclusion_selection print >> self.log, "Minimizing whole model" self.minimize( model = self.model, original_pdb_h=ref_hierarchy_for_final_gm, excl_string_selection=loop_ideal.ref_exclusion_selection, reference_map = self.reference_map) self.shift_and_write_result( model = self.model, fname_suffix="all_idealized") self.final_model_statistics = self.get_statistics(self.model) self.time_for_run = time() - t_0 if self.params.output_pkl or self.params.debug: easy_pickle.dump( file_name="%s.pkl" % self.params.output_prefix, obj = self.get_stats_obj())