def __init__(self, model, target_map, refine_ncs_operators=False, number_of_cycles=1, cycles_to_converge=2, log=None): # completely new way of doing this. using RSR macro-cycle # for test compatibility: print("Minimizing using reference map...", file=log) if model.ncs_constraints_present(): print(" Minimizing... (NCS)", file=log) else: print(" Minimizing...", file=log) from phenix.refinement.macro_cycle_real_space import run as rsr_mc_run import scitbx.math from phenix.command_line.real_space_refine import extract_rigid_body_selections from phenix.command_line.real_space_refine import master_params as rsr_master_params from mmtbx.refinement.real_space.utils import target_map as rsr_target_map import mmtbx.idealized_aa_residues.rotamer_manager sin_cos_table = scitbx.math.sin_cos_table(n=10000) params = rsr_master_params().extract() params.pdb_interpretation = model._pdb_interpretation_params.pdb_interpretation params.refinement.run = "minimization_global+local_grid_search" params.refine_ncs_operators = False params.output.write_all_states = True rotamer_manager = mmtbx.idealized_aa_residues.rotamer_manager.load( rotamers="favored") rigid_body_selections = extract_rigid_body_selections( params=params, ncs_groups=model.get_ncs_groups(), pdb_hierarchy=model.get_hierarchy()) rsr_tm = rsr_target_map(map_data=target_map, xray_structure=model.get_xray_structure(), d_min=3.8, atom_radius=params.refinement.atom_radius) res = rsr_mc_run(params=params, model=model, target_map=rsr_tm, log=log, ncs_groups=model.get_ncs_groups(), rotamer_manager=rotamer_manager, sin_cos_table=sin_cos_table, rigid_body_selections=rigid_body_selections) model.set_sites_cart_from_hierarchy(res.model.get_hierarchy()) res.structure_monitor.states_collector.write( file_name="rsr_all_states.pdb") return # end =================================================== from mmtbx.refinement.geometry_minimization import add_rotamer_restraints from mmtbx.refinement.minimization_monitor import minimization_monitor self.model = model self.log = log print("Minimizing using reference map...", file=self.log) self.log.flush() # copy-paste from cctbx_project/mmtbx/refinement/geometry_minimization.py: # minimize_wrapper_for_ramachandran self.model.get_restraints_manager().geometry.pair_proxies( sites_cart=self.model.get_sites_cart()) ncs_restraints_group_list = self.model.get_ncs_groups() if ncs_restraints_group_list is None: ncs_restraints_group_list = [] ncs_groups = None if len(ncs_restraints_group_list) > 0: ncs_groups = ncs_restraints_group_list min_monitor = minimization_monitor( number_of_cycles=number_of_cycles, max_number_of_cycles=20, cycles_to_converge=cycles_to_converge, mode="no_outliers") selection_real_space = None import mmtbx.refinement.real_space.weight self.w = 1 print("number_of_cycles", number_of_cycles, file=log) print("Stats before minimization:", file=log) ms = self.model.geometry_statistics() ms.show(log=log) while min_monitor.need_more_cycles(): print("Cycle number", min_monitor.get_current_cycle_n(), file=self.log) self.model.get_restraints_manager().geometry.\ update_ramachandran_restraints_phi_psi_targets( hierarchy=self.model.get_hierarchy()) print(" Updating rotamer restraints...", file=self.log) add_rotamer_restraints( pdb_hierarchy=self.model.get_hierarchy(), restraints_manager=self.model.get_restraints_manager(), selection=None, sigma=5, mode="fix_outliers", accept_allowed=False, mon_lib_srv=self.model.get_mon_lib_srv(), rotamer_manager=self.model.get_rotamer_manager()) self.model.set_sites_cart_from_hierarchy() if min_monitor.need_weight_optimization(): # if self.w is None: print(" Determining weight...", file=self.log) self.log.flush() self.weight = mmtbx.refinement.real_space.weight.run( map_data=target_map, xray_structure=self.model.get_xray_structure(), pdb_hierarchy=self.model.get_hierarchy(), geometry_restraints_manager=self.model. get_restraints_manager(), rms_bonds_limit=0.015, rms_angles_limit=1.0, ncs_groups=ncs_groups) # division is to put more weight onto restraints. Checked. Works. self.w = self.weight.weight / 3.0 # self.w = self.weight.weight/15.0 # self.w = 0 # self.w = self.weight.weight for s in self.weight.msg_strings: print(s, file=self.log) if ncs_restraints_group_list is None or len( ncs_restraints_group_list) == 0: #No NCS print(" Minimizing...", file=self.log) print(" with weight %f" % self.w, file=self.log) self.log.flush() refine_object = simple( target_map=target_map, selection=None, max_iterations=150, geometry_restraints_manager=self.model. get_restraints_manager().geometry, selection_real_space=selection_real_space, states_accumulator=None, ncs_groups=ncs_groups) refine_object.refine( weight=self.w, xray_structure=self.model.get_xray_structure()) self.rmsd_bonds_final, self.rmsd_angles_final = refine_object.rmsds( ) print("RMSDS:", self.rmsd_bonds_final, self.rmsd_angles_final, file=log) # print >> log, "sizes:", len(refine_object.sites_cart()), len(self.xrs.scatterers()) self.model.set_sites_cart(refine_object.sites_cart(), update_grm=True) # print >> log, "sizes", self.xrs.scatterers() else: # Yes NCS # copy-paste from macro_cycle_real_space.py # !!! Don't rearrange NCS groups here because master was just fixed! # import mmtbx.ncs.ncs_utils as nu # nu.get_list_of_best_ncs_copy_map_correlation( # ncs_groups = ncs_restraints_group_list, # xray_structure = self.model.get_xray_structure(), # map_data = target_map, # d_min = 3) print(" Minimizing... (NCS)", file=self.log) tfg_obj = mmtbx.refinement.minimization_ncs_constraints.\ target_function_and_grads_real_space( map_data = target_map, xray_structure = self.model.get_xray_structure(), ncs_restraints_group_list = ncs_restraints_group_list, refine_selection = None, real_space_gradients_delta = 1, restraints_manager = self.model.get_restraints_manager(), data_weight = self.w, refine_sites = True) minimized = mmtbx.refinement.minimization_ncs_constraints.lbfgs( target_and_grads_object=tfg_obj, xray_structure=self.model.get_xray_structure(), ncs_restraints_group_list=ncs_restraints_group_list, refine_selection=None, finite_grad_differences_test=False, max_iterations=100, refine_sites=True) self.model.set_sites_cart(tfg_obj.xray_structure.sites_cart()) ncs_restraints_group_list.recalculate_ncs_transforms( self.model.get_sites_cart()) ms = self.model.geometry_statistics() min_monitor.save_cycle_results(geometry=ms) ms.show(log=log)
def __init__(self, model, target_map, refine_ncs_operators=False, number_of_cycles=1, log=None): from mmtbx.refinement.geometry_minimization import add_rotamer_restraints from mmtbx.refinement.minimization_monitor import minimization_monitor self.model = model self.log = log print >> self.log, "Minimizing using reference map..." self.log.flush() # copy-paste from cctbx_project/mmtbx/refinement/geometry_minimization.py: # minimize_wrapper_for_ramachandran self.model.get_restraints_manager().geometry.pair_proxies( sites_cart=self.model.get_sites_cart()) ncs_restraints_group_list = self.model.get_ncs_groups() if ncs_restraints_group_list is None: ncs_restraints_group_list = [] ncs_groups=None if len(ncs_restraints_group_list) > 0: ncs_groups=ncs_restraints_group_list min_monitor = minimization_monitor( number_of_cycles=number_of_cycles, max_number_of_cycles=20, mode="no_outliers") selection_real_space = None import mmtbx.refinement.real_space.weight self.w = 1 print >> log, "number_of_cycles", number_of_cycles print >> log, "Stats before minimization:" ms = self.model.geometry_statistics() ms.show(log=log) while min_monitor.need_more_cycles(): print >> self.log, "Cycle number", min_monitor.get_current_cycle_n() self.model.get_restraints_manager().geometry.update_ramachandran_restraints_phi_psi_targets( sites_cart=self.model.get_sites_cart()) print >> self.log, " Updating rotamer restraints..." add_rotamer_restraints( pdb_hierarchy = self.model.get_hierarchy(), restraints_manager = self.model.get_restraints_manager(), selection = None, sigma = 5, mode = "fix_outliers", accept_allowed = False, mon_lib_srv = self.model.get_mon_lib_srv(), rotamer_manager = self.model.get_rotamer_manager()) self.model.set_sites_cart_from_hierarchy() if min_monitor.need_weight_optimization(): # if self.w is None: print >> self.log, " Determining weight..." self.log.flush() self.weight = mmtbx.refinement.real_space.weight.run( map_data = target_map, xray_structure = self.model.get_xray_structure(), pdb_hierarchy = self.model.get_hierarchy(), geometry_restraints_manager = self.model.get_restraints_manager(), rms_bonds_limit = 0.015, rms_angles_limit = 1.0, ncs_groups = ncs_groups) # division is to put more weight onto restraints. Checked. Works. self.w = self.weight.weight/3.0 # self.w = self.weight.weight/15.0 # self.w = 0 # self.w = self.weight.weight for s in self.weight.msg_strings: print >> self.log, s if ncs_restraints_group_list is None or len(ncs_restraints_group_list)==0: #No NCS print >> self.log, " Minimizing..." print >> self.log, " with weight %f" % self.w self.log.flush() refine_object = simple( target_map = target_map, selection = None, max_iterations = 150, geometry_restraints_manager = self.model.get_restraints_manager().geometry, selection_real_space = selection_real_space, states_accumulator = None, ncs_groups = ncs_groups) refine_object.refine(weight = self.w, xray_structure = self.model.get_xray_structure()) self.rmsd_bonds_final, self.rmsd_angles_final = refine_object.rmsds() print >> log, "RMSDS:", self.rmsd_bonds_final, self.rmsd_angles_final # print >> log, "sizes:", len(refine_object.sites_cart()), len(self.xrs.scatterers()) self.model.set_sites_cart(refine_object.sites_cart(), update_grm=True) # print >> log, "sizes", self.xrs.scatterers() else: # Yes NCS # copy-paste from macro_cycle_real_space.py # !!! Don't rearrange NCS groups here because master was just fixed! # import mmtbx.ncs.ncs_utils as nu # nu.get_list_of_best_ncs_copy_map_correlation( # ncs_groups = ncs_restraints_group_list, # xray_structure = self.model.get_xray_structure(), # map_data = target_map, # d_min = 3) print >> self.log, " Minimizing... (NCS)" tfg_obj = mmtbx.refinement.minimization_ncs_constraints.\ target_function_and_grads_real_space( map_data = target_map, xray_structure = self.model.get_xray_structure(), ncs_restraints_group_list = ncs_restraints_group_list, refine_selection = None, real_space_gradients_delta = 1, restraints_manager = self.model.get_restraints_manager(), data_weight = self.w, refine_sites = True) minimized = mmtbx.refinement.minimization_ncs_constraints.lbfgs( target_and_grads_object = tfg_obj, xray_structure = self.model.get_xray_structure(), ncs_restraints_group_list = ncs_restraints_group_list, refine_selection = None, finite_grad_differences_test = False, max_iterations = 100, refine_sites = True) self.model.set_sites_cart(tfg_obj.xray_structure.sites_cart()) ncs_restraints_group_list.recalculate_ncs_transforms(self.model.get_sites_cart()) ms = self.model.geometry_statistics() min_monitor.save_cycle_results(geometry=ms) ms.show(log=log)
def __init__(self, pdb_h, xrs, target_map, grm=None, ncs_restraints_group_list=[], mon_lib_srv=None, rotamer_manager=None, ss_annotation=None, refine_ncs_operators=False, number_of_cycles=1, log=None): assert grm is not None from mmtbx.refinement.geometry_minimization import add_rotamer_restraints from mmtbx.model_statistics import geometry_no_grm from mmtbx.refinement.minimization_monitor import minimization_monitor self.pdb_h = pdb_h self.xrs = xrs self.log = log # self.cs = self.xrs.crystal_symmetry() self.cs = crystal.symmetry( unit_cell=self.xrs.crystal_symmetry().unit_cell(), space_group=1) print >> self.log, "Minimizing using reference map..." self.log.flush() self.grm = grm # copy-paste from cctbx_project/mmtbx/refinement/geometry_minimization.py: # minimize_wrapper_for_ramachandran self.grm.geometry.pair_proxies( sites_cart=self.pdb_h.atoms().extract_xyz()) if self.grm.geometry.ramachandran_manager is not None: self.grm.geometry.ramachandran_manager.update_phi_psi_targets( sites_cart=self.pdb_h.atoms().extract_xyz()) ncs_groups=None if len(ncs_restraints_group_list) > 0: ncs_groups=ncs_restraints_group_list if rotamer_manager is None: from mmtbx.rotamer.rotamer_eval import RotamerEval rotamer_manager = RotamerEval(mon_lib_srv=mon_lib_srv) # self.pdb_h.write_pdb_file(file_name="rsr_before_rot_fix.pdb", # crystal_symmetry=self.xrs.crystal_symmetry()) # STOP() # selection_real_space = xrs.backbone_selection() # XXX What is it??? min_monitor = minimization_monitor( number_of_cycles=number_of_cycles, max_number_of_cycles=20, mode="no_outliers") selection_real_space = None import mmtbx.refinement.real_space.weight self.w = 1 print >> log, "number_of_cycles", number_of_cycles print >> log, "Stats before minimization:" ms = geometry_no_grm( pdb_hierarchy=self.pdb_h, molprobity_scores=True) print >> self.log, ms.format_molprobity_scores(prefix=" ") while min_monitor.need_more_cycles(): # for x in xrange(number_of_cycles): print >> self.log, "Cycle number", min_monitor.get_current_cycle_n() print >> self.log, " Updating rotamer restraints..." self.pdb_h, grm = add_rotamer_restraints( pdb_hierarchy = self.pdb_h, restraints_manager = grm, selection = None, sigma = 5, mode = "fix_outliers", accept_allowed = False, mon_lib_srv = mon_lib_srv, rotamer_manager = rotamer_manager) self.xrs = self.pdb_h.extract_xray_structure(crystal_symmetry=self.cs) # self.pdb_h.write_pdb_file(file_name="rsr_after_rot_fix.pdb", # crystal_symmetry=self.xrs.crystal_symmetry()) # if True: if ncs_restraints_group_list is None or len(ncs_restraints_group_list)==0: #No NCS if min_monitor.need_weight_optimization(): # if self.w is None: print >> self.log, " Determining weight..." self.log.flush() self.weight = mmtbx.refinement.real_space.weight.run( map_data = target_map, xray_structure = self.xrs, pdb_hierarchy = self.pdb_h, geometry_restraints_manager = grm, rms_bonds_limit = 0.015, rms_angles_limit = 1.0) # for s in self.weight.msg_strings: # print >> self.log, s # division is to put more weight onto restraints. Checked. Works. self.w = self.weight.weight/3.0 # self.w = self.weight.weight/15.0 # self.w = 0 # self.w = self.weight.weight # print >> self.log, self.w print >> self.log, " Minimizing..." print >> self.log, " with weight %f" % self.w self.log.flush() refine_object = simple( target_map = target_map, selection = None, max_iterations = 150, geometry_restraints_manager = grm.geometry, selection_real_space = selection_real_space, states_accumulator = None, ncs_groups = ncs_groups) refine_object.refine(weight = self.w, xray_structure = self.xrs) self.rmsd_bonds_final, self.rmsd_angles_final = refine_object.rmsds() print >> log, "RMSDS:", self.rmsd_bonds_final, self.rmsd_angles_final # print >> log, "sizes:", len(refine_object.sites_cart()), len(self.xrs.scatterers()) self.xrs=self.xrs.replace_sites_cart( new_sites=refine_object.sites_cart(), selection=None) # print >> log, "sizes", self.xrs.scatterers() else: # Yes NCS # copy-paste from macro_cycle_real_space.py import mmtbx.ncs.ncs_utils as nu nu.get_list_of_best_ncs_copy_map_correlation( ncs_groups = ncs_restraints_group_list, xray_structure = self.xrs, map_data = target_map, d_min = 3) if min_monitor.need_weight_optimization(): # if self.w is None: print >> self.log, " Determining weight... (NCS)", self.weight = mmtbx.refinement.real_space.weight.run( map_data = target_map, xray_structure = self.xrs,#.select(sel_master), pdb_hierarchy = self.pdb_h,#.select(sel_master), geometry_restraints_manager = grm, rms_bonds_limit = 0.01, rms_angles_limit = 1.0, ncs_groups = ncs_restraints_group_list) # division supposed to put more weight onto restraints. Need checking. self.w = self.weight.weight/3.0 for s in self.weight.msg_strings: print >> self.log, s print >> self.log, " Minimizing... (NCS)" tfg_obj = mmtbx.refinement.minimization_ncs_constraints.\ target_function_and_grads_real_space( map_data = target_map, xray_structure = self.xrs, ncs_restraints_group_list = ncs_restraints_group_list, refine_selection = None, real_space_gradients_delta = 1, restraints_manager = grm, data_weight = self.w, refine_sites = True) minimized = mmtbx.refinement.minimization_ncs_constraints.lbfgs( target_and_grads_object = tfg_obj, xray_structure = self.xrs, ncs_restraints_group_list = ncs_restraints_group_list, refine_selection = None, finite_grad_differences_test = False, max_iterations = 100, refine_sites = True) self.xrs = tfg_obj.xray_structure # self.structure_monitor.update( # xray_structure = tfg_obj.xray_structure, # accept_as_is = True) self.pdb_h.adopt_xray_structure(self.xrs) ms = geometry_no_grm( pdb_hierarchy=self.pdb_h, molprobity_scores=True) min_monitor.save_cycle_results(geometry=ms) print >> self.log, ms.format_molprobity_scores(prefix=" ")